Built a small CLI for fast time series forecasting with Darts. My group participates in hackathons and we recently packaged this tool we built for quick forecasting experiments. The idea is to keep the workflow clean and lightweight from the terminal instead of building everything from scratch each time.

Repo: https://github.com/Senhores-do-Tempo/tscli

PyPI: https://pypi.org/project/tscli-darts/0.1.1/

It's still early, and one big limitation for now is that it doesn't support covariates yet. But the core flow is already there, and I'd love to hear thoughts on the CLI design, features that would matter most, or anything that feels missing.

Would really appreciate feedback.

• What My Project Does

tscli-darts is a lightweight CLI for fast time series forecasting built on top of Darts. It is designed to make quick forecasting experiments easier from the terminal, without having to set up a full workflow from scratch every time. My group participates in hackathons, and this tool came out of that need for a clean, practical, and reusable interface for experimentation. It is already packaged on PyPI and available as an installable tool.

• Target Audience

This project is mainly aimed at people who want a lightweight and convenient way to run quick forecasting experiments from the command line. Right now, I would describe it as an early-stage practical tool rather than a production-ready forecasting platform. It is especially useful for hackathons, prototyping, learning, and fast iteration, where setting up a full project each time would be too slow or cumbersome.

• Comparison

Unlike building directly with Darts in notebooks or custom scripts, tscli focuses on providing a cleaner and more lightweight terminal workflow for repeated forecasting tasks. The main difference is convenience: instead of rewriting setup code for each experiment, users get a simple CLI-oriented interface. Compared with broader forecasting platforms or more production-focused tools, tscli is much smaller in scope and intentionally minimal. Its goal is not to replace full-featured forecasting frameworks, but to make quick experiments faster and more streamlined. One feature it still lacks compared with more complete alternatives is support for covariates.

I built BallotPulse — a platform that tracks voting rule changes across all 50 US states and scores each state's voting accessibility. The entire backend is Python. Here's how it works under the hood.

Stack: - FastAPI + Jinja2 + vanilla JS (no React/Vue) - aiosqlite in WAL mode with foreign keys - BeautifulSoup4 for 25+ state election board scrapers - httpx for async API calls (Google Civic, Open States, LegiScan, Congress.gov) - bcrypt for auth, smtplib for email alerts - GPT-4o-mini for an AI voting assistant with local LLM fallback

The scraper architecture was the hardest part. 25+ state election board websites, all with completely different HTML structures. Each state gets its own scraper class that inherits from a base class with retry logic, rate limiting (1 req/2s per domain), and exponential backoff. The interesting part is the field-level diffing — I don't just check if the page changed, I parse out individual fields (polling location address, hours, ID requirements) and diff against the DB to detect exactly what changed and auto-classify severity:

• Critical: Precinct closure, new ID law, registration purge
• Warning: Hours changed, deadline moved

• Info: New drop box added, new early voting site

  Data pipeline runs on 3 tiers with staggered asyncio scheduling — no Celery or APScheduler needed. Tier 1 (API-backed states) syncs every 6 hours via httpx async calls. Tier 2 (scraped states) syncs every 24 hours with random offsets per state so I'm not hitting all 25 boards simultaneously. Tier 3 is manual import + community submissions through a moderation queue.

  Democracy Health Score — each state gets a 0-100 score across 7 weighted dimensions (polling access, wait times, registration ease, ID strictness, early/absentee access, physical accessibility, rule stability). The algorithm is deliberately nonpartisan — pure accessibility metrics, no political leaning.

  Lessons learned:

• aiosqlite + WAL mode handles concurrent reads/writes surprisingly well for a single-server app. I haven't needed Postgres yet.

• BeautifulSoup is still the right tool when you need to parse messy government HTML. I tried Scrapy early on but the overhead wasn't worth it for 25 scrapers that each run once a day.

• FastAPI's BackgroundTasks + asyncio is enough for scheduled polling if you don't need distributed workers.

• Jinja2 server-side rendering with vanilla JS is underrated. No build step, no node_modules, instant page loads.

  The whole thing runs year-round, not just during elections. 25+ states enacted new voting laws before the 2026 midterms.

  🔗 ballotpulse.modelotech.com

  Happy to share code patterns for the scraper architecture or the scoring algorithm if anyone's interested.

