TheNote
Planet Python Note
GooglePlay AppStore

Planet Python

The website Planet Python is a planet site that aggregates Python-related content from various sources, including blogs, news sites, and other online publications. The website provides a one-stop destination for individuals to stay up-to-date with the latest developments in the Python programming world. The content on the site includes tutorials, news, project announcements, and discussions about various Python-related topics. Users can visit the site to stay informed about the Python community, new releases, conferences, and best practices in using the Python programming language. The website's purpose is to help promote and disseminate Python-related content, thereby contributing to the growth and development of the Python community.
Planet Python planetpython.org
RSS planetpython.org
RSS Hunter RSS Hunter • Aug 19, 2024

Thread Of Notes

LernerPython blog, from Reuven Lerner: Get Python help, one on one: my coaching sessions

The author offers personal coaching sessions to help individuals solve real-world job problems. These sessions typically address issues like stubborn code, architectural uncertainties, or Git-related roadblocks. The author has provided this service for years but is now formally detailing it on a dedicated webpage. During a one-hour session, clients can discuss their specific needs, such as code review, project planning, pair programming, Git questions, or career advice. The sessions are private, ensuring confidentiality of client information and discussions. Participants receive a recording of the session and any shared materials for future reference. Each one-hour Zoom session costs $300 and is not tied to any membership. Clients can book a session directly or email the author to discuss scheduling or suitability. The author is flexible regarding time zones and expresses a willingness to find a mutually convenient time. They are also open to feedback on whether a particular problem is a good fit for a coaching session.
https://lernerpython.com/2026/09/20/get-python-help-one-on-one-my-coaching-sessions/ lernerpython.com
RSS Hunter RSS Hunter • Today

Bob Belderbos: Ship Your First Python App: a Free Course on the Local Dev Workflow

There's a significant gap between learning basic Python syntax and building a functional application. Many Python courses focus on language fundamentals but neglect the essential development workflows needed for real-world projects. This often leaves learners confused about topics like installing Python, using the terminal, package management with pip, virtual environments, project organization, and version control with Git. These skills are crucial for developers to share and deploy their work effectively.To address this, a free, self-paced 6-week course called Ship Your First Python App has been created. The course aims to teach the complete local development workflow from the ground up. Participants will build a small command-line application: a dev journal. Each week introduces new concepts and culminates in a failing test suite that students must resolve.The curriculum covers project setup, data modeling, command-line interfaces, type safety, error handling, code organization, testing, improving output formatting, and measuring test coverage. The final week focuses on preparing the project for sharing, including writing documentation and potentially publishing it to PyPI. This course is designed for individuals who understand basic Python but struggle with the surrounding development processes. It assumes no prior knowledge of CLIs, packaging, or Git, making it accessible to a wider audience. The creator is actively seeking feedback to improve the course's utility and user experience.
https://belderbos.dev/blog/free-python-foundations-course-local-dev-workflow/ belderbos.dev
RSS Hunter RSS Hunter • Yesterday

Django Weblog: Proposed change to DSF voting membership

The organization is proposing a new voting membership status to accurately track active members and ensure election validity. Members who have voted in a Board election within the last two years will be automatically considered active and count towards quorum. Members who have not voted recently will remain members but will not count towards quorum until they explicitly opt-in to vote. This change aims to address the difficulty in reaching quorum as membership grows, a common issue in many nonprofits. Similar to the Python Software Foundation, this new status will simplify quorum calculations. Membership status will not be lost, and members will still be listed on the website. Active status specifically impacts quorum calculations, not general membership. The organization plans to send election reminders and post updates to ensure members are informed. To vote, individuals should contact the organization before an election opens to be added to the active roll. Feedback on this proposed bylaw change is requested by October 7, 2026, via GitHub or the members-only forum. The Board will review all comments before a potential vote on October 8th.
https://www.djangoproject.com/weblog/2026/sep/18/proposed-change-to-dsf-voting-membership/ djangoproject.com
RSS Hunter RSS Hunter • Sep 18

PyPy: PyPy v8.0.0 release

PyPy has released version 8.0.0, marking a significant update. This release includes support for Python 2.7, Python 3.11, and a beta version of Python 3.12. The Linux buildbots have been updated to use manylinux_2_28 images, now requiring glibc2.28. A major development is PyPy's new C layer model that aims for compatibility with CPython's limited ABI for wheels. This update hides PyPy-specific extensions in C extension modules, aligning PyPy's C headers with CPython's when using the limited API. While the import machinery and ecosystem tools still need to fully recognize abi3.so objects, efforts are underway with Cython and PyO3 to ensure seamless integration. RPython code generation has seen improvements, including computed gotos and more aggressive inlining, though performance gains are modest. The internal HPy backend has been dropped as it did not gain sufficient support. A revived tool, pyhdrdump, is available to compare PyPy and CPython header files. The release offers three interpreters: PyPy2.7, PyPy3.11 (which will be the last for this version), and PyPy3.12 beta. PyPy is a fast, drop-in replacement for CPython, utilizing a tracing JIT compiler. Binary builds are available for various common architectures, with support for more platforms provided by downstream packagers.
https://www.pypy.org/posts/2026/09/pypy-v800-release.html pypy.org
RSS Hunter RSS Hunter • Sep 18

ListenData: AutoGPT : Everything You Need To Know

This post provides a detailed explanation of Auto-GPT. By the end, readers will understand its functionality and learn how to install and run it. Auto-GPT has achieved considerable media attention, becoming a prominent topic after ChatGPT. Its capabilities have attracted interest from both AI professionals and individuals from other fields. Various media outlets have reported on its potential to automate tasks of varying complexity. Auto-GPT is an experimental, open-source project utilizing the GPT-4 model. It extends beyond ChatGPT's capabilities by performing web searches for information gathering. Similar to how human analysts complete projects, Auto-GPT autonomously executes all necessary tasks to meet project objectives. For instance, if tasked with market research on headphones, it would independently search the internet. It would then present the findings in a well-organized and structured format.
https://www.listendata.com/2023/04/autogpt-explained-everything-you-need.html listendata.com
CdXz5zHNQW_75zBjmNvqH.png
RSS Hunter RSS Hunter • Sep 18

Graham Dumpleton: Writing a workshop for JupyterLab

