semvec/pypi-packages huggingface dataset:
udbserver 0.2.2
Python bindings of udbserver

Python bindings for udbserver
=============================

This package provides Python bindings for udbserver, allowing you to debug your Unicorn-based projects with GDB.
For more details about udbserver, please check the `project homepage <https://github.com/bet4it/udbserver>`_.

Installation
------------

From PyPI
~~~~~~~~~

It's highly recommended to install the Python package via pip::

    pip install udbserver

From source
~~~~~~~~~~~

To build and install this package manually::

    python3 -m build --wheel
    pip install dist/*.whl
vistools 0.4.3
Utility functionality for vtk and pyvista
Requires Python: >=3.10

# VisTools

**VisTools** is a utility library for scientific visualization workflows, focused on the pure VTK data format as well as PyVista.

## Modules

- `vistools.vtk`: Utility functions based only on the plain `vtk` python package.

- `vistools.pyvista`: Utility functions for PvVista, depends on `vistools.vtk`.

## Installation

VisTools is available via `pip` and can be installed with
```bash
# Install only vistools.vtk
pip install vistools
# Install all modules
pip install "vistools[pyvista]"
```
PyMUMPS 0.4.0
Python bindings for MUMPS, a parallel sparse direct solver
Requires Python: >=3.8

PyMUMPS: A parallel sparse direct solver
========================================


Requirements
------------

* [MUMPS](http://graal.ens-lyon.fr/MUMPS/)
* [mpi4py](https://code.google.com/p/mpi4py/)


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

PyMUMPS can be installed from PyPI using pip:

```
pip install pymumps
```

Custom build flags, e.g. to specify the MUMPS installation location,
can be specified using `-C`:

```
pip install -v \
    -Cbuild.verbose=true \
    -Ccmake.define.MUMPS_ROOT=<PATH_OF_MUMPS_INSTALLATION> \
    pymumps
```

There is also conda recipe:

```
conda install -c conda-forge pymumps
```


Examples
--------

Centralized input & output. The sparse matrix and right hand side are
input only on the rank 0 process. The system is solved using all
available processes and the result is available on the rank 0 process.

```python
from mumps import DMumpsContext
ctx = DMumpsContext()
if ctx.myid == 0:
    ctx.set_centralized_sparse(A)
    x = b.copy()
    ctx.set_rhs(x) # Modified in place
ctx.run(job=6) # Analysis + Factorization + Solve
ctx.destroy() # Cleanup
```

Re-use symbolic or numeric factorizations.

```python
from mumps import DMumpsContext
ctx = DMumpsContext()
if ctx.myid == 0:
    ctx.set_centralized_assembled_rows_cols(A.row+1, A.col+1) # 1-based
ctx.run(job=1) # Analysis

if ctx.myid == 0:
    ctx.set_centralized_assembled_values(A.data)
ctx.run(job=2) # Factorization

if ctx.myid == 0:
    x = b1.copy()
    ctx.set_rhs(x)
ctx.run(job=3) # Solve

# Reuse factorizations by running `job=3` with new right hand sides
# or analyses by supplying new values and running `job=2` to repeat
# the factorization process.
```
alg-etf 0.1.3
analog layout generator using rust backend mainly for etf layouts
Requires Python: >=3.9.0

# alg_etf

Analog layout generator using a Rust backend, specifically designed for ETF layouts.

## Features
- Rust-powered performance for geometric operations.
- Python bindings for easy layout scripting.
- Integrated viewer for GDS layouts.

## Installation
```bash
pip install alg_etf
```

## Usage
Refer to the documentation and examples for detailed usage.
pypn-ref-geo 1.5.7
Référentiel géographique

# Référentiel géographique

Prérequis : vous devez installer l’extension PostGIS dans votre base de données.

Création et remplissage du référentiel géographique :

```sh
python3 -m venv venv
source venv/bin/activate
pip install -e .
pip install psycopg2  # for postgresql database
export SQLALCHEMY_DATABASE_URI="postgresql://user:password@localhost:5432database"
cd src/ref_geo/migrations
alembic -x local-srid=2154 upgrade ref_geo@head
alembic upgrade ref_geo_fr_municipalities@head  # Insertion des communes françaises
alembic upgrade ref_geo_fr_departments@head  # Insertion des départements français
alembic upgrade ref_geo_fr_regions@head  # Insertion des régions françaises
alembic upgrade ref_geo_fr_regions_1970@head  # Insertion des anciennes régions françaises
alembic upgrade ref_geo_inpn_grids_1@head  # Insertion du maillage 1×1km de l’hexagone fourni par l’INPN
alembic upgrade ref_geo_inpn_grids_2@head  # Insertion du maillage 2x2km de l’hexagone fourni par l’INPN
alembic upgrade ref_geo_inpn_grids_5@head  # Insertion du maillage 5×5km de l’hexagone fourni par l’INPN
alembic upgrade ref_geo_inpn_grids_10@head  # Insertion du maillage 10×10km de l’hexagone fourni par l’INPN
alembic upgrade ref_geo_inpn_grids_20@head  # Insertion du maillage 20x20km de l’hexagone fourni par l’INPN
alembic upgrade ref_geo_inpn_grids_50@head  # Insertion du maillage 50x50km de l’hexagone fourni par l’INPN
```
gliner2-onnx 0.1.1
GLiNER2 ONNX runtime for NER and classification without PyTorch
Requires Python: >=3.10
Keywords: gliner, named-entity-recognition, ner, nlp, onnx, zero-shot

# gliner2-onnx

GLiNER2 ONNX runtime for Python. Runs GLiNER2 models without PyTorch.

This library is experimental. The API may change between versions.

## Features

- Zero-shot NER and text classification
- Runs with ONNX Runtime (no PyTorch dependency)
- FP32 and FP16 precision support
- GPU acceleration via CUDA

All other GLiNER2 features such as JSON export are not supported. 

## Installation

```bash
pip install gliner2-onnx
```

## NER

```python
from gliner2_onnx import GLiNER2ONNXRuntime

runtime = GLiNER2ONNXRuntime.from_pretrained("lmo3/gliner2-large-v1-onnx")

entities = runtime.extract_entities(
    "John works at Google in Seattle",
    ["person", "organization", "location"]
)
# [
#   Entity(text='John', label='person', start=0, end=4, score=0.98),
#   Entity(text='Google', label='organization', start=14, end=20, score=0.97),
#   Entity(text='Seattle', label='location', start=24, end=31, score=0.96)
# ]
```

## Classification

```python
from gliner2_onnx import GLiNER2ONNXRuntime

runtime = GLiNER2ONNXRuntime.from_pretrained("lmo3/gliner2-large-v1-onnx")

# Single-label classification
result = runtime.classify(
    "Buy milk from the store",
    ["shopping", "work", "entertainment"]
)
# {'shopping': 0.95}

# Multi-label classification
result = runtime.classify(
    "Buy milk and finish the report",
    ["shopping", "work", "entertainment"],
    threshold=0.3,
    multi_label=True
)
# {'shopping': 0.85, 'work': 0.72}
```

## CUDA

To use CUDA for GPU acceleration:

```python
runtime = GLiNER2ONNXRuntime.from_pretrained(
    "lmo3/gliner2-large-v1-onnx",
    providers=["CUDAExecutionProvider", "CPUExecutionProvider"]
)
```

## Precision

Both FP32 and FP16 models are supported. Only the requested precision is downloaded.

```python
runtime = GLiNER2ONNXRuntime.from_pretrained(
    "lmo3/gliner2-large-v1-onnx",
    precision="fp16"
)
```

## Models

Pre-exported ONNX models:

| Model | HuggingFace |
|-------|-------------|
| gliner2-large-v1 | [lmo3/gliner2-large-v1-onnx](https://huggingface.co/lmo3/gliner2-large-v1-onnx) |
| gliner2-multi-v1 | [lmo3/gliner2-multi-v1-onnx](https://huggingface.co/lmo3/gliner2-multi-v1-onnx) |

Note: `gliner2-base-v1` is not supported (uses a different architecture).

## Exporting Models

To export your own models, clone the repository and use make:

```bash
git clone https://github.com/lmoe/gliner2-onnx
cd gliner2-onnx

# FP32 only
make onnx-export MODEL=fastino/gliner2-large-v1

# FP32 + FP16
make onnx-export MODEL=fastino/gliner2-large-v1 QUANTIZE=fp16
```

Output is saved to `model_out/<model-name>/`.

## JavaScript/TypeScript

For Node.js, see [@lmoe/gliner-onnx.js](https://github.com/lmoe/gliner-onnx.js).

## Credits

- [fastino-ai/GLiNER2](https://github.com/fastino-ai/GLiNER2) - Original GLiNER2 implementation
- [fastino/gliner2-large-v1](https://huggingface.co/fastino/gliner2-large-v1) - Pre-trained models

## License

MIT