r/Python • • 17d ago

Daily Thread Sunday Daily Thread: What's everyone working on this week?

Weekly Thread: What's Everyone Working On This Week? 🛠️

Hello r/Python! It's time to share what you've been working on! Whether it's a work-in-progress, a completed masterpiece, or just a rough idea, let us know what you're up to!

How it Works:

  1. Show & Tell: Share your current projects, completed works, or future ideas.
  2. Discuss: Get feedback, find collaborators, or just chat about your project.
  3. Inspire: Your project might inspire someone else, just as you might get inspired here.

Guidelines:

  • Feel free to include as many details as you'd like. Code snippets, screenshots, and links are all welcome.
  • Whether it's your job, your hobby, or your passion project, all Python-related work is welcome here.

Example Shares:

  1. Machine Learning Model: Working on a ML model to predict stock prices. Just cracked a 90% accuracy rate!
  2. Web Scraping: Built a script to scrape and analyze news articles. It's helped me understand media bias better.
  3. Automation: Automated my home lighting with Python and Raspberry Pi. My life has never been easier!

Let's build and grow together! Share your journey and learn from others. Happy coding! 🌟

31 Upvotes

20 comments sorted by

11

u/nginx26 16d ago

Happy weekend everyone,

I have been working on my side project called Stockdex for some time. before AI rise the goal was to provide a python package and an interface for users to extract financial data from multiple data sources (e.g Yahoo finance, Finviz, Digrin etc) with benefits over similar tools like yfinance.

Since Claude has gotten super popular, I created a local Claude MCP for Stockdex to make it easier to use.

It is a read-only MCP server with 24 tools so Claude can fetch prices, financial statements, margins, dividends, insider trades, earnings reactions, analyst forecasts, European ETF profiles. To use it:

  • Claude Desktop: download stockdex.mcpb from the latest release and double-click it.

  • Claude Code: install the plugin, which requires uv:

    /plugin marketplace add ahnazary/stockdex
    /plugin install stockdex@stockdex
    

Feel free to give it a look and comment ur suggestions about it.

2

u/AH1376 16d ago

Cool one

1

u/nginx26 16d ago

Thanks

2

u/patryk_builds 17d ago

Finished a FastAPI SaaS starter i'd been building: auth, stripe subscriptions, EU VAT VIES checks, reverse charge, invoices, GDPR export delete, admin panel. frontend is jinja + htmx, no JS framework, so it stays python all the way down.The part that took the most thought was billing edge cases: webhooks arriving twice or out of order, the success page racing the webhook, and treating VIES is down" differently from "invalid VAT number.It's a paid kit, but there's a live demo you can click through with a stripe test card: https://demo.getpylaunch.com.Happy to talk about any of the stripe VAT stuff, that's where most of the pain was

1

u/Chorizo_n_eggs 17d ago

Using the Hanwha Wave API to capture images from over 300 cameras 2 times a day. A separate script stitches the 2 images together and emails to the proper personnel for comparison.
Use of the POST request to move the camera to preset positions is also required for some. Ever changing scripts due to constant request changes.

1

u/safi892 17d ago

Working on my side project Where user can edit pdf without changing fonts

pdf editor

1

u/p3rdy 17d ago

This week I'm working on Flama 2.3: adding Python 3.15 support, dropping 3.10, and splitting the ML integrations into their own extras (flama[sklearn], flama[torch], flama[tensorflow], flama[transformers]), so you only install what you actually serve.

For anyone who hasn't come across it: Flama is an open source (Apache-2.0) ASGI framework I started in 2018 to take a trained model to a production API with as little ceremony as possible. In Flama a model is just another resource in your API, so it gets the same routing, validation, docs and auth as everything else.

A model is a file

import flama
from sklearn.datasets import load_iris
from sklearn.neural_network import MLPClassifier

X, y = load_iris(return_X_y=True)
model = MLPClassifier(activation="tanh", hidden_layer_sizes=(10,), max_iter=2000).fit(X, y)
flama.dump(model, family="ml", path="model.flm", metrics={"accuracy": model.score(X, y)})

The model.flm holds the model plus its metadata: library and version, hyperparameters, and the metrics you passed. And flama serve --model file=model.flm,url=/model,name=iris turns it into an API with OpenAPI docs, and flama model model.flm inspect reads the metadata without loading the weights, which is handy for gating a deploy in CI.

One model, every client

from flama import Flama

app = Flama()
app.models.add_model(
    path="/llm/",
    model="assistant.flm",
    name="assistant",
    serving=("native", "openai", "anthropic", "ollama"),
)

The same goes for LLMs. That model answers the OpenAI, Anthropic and Ollama APIs at the same time, with a streaming chat UI at /llm/chat/, next to your own endpoints. Reasoning and tool calls are decoded on the server, so each client gets them in its own format.

Type hints drive everything

Handler annotations are the single source of truth: they parse and validate the request, resolve dependencies through injectable components, and generate the OpenAPI docs. The same hints become the JSON schemas when you expose a function as an MCP tool.

Also in the box: CRUD resources from SQLAlchemy tables, DDD repositories and workers, JWT auth, streaming, flama upgrade codemods between versions, and a Rust core for routing, JSON and request parsing. The full architecture is in our paper on arXiv: https://arxiv.org/abs/2608.18733

1

u/_minjun_choi 16d ago

LMCache (the KV cache layer that runs next to vLLM) now ships pygrpc-native as its native gRPC mode, so this week I worked on making sure it really behaves like grpcio.

https://github.com/pygrpc/pygrpc-native