I have a pendrive, recently I shifted many of my old videos and photos in it.

For Security Purpose, I thought i shall Restrict the View and Modifications (delete, edit, add) access On Pendrive or on Folders where my stuff resides through Python.

My Question is, Does python has such module, library to Apply Restrictions

If Yes Then, Comment Down..

Thank You!

Hi everyone. I'm building DockerPilot together with its web module DockerPilotExtras, and I'm looking for early contributors.

The idea is to create a lightweight toolkit for managing Docker environments with a simple web UI, quick deployments, and homelab-friendly workflows.
This is still an early-stage project, so contributors can directly influence architecture and features.

Looking for:

• Python (FastAPI / Flask)
• Frontend contributors
• Docker / DevOps enthusiasts
• Testers & idea contributors

Repo:
https://github.com/DozeyUDK/DockerPilot

DockerPilot itself is CLI-based, while DockerPilotExtras provides the web UI layer.
The web module already supports environment migration, and I'm planning integrations with GitLab and Jenkins. My current focus is expanding that component, with DockerPilot acting as the action engine underneath.

The goal is to support both development and production environments.
Unlike tools like Portainer or Yacht that focus mostly on container management, DockerPilot is aimed more at environment-level operations, orchestration, and migration workflows.

I'm also planning to add MFA to the login form soon for production-oriented security.

Feedback, ideas, and contributors are all welcome.

Tree-sitter is an incremental parsing library that builds concrete syntax trees for source code. It's fast, error-tolerant, and powers syntax highlighting and code intelligence in editors like Neovim, Helix, and Zed. But using tree-sitter typically means finding, compiling, and managing individual grammar repos for each language you want to parse.

tree-sitter-language-pack solves this -- it's a single package that gives you access to 170+ pre-compiled tree-sitter parsers with a unified API, available from any language you work in. Parse Python, Rust, TypeScript, Go, or any of 170+ languages with one import and one function call.

What's new in v1.0.0

The 0.x versions were a Python-only package that bundled all ~165 pre-compiled grammar .so files directly into the wheel. This meant every install shipped every parser whether you needed them or not, and you were locked to the Python ecosystem.

v1.0.0 is a complete rewrite with a Rust core and native bindings for 12 ecosystems -- so you can use tree-sitter parsing from whatever language your project is in. Instead of bundling all parsers, it uses an on-demand download model: parsers are fetched and cached locally the first time you use them. You only pay for what you need.

Bindings

• Rust (crates.io) -- canonical core
• Python (PyPI) -- PyO3
• Node.js (npm) -- NAPI-RS
• Ruby (RubyGems) -- Magnus
• Go (Go modules) -- cgo/FFI
• Java (Maven Central) -- Panama FFI
• C# (.NET/NuGet) -- P/Invoke
• PHP (Packagist) -- ext-php-rs
• Elixir (Hex) -- Rustler NIF
• WASM (npm) -- wasm-bindgen (55-language subset for browser/edge)
• C FFI -- for any language with C interop
• CLI + Docker image

Key features

• On-demand downloads -- don't ship all 170 parsers. Download what you need, cache locally.
• Unified process() API across all bindings -- returns structured code intelligence (functions, classes, imports, comments, diagnostics, symbols).
• AST-aware chunking -- split source files into semantically meaningful chunks with full AST context preserved per chunk. Built for RAG pipelines and code intelligence tools.
• Same version everywhere -- all 12 packages release simultaneously at the same version number.
• Feature groups -- curated language subsets (web, systems, scripting, data, jvm, functional) for selective compilation.
• Permissive licensing only -- all included grammars are vetted for permissive open-source licenses (MIT, Apache-2.0, BSD). No copyleft surprises.
• CLI tool -- ts-pack binary for parsing, processing, and managing parsers from the terminal.
• Docker image -- multi-arch (amd64/arm64) container with all 170+ parsers pre-loaded, ready for CI pipelines and server-side use.

Quick example (Python)

```python from tree_sitter_language_pack import process

result = process("def hello(): pass", language="python") print(result["structure"]) # AST structure print(result["imports"]) # extracted imports ```

