Hasty Briefsbeta

All tags

#python

387 stories total

Bilingual

Fun with uv and PEP 723
10 months ago
- uv is a fast Python package and project manager written in Rust.
- uvx is a tool similar to npx in the Node/NPM ecosystem, allowing Python tools to be invoked with automatic environment setup.
- PEP 723 introduces inline script metadata for Python scripts, aiding tools and launchers.
- Combining uv and PEP 723 metadata enables seamless execution of Python scripts with dependency management.
- A practical example demonstrates extracting YouTube transcripts using a Python script with uv and PEP 723 metadata.
- The shebang `#!/usr/bin/env -S uv run --script` is crucial for executing scripts with uv.
Switching Pip to Uv in a Dockerized Flask / Django App
10 months ago
- Switching from pip to uv in Dockerized Flask/Django apps results in a 10x speedup.
- Using pyproject.toml instead of requirements.txt for defining dependencies, with uv automatically generating a lock file.
- Dockerfile changes include installing uv, updating dependency file references, and setting environment variables for uv.
- uv commands like 'uv lock' and 'uv sync' ensure dependency management is efficient and up-to-date.
- Scripts and shortcuts are provided for managing dependencies, including adding, updating, and removing packages.
- A demo video is available, covering the transition to uv and demonstrating commands for dependency management.
uv: An extremely fast Python package and project manager, written in Rust
10 months ago
- uv is an extremely fast Python package and project manager written in Rust.
- It replaces multiple tools like pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv.
- Offers 10-100x faster performance compared to pip.
- Provides comprehensive project management with a universal lockfile.
- Supports running scripts with inline dependency metadata.
- Manages and installs Python versions.
- Runs and installs tools published as Python packages.
- Includes a pip-compatible interface for a familiar CLI with performance boost.
- Supports Cargo-style workspaces for scalable projects.
- Disk-space efficient with a global cache for dependency deduplication.
- Installable without Rust or Python via curl or pip.
- Supports macOS, Linux, and Windows.
- Backed by Astral, the creators of Ruff.
- Can update itself to the latest version if installed via standalone installer.
- Manages project dependencies and environments with lockfiles and workspaces.
- Supports building and publishing projects, even those not managed with uv.
- Executes and installs command-line tools provided by Python packages.
- Installs Python and allows quick switching between versions.
- Provides a drop-in replacement for common pip, pip-tools, and virtualenv commands.
- Extends interfaces with advanced features like dependency version overrides and reproducible resolutions.
- Licensed under Apache License 2.0 or MIT license.
Advanced Python Function Debugging with MCP Integration
10 months ago
- Gnosis Mystic enables AI assistants to interact with Python functions through runtime hijacking and analysis.
- Minimal decorators allow AI like Claude to inspect, optimize, and control code in real-time.
- AI assistants typically lack real-time function performance visibility and runtime behavior access.
- Gnosis Mystic provides AI with real-time function calls, performance metrics, and behavior insights.
- Features include safe experimentation, runtime control, intelligent analysis, and live debugging.
- Example use cases: adding caching, performance profiling, security vulnerability detection.
- Installation involves cloning the repository, initializing the project, and starting the server.
- Integration with Claude Desktop allows AI to analyze and optimize functions dynamically.
- Future enhancements include web dashboards, IDE extensions, and distributed debugging.
- Open-source under Apache 2.0 License, with contributions welcome.
Uv and Ray: Pain-Free Python Dependencies in Clusters
10 months ago
- The uv package manager introduces a new era of Python package management with speed and consistency.
- uv packages the entire Python environment, eliminating the need for manual setup.
- Written in Rust, uv is designed for speed, with features like local caching and dependency de-duplication.
- uv respects Python conventions, supporting pyproject.toml, lockfiles, editable packages, and more.
- Managing dependencies in distributed contexts is challenging, often requiring containerization, which slows development.
- Ray 2.43 integrates with uv to synchronize environments across distributed clusters, simplifying dependency management.
- Example provided: running a distributed Python application with Ray and uv, ensuring consistent dependencies across workers.
- Advanced use cases include heterogeneous dependencies and custom worker commands via py_executable.
- uv supports generating lockfiles, using system Python, and managing projects in subdirectories.
- Combining uv with Ray improves dependency management for distributed systems, ensuring consistent execution.
- Anyscale offers alternative solutions for complex dependency needs, including a fast container runtime.
Show HN: A Python Language Server, Mypy-compatible
10 months ago
- A Mypy-compatible Python Language Server built in Rust.
- Standards-compliant with a fully featured type system.
- Unparalleled performance: 20-200x faster than Mypy with optimized memory usage.
- Currently supports diagnostics; features like completions and go-to-definition are in development.
- Developed by the creator of Jedi, leveraging 14 years of Python auto-completion and static analysis experience.
- Alpha release with some expected false positives; beta release coming soon.
- Works in VSCode, Vim, and all other LSP-compatible editors including Helix, NeoVIM, SublimeText, Emacs, Zed, etc.
- Key features: Mypy config compatibility, error recovery, incremental checking, file watching, Python 3.13 support.
- Advanced code understanding: passes >95% of Mypy's tests, supports various imports, type narrowing, and more.
- Performance optimized: written in Rust, significantly faster than Mypy, minimal memory usage.
- Comprehensive type system support including TypeVar, Overloads, Dataclasses, Protocols, Literal Types, and more.
- Includes executables: zubanls (language server) and zmypy (Mypy replacement), compatible with Linux, Mac, and Windows.
- Free during alpha; pricing post-alpha based on code size—free for most users, paid for large codebases.
- Built by David Halter, founder of Jedi, addressing speed limitations in existing tools.
- Aimed at professionals needing precision, reliability, and speed; future support for Django, LSP features underway.
- Initial 2025 release may not cover all needs; open to feature requests based on real-world demand.
uv: The Fast Python Package Manager
10 months ago
- uv is a lightning-fast Python package manager built in Rust by Astral.
- It offers 10-100x faster performance than pip and replaces multiple Python tools like pip, pip-tools, pipx, poetry, pyenv, and virtualenv.
- Key features include rapid package installation, virtual environment creation, and a single binary with zero Python dependencies.
- Installation is simple via curl or Homebrew, and it includes Python version management.
- Commands cover project initialization, dependency management, and script execution without manual virtual environment activation.
- Best practices include project structure recommendations, Python version strategies, and dependency management tips.
- CI/CD integration with GitHub Actions is supported, and common pitfalls are addressed.
- Future updates include universal lockfiles and built-in Python version management.
- uv is recommended for faster dependency installation, simpler project management, and a modern Python development experience.
Run Coverage on Tests
10 months ago
- Running coverage on tests helps identify issues like duplicated test function names that prevent tests from running.
- Example one shows how duplicated test names can lead to tests being skipped, which coverage reports can highlight.
- Example two demonstrates a subtle bug where a generator is consumed prematurely, revealed by coverage tools like Codecov.
- Coverage tools can uncover hidden issues in test code, ensuring all tests are executed and potential bugs are caught.
Intro to GIS Programming: A Practical Python Guide to OSS Geospatial Tools
10 months ago
- The repository contains code examples for the book 'Introduction to GIS Programming: A Practical Python Guide to Open Source Geospatial Tools'.
- The book is available in PDF format in English and Chinese, with a color print version coming soon on Amazon.
- The book covers Python programming fundamentals, geospatial programming with Python, and various tools like GeoPandas, Rasterio, and Earth Engine.
- Code examples can be run using MyBinder, Google Colab, or Docker with two available Docker images.
- Video tutorials complement the book, providing visual learning aids and additional examples.
- The book is licensed under Creative Commons Attribution 4.0 for code examples, while text and images are copyrighted.
uv: Locking and Syncing
10 months ago
- Locking resolves project dependencies into a lockfile, while syncing installs packages from the lockfile into the project environment.
- uv automatically locks and syncs projects before running commands, ensuring environments are up-to-date.
- Options like --locked, --frozen, and --no-sync control automatic locking and syncing behavior.
- The lockfile is considered outdated if project metadata changes, but not when new package versions are released.
- Commands like uv lock and uv sync allow explicit lockfile creation and environment syncing.
- Editable installations are enabled by default, allowing changes to reflect without re-syncing.
- Optional dependencies (extras) and development dependencies can be managed with specific flags.
- Upgrading locked package versions requires explicit commands like --upgrade or --upgrade-package.
- The lockfile can be exported to requirements.txt format for integration with other tools.
- Partial installations can be performed for scenarios like Docker layer caching, with flags to omit specific packages.
Use keyword-only arguments in Python dataclasses
10 months ago
- Python dataclasses are useful for constructing data-holding classes, offering an alternative to dictionaries and custom classes.
- Using `kw_only=True` in dataclasses ensures initialization with keyword arguments, enhancing maintainability.
- Keyword-only initialization prevents issues from field reordering and allows subclasses to add required fields without defaults.
- This approach is particularly beneficial for library authors focusing on backward compatibility and forward extensibility.
Hand-Drawn QR Codes
10 months ago
- Author purchased a sticky-note-like pad with a 10x10 and 2x10 grid to create a QR code.
- Version 1 QR codes can hold URLs up to 17 bytes; 'sethmlarson.dev' was used initially due to length constraints.
- Learned that using all capital letters allows fitting the full domain 'HTTPS://SETHMLARSON.DEV' in a version 1 QR code.
- Used the Python 'qrcode' package to generate a reference QR code with the '-n' option in echo to avoid trailing newlines.
- Hand-drew the QR code, starting with corner squares (position patterns) and timing lines, making a minor mistake that didn't affect functionality.
- Scanning the hand-drawn QR code was finicky due to paper curling but worked well when hung from a monitor.
- Encourages readers to try hand-drawing on grid paper and provides contact details for thoughts or questions.
- Offers subscription options for new posts via RSS feed or email newsletter and mentions the blog's open-source nature.
The uv build back end is now stable
10 months ago
- The uv build backend is currently the default for uv init, but will replace hatchling in future versions.
- uv supports all PEP 517-compliant build backends and provides its own (uv_build) for better performance and UX.
- The uv build backend is ideal for most Python projects, offering zero-config defaults and tight integration with uv.
- It validates project metadata, prevents common mistakes, and is very fast, but only supports pure Python code.
- To use uv as a build backend, add uv_build to the [build-system] section in pyproject.toml.
- For new projects, use uv init to set up the uv build backend.
- The uv executable includes a bundled build backend, but external frontends like python -m build use the uv_build package.
- Python modules default to src/<package_name>/__init__.py, with name normalization (e.g., Foo-Bar → foo_bar).
- Namespace packages use dots in module-name (e.g., foo.bar) and omit __init__.py in shared namespaces.
- Type stub packages use -stubs suffix (e.g., foo-stubs) and __init__.pyi files.
- File inclusion/exclusion follows anchored patterns for includes and non-anchored for excludes, with defaults like excluding __pycache__.
Show HN: Fast Thermodynamic Calculations in Python
10 months ago
- Gaspype is a Python package for thermodynamic calculations of gas species and mixtures, ideal for moderate pressures or high temperatures.
- Features include pure Python with NumPy for performance, immutable types, comprehensive type hints, and support for Jupyter Notebooks.
- Designed for future GPU support (JAX, PyTorch) and includes a NASA9-based species database.
- Installation is possible via pip (`pip install gaspype`) or conda (`conda install conda-forge::gaspype`).
- Main classes are `fluid` for gas mixtures and `elements` for atomic compositions, supporting operations with NumPy arrays.
- Supports conversion to pandas DataFrames and multidimensional operations for complex models.
- Equilibrium calculations can be performed to transition from atomic to molecular compositions.
- Developer contributions are welcome, with guidelines for setup, testing, and database compilation provided.
- Licensed under MIT License.
Uncommon Uses of Python in Commonly Used Libraries (2022)
10 months ago
- Python's `super()` function is essential for cooperative multiple inheritance, especially in base classes.
- Mixin classes provide reusable functionality without state, ideal for optional features across multiple classes.
- Relative imports (using `.`) ensure Python searches the current package first, preventing module conflicts.
- Non-empty `__init__.py` files can simplify APIs, refactor code without breaking changes, and initialize package-wide resources.
- Class methods are used when needing class-level operations, while static methods serve as utility functions within a class's namespace.
- `conftest.py` in pytest not only provides fixtures but also helps in modifying `sys.path` for module recognition.
- Design principles in libraries like scikit-learn emphasize consistency and composition, while PyTorch focuses on pragmatic performance and simplicity.
Solving Wordle with uv's dependency resolver
10 months ago
- The article discusses using Python's uv dependency resolver to solve Wordle, similar to a previous approach with Sudoku and Poetry.
- Wordle is a five-letter word guessing game where feedback (green, yellow, blank) helps narrow down possible solutions.
- The solution involves encoding Wordle rules into Python package dependencies, with packages representing words, positions, and feedback.
- Feedback packages encode constraints based on Wordle's feedback, ensuring letters are correctly placed or excluded.
- The implementation dynamically updates dependencies based on feedback, using uv to resolve the correct word.
- The solver is efficient, generating thousands of package versions quickly and leveraging uv's speed for dependency resolution.
- A GitHub repository provides the solver, which can be run with uv to interactively solve Wordle puzzles.
I made a parody of enterprise AI chatbots
10 months ago
- Download and install Python 3.12 using uv.
- Use the provided curl command to install uv.
- Activate the virtual environment and navigate to the project directory.
- Run the uvicorn server for the ChatGPT parody application.
- Enter a username and use the demo API key 'sk-demo'.
- Enhance the application to make it enterprise demo-worthy.
GenAI Processors: Build powerful and flexible Gemini applications
10 months ago
- Google DeepMind introduces GenAI Processors, an open-source Python library for building AI applications with Large Language Models (LLMs).
- GenAI Processors provides an abstraction layer with a consistent Processor interface for handling input, pre-processing, model calls, and output processing.
- The library treats all input and output as asynchronous streams of ProcessorParts, enabling seamless chaining and composition of operations.
- Example use cases include building a 'Live Agent' for real-time audio and video processing with the Gemini Live API.
- GenAI Processors leverages native Python features like asyncio for efficient handling of I/O-bound and compute-bound tasks.
- The library simplifies interaction with the Gemini API, reducing boilerplate and accelerating integration.
- GenAI Processors is designed for both streaming and non-streaming use cases, improving latency and user experience.
- The library is currently in early stages and encourages community contributions for specialized functionalities.
Dict Unpacking in Python
10 months ago
- Introduces a humorous Python package called 'dict-unpacking-at-home' for dictionary unpacking.
- Instructions include adding a specific coding declaration to enable dictionary unpacking syntax.
- Demonstrates basic and nested dictionary unpacking with examples.
- Mentions a known issue with line numbers in stacktraces and a branch with a fix.
- Strongly advises against using the package in serious projects.
- Notes the package's popularity with almost a million monthly downloads and 30M+ total.
Watchfiles: Simple, modern and fast file watching for Python, written in Rust
10 months ago
- Simple, modern, and high-performance file watching and code reload in Python.
- Documentation available at watchfiles.helpmanual.io.
- Source code on GitHub: github.com/samuelcolvin/watchfiles.
- Uses the Notify Rust library for file system notifications.
- Previously named 'watchgod'; includes a migration guide.
- Requires Python 3.9 - 3.14.
- Install via pip: 'pip install watchfiles'.
- Binaries available for Linux, MacOS, and Windows; can also install from source with Rust stable.
- Examples provided for synchronous and asynchronous file watching.
- Includes 'run_process' and 'arun_process' for running and reloading code.
- Comes with a CLI for running commands when files change.

first prev6next

About|Login

#python

Fun with uv and PEP 723

Switching Pip to Uv in a Dockerized Flask / Django App

uv: An extremely fast Python package and project manager, written in Rust

Advanced Python Function Debugging with MCP Integration

Uv and Ray: Pain-Free Python Dependencies in Clusters

Show HN: A Python Language Server, Mypy-compatible

uv: The Fast Python Package Manager

Run Coverage on Tests

Intro to GIS Programming: A Practical Python Guide to OSS Geospatial Tools

uv: Locking and Syncing

Use keyword-only arguments in Python dataclasses

Hand-Drawn QR Codes

The uv build back end is now stable

Show HN: Fast Thermodynamic Calculations in Python

Uncommon Uses of Python in Commonly Used Libraries (2022)

Solving Wordle with uv's dependency resolver

I made a parody of enterprise AI chatbots

GenAI Processors: Build powerful and flexible Gemini applications

Dict Unpacking in Python

Watchfiles: Simple, modern and fast file watching for Python, written in Rust