semvec/pypi-packages huggingface dataset:
hmr 0.7.6.2
Hot Module Reload and Fine-grained Reactive Programming for Python
Requires Python: >=3.12
Keywords: reactive-programming, hot-module-reload, signals, hmr

<div align="center">

# HMR for Python

<sup> on-demand · fine-grained · push-pull reactivity </sup>

[![PyPI - Version](https://img.shields.io/pypi/v/hmr)](https://pypi.org/project/hmr/)
[![Supported Python Version](https://img.shields.io/python/required-version-toml?tomlFilePath=https://github.com/promplate/pyth-on-line/raw/refs/heads/main/packages/hmr/pyproject.toml)](https://github.com/promplate/pyth-on-line/blob/main/packages/hmr/pyproject.toml)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/hmr)](https://pepy.tech/projects/hmr)

</div>

HMR means Hot Module Reload / [Hot Module Replacement](https://webpack.js.org/concepts/hot-module-replacement/). It is a feature that allows part of your app to be updated at runtime without a full rerun.

- The module whose source file **you changed** will rerun
- The module / function that **depends on** the changed module will rerun
- Other modules that are unaffected (like third-party libraries) will not rerun

Thus, in contrast to the traditional way of **cold-reloading** Python applications (like [watchfiles CLI](https://watchfiles.helpmanual.io/cli/)), HMR is just more efficient.

Unlike static-analysis tools like [Tach](https://github.com/gauge-sh/tach), HMR works by tracking the dependencies between names and modules **during runtime** through a [reactive system](https://wikipedia.org/wiki/Reactive_programming).

> The [docs site](https://pyth-on-line.promplate.dev/hmr) is available, but the documentation is still under construction. However, we have first-class [llms.txt](https://pyth-on-line.promplate.dev/hmr/llms.txt) and [MCP](https://pyth-on-line.promplate.dev/hmr/mcp) support for AI agents.
>
> [![MCP Server](https://img.shields.io/badge/-MCP_Server-black?logo=modelcontextprotocol)](https://pyth-on-line.promplate.dev/hmr/mcp)

## Usage

If you are running your entry file with `python foo.py bar baz ...`, you can just replace it with `hmr foo.py bar baz ...`.

You can also run modules with `hmr -m <module>`, just like `python -m <module>`.

Try it with `uvx` or `pipx`. If you are using a virtual environment, it is recommended to install `hmr` in the virtual environment instead of globally.
ebuffer 0.2.0a4
Ephemeral buffer service
Requires Python: >=3.10
Keywords: HPC, buffers, workflow, distributed

# Ephemeral Buffer API

## Overview
This project represent the reference implementation of **Ephemeral buffer** concept.
A full description of the concept is available in *[the ephemeral buffer proposal](docs/2025.12.03-EphemeralBuffers-v2.md)*

## Installation

The installation is the standard installation procedure of any WSGI python library. See details below.

### From source code

Clone the repository [ebuffer](https://gitlab.aqmo.org/numpex/ebuffer.git):

```sh
git clone https://public:uhpzy8bFXwcYszCtkkcU@gitlab.aqmo.org/numpex/ebuffer.git
# Navigate into the project directory
cd ebuffer

# Create and load a virtual environment
python3 -mvenv venv
source venv/bin/activate
```

#### Local Deployment
For a local deployment install the server dependencies :
```sh
# Install dependencies for local deployment
pip install -r requirements-server.txt
```

#### For an WSGI Server
The core dependencies are in *requirements.txt*:
```sh
# Install core dependencies for an WSGI web server
pip install -r requirements.txt
```

## Authentication

The authentication mechanism depends on backends, and each depends on
a particular configuration.  All actions that a user can operate on a
ephemeral buffer required a **Bearer Token**. This token is received
after the authentication process from keycloak (IDP used). The token
has a limited lifetime and can be refresh.

## Usage
To Run the project, start the server : `fastapi dev server/src/main.py`

A swagger documentation is available on  `http://127.0.0.1:8000/docs/ui`
delivery-optimizer 1.0.0
A Python library for calculating delivery distances and pricing using the Haversine formula
Requires Python: >=3.8
Keywords: delivery, distance, haversine, pricing, courier, logistics, geolocation

# Delivery Optimizer

A Python library for calculating delivery distances and pricing using the Haversine formula.

## Features

- **Distance Calculation**: Calculate the great-circle distance between two geographical locations using the Haversine formula
- **Pricing Engine**: Calculate delivery pricing based on distance and weight
- **Location Management**: Simple Location class for managing geographical coordinates
- **Customizable**: Configurable pricing parameters

## Installation

```bash
pip install delivery-optimizer
```

## Quick Start

```python
from delivery_optimizer import Location, DistanceCalculator, PricingEngine

# Create locations
pickup = Location(53.3498, -6.2603, "Dublin, Ireland")
delivery = Location(53.4129, -8.2439, "Galway, Ireland")

# Calculate distance
distance = DistanceCalculator.calculate(pickup, delivery)
print(f"Distance: {distance} km")  # Distance: 208.42 km

# Calculate price
pricing = PricingEngine()
price = pricing.calculate(distance, weight_kg=2.5)
print(f"Price: ${price}")  # Price: $528.55
```

## Usage

### Location

The `Location` class represents a geographical location:

```python
from delivery_optimizer import Location

location = Location(
    latitude=53.3498,
    longitude=-6.2603,
    address="Dublin, Ireland"
)
```

### Distance Calculation

Calculate the distance between two locations:

```python
from delivery_optimizer import Location, DistanceCalculator

location1 = Location(53.3498, -6.2603)
location2 = Location(53.4129, -8.2439)

distance_km = DistanceCalculator.calculate(location1, location2)
print(f"Distance: {distance_km} km")
```

### Pricing

Calculate delivery pricing:

```python
from delivery_optimizer import PricingEngine

# Default pricing
pricing = PricingEngine()
price = pricing.calculate(distance_km=100, weight_kg=2.5)

# Custom pricing
custom_pricing = PricingEngine(
    base_price=10.0,
    price_per_km=3.0,
    price_per_kg=1.5
)
price = custom_pricing.calculate(distance_km=100, weight_kg=2.5)
```

## Pricing Formula

The default pricing formula is:

```
price = base_price + (distance_km × price_per_km) + (weight_kg × price_per_kg)
```

Default values:
- Base price: $5.0
- Price per km: $2.5
- Price per kg: $1.0

## API Reference

### Location

```python
Location(latitude: float, longitude: float, address: str = "")
```

### DistanceCalculator

```python
DistanceCalculator.calculate(location1: Location, location2: Location) -> float
```

Returns distance in kilometers (rounded to 2 decimal places).

### PricingEngine

```python
PricingEngine(base_price: float = None, price_per_km: float = None, price_per_kg: float = None)
pricing.calculate(distance_km: float, weight_kg: float = 1.0) -> float
```

Returns price rounded to 2 decimal places.

## Requirements

- Python 3.8+

## License

MIT License

## Author

Abhishek Sharma

## Links

- GitHub: https://github.com/AbhishekSharmaIE/courier-delivery-system
- PyPI: https://pypi.org/project/delivery-optimizer/
socat-lib-ash404 1.0.0
A Python library for network communication using socat
Requires Python: >=3.6

# Socat Library

A Python library for network communication using socat.

## Installation
```bash
pip install -e .
```

## Usage
```python
from socat_lib import Sending, Listening

server = Listening(4444)
result = Sending("Hello", "127.0.0.1", 4444)
print(result)
server.terminate()
```
sphinx-markdown-builder 0.6.9
A Sphinx extension to add markdown generation support.
Requires Python: >=3.7
Keywords: sphinx, sphinx-extension, markdown, docs, documentation, builder

# sphinx-markdown-builder

[![Coverage Status](https://coveralls.io/repos/github/liran-funaro/sphinx-markdown-builder/badge.svg?branch=main&cache-bust=1)](https://coveralls.io/github/liran-funaro/sphinx-markdown-builder?branch=main)

A Sphinx extension to add markdown generation support.

## Install

```sh
pip3 install sphinx-markdown-builder==0.6.9
```

## Usage

Add the extension to your `conf.py` file:
```python
extensions = [
    ...,
    "sphinx_markdown_builder",
    ...,
]
```

Build markdown files with `sphinx-build` command
```sh
sphinx-build -M markdown ./docs ./build
```

## Configurations

You can add the following configurations to your `conf.py` file:

* `markdown_anchor_sections`/`markdown_anchor_signatures`: If set to `True`, 
  then anchors will be added before each section/function/class signature. 
  This allows references to a specific anchor in the document.
* `markdown_docinfo`: Adds metadata to the top of each document containing author, copyright, and version.
* `markdown_http_base`: If set, all references will link to this prefix address
* `markdown_uri_doc_suffix`: If set, all references will link to documents with this suffix.
* `markdown_file_suffix`: Sets the file extension for generated markdown files (default: `.md`).
* `markdown_bullet`: Sets the bullet marker.
* `markdown_flavor`: If set to `github`, output will suit GitHub's flavor of Markdown.

For example, if your `conf.py` file have the following configuration:

```python
markdown_http_base = "https://your-domain.com/docs"
markdown_uri_doc_suffix = ".html"
markdown_bullet = "*"
```

Then a reference to `your-doc-name#your-header` will be substituted with `https://your-domain.com/docs/your-doc-name.html#your-header`. 


## Contributing

See the [code contribution guidelines](CONTRIBUTING.md) for more information.

## Credits
This project forked from [clayrisser/sphinx-markdown-builder], which was developed by [Clay Risser] under the [MIT] license.

The original implementation was based on [doctree2md] by [Matthew Brett] under the [BSD-2] license.

## License

[MIT]

[clayrisser/sphinx-markdown-builder]: https://github.com/clayrisser/sphinx-markdown-builder
[Clay Risser]: https://github.com/clayrisser
[doctree2md]: https://github.com/matthew-brett/nb2plots/blob/master/nb2plots/doctree2md.py
[Matthew Brett]: https://github.com/matthew-brett
[MIT]: LICENSE
[BSD-2]: https://github.com/matthew-brett/nb2plots/blob/main/LICENSE
swcgeom 0.21.2
Neuron geometry library for swc format
Requires Python: >=3.10
Keywords: neuroscience, neuron, neuroanatomy, neuron-morphology

# SWCGEOM

[![Run tests](https://github.com/yzx9/swcgeom/actions/workflows/test.yml/badge.svg)](https://github.com/yzx9/swcgeom/actions/workflows/test.yml)
[![Release to GitHub](https://github.com/yzx9/swcgeom/actions/workflows/github-publish.yml/badge.svg)](https://github.com/yzx9/swcgeom/releases)
[![Release to PyPI](https://github.com/yzx9/swcgeom/actions/workflows/pypi-publish.yml/badge.svg)](https://pypi.org/project/swcgeom/)

A neuron geometry library for swc format.

## Usage

See examples for details.

## Development

```bash
# clone repo
git clone git@github.com:yzx9/swcgeom.git
cd swcgeom

# install dependencies
python -m pip install --upgrade pip
pip install build

# install editable version
pip install --editable .
```

Static analysis don't support import hook used in editable install for
[PEP660](https://peps.python.org/pep-0660/) since upgrade to setuptools v64+,
detail information at [setuptools#3518](https://github.com/pypa/setuptools/issues/3518),
a workaround for vscode with pylance:

```json
{
  "python.analysis.extraPaths": ["/path/to/this/project"]
}
```

## LICENSE

This work is licensed under a
<a rel="license" href="https://www.apache.org/licenses/">Apache-2.0</a>.

Copyright (c) 2022-present, Zexin Yuan
zipip 2.0.0
A simple, custom Python package manager.
Requires Python: >=3.9

## ZIPIP

A Python package installer that feels just like pip, but is built for speed.

## Why Zipip?

I got tired of waiting for big packages like PyTorch or TensorFlow to download one by one.

Zipip's main goal is to make installations faster. It does this by using parallel downloads to fetch a package utilizing multiple threads. This can seriously cut down on the time you spend waiting for your environment to be ready.

It handles dependency resolution and finds the right wheels for your system, so you can trust it to set up your projects correctly, just faster.

## Installation

pip install zipip

## Usage

In your commands, just replace pip with zipip :p
shapes-geometry 0.1.5
Functions to calculate geometric properties of 2D and 3D shapes.
Requires Python: >=3.6
Keywords: geometry shapes math area volume 2D 3D

# shapes_geometry

`shapes_geometry` is a lightweight Python package for performing geometry calculations for common 2D and 3D shapes. It provides simple functions to compute area, perimeter, volume, surface area, and other geometric properties — perfect for students, educators, and developers building math-related tools.

---

## Features

- **2D Shapes:** Circle, Triangle, Square, Rectangle, Parallelogram, Rhombus, Trapezium, Kite, Semicircle, Regular Polygons (Pentagon, Hexagon, Octagon, Decagon)
- **3D Shapes:** Sphere, Cube, Cuboid, Cone, Cylinder
- Simple API with functional structure (no classes)
- Easy to extend and integrate into other Python projects

---

## 📌 Version History

### v0.1.5 - Current Version
- Added `utils.validate_positive_numbers()` for reusable validation.
- Added Geometric Calculations for Capsule.

### v0.1.4
- Added `utils.validate_positive_numbers()` for reusable validation.
- Applied consistent dimension checks across shapes (circle, cylinder, etc.).
- Improved exception handling with:
  - `ShapesGeometryError`
  - `InvalidDimensionError`
  - `InvalidCoordinateError`

### v0.1.3
- Added support for more 2D and 3D shapes (parallelogram, trapezium, cone, etc.).
- Introduced initial exception handling for invalid dimensions.

### v0.1.2
- Implemented core shapes: Circle, Square, Rectangle, Triangle, Cube, Sphere, Cylinder.
- Added area, perimeter, surface area, and volume functions.

### v0.1.1
- Basic setup with `__init__.py`.
- Organized shapes into modules.
- First working release with Circle and Square.

---

## Installation

```bash
pip install shapes-geometry
```

## Example Usage 

```bash
from shapes_geometry.shapes import circle, square, rectangle

print(circle.area(5))           # Output: 78.53981633974483
print(square.perimeter(4))      # Output: 16
print(rectangle.area(10, 5))    # Output: 50
```
requers 0.1.1
A Rust-based HTTP client for Python with some requests-like methods.
Requires Python: >=3.12
Keywords: http, client, requests, rust, python

# requers

A fast, Rust-based HTTP client for Python with a requests-like API.

## Installation

```bash
pip install requers
```

## Usage

```python
import requers

# GET request
response = requers.get('https://httpbin.org/get')
print(response.status_code)
print(response.text)

# Download a file
handle = requers.download_file('https://example.com/file.zip', 'file.zip')
while not handle.is_finished():
    progress = handle.get_progress()
    print(f"Downloaded: {progress['downloaded']} / {progress['total']}")
```

## Features

- Fast HTTP requests powered by Rust
- File downloading with progress tracking and resumability
- SHA256 hashing for files and bytes
- Similar API to the popular `requests` library

## License

MIT
biontfy 2.0.0
A customizable PyQt6 notification library based on a Telegram-like design.
Requires Python: >=3.8

# PyQt Custom Notification Library

A highly customizable PyQt6 notification system, inspired by Telegram's desktop notifications.

## Features

- **Customizable Appearance**: Easily change the background color of notifications.
- **Customizable Buttons**: Change the text and action of the 'Reply' button.
- **Customizable Hide All**: Change the text and color of the 'Hide all' button.
- **Sound Support**: Plays a custom sound (`msr.mp3`) upon notification display using `mpg123` (must be installed separately).
- **Queuing System**: Manages multiple notifications gracefully.
- **Animation**: Smooth fade-in and fade-out animations.

## Installation

Since this is a custom library, you would typically install it from a local source or a private repository.

**Dependencies**

You must have `PyQt6` installed. For sound support, you need the `mpg123` player installed on your system.

```bash
# Install PyQt6
pip install PyQt6

# Install mpg123 (Linux example)
sudo apt-get install mpg123
```

## Usage

```python
import sys
from PyQt6.QtWidgets import QApplication
from pyqt_custom_notify import get_manager

def main():
    app = QApplication(sys.argv)
    manager = get_manager()

    # 1. Set global customizations
    manager.set_customization(
        default_bg_color="#1E1E1E", # Darker background
        default_reply_text="Action", # Change 'Reply' text
        hide_all_text="Close All", # Change 'Hide all' text
        hide_all_color="#FF5733" # Change 'Hide all' text color to orange
    )

    # 2. Connect to the reply signal
    def handle_reply(title: str, message: str):
        print(f"Custom Action triggered for: {title} Message: {message}")
    
    manager.notificationReplied.connect(handle_reply)

    # 3. Send a custom notification
    manager.sendNotification(
        user_pic_path="userpic1.png", # Image from the resources folder
        title="Custom Title",
        message="This is a fully customized notification!",
        bg_color="#333333", # Override default background for this specific notification
        reply_text="Click Me" # Override default reply text for this specific notification
    )

    # 4. Send a default notification
    manager.sendNotification(
        user_pic_path="userpic2.png",
        title="Default Notification",
        message="This uses the global default settings."
    )

    sys.exit(app.exec())

if __name__ == "__main__":
    main()
```
larql 0.1.0
Lark Parser for SPARQL 1.1
Requires Python: >=3.11

# ⅃arqL 🐦✨

[![W3C SPARQL 1.1. Tests](https://github.com/lu-pl/larql/actions/workflows/w3c_tests.yml/badge.svg)](https://github.com/w3c/rdf-tests)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)

`larql` is a simple [Lark](https://github.com/lark-parser/lark) parser for [SPARQL 1.1](https://www.w3.org/TR/sparql11-query/).

Apart from parsing SPARQL strings into Lark parse trees, the only additional feature `larql` will provide is a `lark.Transformer` for (pretty) serializing parsed queries back to strings. That's it.

> WARNING: This project is in an early stage of development and should be used with caution.

#### Usage

```python
from larql import SPARQLParser

parsed = SPARQLParser("select * where {?s ?p ?o .}")
parsed.tree  # lark.Tree

# not yet available
parsed.serialize(indent=2)
```
djvite 1.5.0
Integrates Vite resources into a Django web site.
Requires Python: >=3.12
Keywords: django, vite, javascript

DjVite
======

<div align="center"><img src="./djvite.svg" alt="djvite logo" width="30%"/></div>

Integrates [Vite](https://vite.dev/) resources into a [Django](https://www.djangoproject.com/) web site.

Web requests are first served through **vite** dev server, then either proxified to **django** dev server or served directly.

This simulates a **nginx** proxy and **wsgi** server.

How to use
----------

### Django side

- Add `djvite` to your `INSTALLED_APPS` django config and define your static directories.

```python
# settings.py
INSTALLED_APPS = [
    ...
    'djvite',
]
STATIC_URL = "static/"
STATIC_ROOT = BASE_DIR / 'static'
STATICFILES_DIRS = ['dist']
```

- Load the `djvite` plugin into your templates.
- Inject any *script* or *link* from *vite* into your template:
  - `{% vite hotreload %}` enables vite hot module reload in dev mode
  - `{% vite '/src/main.js' %}` for module
  - `{% vite '/src/style.css' %}` for asset
  - Add any attributes to the `vite` tag and it will be added to the final tags.
  - Specifiy multiple sources within one `vite` tag, separate them with spaces.

```html
<!-- myapp/templates/index.html -->
<html>{% load djvite %}
  <heead>
    <title>My title</title>
    {% vite hotreload '/src/main.js' %}
  </head>
  ...
</html>
```

Notes:

You can use the `get_nginx_config` command to generate a working nginx static configuration.

### Vite side

- Add `DjVitePlugin` to your `vite.config.js` file:

```javascript
// vite.config.js
import { defineConfig } from 'vite'
import DjVitePlugin from 'djvite'
export default defineConfig({
  plugins: [
    DjVitePlugin({verbose: true}),
  ],
})
```

Configuration
-------------

In **django** settings:

- `DJVITE` dict, with the following keys:
  - `DEV_MODE` (boolean, default `True`)  
  When `False`, resources are resolved using the `vite-manifest.json` file that list bundle files. This file is generated using `vite build`.
  - `MODULE_EXTS` (extension list, default ot `['.js']`)  
  Use this to provide other extensions to be served as module, for instance `['.js', '.ts', '.jsx', '.tsx']` in Typescript React application.
  - `VITE_MANIFEST_PATH` (`Path | str`, default to `vite.manifest.json`)  
  Location to search for the Vite manifest. Used when `DEV_MODE` is `False`.

In **vite** config plugin:

- `options` object for `DjVitePlugin`.
  - `verbose` default to `false`.
  - `djangoPort` default to `DJANGO_PORT` environment variable or `8000` if not defined.
  - `djangoTemplatesGlob` default to the globbing pattern `**/templates`.
  - `manifestPath` default to `vite.manifest.json`.