Hasty Briefsbeta

All tags

#python

387 stories total

Bilingual

Connecting the Dots: Understanding the PSF's Current Financial Outlook
6 months ago
- The PSF is facing financial challenges due to inflation, reduced sponsorship, and economic pressures in the tech sector.
- PyCon US has run at a loss for three years despite cost-cutting efforts, impacting the PSF's revenue.
- Corporate investment in Python has declined, though usage of the language continues to grow.
- The PSF has sought alternate revenue channels, including PyPI Organizations and grants, with mixed success.
- A recent surge in community support ($135K+ from 1,400+ donors) followed the PSF's withdrawal from a conflicting grant.
- The PSF's 2024 Annual Impact Report shows a loss in net income and limited financial flexibility due to restricted funds.
- The PSF is actively pursuing new sponsors, adjusting PyCon US expenses, and exploring funding opportunities in the US and Europe.
- Community members can help by encouraging their companies to sponsor the PSF or by becoming Supporting Members themselves.
How often does Python allocate?
6 months ago
- CPython represents each integer in a heap-allocated PyLongObject*.
- Python uses a freelist to reuse PyLongObject allocations, reducing the frequency of heap allocations.
- Small integers (-5 to 1025) are pre-allocated and shared to avoid repeated heap allocations.
- The print() function in Python allocates scratch PyLongObject* for conversions, even when avoidable.
- CPython's memory allocator uses pool allocation for objects, improving allocation speed and reducing fragmentation.
- Despite optimizations, Python's integer handling still involves significant overhead compared to direct CPU operations.
- Python lacks a tagged pointer optimization for integers, a common technique in other dynamic language interpreters.
- Zig's approach to memory allocation is highlighted as a contrast, where allocators are explicitly passed to functions.
Text case changes the size of QR codes
6 months ago
- Creating QR codes in Python using the qrcode library with mixed case and upper case sentences.
- Mixed case sentences are encoded as binary data (ISO/IEC 8859-1), using 8 bits per character.
- Upper case sentences are encoded as alphanumeric data, using 5.5 bits per character, reducing QR code size by about 30%.
- Alphanumeric QR codes use a 44-character alphabet, allowing two characters to be encoded in 11 bits.
- Example shows a reduction from a 33×33 grid (1089 pixels) to a 29×29 grid (841 pixels) when switching to upper case.
- Application to Bitcoin addresses: Bech32 encoding (monocase) requires fewer QR code pixels than Base58 encoding despite needing 17% more characters.
- Bech32 uses a lower case alphabet but converts to upper case before QR code generation.
Show HN: I built an HTTP client that perfectly mimics Chrome 142
6 months ago
- Python HTTP client mimicking browser fingerprints with requests-compatible API.
- High performance with native C implementation and BoringSSL for HTTP/HTTPS.
- Supports HTTP/2 with ALPN negotiation via nghttp2.
- Perfect JA3N, JA4, and JA4_R fingerprint matching for Chrome 142.
- Includes realistic Chrome 142 browser profile and TLS fingerprinting.
- Features connection pooling and session management for persistent cookies and headers.
- Easy installation via pip with support for Python 3.8+ on Windows, macOS, and Linux.
- Simple API for GET, POST requests, sessions, and HTTP/2 support.
- Mimics browser behavior with pre-configured profiles and OS-specific user agents.
- Accurate Chrome 142 TLS fingerprints with post-quantum cryptography.
- Supports various HTTP features like custom headers, file uploads, timeouts, and authentication.
- High compatibility with Python's requests library for most use cases.
- Detailed response handling including status codes, headers, JSON parsing, and TLS info.
- Comprehensive error handling with specific exceptions for timeouts, connection errors, etc.
- Cross-platform support with BoringSSL for consistent TLS behavior.
- Development setup includes building from source with BoringSSL and nghttp2.
- Extensive test suite covering HTTP methods, fingerprint validation, and real-world scenarios.
- Open for contributions, especially in Windows compatibility, browser profiles, and performance.
- MIT licensed with a strong disclaimer for ethical and legal use only.
Python Software Foundation gets a donor surge after rejecting federal grant
6 months ago
- The Python Software Foundation (PSF) rejected a $1.5 million federal grant due to anti-DEI terms, sparking community support.
- Following the rejection, the PSF received an overwhelming surge in donations, including 295 new Supporting Members.
- Key figures like Guido van Rossum and Simon Willison publicly supported the PSF's decision to prioritize DEI values.
- The grant was intended to improve security for PyPI, but its rejection delays automated package review tools.
- The PSF is exploring alternative funding sources, including European grants and corporate sponsorships, to sustain its mission.
Solving Every Sudoku Puzzle (2006)
6 months ago
- The essay discusses solving Sudoku puzzles using constraint propagation and search.
- A Sudoku puzzle is solved when each unit (row, column, or 3x3 box) contains a permutation of digits 1 to 9 without repetition.
- The solution involves two main strategies: eliminating impossible values (constraint propagation) and searching through possibilities when stuck.
- The Python implementation includes functions for parsing the puzzle grid, assigning values, and eliminating possibilities.
- The search algorithm uses depth-first search with backtracking, prioritizing squares with the fewest remaining possibilities (minimum remaining values heuristic).
- The solver can handle both easy and hard puzzles, with most puzzles solved in under a second, though some hard puzzles take significantly longer.
- Random puzzles were generated to test the solver, with checks to ensure at least 17 squares filled and 8 different digits to avoid trivial or unsolvable puzzles.
- The solver's performance was analyzed, showing that most puzzles are solved quickly, but a few take much longer due to specific value choices leading to deep searches.
- The essay concludes with the solver successfully solving a variety of puzzles, including those labeled as the hardest, demonstrating the effectiveness of the approach.
A Plan for 5-10%* Faster Free-Threaded JIT by Python 3.16
6 months ago
- Plans to improve CPython's JIT performance: 5% faster by 3.15, 10% by 3.16.
- Profiling and debugger support is essential for production-ready JIT.
- Current JIT region selection uses trace projection; improvements proposed with trace recording.
- New JIT frontend developed, showing promising speed improvements.
- Optimizations in Copy-and-Patch code generation for better performance.
- Register allocation optimizations proposed to speed up the stack machine.
- Reference count semantics in CPython pose challenges for optimizations.
- Free-threading support for JIT is under development, with initial basic support planned.
- Encouragement for contributions to CPython, especially after initial JIT improvements land.
Smart Performance Hacks for Faster Python Code
6 months ago
- Use sets for membership testing to achieve constant-time lookups (O(1)) instead of linear scans (O(n)).
- Avoid unnecessary copies of large objects; modify in place to save memory and time.
- Use `__slots__` in classes to reduce memory overhead and speed up attribute access.
- Prefer `math` module functions over operators for faster and more precise numerical computations.
- Pre-allocate memory for lists or arrays when the final size is known to avoid resizing overhead.
- Avoid exception handling in performance-critical loops; use conditional checks instead.
- Define local functions for repeated logic to benefit from faster name resolution.
- Use `itertools` for efficient combinatorial operations with lazy evaluation.
- Leverage `bisect` for fast insertions and searches in sorted lists (O(log n)).
- Cache function results outside loops to avoid redundant computations.
Building a CI/CD Pipeline Runner from Scratch in Python
6 months ago
- The article explains how to build a CI/CD pipeline runner from scratch in Python, covering core features like stages, parallel execution, job dependencies, and artifact passing.
- It starts with a basic single job executor and progressively adds features like multi-stage support, parallel execution, dependency management, and artifact passing.
- The final version includes production-ready features such as environment variables, branch filtering, timeouts, and better error handling.
- The runner demonstrates how CI/CD tools like GitLab Runner and GitHub Actions work internally, focusing on job orchestration in isolated environments.
- Key components of the pipeline include stages (defining execution order), jobs (work units in isolated environments), and artifacts (files passed between jobs).
- The article provides a step-by-step implementation, from parsing YAML configurations to executing jobs in Docker containers with real-time log streaming.
- It also discusses real-world use cases, performance considerations, and potential extensions like caching, matrix builds, and service containers.
- The conclusion emphasizes understanding CI/CD fundamentals to troubleshoot and optimize pipelines, with suggestions for further learning and next steps.
Tetrahedral Analog of the Pythagorean Theorem
6 months ago
- A tetrahedron has four triangular faces, with three meeting at a right angle.
- De Gua's theorem states: A0² = A1² + A2² + A3² for the areas of the faces.
- Python code demonstrates De Gua's theorem numerically, confirming the theorem holds.
- The theorem generalizes to higher dimensions, such as a 4-simplex in a hypercube.
- For a 4-simplex, V0² = V1² + V2² + V3² + V4², extending De Gua's theorem.
- Python code for the 4-simplex shows the theorem holds, with minor floating-point errors.
- Floating-point arithmetic limitations cause precision loss when subtracting nearly equal numbers.
Fizz Buzz without conditionals or booleans
6 months ago
- The challenge was to write Fizz Buzz without using booleans, conditionals, or pattern matching.
- A Python solution was provided using itertools.cycle to create endless sequences for 'Fizz' and 'Buzz'.
- The solution combines these sequences with numbers 1 through 100 using zip.
- A string_mask function is used to overlay 'Fizz', 'Buzz', or 'FizzBuzz' over the number strings.
- The solution has a limitation where numbers above 10,000 cause digit leakage in the output.
- The author invites others to share their solutions to the problem.
Blending SQL and Python with Sqlorm
6 months ago
- SQLORM is a Python ORM designed with SQL as the primary focus, allowing direct SQL query execution.
- Key features include immediate query execution, unattached objects to sessions, and preference for hand-written SQL over query builders.
- SQLORM supports templated SQL queries via Python functions, using docblocks for SQL statements.
- Connections and transactions are managed via context managers with the Engine class.
- Rows can be returned as dictionaries or hydrated into objects, with support for Active Record pattern via the Model class.
- Model classes can include SQL methods and column definitions via Python annotations for better tooling support.
- Supports operations across different databases, like reading from a replica and writing to a primary.
- Includes utilities for relationships, lazy loading, and integrates with Flask.
Archimedes – A Python toolkit for hardware engineering
6 months ago
- Archimedes is a Python framework designed for hardware engineering, specifically for control systems development.
- It aims to be the 'PyTorch for hardware' by enabling Python development with C code deployment capabilities.
- The toolkit allows for the development and analysis of algorithms in NumPy and automatically generates optimized C code for embedded systems.
- Archimedes addresses the gap between high-level Python development and low-level hardware deployment, offering a solution that avoids manual translation to C or vendor-locked ecosystems.
- Key features include Python to C code generation, compilation for performance speedups, simulation and optimization tools, and automatic differentiation.
- The framework supports structured data types, enabling hierarchical system modeling that mirrors physical system decompositions.
- Archimedes is built on CasADi, leveraging its capabilities for nonlinear optimization and algorithmic differentiation.
- The project is currently in public beta, with plans for future enhancements in hybrid simulations, hardware deployment, physics modeling, and algorithm development.
- Users are encouraged to try Archimedes, provide feedback, and contribute to its development through GitHub discussions and issue reporting.
Why your mock breaks later
6 months ago
- Overly aggressive mocks can work initially but break later due to unintended side effects.
- Mocking should be done where the object is used, not where it's defined, to avoid affecting unrelated code.
- Example: Mocking `open()` globally can interfere with libraries like `coverage.py`, causing unexpected errors.
- Best practices include using `autospec=True`, making assertions about mock calls, and preferring dependency injection over mocks.
- A defensive fix in `coverage.py` saves the original `open` to avoid issues from global mocking.
Show HN: Onlymaps, a Python Micro-ORM
5 months ago
- Onlymaps is a Python micro-ORM library for database interactions using plain SQL queries.
- Provides sync and async query execution with fine-grained type-hinting via Pydantic.
- Supports major databases: PostgreSQL, MySQL, MariaDB, MS SQL Server, and SQLite.
- Features connection pooling and custom connection factory support.
- Includes methods like exec, fetch_one, fetch_many, and iter for query execution.
- Supports type validation for query results using Pydantic models or other Python types.
- Handles transactions automatically, with explicit transaction support for batch operations.
- Parameter handling includes JSON conversion and bulk operations.
- Supports various data types for single and multiple column queries, including complex types.
Statistical Process Control in Python
5 months ago
- Introduction to Statistical Process Control (SPC) in Python, focusing on measuring variation and identifying intervention benchmarks.
- Setup involves installing pandas, plotnine, and scipy packages, and importing custom functions for distributions and process control.
- Case study on Japanese Hot Springs (onsen) quality control, highlighting temperature, pH, and sulfur levels as key metrics.
- Data collection involves 15 months of 20 random samples each, aiming to monitor quality shifts in onsen attributes.
- Descriptive statistics and visualization techniques are introduced to analyze process variation and subgroup statistics.
- Control charts (X-bar and S charts) and moving range charts are demonstrated for monitoring process stability and variation.
Await Is Not a Context Switch: Understanding Python's Coroutines vs. Tasks
5 months ago
- Python's async model differs from JavaScript, C#, and Java, where awaiting a coroutine doesn't yield to the event loop by default.
- Concurrency in Python is introduced by tasks, not coroutines, which is a key distinction often misunderstood by developers.
- Awaiting a coroutine in Python is synchronous unless the awaited object isn't ready, unlike in other languages where every await is a potential context switch.
- Tasks in Python are the unit of concurrency, and only awaiting a task yields control back to the event loop.
- The misconception that all async boundaries are suspension points leads to unnecessary locking and complexity in Python code.
- Python's async design stems from generators, offering fine-grained control over concurrency and explicit task creation.
- Practical guidelines include auditing task creation points, scanning critical sections for suspension points, and teaching the coroutine vs. task distinction.
- Understanding where code can actually interleave is more effective for ensuring correctness than applying blanket locking rules in async Python code.
Qiskit open-source SDK for working with quantum computers
5 months ago
- Qiskit is an open-source SDK for quantum computing, focusing on circuits, operators, and primitives.
- It includes tools for creating quantum circuits, transpiling for optimization, and a quantum information toolbox.
- Installation is recommended via pip: `pip install qiskit`.
- Key steps in quantum programming: define a quantum circuit, specify classical output, and use Sampler or Estimator primitives.
- Example provided for creating a GHZ state using QuantumCircuit.
- Sampler and Estimator primitives are demonstrated with code examples.
- Running circuits on real quantum hardware requires transpilation to match hardware constraints.
- Qiskit supports multiple quantum hardware providers through backend interfaces.
- Contribution guidelines and community resources like Slack and Stack Overflow are available.
- Qiskit development is partially supported by the DOE Office of Science.
Closest Harmonic Number to an Integer
5 months ago
- Harmonic numbers Hn are never integers for n > 1.
- Two problems to solve: accurately compute harmonic numbers and find n such that Hn is closest to a given integer m.
- For small n, compute Hn directly; for large n, use an asymptotic approximation involving the Euler-Mascheroni constant γ.
- To find n for Hn closest to m, approximate n as exp(m − γ).
- Python code provided to compute Hn and find the nearest harmonic number to a given m.
- Example usage: nearest_harmonic_number(10) returns 12366 with H(12366) ≈ 9.99996.
- Code also works with real numbers, e.g., finding Hn closest to √20.
Show HN: Runprompt – run .prompt files from the command line
5 months ago
- A single-file Python script named 'runprompt' for running .prompt files.
- Quick start guide includes downloading the script, setting API keys, and running example .prompt files.
- Supports piping structured JSON data between prompts for chained operations.
- Allows command-line overrides for frontmatter values and model specifications.
- Supports multiple AI providers including Anthropic, OpenAI, Google AI, and OpenRouter.
- Environment variables can be used to set default configurations across multiple runs.
- Verbose mode (-v) available for debugging request/response details.
- OpenRouter provides access to multiple AI models through a single API key.

first prev14next

About|Login

#python

Connecting the Dots: Understanding the PSF's Current Financial Outlook

How often does Python allocate?

Text case changes the size of QR codes

Show HN: I built an HTTP client that perfectly mimics Chrome 142

Python Software Foundation gets a donor surge after rejecting federal grant

Solving Every Sudoku Puzzle (2006)

A Plan for 5-10%* Faster Free-Threaded JIT by Python 3.16

Smart Performance Hacks for Faster Python Code

Building a CI/CD Pipeline Runner from Scratch in Python

Tetrahedral Analog of the Pythagorean Theorem

Fizz Buzz without conditionals or booleans

Blending SQL and Python with Sqlorm

Archimedes – A Python toolkit for hardware engineering

Why your mock breaks later

Show HN: Onlymaps, a Python Micro-ORM

Statistical Process Control in Python

Await Is Not a Context Switch: Understanding Python's Coroutines vs. Tasks

Qiskit open-source SDK for working with quantum computers

Closest Harmonic Number to an Integer

Show HN: Runprompt – run .prompt files from the command line