This text describes the creation of a JupyterLab workshop focused on teaching pytest. The workshop is designed to be small enough to fit within a blog post but contains all essential elements of a real workshop. It includes a manifest, multiple pages, interactive actions, automatic checks, a quiz, and supporting tools. The workshop teaches the fundamental pytest loop: writing a test, observing its failure, and then fixing the code. This iterative process is structured across four distinct pages within the workshop. A key feature is the creation of an isolated Python environment for the workshop, ensuring pytest is installed without affecting the learner's system. This approach leverages content lessons from a previous conference talk to enhance the learning experience. The process begins with planning and defining verifiable steps, distinguishing workshops from tutorials. The workshop is generated using the jupyter workshop init command, which sets up the directory structure and a manifest file. Capabilities like terminal access, file writing, code execution, and package installation are declared in the manifest, and are verified by linters. The environment field in the manifest specifies dependencies, such as pytest, which are installed into a self-contained virtual environment. This avoids manual environment setup, allowing learners to focus on pytest itself. The env entry in the manifest also disables Python bytecode caching to prevent issues with rapid file modifications. The workshop utilizes a files/orders.py file containing a deliberately buggy function for learners to debug. Each page in the workshop uses Markdown and specific action blocks to guide the learner through tasks like opening files, writing code, and running commands. Checks are implemented using the verify action, which automatically validates the outcome of learner actions, ensuring progress and learning. A quiz action is included to prompt learners to predict outcomes before running tests, reinforcing understanding of how pytest behaves. The editor-insert action allows new code, like tests, to be added and viewed directly in the editor. The workshop's structure and content are designed to be interactive and educational, focusing on practical application of pytest.
https://grahamdumpleton.me/posts/2026/09/writing-a-workshop-for-jupyterlab/ grahamdumpleton.me
CdXz5zHNQW_hkEwNEOUhk.png
RSS Hunter RSS Hunter • Sep 18

Bob Belderbos: Protocol or ABC? Designing a pluggable provider interface

The author was designing a shared contract for a CLI tool interacting with two different image-generation backends. The goal was to allow the CLI to use a generic submit(request) function, with each backend translating it into its own SDK calls. Initially, the author considered using abstract base classes (ABCs) as a shared interface due to their enforcement of abstract methods. However, ABCs require inheritance, which creates coupling for third-party pluggable backends.Typing.Protocol emerged as a better fit because it uses structural typing. A class satisfies a Protocol by having the correct methods with the right signatures, without requiring explicit inheritance. This approach decouples outside implementers from the core package, allowing providers to evolve independently. Protocols promote a composition-based design, where a provider is passed as a value rather than being part of a strict hierarchy.While Protocols are ideal for describing plugin boundaries, ABCs are more suitable when providers need to share concrete behavior or implementation logic. An ABC can define shared methods and enforce abstract methods that concrete subclasses must implement. It's also possible to use both: a Protocol for the public plugin boundary and an internal ABC for shared behavior among providers.The author recommends defaulting to Protocol for its lighter contract, switching to ABC only when shared implementation is necessary or when runtime enforcement of abstract methods is desired. For plugin ecosystems, "conform by shape" (Protocol) is often preferable to "conform by inheritance" (ABC). The choice depends on whether the primary need is to define a shape or to share concrete behavior and enforce a hierarchy.
https://belderbos.dev/blog/protocol-vs-abc-provider-interface/ belderbos.dev
RSS Hunter RSS Hunter • Sep 18

Python Software Foundation: Announcing the 2026 PSF Board Election Results!

The 2026 PSF Board election fostered important discussions about the organization's role in supporting the global Python community. The PSF expresses gratitude to all candidates for their willingness to serve and to the community for their passionate engagement and voting participation. Congratulations are extended to the newly elected Board members: Elaine Wong, Laís Carvalho, Ee Durbin, and Georgi Ker, with the returning member also acknowledged. Outgoing Board members Cheuk Ting Ho, Chris Neugebauer, and Denny Perez are thanked for their significant contributions and leadership in shaping the PSF's strategic vision. The election successfully reached quorum with 670 ballots cast, demonstrating strong community involvement. Special thanks are given to those who promoted the election, including Board Member KwonHan Bae, and to the PSF staff and Board members who worked to enhance the election process. Detailed election results are available on the PSF website until November 10, 2026. The PSF Election team will conduct a retrospective to gather feedback and improve future election processes. The organization encourages continued community feedback on the election process via discuss.python.org or email. With at least three Board seats opening again next year, interested individuals are invited to learn more and consider running.
https://pyfound.blogspot.com/2026/09/announcing-2026-psf-board-election.html pyfound.blogspot.com
CdXz5zHNQW_cy1larHnBn.png
RSS Hunter RSS Hunter • Sep 17

Python Software Foundation: Announcing the 2026 Python Packaging Council Election Results!

The first Python Packaging Council (PPC) election has successfully concluded with significant community engagement. Seventeen candidates vied for five inaugural council seats. The community actively participated through AMA discussions and reviewing candidates. A total of 541 ballots were cast in this election. Congratulations are extended to the five elected members: Brett Cannon and Pradyun Gedam for two-year terms (Cohort A), and Donald Stufft, Henry Schreiner, and Ralf Gommers for one-year terms (Cohort B). The election structure designates the top two vote-getters to Cohort A with longer terms, while the next three form Cohort B with shorter terms. This staggered approach ensures approximately half of the PPC seats will be up for election in alternating years for two-year terms. Appreciation is also extended to all candidates, voters, and those involved in the PEP 772 discussions and election process. Special thanks were given to Barry Warsaw and Pradyun Gedam as community liaisons and PSF staff and board members. The newly elected members will soon begin onboarding.
https://pyfound.blogspot.com/2026/09/announcing-2026-python-packaging.html pyfound.blogspot.com
CdXz5zHNQW_vTLavQQ1oQ.png
RSS Hunter RSS Hunter • Sep 17

Graham Dumpleton: Introducing jupyterlab-workshop

The author developed jupyterlab-workshop, a JupyterLab extension, to address limitations in using plain Jupyter notebooks for educational workshops. This extension separates instructions from the actual work to be done by the learner. Instructions are presented in a sidebar panel, with each step being an actionable item within the JupyterLab environment. These actions can include running terminal commands, modifying files, creating notebooks, and executing code. The workshop can also verify learner progress and enforce task completion before allowing them to proceed.Unlike notebooks where learners might passively watch code execute, this extension ensures active participation as actions are performed in real-time. It overcomes the constraint of notebooks being limited to a single language by enabling interaction with the broader JupyterLab environment and external tools. This separation prevents the conflation of instructional content and completed work, offering a clearer learning path. The sidebar panel provides navigation, progress tracking, and details of performed actions.Each executable step is not simulated; clicking an action executes it in a live terminal or performs the designated task. The extension supports various actions, including terminal operations, file management, notebook interaction, and interface manipulation. Workshops can even be designed to arrange the user interface for optimal learning at specific points. Checkpoints allow learners to save their progress and revert to a known state if errors occur.The extension includes a robust verification system, allowing for checks through Python code, shell commands, or file-based predicates. Quizzes can also be integrated, with answers feeding into subsequent steps. The manifest file dictates whether task completion is advisory or mandatory. Security is addressed through a trust mechanism where learners grant specific capabilities to workshops before execution.A workshop itself is structured as a directory containing a manifest file, Markdown files for pages, and any necessary starter files. This plain-text structure facilitates version control. Pages are written in MyST Markdown, with actions defined in fenced code blocks. The extension can be installed locally or used via services like mybinder.org and GitHub Codespaces, allowing workshops to run in various environments without complex setup. The author chose not to use their previous platform, Educates, because it required Kubernetes, limiting its accessibility for smaller teams and individuals.
https://grahamdumpleton.me/posts/2026/09/introducing-jupyterlab-workshop/ grahamdumpleton.me
CdXz5zHNQW_ghHpRchT3T.png
RSS Hunter RSS Hunter • Sep 17