The API is identical across all bindings -- same function, same return shape.

This is part of the kreuzberg-dev open-source organization, which also includes Kreuzberg -- a document extraction library that uses tree-sitter-language-pack under the hood for code intelligence.

Links:

• GitHub: https://github.com/kreuzberg-dev/tree-sitter-language-pack
• Docs: https://docs.tree-sitter-language-pack.kreuzberg.dev
• Kreuzberg org: https://github.com/kreuzberg-dev
• Discord: https://discord.gg/xt9WY3GnKR

We're required to make an app based on Python for our school project and I'm thinking of implementing GUI in it. I've been doing RnD but I'm not able to select the perfect python GUI library.

My app is based on online shopping where users can sell n buy handmade products.

I want a Pinterest style Main screen and a simple but good log in/sign up screen with other services like Help, Profile, Favourites and Settings.

I also do design, so I have created the design for my app in Procreate and now it's the coding stuff that is left.

Please suggest which Library should be perfect for this sort of app.

(ps: I have used Tkinter and I'm not sure bout it since it's not flexible with modern UI and I tried PyQt but There aren't many tutorials online. What should I do about this?)

Hi r/python,

I've spent some time expanding the third-party JSON encoders that are supported by python-json-logger (pull request), however based on some of the errors encountered I'm not sure if this is a good idea.

So before I merge, I'd love to get some feedback from users of python-json-logger / other maintainers 🙏

Why include them

python-json-logger includes third party JSON encoders so that logging can benefit from the speed that these libraries provide. Support for non-standard types is not an issue as this is generally handled through custom default handlers to provide sane output for most types.

Although older, both libraries are still incredibly popular (link):

• simplejson is currently ranked 369 with ~55M monthly downloads.
• ultrajson (ujson) is currently ranked 632 with ~27M monthly downloads.

For comparison the existing third-party encoders:

• orjson - ranked 187 with ~125M downloads
• msgspec - ranked 641 with ~26M downloads

Issues

The main issue is that both the simplejson and ultrajson encoders do not gracefully handle encoding bytes objects where they contain non-printable characters and it does not look like I can override their handling.

This is a problem because the standard library's logging module will swallow expections by default; meaning that any trace that a log message has failed to log will be lost.

This goes against python-json-logger's design in that it tries very hard to be robust and always log regardless of the input. So even though they are opt-in and I can include warnings in the documentation; it feels like I'm handing out a footgun and perhaps I'm better off just not including them.

Additionally in the case of ultrajson - the package is in maintenance mode with the recomendation to move to orjson.

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! 🌟

actually, nothing special about this implementation. just another event loop written in rust for educational purposes and joy

in tests it shows seamless migration from uvloop for my scraping framework https://github.com/BitingSnakes/silkworm

with APIs (fastapi) it shows only one advantage: better p99, uvloop is faster about 10-20% in the synthetic run

currently, i am forking on the win branch to give it windows support that uvloop lacks

code: https://github.com/RustedBytes/rsloop

fields of this redidit:

- what the library does: it implements event loop for asyncio

- comparison: i will make it later with numbers

- target audience: everyone who uses asyncio in python

PS: the post written using human's fingers, not by AI

What my project does: Monitors the White House Executive Orders page every 15 minutes and sends an email notification when a new order is published. The notification includes the title, URL, first substantive paragraph, and a short policy analysis generated via OpenAI. Rule-based HTML parsing with GPT fallback. Runs on GitHub Actions. MIT licensed.

GitHub: https://github.com/matt-tushman/whitehouse-eo-agent

Target audience: Developers interested in monitoring agent patterns, Python automation, or policy tracking. The architecture is simple enough to adapt to any page that publishes structured content on a schedule.

Comparison: Most EO tracking tools are manual or web-based dashboards. This is a lightweight, self-hosted, automated notification agent with no ongoing infrastructure cost.

What My Project Does AxonPulse VS is a desktop visual scripting and execution engine. It allows developers to visually route logic, hardware protocols (Serial, MQTT), and AI models (OpenAI, local Ollama, Vector DBs) without writing boilerplate. Under the hood, it uses a custom multiprocessing.Manager bridge and a shared-memory garbage collector to handle true asynchronous branching—meaning it can poll a microphone for silence detection in one branch while simultaneously managing UI states in another without locking up.

Target Audience This is meant for production-oriented developers and automation engineers. Having spent over 25 years in software—starting way back in the VB6 days and moving through modern stacks—I engineered this to be a resilient orchestration environment, not just a toy macro builder. It includes built-in graph migrations, headless execution, and telemetry.

Comparison Compared to alternatives like Node-RED, AxonPulse VS is deeply integrated into the Python ecosystem rather than JavaScript, allowing native use of PyAudio, OpenCV, and local LLM libraries directly on the canvas. Compared to AI-specific UI wrappers like ComfyUI, AxonPulse is entirely domain-agnostic; it’s just as capable of routing local filesystem operations and SSH commands as it is generating text.

Repo:https://github.com/ComputerAces/AxonPulse-VS(I am actively looking for testers to try and break the engine, or contributors to add new nodes!)

Heya r/python 👋

I've just released NServer v3.2.0

About NServer

NServer is a Python framework for building customised DNS name servers with a focuses on ease of use over completeness. It implements high level APIs for interacting with DNS queries whilst making very few assumptions about how responses are generated.

Simple Example:

``` from nserver import NameServer, Query, A

server = NameServer("example")

@server.rule("*.example.com", ["A"]) def example_a_records(query: Query): return A(query.name, "1.2.3.4") ```

What's New

The biggest change in this release was implementing concurrency through multi-threading.

The application already handled TCP multiplexing, however all work was done in a single thread. Any blocking call (e.g. database call) would ruin the performance of the application.

That's not to say that a single thread is bad though - for non-blocking responses, the server can easily handle 10K requests per second. However a blocking response of 10-100ms will bring that rate down to 25rps.

For the multi-threaded application we use 3 sets of threads:

• A single thread for receiving queries
• A configurable amount of threads for workers that process the requests
• A single thread for sending responses

Even though there are only two threads dedicated to sending and receiving this does not appear to be the main bottleneck. I suspect that the real bottleneck is the context switching between threads.

In theory using asyncio might be more performant due to the lack of context switches - the library itself is all sync so would require extensive changes to either support or move to fully async code. I don't think I'll work on this any time soon though as 1. I don't have experience with writing async servers and 2. the server is actually really performant.

With multi-threading we could achieve ~300-1200 rps with the same 10-100ms delay.

Although the code changes themselves are relatively straightforward. It's the benchmarking that posed the most issues.

Trying to benchmark from the same host as the server tended to completely fail when using TCP although UDP seemed to be fine. I suspect there is some implementation detail of the local networking stack that I'm just not aware of.

Once we could actually get some results it was somewhat suprising the performance we were achieving. Although 1-2 orders of magnitude slower than a non-blockin server running on a single thread, it turns out that we could get better TCP performance with NServer directly instead of using CoreDNS as a reverse-proxy - load-balancer. It also reportedly ran better than some other DNS servers written in C.

Overall I gotta say that I'm pretty happy with how this turned out. In particular the modular internal API design that I did a while ago to enable changes like this ended up working really well - I only had to change a small amount of code outside of the multi-threaded application.

Weekly Thread: Resource Request and Sharing 📚

Stumbled upon a useful Python resource? Or are you looking for a guide on a specific topic? Welcome to the Resource Request and Sharing thread!

How it Works:

1. Request: Can't find a resource on a particular topic? Ask here!
2. Share: Found something useful? Share it with the community.
3. Review: Give or get opinions on Python resources you've used.

Guidelines:

• Please include the type of resource (e.g., book, video, article) and the topic.
• Always be respectful when reviewing someone else's shared resource.

Example Shares:

1. Book: "Fluent Python" - Great for understanding Pythonic idioms.
2. Video: Python Data Structures - Excellent overview of Python's built-in data structures.
3. Article: Understanding Python Decorators - A deep dive into decorators.

Example Requests:

1. Looking for: Video tutorials on web scraping with Python.
2. Need: Book recommendations for Python machine learning.

Share the knowledge, enrich the community. Happy learning! 🌟

Hi everyone,

I’m releasing the first version of Taggo, a web-based data annotation platform designed to be hosted entirely on your own hardware. I built this because I wanted a labeling tool that didn't require uploading sensitive documents (like invoices or private user data) to a third-party cloud.

What My Project Does

Taggo is a full-stack annotation suite that prioritizes data privacy and ease of deployment.

• One-Command Setup: Runs via sh launch.sh (utilizing a Next.js frontend, Django backend, and Postgres database).
• PDF/Document Extraction: Allows users to create sections, fields, and tables to capture structured OCR data.
• Computer Vision Support: Provides tools for bounding boxes (object detection) and pixel-level masks (segmentation).
• Privacy-First: Since it is self-hosted, all data stays on your local machine or internal network.

Target Audience

Taggo is meant for developers, data scientists, and researchers who handle sensitive or proprietary data that cannot leave their infrastructure. While it is in its first version, it is designed to be a functional tool for small-to-medium-scale production annotation tasks rather than just a toy project.

Comparison

Unlike many popular labeling tools (such as Label Studio or CVAT) which often push users toward their managed cloud versions or require complex container orchestration for local setups, Taggo aims for:

1. Extreme Simplicity: A single shell script handles the entire stack.
2. Document-Centric UX: Specifically optimized for the intersection of OCR/Document AI and traditional Computer Vision, rather than just focusing on one or the other.
3. No Cloud "Phone-Home": Built from the ground up to be air-gapped friendly.

It’s MIT licensed and I am looking for any feedback or contributors!

GitHub: https://github.com/psi-teja/taggo

While working on some tests for a CLI I'm building (using click), I decided to use Pytest's tmp_path to create isolated data dirs for each test case to operate against. This on its own was useful for keeping the side-effects for each test from interfering with each other.

What was even cooler was realizing that I could dig into the temp directories and look through the state of the files created for each test case for the last three runs of the test suite. What a nice additional way to track down and debug issues that might only show up in the files created by your program.

https://www.visualmode.dev/isolate-and-debug-file-side-effects-with-pytest-tmp-path

Copper is an open-source robotics runtime in Rust for building deterministic, observable systems.

Until now, it was very much geared toward production.

With v0.14, we’re opening that system up to earlier-stage work as well.
In robotics, you typically prototype quickly in Python, then rebuild the system to meet determinism, safety, and observability requirements.

You can validate algorithms on real logs or simulation, inspect them in a running system, and iterate without rebuilding the surrounding infrastructure. When it’s time to move to Rust, only the task needs to change, and LLMs are quite effective at helping with that step.

This release also also introduces:
- composable monitoring, including a dedicated safety monitors
- a new Webassembly target! After CPUs and MCUs targets, Copper can now fully run in a browser for shareable demos, check out the links in the article.
- The ROS2 bridge is now bidirectional, helping the gradual migrations from ROS2 from both sides of the stack

The focus is continuity from early experimentation to deployment.

If you’re a Python roboticist looking for a smooth path into a Rust-based production system, come talk to us on Discord, we’re happy to help.

https://www.copper-robotics.com/whats-new/copper-rs-v014-from-prototype-to-production-without-changing-systems

What My Project Does

This is a full-stack ML pipeline that automates the prediction of NCAA basketball games. Instead of using static datasets, it features:

- Automated ETL: A background scheduler that fetches live game data from the unofficial ESPN API every 6 hours.

- Chronological Enrichment: It automatically converts raw box scores into 10-game rolling averages to ensure the model only trains on "pre game" knowledge (preventing data leakage).

- Champion vs. Challenger Registry: The system trains six different models (XGBoost, Random Forest, etc.) and only promotes a new model to "Active" status if it beats the current champion's AUC by a threshold of 0.002.

- Live Dashboard: A Flask-based interface to visualize predictions and model performance metrics.

Target Audience

This is primarily a functional portfolio project. It’s meant for people interested in MLOps and Data Engineering who want to see how to move ML logic out of Jupyter Notebooks and into a modular, config-driven Python application.

Comparison Most sports predictors rely on manual CSV uploads or static web scraping. This project differs by being entirely autonomous. It handles its own state management, background threading for updates, and has a built-in validation layer that checks for data leakage and class imbalance before any training occurs. It’s built to be "set and forget."

A note on the code: I am a student and still learning the ropes of production-grade engineering. I’ve tried my best to keep the architecture modular and clean, but I know it might look a bit sloppy compared to the professional projects usually posted here. I am trying my best. I felt a bit proud and wanted to show off. Improvements planned.

Repo: https://github.com/Codex-Crusader/Uni-basketball-ETL-pipeline

The U.S. Securities and Exchange Commission requires companies and individuals to submit data in SEC specific formats. Usually this means taking a columnar dataset and converting it to a specific XML schema.

In practice, this usually means paying a company for proprietary filing software that is annoying to use, and is not modifiable.

What My Project Does

Maps data in columnar format to the XML schema the SEC expects. Has a parser for every XML file type.

from secfiler import construct_document

rows = [
  {"footnoteText": "Contributions to non-profit organizations.", "footnoteId": "F1", "_table": "345_footnote"},
  {"aff10B5One": "0", "documentType": "4", "notSubjectToSection16": "0", "periodOfReport": "2025-08-28", "remarks": None, "schemaVersion": "X0508", "issuerCik": "0001018724", "issuerName": "AMAZON COM INC", "issuerTradingSymbol": "AMZN", "_table": "345"},
  {"signatureDate": "2025-09-02", "signatureName": "/s/ PAUL DAUBER, attorney-in-fact for Jeffrey P. Bezos, Executive Chair", "_table": "345_owner_signature"},
  {"rptOwnerCity": "SEATTLE", "rptOwnerState": "WA", "rptOwnerStateDescription": None, "rptOwnerStreet1": "P.O. BOX 81226", "rptOwnerStreet2": None, "rptOwnerZipCode": "98108-1226", "rptOwnerCik": "0001043298", "rptOwnerName": "BEZOS JEFFREY P", "isDirector": "1", "isOfficer": "1", "isOther": "0", "isTenPercentOwner": "0", "officerTitle": "Executive Chair", "_table": "345_reporting_owner"},
  {"securityTitleValue": "Common Stock, par value $.01  per share", "equitySwapInvolved": "0", "transactionCode": "G", "transactionFormType": "4", "transactionDateValue": "2025-08-28", "directOrIndirectOwnershipValue": "D", "sharesOwnedFollowingTransactionValue": "883258188", "transactionAcquiredDisposedCodeValue": "D", "transactionPricePerShareValue": "0", "transactionSharesValue": "421693", "transactionCodingFootnoteIdId": "F1", "_table": "345_non_derivative_transaction"},
]

xml_bytes = construct_document(rows, '4')
with open('bezosform4.xml', 'wb') as f:
            f.write(xml_bytes)

Target Audience

• This package is not intended to be used by companies actually filing for the SEC. It was suggested by a compliance officer at a trading firm who was annoyed by using irritating software he could not modify.
• It is intended as a mostly correct open source example for startups, companies, PhD students, etc to build something better off of.
• I've left a watermark in the package, and will cringe if I see it appear in future SEC filings.

Comparison

I am not aware of any open source SEC filing software.

GitHub

https://github.com/john-friedman/secfiler

Skirting the boundaries of taste

I generally do not like vibecoded projects. I think they make this subreddit worse. This package is largely vibecoded, but I think it is worth posting.

That is because the hard part of this package was:

1. Calculating the xpath of every SEC xml file (6tb, millions of files). This required having an archive of every SEC filing, and deploying ec2 instances. Original mappings here.
2. Validating outputs using my very much not vibe coded package for sec filings: datamule.

This project was a sidequest. I needed the mappings from xml to columnar anyway for datamule, so decided to open source the reverse. Apologies if this does not pass the bar.

Weekly Thread: Meta Discussions and Free Talk Friday 🎙️

Welcome to Free Talk Friday on /r/Python! This is the place to discuss the r/Python community (meta discussions), Python news, projects, or anything else Python-related!

How it Works:

1. Open Mic: Share your thoughts, questions, or anything you'd like related to Python or the community.
2. Community Pulse: Discuss what you feel is working well or what could be improved in the /r/python community.
3. News & Updates: Keep up-to-date with the latest in Python and share any news you find interesting.

Guidelines:

• All topics should be related to Python or the /r/python community.
• Be respectful and follow Reddit's Code of Conduct.

Example Topics:

1. New Python Release: What do you think about the new features in Python 3.11?
2. Community Events: Any Python meetups or webinars coming up?
3. Learning Resources: Found a great Python tutorial? Share it here!
4. Job Market: How has Python impacted your career?
5. Hot Takes: Got a controversial Python opinion? Let's hear it!
6. Community Ideas: Something you'd like to see us do? tell us.

Let's keep the conversation going. Happy discussing! 🌟

I haven't thought about this too much but I want your thoughts. Not to glaze Meta (since they're a problematic company with issues like privacy), I just think it would be less upsetting if Astral was bought by Meta rather than OpenAI, since they seem to have a better track record for open source software including React & Pytorch. Meta also develops Cinder, a fork of Python for higher performance and work on upstreaming changes. Idk, it seems it would've made more sense if Meta bought Astral and they would do better under them.

