A quick hands-on intro to Python if you already know Java (or vice versa) https://blog.geekuni.com/2026/02/python-for-java-developers.html submitted by /u/Horror-Willingness74 [link] [comments]

Hi, Pyrefly maintainer here. Today we are pleased to share that Pyrefly, a fast type checker and language server for Python, has reached stable v1.0 status, meaning we are confident that Pyrefly is ready for production use. Pyrefly was first released as an alpha in mid-2025 and followed up with a beta in November of that year. Since then, we have shipped over 60 minor releases: fixing hundreds of bugs, adding the features you’ve been asking for, and improving performance to be one of the fastest tools out there. This would not have been possible without our amazing open-source community. To everyone who filed GitHub issues, submitted pull requests, gave us feedback at conferences, or joined us on Discord: thank you. Your contributions shaped this release, we’re grateful for every one of them, and we hope you continue being a part of the journey for future releases too. We've published a blog post explaining what v1.0 means exactly, and what's next for Pyrefly. Below is a summary of the changes to Pyrefly since the Beta release. The full release notes for v1.0 can be read on our Github. Pyrefly v1.0 Release Notes Performance Improvements We've continued to push Pyrefly's performance since the speed improvements we shared in February. Since beta: 2–125x faster updated diagnostics after saving a file (no, that’s not a typo!). Thanks to fine-grained dependency tracking and streaming diagnostics, updates now consistently arrive in milliseconds 20–36% faster full type checking on large projects like PyTorch and Pandas 2–3x faster initial indexing when Pyrefly first scans your project 40–60% less memory usage during both indexing and incremental type checking (Tested on an M4 Macbook Pro using open-source benchmarks from type_coverage_py and ty_benchmark.) Compare the performance of Pyrefly and other Python type checkers on our regularly updated benchmarking suite, which runs against 53 popular Python packages. Configuration Presets A new preset configuration option provides named bundles of error severities and behavior settings. Preset Description off Silences all diagnostics. Useful for IDE-only users or if you want total control of which errors are enabled. basic Low-noise, high-confidence diagnostics only (syntax errors, missing imports, unknown names, etc.). Ideal for unconfigured projects or IDE-first users. legacy For codebases migrating from mypy. Disables checks mypy doesn't have. pyrefly init now emits this preset automatically when migrating from a mypy config. default The standard Pyrefly experience. Equivalent to having no preset. strict Enables additional strict checks on top of the default preset. For users who want to avoid Any types in their codebase. See the configuration docs for details. Onboarding Experience We’ve made improvements to the out-of-the-box experience for projects without a pyrefly.toml. Automatic config synthesis — if you have a mypy or pyright config, Pyrefly automatically migrates your settings and synthesizes an appropriate in-memory Pyrefly config. (This is the same migration that pyrefly init would commit to disk.) Basic preset for unconfigured projects — projects with no type checker config get the lightweight “basic” preset, which surfaces only high-confidence errors. VS Code status bar — the status bar shows the active preset — e.g. Pyrefly (Basic) or Pyrefly (Legacy) — so you always know which mode is active. Type error display settings — new VS Code settings let you control which preset applies to unconfigured files and suppress all diagnostics workspace-wide. Type Checker Improvements We've been hard at work making the type checker robust and feature-complete, with a focus on driving down false positives and improving type quality in real-world code bases. Here are some highlights: Across the board we've eliminated many sources of false positives in enums, dataclasses, ParamSpec, descriptors, and more. Support has been added for more type narrowing patterns, including preserving narrows in nested scopes and recognizing container membership checks. Overload resolution was substantially reworked to handle more real-world patterns. Pyrefly’s conformance to the Python typing specification has improved from 70% at beta to over 90% today. We've added experimental support for tracking tensor dimensions through PyTorch models — see "What's Next" below. LSP & IDE Improvements We've added new refactoring capabilities like Safe Delete (with reference checking) and bulk source.fixAll. Navigation is more precise, and hover cards surface richer information for imports, tuples, and NamedTuples. Workspace mode is more stable, with multiple crash fixes and improved diagnostic publishing. Framework & Notebook Support Django — Pyrefly has improved support for model relationships, fields, and views, and understands factory_boy factories. Pydantic — Pyrefly models Pydantic's runtime behavior more faithfully, with support for lax mode and range constraint validation, and handles more of the Pydantic ecosystem: RootModel, pydantic-settings, and pydantic.dataclasses. Pytest integration — We've added Code Lens run buttons for test functions, as well as code actions to annotate fixture return types and parameters. Jupyter notebooks — .ipynb IDE support has reached full parity with .py files, with rename, find references, code actions, and document symbols all supported. Complementary Tooling Pyrefly ships with tools to aid with adopting type checking in an existing codebase. Two new tools since beta: pyrefly coverage report outputs a JSON report with annotation completeness and type completeness metrics per function, class, and module, so you can track coverage over time. Baseline files let you snapshot current errors into a JSON file so only new errors are reported, as an alternative to inline suppression comments. Updated Version Policy Going forward, we’ll switch from a weekly to monthly cadence for minor (1.x.0) releases, with patch releases in between as-needed for critical fixes. We’ll continue providing release notes for minor versions, so you can see what’s new in each release. What's Next Tensor shape checking — Experimental support for tracking tensor dimensions through PyTorch models and catching shape mismatches statically. Learn more. Pyrefly + AI agents — Pyrefly's speed makes it a natural verification step in agentic workflows. See our guide on adding Pyrefly to your agentic loop. Continued improvements — We'll keep expanding library support, reducing false positives, and iterating on your feedback. Let us know what you need on Github or Discord. submitted by /u/BeamMeUpBiscotti [link] [comments]