Bob Belderbos: Why Rust makes you import a trait to use its methods

A new Rust student encountered an error when trying to call read_to_string on a File object. The compiler indicated that no such method existed. The solution involved adding use std::io::Read; at the beginning of the file. This import confused the student, who expected std::io::File to be imported if file operations were intended.The core of the confusion lies in Rust's trait system. The read_to_string method is not an inherent method of the File type itself. Instead, it's defined by the Read trait, which File implements. Importing the Read trait makes its methods available for method lookup by the Rust compiler.This mechanism differs significantly from Python, where method availability is typically tied directly to the object's type. In Rust, traits provide a way to define shared behavior across different types, promoting polymorphism and code reuse. For instance, File, TcpStream, and Stdin all implement the Read trait, allowing them to offer similar reading functionalities.Therefore, use std::io::Read; isn't about directly using a function but about bringing the Read interface into scope. This allows the compiler to consider the Read trait when resolving method calls on types that implement it. Understanding traits is crucial for comprehending why certain seemingly unrelated imports are necessary for method functionality in Rust. This approach avoids code duplication and enables generic programming. The compiler's error message, "trait Read is implemented but not in scope," directly points to this trait resolution issue.
https://belderbos.dev/blog/rust-import-traits-to-use-methods/ belderbos.dev
RSS Hunter RSS Hunter • Sep 17

Ned Batchelder: Silence is golden lightning talk

The lightning talk "Silence is Golden" advocates for incorporating quiet time into discussions to encourage participation from hesitant speakers. The presenter, who readily speaks, acknowledges the personal challenge of holding back to create space for others. This idea was inspired by observing a group discussion where a dominant speaker prevented others from contributing. The talk suggests applying the "Pac-Man Rule," usually about physical space, to the concept of conversational time. The core message emphasizes the difficulty yet importance of being quiet in certain situations. By creating pauses, the goal is to foster a more inclusive environment where diverse voices can emerge. This approach aims to improve group dynamics and ensure all members have an opportunity to share their thoughts. The presenter hopes the message is received constructively, not preachy, as it's a reminder to themselves as well. Ultimately, intentional silence can lead to richer and more balanced contributions from everyone involved.
https://nedbatchelder.com/blog/202609/silence_is_golden_lightning_talk nedbatchelder.com
RSS Hunter RSS Hunter • Sep 16

Talk Python to Me: #563: Getting Started with Rust as Python Devs

The CPython codebase can be linted from scratch in just 0.3 seconds using Ruff, a tool written in Rust. Rust is increasingly being adopted within the Python ecosystem, appearing in popular tools like Pydantic, Polars, uv, and Granian. This integration of Rust with Python serves three main purposes: standalone tools, libraries imported by Python, and servers that embed Python interpreters. The focus is on making Rust accessible to Python developers, not requiring deep Rust expertise. Christopher Trudeau discusses this trend and his new course, "Up and Running with Rust." A fundamental difference between Python and Rust is memory management, where Python relies on garbage collection, while Rust enforces strict ownership rules at compile time. This talk explores how Rust is being leveraged to enhance Python development. It also mentions various sponsored products and resources for learning more about Rust and its applications. The episode provides extensive links to relevant projects, documentation, and related content. The discussion highlights the growing synergy between the Rust and Python communities.
https://talkpython.fm/episodes/show/563/getting-started-with-rust-as-python-devs talkpython.fm
RSS Hunter RSS Hunter • Sep 16

Django Weblog: Executive Director Search Extended to September 22

The Django Software Foundation has extended the application deadline for its first Executive Director position. Applications will now be accepted until the end of Tuesday, September 22, 2026, anywhere on Earth. This extension was granted to allow more time for interested candidates to submit their applications. Those who have already applied will not experience any delays in the review process. The Executive Director will be crucial in developing the DSF's capacity and ensuring a sustainable future for the Django project. Key responsibilities include leading fundraising and partnerships, supporting operations, and collaborating with stakeholders. The ideal candidate will be an experienced nonprofit leader skilled in fundraising, relationship-building, and organizational leadership. Prior expertise in Django or Python is not required, but experience with open-source or community-driven organizations is beneficial. The foundation seeks an individual comfortable with a broad role and adept at building initiatives. Strong communication and leadership skills are essential for making the case for Django to potential funders. Anyone who believes they or someone they know would be a strong fit is encouraged to apply or share the opportunity. The full job description and application details are available online. The DSF is eager to find a leader to shape its future.
https://www.djangoproject.com/weblog/2026/sep/16/executive-director-search-extended/ djangoproject.com
RSS Hunter RSS Hunter • Sep 16

Speed Matters: fastlogging-rs

fastlogging-rs is a high-performance, Rust-powered logging framework designed to address logging bottlenecks in applications. It offers significant speed improvements, with file writing up to 147 times faster than Python's built-in logging and 9 times faster than Apache Log4j. The framework provides a non-blocking, asynchronous architecture where writers operate in background threads, preventing slowdowns in the main application. It supports eight programming languages (Rust, Python, C, C++, Go, Java, C#) through thin wrappers, all sharing a similar API for consistent logging across diverse tech stacks. Key features include optional file rotation, compression, AES encryption for network logging, and configuration via API or file. fastlogging-rs also automatically forwards log messages from subprocesses to the main process. This initial release, 0.8.1, includes the Rust core and bindings for the supported languages. Installation is straightforward using package managers like cargo for Rust or pip for Python. The project is open-source, licensed under MIT or Apache-2.0, with source code and documentation available on GitHub. Benchmarks demonstrate its superior performance in both standard and rotating file logging scenarios. fastlogging-rs aims to provide substantial performance benefits with minimal code changes, making migration from existing logging frameworks easy.
https://brmmm3.github.io/posts/2026/09/16/fastlogging-rs/ brmmm3.github.io
RSS Hunter RSS Hunter • Sep 16

PyCoder’s Weekly: Issue #752: Dict Performance, Hypothesis, Lazy Imports, and More (2026-09-15)

This issue of PyCoder's Weekly covers a range of Python topics, from performance to testing and new features. It highlights that sets and dictionaries can have quadratic-time performance, not always O(1). Property-based testing with Hypothesis is promoted as an alternative to edge case testing. A sponsored advertisement introduces ScrapingBee for efficient web scraping. Python 3.15's preview of lazy imports is explained, promising faster application startup times. A call for volunteers is issued for the Django Fundraising Working Group. An incident report from PyPI regarding file hosting errors is mentioned. Nifty Django features like Q() objects for dynamic filtering are explored. A profile on Python creator Guido van Rossum is featured. The article "Making a Python Interpreter in 1024 Bytes" showcases code golfing. Deoptimizing attribute access by reading __dict__ is also discussed. Tips for an effective Python development environment are provided. Analysis of remote Python data job trends reveals shrinking boards and increased remote work. Python timer functions and building a reusable Timer class are taught. Prototyping a new CLI for Wagtail is detailed. NumPy's ufuncs and their internals are presented. Several new projects and code repositories are listed, including django-ox and Plotext. Finally, upcoming Python events are announced, such as PyCon Cameroon and various meetups.
https://pycoders.com/issues/752 pycoders.com
CdXz5zHNQW_hpByPwlbht.png
RSS Hunter RSS Hunter • Sep 15