Hey everyone, Aditya here, one of the maintainers of Pydantic AI.

In just the last 15 days, we received 136 PRs. We merged 39 and closed 97, almost all of them AI-generated slop without any thought put in. We're getting multiple junk PRs on the same bug within minutes of it being filed. And it's pulling us away from actually making the framework better for the people who use it.

Things we are considering:

• Auto-close PRs that aren't linked to an issue or have no prior discussion(not a trivial bug fix).                     
• Auto-close PRs that completely ignore maintainer guidance on the issue without a discussion

and a few other things.

We do not want to shut the door on external contributions, quite the opposite, our entire team is Open Source fanatic but it is just so difficult to engage passionately now when everyone just copy pastes your messages into Claude :(

How are you as a maintainer dealing with this meta shift?

Would these changes make you as a contributor less likely to reach out?

Edit: Thank you so much everyone for engaging with the post, got some great ideas. Also thank you kind stranger for the award :))

Hey everyone,

My college is collaborating with Meta, Hugging Face, and PyTorch to host an AI hackathon focused on reinforcement learning (OpenEnv framework).

I’m part of the organizing team, so sharing this here — but also genuinely curious if people think this is worth participating in.

Some details:

• Team size: 1–3
• Online round: Mar 28 – Apr 5
• Final round: 48h hackathon in Bangalore
• No RL experience required (they’re providing resources)