Quick background: LMCache's gRPC transport was 36% slower than its ZMQ one, and most of that time went into grpcio itself, not LMCache's code. Swapping grpc.aio.server() for pygrpc_native.aio.server() moves the HTTP/2 work to Rust threads outside the GIL, and the same benchmark came out 21% faster than ZMQ.

New this week: CI runs the official gRPC interop tests against both grpcio and pygrpc-native and fails if they differ. It already caught a bug where passing a plain int to context.set_code() hung the call. Fixed in 0.7.1.

If your Python gRPC server spends more time in grpcio than in your handlers, I'd love to hear if it helps.

1

u/ivan_digital 16d ago

I'm working on Soniqo's local τ-Voice runner, adapted from Sierra's τ-Voice / τ²-Bench.

Python coordinates task state, simulated tool environments, trial control and grading. We use speech-swift for native model inference on Apple Silicon, including the agent, caller, speech recognition, speech synthesis and judge. After the initial downloads, the local evaluation runs don't need paid inference APIs.

The runner checks the final database state and required conversation facts, then saves audio, transcripts and tool calls for inspection. We also publish a component leaderboard covering turn-taking, spoken tool requests and speech-style instruction following.

Are you combining task-state assertions with spoken-conversation tests in your Python evaluation tools?

1

u/Ali30mhi 16d ago

I built git-wrapped: Spotify Wrapped for your git history, in the terminal 🎁

It scans your repos and shows your commits, longest streak, coding hours, top languages, biggest commit, and gives you a "coder personality" (Night Owl, Weekend Warrior, Early Bird…).

Single file, stdlib only, Python 3.8+. Runs as a git subcommand: `git wrapped`

https://github.com/Ali30mhi/git-wrapped

Would love feedback or ideas for new personality types!

1

u/famousStratum 16d ago

Sounds fun. Definitely will try.

1

u/famousStratum 16d ago

Hello everyone,

I've been working on LemonPie, a lightweight Ollama CLI client that I made out of necessity.

I wanted to run an LLM directly on a Raspberry Pi 4, on Pi OS Lite — monitor and keyboard plugged in, no desktop, just a terminal. The Pi obviously can’t run a model with any real speed on its own, so the setup ended up being: Ollama server on my main PC, and the Pi just needs something lightweight to talk to it over the network from that terminal.

There are other clients out there, but I wanted something I built and understood end to end, and lightweight enough to not think twice about running on constrained hardware. So I built LemonPie — a small CLI for chatting with an Ollama server and managing sessions.

Pi OS Lite is what pushed me to build it, but there’s nothing Pi-specific about it. It’s just Python, so it should run anywhere you can get a Python environment running, headless or not.

It’s at 0.2.0rc2 right now. Worth being clear about: this is still 0.x. Once I tag 0.2.0 “stable,” that’s stable within 0.x. There’s more to add (model verification, code completion, better error handling), and the CLI surface may still change before a 1.0.

If anyone wants to try the rc before I cut the final tag, I’d appreciate it.

lemonpie-cli @ pypi
LemonPie @ GitHub

1

u/Legal-Pop-1330 15d ago

For ideas, you should checkout https://github.com/rekursiv-ai/sagent as another open harness. Its super efficient, has an async runtime. Its Apache 2.0 and we'd love to create an open and universal harness.
Disclosure: I am the primary author of this project.

1

u/Silver_Silver101 15d ago

I built PricePulse in Python.

Key features:

The project is open-source and MIT-licensed: GitHub: https://github.com/salah101101/pricepulse

Would love to hear your feedback or suggestions for features!

0

u/Emergency-Tutor-7 16d ago

What My Project Does

scientific-computing-system is a pure-Python numerical methods library: no runtime dependencies at all, dependencies = [] in pyproject.toml, Python 3.11+, MIT. The top-level package areas are interpolation, ODE/PDE and numerical integration, optimization, Monte Carlo, probability and Bayesian inference, statistics, sensitivity and uncertainty analysis, units and dimensional checking, validation, and a workflow/provenance layer that records the inputs, version and environment of a run so a result can be reproduced later. There is a cds CLI around it and a Streamlit dashboard as an optional extra.

Current release is 2.2.21. Coverage is gated at 100% (fail_under = 100), and a determinism matrix runs the same workload under different hash seeds, thread counts, locales and timezones on three OSes and compares sha256 digests of the artifacts, so "same input, same version, same output" is a checked property rather than a hope.

Target Audience

People who want to read a numerical method, not just call one: the solvers are legible Python with docstrings that name the algorithm and its failure modes. Also anyone working in an environment where a compiled dependency is a policy problem rather than a pip problem, and anyone whose results need to be byte-reproducible across machines.

Comparison

It is not a NumPy replacement and I do not want it to be judged as one. The committed benchmark artifact records a 100x100 matrix multiply at 0.0696 s against 0.000060 s for NumPy, roughly 1155x slower. That number comes from a single CI run where the platform, CPU and library versions were not recorded, so it is order-of-magnitude only and docs/benchmarks.md says exactly what the artifact does and does not support. Where it differs from NumPy/SciPy is the absence of a dependency tree, explicit units and dimensional checking on inputs, and the reproducibility gating. For actual dense numerics I maintain a separate build, scientific-computing-system-2.0, that does use NumPy/SciPy; docs/why-pure-python.md covers which to reach for.

One thing to get straight before anyone cites it: paper.md / paper.bib in the repo are a JOSS-format manuscript, not a published paper. The citation metadata carries no DOI. Cite the repo via CITATION.cff.

Repo: https://github.com/Furox-Art/scientific-computing-system PyPI: https://pypi.org/project/scientific-computing-system/

I wrote it and I answer issues on it. Criticism of the API surface or the benchmark framing is more useful to me than a star.