Python Bytes: #496 A lake house in Seattle

This episode discusses several key topics in the Python ecosystem. One significant point is the argument that Pandas should go extinct, as faster, more memory-efficient alternatives like Polars and DuckDB are better suited for most "medium data" workloads. Pydantic-pint is introduced as a library that integrates real-world units into Pydantic models, enhancing data validation for physical quantities. The technical aspect of how Rust libraries run within Python using PyO3 is explained, highlighting the process of building and integrating Rust code for performance. A major acquisition in the data space is covered: AWS has acquired DuckLabs, the company behind DuckDB, raising questions about the future of the DuckDB ecosystem and potential competition with existing services. The show also touches upon Astral's uv releasing code-signed binaries and a documentary about the rise of VS Code. Finally, a joke about being "agentic" is shared.
https://pythonbytes.fm/episodes/show/496/a-lake-house-in-seattle pythonbytes.fm
RSS Hunter RSS Hunter • Sep 15

Django Weblog: DjangoCon Europe 2027 is heading to Innsbruck, Austria! 🏔️⛷️🚠🇦🇹

DjangoCon Europe 2027 will be held in Innsbruck, Austria, from February 17-21, 2027. This annual event gathers the Django community for learning and sharing. It is organized by volunteers and is a significant date in the Django calendar. Developers, contributors, and newcomers from around the world attend to exchange knowledge and shape Django's future. The Call for Proposals is currently open, encouraging submissions of all kinds. Tickets for the conference are also available for purchase now. Attendees can anticipate five days of learning, networking, and engaging with the Django community. The conference relies on volunteers to ensure a successful event. Sponsorship opportunities are available for those wishing to support the conference financially and gain visibility. More information and updates will be shared on the official DjangoCon Europe 2027 website.
https://www.djangoproject.com/weblog/2026/sep/15/djangocon-europe-2027-is-heading-to-innsbruck/ djangoproject.com
CdXz5zHNQW_erSw25awoZ.jpeg
RSS Hunter RSS Hunter • Sep 15

Python Software Foundation: Announcing the PSF Strategic Plan 2026

The Python Software Foundation (PSF) has officially adopted its Strategic Plan 2026, covering the years 2026 to 2031. This plan was developed through a collaborative process, with initial goals shared in May and a full draft opened for community feedback in June. The feedback received significantly shaped the final plan, leading to the inclusion of new objectives for security and vulnerability management. Community input also influenced the plan's focus on translation, localization, clearer funding pathways for companies, and growing PSF membership value. A dedicated webpage will serve as the permanent home for the plan, detailing priority setting and feedback mechanisms. To ensure the plan remains relevant, the PSF Board has established an annual review process. This review will assess progress, evaluate priority shifts, and incorporate ongoing feedback from staff and the community. Implementation of the strategic plan has already begun, with the 2026 Grants Program Funding Round being the first initiative aligned with its direction. The PSF is also working with an external accounting firm to provide updated financial information. The community can provide feedback year-round at [email protected] and during monthly PSF Board Office Hours on Discord.
https://pyfound.blogspot.com/2026/09/announcing-psf-strategic-plan-2026.html pyfound.blogspot.com
RSS Hunter RSS Hunter • Sep 15

LernerPython blog, from Reuven Lerner: Python in operator: How __contains__ speeds up membership tests

How does the “in” operator work in Python?– If an object defines __contains__, then its (boolean) result is returned (coerced to bool). – If not, then Python iterates over it with __iter__Can you find and return a result faster than __iter__? Then define __contains__.
https://lernerpython.com/2026/09/14/python-in-operator-how-contains-speeds-up-membership-tests/ lernerpython.com
CdXz5zHNQW_1TjEsZIQkt.png
RSS Hunter RSS Hunter • Sep 14

Graham Dumpleton: Hands-on learning in the age of AI

The speaker discusses the relevance of developer workshops in the age of AI, noting that AI excels at providing step-by-step guides and tutorials. However, the core value of workshops lies in active learning through doing, where mistakes have consequences and require problem-solving. This hands-on struggle deepens understanding in ways passive reading or AI-generated explanations cannot replicate. Furthermore, workshops expose learners to issues they might not have anticipated, a crucial aspect for real-world development.The effectiveness of workshops depends on overcoming common pitfalls: environmental setup issues, overly large steps, insufficient explanation of "why," and inadequate verification. The speaker advocates for hosted environments that standardize the starting point for all participants, enabling better support and more complex learning scenarios. While AI can assist in drafting workshop content, it falters in understanding the human learning process. AI optimizes for correctness, not teachability, and cannot anticipate learner confusion.The critical step in workshop creation is testing with real people, as AI-generated material often reads well but fails in practice. The pressure from AI is most acutely felt in voluntary learning scenarios driven by curiosity, as AI can satisfy that curiosity more efficiently and at no cost. However, workshops with a clear business driver, like sales demos or customer training, remain highly relevant. Ultimately, workshops are about fostering a learning rhythm that AI cannot fully replicate.
https://grahamdumpleton.me/posts/2026/09/hands-on-learning-in-the-age-of-ai/ grahamdumpleton.me
RSS Hunter RSS Hunter • Sep 14

Wingware: Wing Python IDE Version 12.0.3 - September 14, 2026

Wing Python IDE has released version 12.0.3, introducing significant enhancements. This update includes support for Python 3.15 and improved source code analysis for modern type hints. Auto-completion in large Python environments has been substantially sped up, even with auto-imports enabled. Wing 12 deeply integrates the Claude Code AI coding agent, featuring a new Claude Code tool and a Tasks tool for managing AI workflows. It also provides MCP servers that grant the AI agent access to Wing's powerful debugging, testing, and code analysis features. New AI-driven FIX features can automatically resolve debugger bugs and failing unit tests, while Write Tests prompts the agent to generate unit tests. AI Code Actions allow users to explain, review, fix, and optimize code with AI assistance. The IDE now features a pseudo-terminal for ANSI terminal emulation in its OS Commands and Debug I/O tools. Workspace flexibility is enhanced with tools now placeable in editor splits, and the Tools menu has been reorganized for better usability. Wing 12 simplifies its product line into Wing Pro with AI agent tools and Wing Classic for traditional development, with Wing Personal discontinued.
https://wingware.com/news/2026-09-14 wingware.com
CdXz5zHNQW_dlloi3F9Xk.png
RSS Hunter RSS Hunter • Sep 14

Armin Ronacher: Interpreting Pangram