Python LSP server implementation "Pyrefly" has reached v1.0: https://pyrefly.org/blog/v1.0/ submitted by /u/eszlari [link] [comments]

I wrote a long-form guide about building Python applications around a high-volume public API, using Binance as the concrete example. The focus is less on trading and more on the engineering problems: - REST vs WebSocket architecture - reconnect handling - stream lifecycle observability - local cache correctness - order-book synchronization - avoiding hidden stale-state bugs in long-running services Disclosure: I maintain one of the Python libraries discussed in the article, so that perspective is included. The guide also compares python-binance, official Binance connectors, and CCXT. Feedback from Python developers working with WebSockets, APIs, or long-running data services would be useful: https://blog.technopathy.club/the-complete-binance-python-api-guide-2026 submitted by /u/oliver-zehentleitner [link] [comments]

Many developers working with Android automation hit a wall when dealing with input latency. Standard accessibility overlays are too slow. The native solution is injecting events directly into /dev/uinput using Python, but it comes with a major hurdle: Kernel Struct Padding. When using struct.unpack, 64-bit Android kernels expect a 24-byte event struct (llHHi). However, if you run the same Python script on older 32-bit devices (like Android TV Boxes), it expects a 16-byte struct (IIHHi). Failing to handle this dynamically using sys.maxsize causes instant crash errors. I've implemented a full working architecture for this concept into an open-source project called GPad2Mouse. Instead of just mapping keys, it uses Python's fcntl.ioctl to grab exclusive hardware control (EVIOCGRAB), reads VID:PID directly from /sys/class/input/, and dynamically calculates analog deadzones to prevent controller drift—all running as a daemon with 0% CPU overhead. How to study the code? Due to sub rules against dropping external links, I won't post direct links here. But if you want to see the source code implementation or watch the video demonstration of how the kernel injection works in real-time: 👉 Just Google search: GPad2Mouse Has anyone else here worked extensively with fcntl on Android? I’d love to hear your approach on handling sudden device disconnections gracefully without freezing the read loop. Cheers! submitted by /u/Hungry-Advisor-5152 [link] [comments]

[ Removed by Reddit on account of violating the content policy. ] submitted by /u/Fair-Kaleidoscope677 [link] [comments]

Hey everyone, I’ve been learning and working with Python for a while and realized I also want to connect with more people in the community, make friends, collaborate on projects, and just talk tech/programming in general. Most of my learning has been solo, so I thought I’d post here and see if anyone else is interested in networking, building stuff together, sharing ideas, or even just chatting about Python and development. I’m also interested in hearing how you all met people in the programming world because sometimes it feels difficult to find genuine connections online. Would love to connect with fellow Python devs 🙂 submitted by /u/Gentleman-45 [link] [comments]