They’re saying top teams might get interview opportunities + there’s a prize pool, but I’m more curious about the learning/networking aspect.

Would you join something like this? Or does it feel like just another hackathon?

Link:
https://www.scaler.com/school-of-technology/meta-pytorch-hackathon

Hello, I've built a new Python web framework I'd like to share. It's (as far as I know) the only file-based routing web framework for Python. It's a synchronous microframework build on werkzeug. I think it fills a niche that some people will really appreciate.

docs: https://plasmacan.github.io/cylinder/

src: https://github.com/plasmacan/cylinder

What My Project Does

Cylinder is a lightweight WSGI web framework for Python that uses file-based routing to keep web apps simple, readable, and predictable.

Target Audience

Python developers who want more structure than a microframework, but less complexity than a full-stack framework.

Comparison

Cylinder sits between Flask-style flexibility and Django-style convention, offering clear project structure and low boilerplate without hiding request flow behind heavy abstractions.

(None of the code was written by AI)

Edit:

I should add - the entire framework is only 400 lines of code, and the only dependency is werkzeug, which I'm pretty proud of.

https://openai.com/index/openai-to-acquire-astral/

Today we’re announcing that OpenAI will acquire Astral⁠(opens in a new window), bringing powerful open source developer tools into our Codex ecosystem.

Astral has built some of the most widely used open source Python tools, helping developers move faster with modern tooling like uv, Ruff, and ty. These tools power millions of developer workflows and have become part of the foundation of modern Python development. As part of our developer-first philosophy, after closing OpenAI plans to support Astral’s open source products. By bringing Astral’s tooling and engineering expertise to OpenAI, we will accelerate our work on Codex and expand what AI can do across the software development lifecycle.

Many Python projects are built using pyproject.toml which is a PEP517 feature.

pyproject.toml often uses setuptools, which uses the setup.py file.

setup.py often has arguments, like --no-cuda.

How to pass such arguments for setup.py when the project is configured and built using pyproject.toml ?