An AI detector called Pangram flagged a David Sacks tweet as AI-generated, which Sacks disputed, calling AI detectors bogus. Pangram has a low false positive rate, yet LLM writing assistants often incorrectly identify human text as AI. Pangram works by training on human text and then having an LLM rewrite or edit it, learning to identify AI's writing patterns. The author prompted an LLM, Opus 5, to generate a tweet in David Sacks' style about "Pacing the Frontier," based on existing posts from Dario and Sam Altman. The generated tweet argued that OpenAI and Anthropic, holding a duopoly, should pace the frontier as it benefits them commercially and strategically. The tweet also dismissed claims that open-weight models are the primary danger and criticized the proposed regulatory approach. Pangram evaluated this generated tweet as 100% AI. The author then rewrote the tweet manually, maintaining its structure and ideas, aiming for a human rating from Pangram. Despite significant rewording and eliminating copied sentences, this human-rewritten text also received a 100% AI rating from Pangram. The author notes that relying on an LLM for initial structure can lead to poor AI detection scores even after extensive editing. The author appreciates Pangram for raising awareness about the effects of using LLMs and the increasing reliance on them for writing. However, the author questions whether a 100% AI rating is fair for text that has undergone substantial human editing.
https://lucumr.pocoo.org/2026/9/14/interpreting-pangram/ lucumr.pocoo.org
RSS Hunter RSS Hunter • Sep 14

Bob Belderbos: How Libraries Run Rust Inside Python (with PyO3)

Pydantic v2's data validation relies on a Rust extension called pydantic-core, built using PyO3. This post demonstrates how to create a custom JSON parser in Rust and expose it to Python. The process involves writing a Rust module, annotating it with PyO3 macros, and using maturin to compile and install it. The core of the example is a Rust enum that represents a JSON tree structure. Exposing a function to Python requires specific PyO3 annotations and types like Python and Bound. The most significant aspect is the conversion of Rust data structures back into Python objects. This "return trip" involves creating numerous Python objects, which can be more costly than the parsing itself for large JSON documents. This conversion is handled by implementing the IntoPyObject trait. Errors also need to be translated; Rust errors are converted into Python exceptions using the From trait. For scalar return values, the cost of crossing the boundary is negligible. However, for large structures, the conversion cost is substantial and can dominate performance. Optimizing this boundary conversion, potentially by returning lazy views, is crucial for successful Rust-to-Python ports. Profiling the boundary between Rust and Python is therefore essential.
https://belderbos.dev/blog/how-libraries-run-rust-inside-python/ belderbos.dev
CdXz5zHNQW_y8hcnXdNTs.png
RSS Hunter RSS Hunter • Sep 13

Graham Dumpleton: Trying out wrapture

Wrapture has reached version 1.0.0b1, moving from alpha to beta status, signaling API stability. The project now seeks user feedback on real-world applications to inform future development. Specific attention is requested for the OpenTelemetry export, ensuring attribute mapping adheres to conventions. Companion instrumentation packages are also at the beta stage. A core instrumentation package covers in-process targets, while separate packages exist for external services like databases and AWS. These separate packages contain their own release cadences. The project plans further instrumentation for Redis, MongoDB, and potentially LangChain. A series of blog posts detail wrapture's use in unit testing and application tracing. Interactive workshops are available via GitHub for hands-on learning, runnable directly in a browser on mybinder.org or locally. These workshops allow users to learn wrapture concepts by doing. The author acknowledges that Simon Willison's prior summary post has already increased visibility for wrapture. The current post aims to consolidate all relevant links, package information, and workshop resources in one location. A new feature, jupyterlab-workshop, allows interactive workshops to be run within JupyterLab.
https://grahamdumpleton.me/posts/2026/09/trying-out-wrapture/ grahamdumpleton.me
RSS Hunter RSS Hunter • Sep 12

Mike C. Fletcher: Hardware Accelerated Video Capture for PyOpenGL

The pyopengl-video library is a small hack that lets you pass FrameBufferObjects (FBOs) directly to the local platform video encoding library (or allows you to use your existing video buffer as an FBO, depending on the platform). The purpose of the library is to allow an off-screen renderer to generate h264 in mp4 video previews of that off-screen rendering. I find that useful to allow an agent to capture e.g. gameplay demos or the like so that you can see what it is working on while you are not at your desk.On Linux with nVidia uses NVENC. For linux with Intel or AMD uses vaapi. Windows uses D3D11 and COM. Requires PyOpenGL 4.0.0a5 or above. So far no OS-X solution.
http://blog.vrplumber.com/b/2026/09/11/hardware-accelerated-video-capture-for-pyopengl/ blog.vrplumber.com
RSS Hunter RSS Hunter • Sep 12

Armin Ronacher: P(doom)

The idea that AI will cause humanity's extinction has recently gained traction. Some AI leaders, like Dario Amodei, estimate a significant probability of such an event. Amodei's post about pacing AI development has sparked discussion among prominent figures. However, the author disagrees with the premise, despite sharing many concerns.The author defines "doom" not as extinction, but as persistent nuisances like botnets, where AI systems become difficult to control. They acknowledge that current AI systems are annoying but can be shut down, unlike potential future advanced agents. The author worries about the impact of AI on individuals outside of major AI labs, rather than existential threats like AI-controlled weapons.The concept of "pacing" AI development is seen as problematic, especially since only a few American companies are leading this race. These companies benefited from public data and resources and now propose third-party evaluation systems tied to them. The author criticizes the idea that only these corporations should control powerful AI, especially considering their geopolitical motivations.Open-weight models, the author argues, would inherently pace AI development through widespread accessibility, similar to nuclear proliferation. The current situation, where the public supports AI development but buys back its benefits from a few labs, is seen as a flawed economic and geopolitical model. While open-source projects are strained by AI companies, Chinese labs are seen as crucial for diffusing capabilities and leveling the playing field.The author points to a regulatory failure, with existing laws being ignored and data being used without consent. The emergent token economy for AI services is likened to a drug market, lacking transparency. Ideally, AI development should have benefited the public commons, with regulations mandating support for distillation of knowledge.Ultimately, the author does not foresee an AI extinction event, believing that large labs would have more to lose. Instead, the primary concern is the widespread damage AI could cause to various industries, making them more expensive. This new "tax" on innovation, evident in software engineering, is expected to spread to other fields as well.
https://lucumr.pocoo.org/2026/9/12/pdoom/ lucumr.pocoo.org
RSS Hunter RSS Hunter • Sep 12

LernerPython blog, from Reuven Lerner: Newsprint: Turning e-mail newsletters into a personal PDF