Weekly Wednesday Thread: Advanced Questions 🐍 Dive deep into Python with our Advanced Questions thread! This space is reserved for questions about more advanced Python topics, frameworks, and best practices. How it Works: Ask Away: Post your advanced Python questions here. Expert Insights: Get answers from experienced developers. Resource Pool: Share or discover tutorials, articles, and tips. Guidelines: This thread is for advanced questions only. Beginner questions are welcome in our Daily Beginner Thread every Thursday. Questions that are not advanced may be removed and redirected to the appropriate thread. Recommended Resources: If you don't receive a response, consider exploring r/LearnPython or join the Python Discord Server for quicker assistance. Example Questions: How can you implement a custom memory allocator in Python? What are the best practices for optimizing Cython code for heavy numerical computations? How do you set up a multi-threaded architecture using Python's Global Interpreter Lock (GIL)? Can you explain the intricacies of metaclasses and how they influence object-oriented design in Python? How would you go about implementing a distributed task queue using Celery and RabbitMQ? What are some advanced use-cases for Python's decorators? How can you achieve real-time data streaming in Python with WebSockets? What are the performance implications of using native Python data structures vs NumPy arrays for large-scale data? Best practices for securing a Flask (or similar) REST API with OAuth 2.0? What are the best practices for using Python in a microservices architecture? (..and more generally, should I even use microservices?) Let's deepen our Python knowledge together. Happy coding! 🌟 submitted by /u/AutoModerator [link] [comments]

I've been building Python services that consume LLM output for the past few years, and I kept accumulating the same pile of regex fixups for broken JSON in every project. Markdown fences, trailing commas, Python booleans inside JSON, truncated objects, unescaped quotes, the usual. Instead of keeping a private junk drawer of string manipulations, I decided to actually study the problem. Ran structured output prompts through 288 model calls across every major provider and catalogued what breaks, how often, and whether the failure modes are consistent across model families. (Spoiler: they are. Weirdly consistent.) Wrote it up here: What Breaks When You Ask an LLM for JSON The article covers: A taxonomy of the 8 most common structured output failures Why the order you apply repairs in matters (this was the part that surprised me most) Why JSON mode helps but doesn't solve the problem What changes when you need to support YAML and TOML alongside JSON The findings eventually turned into a library (outputguard), but the article stands on its own if you just want to understand the failure modes. Curious if other people are seeing the same patterns. submitted by /u/kexxty [link] [comments]

https://sethmlarson.dev/library-version-specifiers-not-for-vulnerabilities A blog post from Seth Larson, the Security-in-Residence Developer for the Python Software Foundation. submitted by /u/AlSweigart [link] [comments]

I’ve been stuck in "data engineering hell" for the last few weeks. I had about 10 years of ES Futures tick data (from 2016 to now) sitting in a mountain of messy CSVs. Total row count: ~2.2 billion. If you’ve ever tried to run a vectorized backtest on CSVs of that size, you know the pain. My I/O was a disaster and I was basically spending more time waiting for files to load than actually doing research. I finally moved everything over to Apache Parquet using Polars, and man, I should have done this sooner. A few things I learned (the hard way): Compression is insane: I went from a massive disk footprint to a 22x reduction. Polars is a beast: I used lazy evaluation to handle the rollover logic across 40+ quarterly contracts. Doing this in Pandas would have probably melted my RAM. The "Rollover" nightmare: The hardest part wasn't the storage, it was getting the front-month transitions right without price gaps. Ensuring the bid/ask volume stayed consistent across 10 years of contract switches was... let's just say, "fun." Now I can query specific contract slices in seconds instead of minutes. It’s a game changer for my workflow. Curious to hear from others working with high-frequency data: are you guys still using HDF5/SQL for this scale, or has everyone moved to the Parquet/DuckDB stack already? submitted by /u/Marchese_QuantLab [link] [comments]

Weekly Thread: Project Ideas 💡 Welcome to our weekly Project Ideas thread! Whether you're a newbie looking for a first project or an expert seeking a new challenge, this is the place for you. How it Works: Suggest a Project: Comment your project idea—be it beginner-friendly or advanced. Build & Share: If you complete a project, reply to the original comment, share your experience, and attach your source code. Explore: Looking for ideas? Check out Al Sweigart's "The Big Book of Small Python Projects" for inspiration. Guidelines: Clearly state the difficulty level. Provide a brief description and, if possible, outline the tech stack. Feel free to link to tutorials or resources that might help. Example Submissions: Project Idea: Chatbot Difficulty: Intermediate Tech Stack: Python, NLP, Flask/FastAPI/Litestar Description: Create a chatbot that can answer FAQs for a website. Resources: Building a Chatbot with Python Project Idea: Weather Dashboard Difficulty: Beginner Tech Stack: HTML, CSS, JavaScript, API Description: Build a dashboard that displays real-time weather information using a weather API. Resources: Weather API Tutorial Project Idea: File Organizer Difficulty: Beginner Tech Stack: Python, File I/O Description: Create a script that organizes files in a directory into sub-folders based on file type. Resources: Automate the Boring Stuff: Organizing Files Let's help each other grow. Happy coding! 🌟 submitted by /u/AutoModerator [link] [comments]

