semvec/pypi-packages huggingface dataset:
portal 3.7.4
Fast and reliable distributed systems in Python
Requires Python: >=3.9

[![PyPI](https://img.shields.io/pypi/v/portal.svg)](https://pypi.python.org/pypi/portal/#history)

# 🌀 Portal

Fast and reliable distributed systems in Python.

## Features

- 📡 **Communication:** Portal lets you bind functions to a `Server` and call
  them from one or more `Client`s. Wait on results via `Future` objects.
  Clients can automatically restore broken connections.
- 🚀 **Performance:** Optimized for throughput and latency. Array data is
  zero-copy serialized and deserialized for throughput near the hardware limit.
- 🤸 **Flexibility:** Function inputs and outputs can be nested dicts and lists
  of numbers, strings, bytes, None values, and Numpy arrays. Bytes allow
  applications to chose their own serialization, such as `pickle`.
- 🚨 **Error handlings:** Provides `Process` and `Thread` objects that can
  reliably be killed by the parent. Unhandled exceptions in threads stop
  the program. Error files can be used to stop distributed systems.
- 📦 **Request batching:** Use `BatchServer` to collect multiple incoming
  requests and process them at once, for example for AI inference servers.
  Batching and dispatching happens in a separate process to free the GIL.
- ✅ **Correctness:** Covered by over 100 unit tests for common usage and edge
  cases and used for large scale distributed AI systems.

## Installation

```sh
pip install portal
```

## Example

This example runs the server and client in the same Python program using
subprocesses, but they could also be separate Python scripts running on
different machines.

```python
def server():
  import portal
  server = portal.Server(2222)
  server.bind('add', lambda x, y: x + y)
  server.bind('greet', lambda msg: print('Message from client:', msg))
  server.start()

def client():
  import portal
  client = portal.Client('localhost:2222')
  future = client.add(12, 42)
  result = future.result()
  print(result)  # 54
  client.greet('Hello World')

if __name__ == '__main__':
  import portal
  server_proc = portal.Process(server, start=True)
  client_proc = portal.Process(client, start=True)
  client_proc.join()
  server_proc.kill()
  print('Done')
```

## Questions

Please open a separate [GitHub issue](https://github.com/danijar/portal/issues)
for each question.
handymatt 2.0.2
A collection of custom libraries for my personal use.
Requires Python: >=3.8

# handymatt

A collection of custom libraries that I use in many of my Python projects!

## Libraries
- `JsonHandler`: 
- `StringParser`: 
- `BookmarksGetter`: 
- `wsl_paths`: functions for handling conversion between Windows and WSL filepaths

## Libraries to add:
- `sqlite_api`: 
- `file_tag_manager`: library for reading/writing file tags to json files in the file directories
numpes 0.0.1a2
Numerical operations on polytopes, ellipsoids, and subspaces
Requires Python: >=3.14
Keywords: polytope

# NumPES

[![PyPI version](https://img.shields.io/pypi/v/numpes)](https://pypi.org/project/numpes/)
![Tests](https://github.com/bwolleswinkel/numpes/actions/workflows/run-package-tests.yml/badge.svg)

NumPES is a controls-oriented Python package for performings numerical operations on polytopes, ellipsoids, and subspaces. Its classes are implemented as emulating numeric types, enabling a breadth of operations to be performed and evaluated. A modern scientific computing package implemented in Python, using C/C++ as a backend for efficient computation. 

## Installation

The easiest way to instal NumPES is by running

``` zsh
pip install numpes
```

in your terminal or dedicated virtual environment. Then, import NumPES using

``` py
import numpes as pes
```

at the top of your script to make its functionalities available.

## Quick start

NumPES allows you to construct polytope, ellipsoid, and subspace objects and manipulate these. For example, start by initializing a polytope represented by its half-space representation (H-representation).

``` py
import numpy as np
import numpes as pes

A = np.array([[ 0,  1],
              [-2,  0],
              [ 1,  1],
              [ 0, -1]])
b = np.array([1, 1, 1, 0])

poly = pes.poly(A, b)  # Defines a polytope A x <= b

poly.plot(show=True)
```

## Contribute to NumPES

We wholeheartedly invite collaborators to make contributions to NumPES. The easiest way to contribute is to fork this repository, implement your new functionality/improvement, and then create a pull request to merge this functionality in a new release of NumPES.
customer-question-extractor 0.1.0
Extract and deduplicate customer questions from text data
Requires Python: >=3.9
Keywords: call-center, clustering, deduplication, nlp, questions

# Question Extractor

A Python package for extracting and deduplicating customer questions from text data (e.g., call center transcripts).

## Features

- **Text Summarization**: Remove fillers and extract key content from conversations
- **Question Extraction**: Identify distinct customer questions and concerns using GPT-4o
- **Two-Tier Deduplication**:
  - Fuzzy matching with RapidFuzz (75% similarity threshold)
  - Semantic clustering with OpenAI embeddings
- **Cost Estimation**: Get estimated API costs and processing time before running
- **Analysis Reports**: Auto-generated markdown and HTML reports with insights
- **Interactive Dashboard**: Streamlit app for exploring results

## Installation

```bash
pip install customer-question-extractor
```

Or install from source:

```bash
git clone https://github.com/dan-shah/question-extractor.git
cd question-extractor
pip install -e ".[dev]"
```

## Quick Start

### CLI Usage

```bash
# Set your OpenAI API key
export OPENAI_API_KEY=your-api-key

# Estimate cost and time
question-extractor estimate data.csv --text-col transcript --id-col call_id

# Run the full pipeline
question-extractor run data.csv --text-col transcript --id-col call_id --output-dir output/

# Launch the dashboard
question-extractor serve output/
```

### Python API

```python
from question_extractor import Config, Pipeline

# Configure
config = Config(
    openai_api_key="your-api-key",
    text_column="transcript",
    id_column="call_id",
    output_dir="output",
)

# Initialize and run
pipeline = Pipeline(config)

# Get cost estimate first
estimate = pipeline.estimate(input_path="data.csv")
print(estimate.format_summary())

# Run the pipeline
result = pipeline.run(input_path="data.csv")

# Access results
print(f"Processed {result.stats.input_rows} rows")
print(f"Extracted {result.stats.questions_extracted} questions")
print(f"Final unique questions: {result.stats.final_unique}")
```

## Configuration

| Parameter | Default | Description |
|-----------|---------|-------------|
| `text_column` | `"text"` | Column containing text to process |
| `id_column` | `"row_id"` | Column with unique row identifier |
| `fuzzy_threshold` | `0.75` | RapidFuzz similarity threshold (0-1) |
| `semantic_distance_threshold` | `0.7` | Agglomerative clustering distance |
| `top_questions_percentile` | `0.75` | % of questions by volume for semantic clustering |

## Output Files

After running the pipeline, you'll find these files in the output directory:

- `clean.csv` - Processed data with row_id, question, and semantic_cluster columns
- `cleansing.md` - Summary statistics about the processing
- `analysis.md` / `analysis.html` - LLM-generated insights report
- `app.py` - Streamlit dashboard for interactive exploration

## Requirements

- Python 3.9+
- OpenAI API key
- Dependencies: openai, pandas, rapidfuzz, scikit-learn, streamlit, typer, rich

## License

MIT License
dune-spgrid 2.11.0.5
module providing a structured grid
Requires Python: >=3.4

Dune-SPGrid
===========

The DUNE module dune-spgrid provides a structured, parallel grid: `SPGrid`.


Features
--------

The following table compares the features of SPGrid to those of SGrid and
YaspGrid:

|                                       | `YaspGrid` | `SPGrid` |
| :------------------------------------ | :--------: | :------: |
| Can communicate on codimensions       | all        | all      |
| Coordinate type is template parameter | yes        | yes      |
| Supports anisotropic refinement       | no         | yes      |
| Supports periodic boundary conditions | no[^1]     | yes      |
| Supports non-blocking communication   | no         | yes      |
| Supports tensor-product grids         | yes        | no       |

[^1]: `YaspGrid` supports a different concept of periodicity.

`SPGrid` supports different (global) refinement techniques, selected by a
template parameter. Some refinement techniques allow an optional parameter,
the refinement policy, to be passed to globalRefine.
Currently, isotropic, anisotropic and bisection refinement are supported, but
this list can be extended by downstream modules.
By default, isotropic refinement is used.

If no policy is given, both, isotropic and anisotropic refinement, split each
cube into $2^{dim}$ child cubes.
For anisotropic refinement, a policy may be used to say which directions
to split.

Bisection refinement always splits a cube into $2$ child cubes; the
split direction can be given by the policy. If no policy is given, the split
directions are cycled through.

*Note*: `SPGrid` does not support tensor-product grids, as `YaspGrid` does.
        This feature can be added by a metagrid layer, if desired.


Preprocessor Magic
------------------

`SPGrid` can be used through the preprocessor magic. The following table shows how
to select different variants of SPGrid:

| GRIDTYPE                    | Refinement                     |
| :-------------------------- | :----------------------------- |
| `SPGRID`                    | Default (Isotropic)            |
| `SPGRID_SERIAL`             | Default (Isotropic, no MPI)    |
| `SPGRID_ISOTROPIC`          | Isotropic                      |
| `SPGRID_ISOTROPIC_SERIAL`   | Isotropic (no MPI)             |
| `SPGRID_ANISOTROPIC`        | Anisotropic                    |
| `SPGRID_ANISOTROPIC_SERIAL` | Anisotropic (no MPI)           |
| `SPGRID_BISECTION`          | Bisection                      |
| `SPGRID_BISECTION_SERIAL`   | Bisection (no MPI)             |
| `SPGRID_COUNT_FLOPS`        | use Dune::Fem::Double as ctype |


git-a084ea34b6b4b899e082c0fbaf7e0193703032f7
dune-polygongrid 2.11.0.5
module providing a grid consisting of 2d polygons
Requires Python: >=3.4

DUNE-POLYGONGRID
================

[DUNE-POLYGONGRID][0] is a [Distributed and Unified Numerics Environment][1]
module which defines implements a polygonal grid for use with Virtual Element
(VEM), Finite Volume Methods (FV), and Discontinuous Galerkin Methods (DG).

Dependencies
------------

DUNE-POLYGONGRID depends on the following DUNE modules:

* [dune-common][3]

* [dune-geometry][4]

* [dune-grid][5]

License
-------

The DUNE-POLYGONGRID library, headers and test programs are free open-source software,
licensed under version 2 or later of the GNU General Public License.

See the file [LICENSE][6] for full copying permissions.

Installation
------------

For a full explanation of the DUNE installation process please read
the [installation notes][2].

 [0]: https://www.dune-project.org/modules/dune-polygongrid
 [1]: https://www.dune-project.org
 [2]: https://www.dune-project.org/doc/installation/
 [3]: http://gitlab.dune-project.org/core/dune-common
 [4]: http://gitlab.dune-project.org/core/dune-geometry
 [5]: http://gitlab.dune-project.org/core/dune-grid
 [6]: LICENSE.md


git-e24e51623b0e5b21e22a7b4f4c041cd21a55553b
dune-localfunctions 2.11.0.5
Provides interface and implementation for shape functions defined on the DUNE reference elements
Requires Python: >=3.4

<!--
SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
-->

DUNE-library
============

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox
for solving partial differential equations with grid-based methods.

The main intention is to create slim interfaces allowing an efficient use of
legacy and/or new libraries. Using C++ techniques DUNE allows to use very
different implementation of the same concept (i.e. grid, solver, ...) under
a common interface with a very low overhead.

DUNE was designed with flexibility in mind. It supports easy discretization
using methods, like Finite Elements, Finite Volume and also Finite
Differences.

Dune-localfunctions
-------------------
This module provides interfaces and implementations for local
finite element ansatz spaces, i.e., shape functions, associated
interpolation functionals, and relation to grid entities.

More information
----------------

Check dune-common for more details concerning dependencies, known bugs,
license and installation.


git-d3009a8bb73aaa8e9c4f7b5584b79b80cc98c8f6
dune-istl 2.11.0.5
Iterative solver template library which provides generic sparse matrix/vector classes and a variety of solvers based on these classes
Requires Python: >=3.4

<!--
SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
-->

DUNE-library
============

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox
for solving partial differential equations with grid-based methods.

The main intention is to create slim interfaces allowing an efficient use of
legacy and/or new libraries. Using C++ techniques DUNE allows to use very
different implementation of the same concept (i.e. grid, solver, ...) under
a common interface with a very low overhead.

DUNE was designed with flexibility in mind. It supports easy discretization
using methods, like Finite Elements, Finite Volume and also Finite
Differences. Through separation of data structures DUNE allows fast Linear
Algebra like provided in the ISTL module, or usage of external libraries
like blas.

This package contains the basic DUNE istl classes.

More information
----------------

Check dune-common for more details concerning dependencies, known bugs,
license and installation.


git-a92951b884f66ce78b309db3a2f0dec0cfc38bd8
dune-grid 2.11.0.5
module providing main interfaces for setting and traversing grids
Requires Python: >=3.4

<!--
SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
-->

DUNE-library
============

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox
for solving partial differential equations with grid-based methods.

The main intention is to create slim interfaces allowing an efficient use of
legacy and/or new libraries. Using C++ techniques DUNE allows to use very
different implementation of the same concept (i.e. grid, solver, ...) under
a common interface with a very low overhead.

DUNE was designed with flexibility in mind. It supports easy discretization
using methods, like Finite Elements, Finite Volume and also Finite
Differences. Through separation of data structures DUNE allows fast Linear
Algebra like provided in the ISTL module, or usage of external libraries
like blas.

This package contains the basic DUNE grid classes.

More information
----------------

Check dune-common for more details concerning dependencies, known bugs,
license and installation.


git-3ec921b9bfaf649121b50a14ee2897429c152bf5
dune-geometry 2.11.0.5
Geometry Transformations, Reference Elements and Quadrature Rules
Requires Python: >=3.4

<!--
SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
-->

DUNE-library
============

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox
for solving partial differential equations with grid-based methods.

The main intention is to create slim interfaces allowing an efficient use of
legacy and/or new libraries. Using C++ techniques DUNE allows to use very
different implementation of the same concept (i.e. grid, solver, ...) under
a common interface with a very low overhead.

DUNE was designed with flexibility in mind. It supports easy discretization
using methods, like Finite Elements, Finite Volume and also Finite
Differences. Through separation of data structures DUNE allows fast Linear
Algebra like provided in the ISTL module, or usage of external libraries
like blas.

This package contains the basic DUNE geometry classes.

More information
----------------

Check dune-common for more details concerning dependencies, known bugs,
license and installation.


git-d46a44df225f5e7d709969305f2cda6605ba592f
espro 0.1.0
Professional ESPHome infrastructure: manage devices without breaking entity IDs, automations, or dashboards
Requires Python: >=3.12

# ESPro

*ESPro turns physical ESPHome devices into swappable infrastructure beneath stable logical identities.*



## The Problem

ESPHome ties device identity to physical hardware. When a broken device gets replaced:

- All Home Assistant entity IDs change
- Dashboards break
- Automations need manual updates
- 30+ minutes of recovery work per device

This tool aims to simplify device comissioning and management for professional installers and power users who want to treat home infrastructure as code.

## The Solution

**Hardware abstraction layer for ESPHome.**

Home Assistant connects to stable logical devices (`outdoor_light_1`), not physical hardware. When a device breaks, update a config file and restart—entity IDs stay stable, automations keep working.
```yaml
# config/devices.yaml
logical_devices:
  outdoor_light_1:
    physical: esp-sonoff-1.local

  chicken_scale:
    physical: esp32-coop.local
```

Device dies? Change the IP, reload ESPro mappings. Done.

## Architecture
```
Home Assistant (stable entity IDs)
    ↓
ESPro (device registry + proxy)
    ↓
Physical ESPHome Devices (swappable)
```

Three layers with clear responsibilities:

- **ESPHome** - Firmware and I/O
- **ESPro** - Hardware abstraction and lifecycle management
- **Home Assistant** - Automations and UI

## Philosophy

**Boring technology**: Docker, YAML, Git, REST—nothing exotic.

**Plain text wins**: Configuration in Git-tracked YAML. No database, ever. Audit trail via `git log`, rollback via `git revert`, backup via `git push`.

**Infrastructure as code**: Reproducible deployments. Version-controlled configuration. Offline-capable.

**Unix philosophy**: Do one thing well—provide hardware abstraction. Don't replace ESPHome or Home Assistant.

## Status

**Early development.** Validating technical feasibility and gathering community feedback.

Target audience: Professional installers managing 10-1000+ devices across single or multiple sites who need reproducible deployments and version stability.

## Questions?

This is a proof-of-concept. Feedback is welcome.

---


## Development

**Quick start:**
1. Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
2. Install dependencies: `uv sync`
3. Run CLI: `uv run espro --help`
4. Run tests: `uv run pytest`

**Available invoke tasks** (optional, install with `uv tool install invoke`):
- `invoke lint` - Run ruff and mypy
- `invoke test` - Run tests with coverage
- `invoke clean` - Remove untracked files (interactive)


## License

MIT License - see LICENSE file for details.
neo4j-rust-ext 5.28.3.0
Rust Extensions for a Faster Neo4j Bolt Driver for Python
Requires Python: >=3.7
Keywords: neo4j, graph, database

# Rust Extensions for a Faster Neo4j Bolt Driver for Python

This project contains Rust extensions to speed up the [official Python driver for Neo4j](https://github.com/neo4j/neo4j-python-driver).

The exact speedup depends on the use-case but has been measured to be up to 10x faster.
Use-cases moving only few but big records out of the DBMS tend to benefit the most.


## Installation
Adjust your dependencies (`requirements.txt`, `pyproject.toml` or similar) like so:
```
# remove:
# neo4j == X.Y.Z  # needs to be at least 5.14.1 for a matching Rust extension to exist
# add:
neo4j-rust-ext == X.Y.Z.*
```

I.e., install the same version of `neo4j-rust-ext` as you would install of `neo4j` (except for the last segment which is used for patches of this library).  
That's it!
You don't have to change your code but can use the driver as you normally would.
This package will install the driver as its dependency and then inject itself in a place where the driver can find it and pick it up.

N.B., since the driver is a simple Python dependency of this package, you can also manually install/specify both packages at the same time without issues.
However, make sure the versions match if you do so or leave the version of one of the two unspecified to let the package manager pick a compatible version for you (resolution might be slow, however).

If you experience issues with the driver, consider troubleshooting without the Rust extension first.
For that, simply make sure you haven't installed `neo4j-rust-ext` but *only* `neo4j`.


## Requirements
For many operating systems and architectures, the pre-built wheels will work out of the box.
If they don't, pip (or any other Python packaging front-end) will try to build the extension from source.
Here's what you'll need for this:
 * Rust 1.77 or later:  
   https://www.rust-lang.org/tools/install
 * Further build tools (depending on the platform).  
   E.g., `gcc` on Ubuntu: `sudo apt install gcc`