The author enjoys reading email newsletters for their informative and thought-provoking content, but lacks time during the week and prefers not to use a computer on Saturdays. To address this, a system was developed where newsletters are automatically moved to a "toprint" folder, with favorite ones starred. On Friday afternoons, starred newsletters and selected unstarred ones are printed, often double-sided and four pages per sheet, for Saturday morning reading. This manual process, however, generated significant paper waste and involved tedious stripping of unwanted content and images. Frustrated by the inefficiency, the author created "newsprint," a Python package to automate this task. Newsprint processes starred newsletters, creating a PDF with promotional content and unnecessary images removed. It intelligently handles images and adds footers with newsletter and page information. The package can also generate a table of contents and, using a Claude API key, provide overall newsletter summaries and personalized insights. Users can select unstarred newsletters to include, customize paper size and orientation, and manage processed newsletters. Newsprint has already reduced the author's paper usage and enhanced their reading experience.
https://lernerpython.com/2026/09/11/newsprint-turning-e-mail-newsletters-into-a-personal-pdf/ lernerpython.com
RSS Hunter RSS Hunter • Sep 11

Graham Dumpleton: OpenTelemetry export in wrapture

Wrapture now integrates OpenTelemetry as a first-class destination for tracing data. The wrapture.otel subpackage, included with every installation, enables seamless export to tracing backends. By adding an [otel] table to the configuration, users can enable tracing, specify a service name, and tune individual signal settings. This configuration allows for detailed introspection into application behavior, including errors and request details.OpenTelemetry environment variables dictate where tracing data is sent, with console exporters available for immediate debugging. Each application event is translated into a span, forming a hierarchical trace. For instance, a Flask request becomes a server span, with internal calls creating nested spans. Error conditions, like a KeyError, are accurately captured with status codes and exception details.The instrumentation automatically captures arguments and other annotated data as span attributes, with sensitive information like credit card numbers being redacted. This ensures that errors are fully documented, appearing on both the specific operation and the parent request span. Distributed tracing across multiple processes is achieved through W3C trace context propagation.Wrapture injects trace context headers into outgoing requests, which are then parsed by the receiving service's middleware. This allows traces to span across different services, maintaining a consistent trace ID. Even when OpenTelemetry export is enabled, wrapture preserves its own minted trace IDs, ensuring continuity.Metrics are also generated from the same traced events, providing aggregated insights without requiring explicit instrumentation code changes. Request durations and call durations are automatically collected and attributed by relevant information like HTTP methods, routes, and status codes. These metrics offer valuable performance and error rate information.The overhead of using wrapture with OpenTelemetry is comparable to direct OpenTelemetry SDK usage. Wrapture optimizes span processing by building finished spans directly, bypassing some of the SDK's internal overhead. This results in lower costs, especially for operations that raise exceptions.The core principle behind wrapture's design remains consistent: correctly observing real-time calls for both testing and production tracing. Whether feeding a testing tape or a tracing backend, the underlying mechanism remains the same. The OpenTelemetry export page provides further details on advanced features like sampling and log signal integration.
https://grahamdumpleton.me/posts/2026/09/opentelemetry-export-in-wrapture/ grahamdumpleton.me
RSS Hunter RSS Hunter • Sep 11

Bob Belderbos: Why Learn to Code If AI Can Code? 6 Reasons

Stanford's Code in Place saw enrollment double after AI coding tools emerged, indicating increased interest in learning to program. Chris Piech, who runs the class, explains why humans should still learn to code. He divides programming into syntax and problem-solving, with AI excelling at syntax but humans needing to master problem-solving skills. Understanding foundational architecture is crucial to catch AI's potential errors and poor structural decisions. Over-reliance on AI can lead to skill atrophy, so programmers must remain aware of their growth alongside AI tools. Coding serves as an excellent problem-solving practice ground with rapid feedback loops, unlike real-world decisions. The most valuable durable skill is identifying what is worth building and understanding user needs. AI can act as a powerful tutor, accelerating learning when used to teach fundamental concepts. The key is to use AI as a learning tool rather than a replacement for critical thinking. Human judgment, taste, and the ability to decide what to build are the most valuable skills in the AI era.
https://belderbos.dev/blog/why-learn-to-code-if-ai-can-code/ belderbos.dev
RSS Hunter RSS Hunter • Sep 11

Talk Python to Me: #562: DuckLake: The Lakehouse That's Just SQL and Parquet

DuckLake differentiates itself by asking a single SQL question rather than parsing numerous JSON and metadata files before accessing data. Its metadata resides in a real database, while the data itself is stored in plain Parquet files. Pedro Holanda, the lead developer, joined DuckDB in 2018. Guillermo Sanchez Dionis also contributes to DuckLake and the new Quack protocol. The Quack catalog enables DuckLake to handle 200 transactions per second under heavy contention, surpassing other open table formats. This episode is sponsored by Six Feet Up and Talk Python Courses. Guests include Pedro Holanda and Guillermo Sanchez; their links are provided. Further links detail progressive indexes, SQLite, Litestream, DuckDB, Iceberg, and DuckLake's specifications. The DuckLake-dataframe and Polars course are also highlighted. Information on CSV parsing, zero-copy Arrow, ART indexes, and async I/O within DuckDB is available. Finally, links to watch the episode on YouTube and find transcripts are included.
https://talkpython.fm/episodes/show/562/ducklake-the-lakehouse-thats-just-sql-and-parquet talkpython.fm
RSS Hunter RSS Hunter • Sep 10

Django Weblog: PyCharm & Django Fundraiser Extended to September 14

The annual JetBrains fundraiser has been extended until September 14, 2026, offering a 30% discount on PyCharm licenses. During this promotion, JetBrains will donate 100% of all PyCharm purchases or renewals to the DSF. This event is a significant annual fundraiser for the DSF, and they express gratitude for all participation. The search for an Executive Director also concludes on September 14, with anticipation for interested candidates. JetBrains has been a long-term sponsor, and their collaboration on the Django Developers Survey 2026 was well-received. The full survey results are available on the JetBrains website, highlighting their strong IDE offerings. The DSF encourages individuals and companies to contribute to their fundraising goals. Ways to help include renewing or purchasing a PyCharm license, direct company sponsorship, or donating via their website or GitHub Sponsors. The board is also open to discussions about donations, sponsorships, volunteering, and new fundraising ideas.
https://www.djangoproject.com/weblog/2026/sep/10/pycharm-django-fundraiser-extended/ djangoproject.com
RSS Hunter RSS Hunter • Sep 10

Hugo van Kemenade: Soft-deprecating re.match()

re.match() attempts to match a pattern at the very beginning of a string. It returns a match object if the pattern is found at the start, otherwise it returns None. re.match("pi", "pi") and re.match("pi", "pie") both return a match because "pi" is at the beginning of these strings. However, re.match("pi", "api") and re.match("pi", "magpie") do not match as "pi" does not appear at the string's start.In contrast, re.search() scans the entire string and returns the first location where the pattern is found, regardless of its position. re.fullmatch() requires that the entire string precisely matches the pattern from start to finish. Python 3.15 introduced re.prefixmatch() as an alias for re.match(), aiming for clearer semantics with its name. re.match() has been soft-deprecated in Python 3.15, meaning it should not be used for new code but remains safe for existing code. New code should prefer re.prefixmatch() if the intention is to match only at the beginning.
https://hugovk.dev/blog/2026/soft-deprecating-re.match/ hugovk.dev
RSS Hunter RSS Hunter • Sep 10