I published repowise on PyPI a few weeks ago. It generates and maintains a wiki for your codebase, plus some git intelligence stuff like hotspots and ownership among other things Soon after launch, three packages appeared on PyPI within hours of each other, all with the same description: "Codebase intelligence that thinks ahead, outperforms repowise on every dimension." Repowise is mine. They literally name it. Looked inside the packages. They forked my AGPL-3.0 code, ran an LLM over it to fix a few small things, and republished under new names. No attribution, no license file, no source link. Filed PyPI abuse reports. Filed a DMCA for the license violation. Sent email. Weeks in, all three packages are still live, still pulling downloads off my project's name. PyPI's abuse flow seems to be a single form and silence. There's no copyleft enforcement path baked into the registry itself, so AGPL violations basically depend on DMCA, which is slow and easy to ignore. Any suggestions would be very helpful submitted by /u/Obvious_Gap_5768 [link] [comments]

In other languages I use map() and filter() through piping and my code usually looks readable as I can clearly see a data-stream transformation. As it is today, users cannot do map() |> filter() |> list(), but they need to do list(filter(map())) which makes things unreadable. Lists of comprehension work fine for very simple use-case becoming unreadable very quickly as complexity increases. However, in python there has always been some resistance, especially 15-20 years ago, but times are evolving. Also, by considering the wide adoption in data-science, it is worth noticing that numbers-crunchers are more familiar with the concept of “data transformation flow” than “function calls”. On the packages dimension , libraries like 🐼s support methods chaining which from an external viewpoint, it’s semantically similar. Do you know if there is any indication that python core team may allow operator piping (and/or chaining) in the not-too-long-term? submitted by /u/Desperate_Cold6274 [link] [comments]

I have been usually building my own db sql layer for every project I start. I dislike ORMs in general, but I do like the model to SQL mapping and nowadays use pydantic for it. But anything outside direct CRUD I prefer raw SQL to keep things simple. Anything like this exists already? I open sourced mine (etchdb), as I didn’t want to repeat myself. How should I start discussion around this without it becoming showcase and demoted? submitted by /u/Varjoranta [link] [comments]

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: Show & Tell: Share your current projects, completed works, or future ideas. Discuss: Get feedback, find collaborators, or just chat about your project. 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: Machine Learning Model: Working on a ML model to predict stock prices. Just cracked a 90% accuracy rate! Web Scraping: Built a script to scrape and analyze news articles. It's helped me understand media bias better. 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! 🌟 submitted by /u/AutoModerator [link] [comments]

Python is increasingly abandoning the "batteries included" philosophy in favor of the NPM model of installing a trillion dependencies for everything - look at the still missing websocket implementation, for instance. Given that, it's losing almost all of its advantages — if you have to deal with a system to automatically download and run recursive dependencies, you might as well use Rust. If you have to write everything yourself, you might as well use C. So, what projects are taking up that role? submitted by /u/keiyakins [link] [comments]

I have tried various pool sizes and NullPool. NullPool is slower but also minimizes db connections. Using a pool is faster but tends to max out my db connections. Is there some magic setting that will give me the speed of pooling without running up my connection count? I am using fluid compute so the functions start warm. My feeling is that if I set a very short recycle time that may be helpful but not sure. submitted by /u/carlinwasright [link] [comments]

Honest question. With all the supply chain attacks recently i've been wondering how many people actually look at what they're pip installing. I check the repo, scan the star count, maybe skim the readme. but reading actual source? almost never unless its a small package. How do you decide what to trust? submitted by /u/xander_abhishekh [link] [comments]

How do people setup integration tests on remote CI? Consider if you have long integration tests that you don’t want to run on every pull request. How would you trigger integration tests as needed? I usually separate both by folders as tests/unit and tests/integration, but have also used pytest.mark.integration with flags denoting such config within pyproject.toml. And i know how to run either of those locally. I am interested on how people trigger this on remote github / bitbucket / gitlab / etc … Any guidance or references of beat practice would be most appreciated. submitted by /u/wildetea [link] [comments]