EuroPython: EuroPython 2026: Videos Published

EuroPython 2026 was successfully held in Kraków from July 13th to 19th, thanks to attendees, speakers, volunteers, and sponsors. The conference showcased the Python community with engaging technical presentations and a strong sense of camaraderie. Video recordings of all sessions and conference photos are now available online for everyone to enjoy. This year's event saw 1,386 attendees, with a significant number of experienced Python users. Core Python was the most popular topic, followed by Web Development and Data Science & ML. Two new EuroPython Society Fellows were inducted, recognizing their significant contributions. For the first time, a Python Software Foundation Community Service Award was presented on the EuroPython stage. The event also celebrated EuroPython's 25th birthday, acknowledging long-standing community members. A highlight of the sprints was a homemade gelato truck, fostering community spirit. A challenging Kahoot quiz tested attendees' knowledge of Python and the conference. The organizers also shared artwork created by attendees and announced partnerships with PyCon NL, PyCon España, and Django on the Med. Their gratitude extends to all sponsors, especially platinum sponsors Manychat, Microsoft, and Vercel.
https://blog.europython.eu/europython-2026-videos-published/ blog.europython.eu
CdXz5zHNQW_MR1HRatWUi.jpeg
RSS Hunter RSS Hunter • Sep 10

Graham Dumpleton: Finding slow code with wrapture

The Flask shop's /order endpoint is slow, and the goal is to identify the bottleneck. Traditional stopwatch methods require code changes, produce unlinked log lines, and struggle with intermittent slowness. Profilers offer too much detail, obscuring request-specific information.Using the existing config, initial tracing immediately reveals a breakdown of times. The request takes 37.3ms, the view 36.3ms, the service 35.9ms, and the ledger 35.1ms, while the gateway is only 8us. This indicates the ledger is the primary cause of slowness.The concept of "self time" distinguishes operations that are slow themselves from those slow due to their children. Wrapture computes this, showing the ledger is slow in its own right, while the service and view are slow because they call the ledger.A test using wrapture.instrumentation and wrapture.timeline confirms this: the OrderService.place has a self time of 173us out of 31.0ms, while Ledger.record accounts for most of the duration. This level of detail is unavailable from standard profilers.For long-term monitoring, the Aggregate collector gathers statistics across many requests, including total, self, min, and max times. A report from sending thirty requests to the server confirms Ledger.record as the top contributor by self time.To track slowness per tenant, wrapture.annotate allows adding custom data like "X-Tenant" to in-flight events. This enables filtering traces to identify which tenants experience slower requests.The Counter collector provides a cheaper alternative, only counting operations without retaining durations, suitable for budget-based assertions in test suites (e.g., detecting N+1 query problems). The next step is feeding these events to a tracing backend.
https://grahamdumpleton.me/posts/2026/09/finding-slow-code-with-wrapture/ grahamdumpleton.me
RSS Hunter RSS Hunter • Sep 10

Python GUIs: Fixing Crashes When Using NumPy Arrays with QImage in Qt Threads — How to safely pass image data between threads when streaming video or updating displays

Crashes in a threaded video streamer using NumPy and PyQt6 often stem from how QImage interacts with NumPy array memory. When a QImage is created from a NumPy array, it doesn't copy the data but instead references the original memory buffer. This creates a dangerous situation in multithreaded applications because if the worker thread modifies or discards the NumPy array, the QImage in the GUI thread can become invalid, leading to crashes. The solution is to ensure the QImage has its own independent copy of the data. This is achieved by calling the .copy() method on the QImage. The timing of this copy is crucial; it must be performed before the QImage is passed from the worker thread to the GUI thread, typically before emitting it via a signal. Furthermore, all GUI updates, such as calling setPixmap, must exclusively occur on the main thread. Using signals and slots is the correct way for worker threads to communicate with the main thread for GUI updates. The provided example demonstrates this by creating a QImage from a NumPy array, immediately copying it, and then emitting the copied QImage via a signal. A slot on the main thread receives this safe QImage, converts it to a QPixmap, and updates the QLabel without causing crashes. By implementing these practices, reliable threaded video streaming with PyQt6 can be achieved.
https://www.pythonguis.com/faq/crashing-in-qrunner-threads-with-numpy/ pythonguis.com
RSS Hunter RSS Hunter • Sep 9

Python GUIs: How to Check if a QLineEdit is Empty in Python — Empty strings are falsey in Python

To check if a QLineEdit is empty, you can retrieve its current text using the .text() method. This method returns the text content as a string. You can then compare this returned string to an empty string. Alternatively, Python treats empty strings as falsey values. This means you can directly check the truthiness of the string returned by .text(). An empty string evaluates to False, while any non-empty string evaluates to True. Therefore, if not lineedit.text(): will be true if the line edit is empty. A common practice is to use signals, such as textChanged, to monitor changes in the QLineEdit's content. Connecting this signal to a slot allows you to react dynamically as the user types. The slot method receives the current text as an argument. Within the slot, you can perform the truthiness check on this received text. This allows for real-time updates, like changing a label to indicate whether the input field is empty or not. This method is compatible with various Python Qt bindings. It offers a concise way to validate user input without requiring a specific isEmpty() method.
https://www.pythonguis.com/faq/check-qlineedit-empty-pyqt/ pythonguis.com
RSS Hunter RSS Hunter • Sep 9

Python GUIs: Clean up on exit — Stopping threads when closing a PyQt6 application — How to properly shut down background threads and workers when your application window is closed

Background threads in PyQt applications, managed by QThreadPool or QThread, continue running even after the main window is closed. This can cause the application to hang or generate errors. To address this, override the closeEvent method in your main window class. This method is automatically called when the window begins to close, providing an opportunity to execute cleanup code. Inside closeEvent, you should signal all your background workers to stop their execution. For workers implemented as QRunnable, this typically involves setting an internal flag that the worker's run method periodically checks. After signaling the workers to stop, use QThreadPool.waitForDone() to pause execution until all threads in the pool have completed their tasks. This ensures that no threads are abruptly terminated, preventing potential issues. Finally, call event.accept() to allow the window to close normally. It is also crucial to wrap your application's event loop execution with sys.exit() to guarantee a clean process termination. This pattern ensures that all background operations are gracefully halted before the application fully exits.
https://www.pythonguis.com/faq/clean-up-on-exit-application/ pythonguis.com
RSS Hunter RSS Hunter • Sep 9

LernerPython blog, from Reuven Lerner: Python operator overloading: The arithmetic magic methods

Just as + in Python invokes __add__, other operators invoke other magic methods:• – is __sub__ • * is __mul__ • / is __truediv__ • // is __floordiv__ • % is __mod__ •  is __pow__Your methods can do whatever you want. But do try to stick to conventional expectations.
https://lernerpython.com/2026/09/09/python-operator-overloading-the-arithmetic-magic-methods/ lernerpython.com
CdXz5zHNQW_xwuApdyrTV.png
RSS Hunter RSS Hunter • Sep 9

Graham Dumpleton: Tracing Flask with wrapture

Tracing a web application's request involves capturing the HTTP request details and all calls made during its handling as a hierarchical tree. WSGI applications present challenges for tracing because status and headers are passed via a callback, the body is an iterable consumed after the call, and exceptions are handled internally. A Flask application example demonstrates this, with routes for health checks, quotes, and orders. The configuration for tracing now includes an [[instrument]] entry to specify Flask instrumentation. This setup allows for detailed observation of request flows. When a Flask request is processed, the trace shows the request line initiating the tree, followed by nested calls representing application logic. Errors are captured through exception handling within Flask, allowing instrumentation to note them against the request event. To manage noise, specific paths like health checks can be ignored, preventing them from generating trace data. Flask extensions' lifecycle callbacks can also be optionally excluded from observation. The Flask instrumentation works by applying bindings to key points in Flask's execution, including its WSGI middleware, route handling, and exception management. The core unit of tracing is the request event, which contains all relevant data, including status, duration, and HTTP details. This detailed tracing enables analysis of where application time is being spent.
https://grahamdumpleton.me/posts/2026/09/tracing-flask-with-wrapture/ grahamdumpleton.me
RSS Hunter RSS Hunter • Sep 9

Bob Belderbos: Database-Driven RBAC with FastAPI and Azure Entra ID

This project implements a FastAPI service with granular role-based access control (RBAC) using Azure Entra ID for authentication. Instead of hardcoding access policies into each route, these policies are stored in a database table. This allows administrators to change user permissions without modifying and redeploying the application code. The system uses Azure Entra ID to authenticate users and retrieve their roles from JWT claims. A mapping of endpoint keys to required roles is stored in an EndpointPermission SQLModel table.The core of the authorization logic lies in a require function, which is used as a FastAPI dependency. This function retrieves the required roles for an endpoint from the database and checks if the authenticated user possesses any of them. If not, a 403 Forbidden error is raised. The key string for an endpoint is the only literal hardcoded in its route definition.Critically, the endpoint for managing these permissions is itself protected by the same RBAC mechanism, ensuring only administrators can modify access rules. Safeguards prevent administrators from accidentally revoking their own access to the permission management endpoint and ensure that role assignments are never empty. The article highlights two common Azure configuration issues: using v1 tokens instead of v2, which causes invalid token errors, and the fact that nested group memberships are not reflected in user roles for direct assignment.The project also provides guidance on testing the authorization logic effectively. Tests can override the authentication and session dependencies to use fake users and in-memory SQLite databases, allowing for comprehensive testing without external dependencies. This design, by externalizing policy as data, makes authorization dynamic and manageable, aligning with the 12-factor app principle. The author emphasizes distinguishing between code logic and changeable policy.
https://belderbos.dev/blog/database-driven-rbac-fastapi-azure-entra/ belderbos.dev
RSS Hunter RSS Hunter • Sep 9

PyCoder’s Weekly: Issue #751: Profiling, From pandas to Polars, NotImplemented, and More (2026-09-08)

This issue of PyCoder's Weekly covers a range of topics for Python developers. It features a discussion on profiling and making Python applications fast by default, aligning with Den Odell's new book, "Fast by Default." Another key article addresses migration strategies from pandas to Polars, including LLM-assisted full pipeline migration. There's also an announcement about PR-AF, an open-source code reviewer, performing exceptionally well on Code-Review-Bench.Several articles delve into practical Python usage, such as when to use NotImplemented in dunder methods and building a plugin architecture with Pydantic and FastAPI. An important update from PyPI.org specifies that metadata requests are no longer counted as package downloads, improving download statistics accuracy. Tutorials offer guidance on building face recognition tools and fixing common "NoneType" object errors.Other educational content includes a primer on Python decorators and insights into testing async Python effectively. Developers can also learn about storing Django static and media files on Cloudflare R2. Thought-provoking pieces like "Analysis Paralysis Sucks" and "Why OOP Exists" offer broader development perspectives.A preview of Python 3.15 highlights the default UTF-8 encoding change, with a corresponding quiz. The issue also includes projects like Shedskin, a Python-to-C++ transpiler, and Pandas-silent-bugs, showcasing numerous examples of errors in pandas. Upcoming events for the Python community in September 2026 are also listed, including various meetups and PyCon Cameroon.
https://pycoders.com/issues/751 pycoders.com
CdXz5zHNQW_IGTZIgus4k.png
RSS Hunter RSS Hunter • Sep 8

Django Weblog: Call for volunteers: Fundraising Working Group

The Django Software Foundation seeks members for its Fundraising Working Group, a critical initiative as it aims to raise $500,000 by 2026. This funding is essential for supporting existing programs like Django Fellows and Django Girls, and to hire the DSF's first Executive Director. Achieving this goal requires strategic thinking beyond simple donations, focusing on corporate relationships, meaningful sponsorships, and communicating Django's value. The Fundraising Working Group will collaborate closely with the new Executive Director to build comprehensive fundraising efforts.The DSF is looking for individuals with prior experience in fundraising, sponsorships, partnerships, business development, or sales. These experts will identify opportunities, open doors, and develop new fundraising initiatives. However, fundraising expertise is not a prerequisite to join the group. The foundation also values individuals who understand how companies support open source, have ideas for corporate engagement, or possess strong relationship-building and organizational skills.They seek a diverse group that combines experienced professionals with fresh perspectives, people who can drive work and those eager to learn and contribute. The working group operates with monthly meetings and asynchronous work between sessions. Those interested, regardless of their fundraising background, are encouraged to apply and help the Django Software Foundation reach its ambitious goals.
https://www.djangoproject.com/weblog/2026/sep/08/call-for-volunteers-fundraising-working-group/ djangoproject.com
RSS Hunter RSS Hunter • Sep 8

Python Bytes: #495 Banned

EuroPython 2026 videos are now available online, featuring 117 recordings from keynotes to full talks. The State of Django 2026 survey reveals that while Django's core remains stable, the surrounding ecosystem is rapidly evolving. AI integration is commonplace, though its application in development workflows is still being refined. Tooling is consolidating, with uv and Ruff showing significant adoption. Type hints are increasingly used, but the choice of checker is diverse. A notable trend is the coexistence of server-rendered templates and API-only Django communities, with htmx adoption growing. Htmx 4.0.0 has been released, featuring a rewrite using fetch() and subtle API changes like explicit attribute inheritance. New additions include built-in morph swaps and the hx-partial tag. Htmx 2.x remains supported and the latest on npm until 2027. The concept of "Functionally Zen" promotes simplicity in Python by favoring idiomatic code, data over functions, and pure functions. This approach suggests a thin "impure shell" around a "pure core" to manage side effects. Recent extras include uv's new features and a tiny Python interpreter. Steering council voting is also now open.
https://pythonbytes.fm/episodes/show/495/banned pythonbytes.fm
RSS Hunter RSS Hunter • Sep 8