semvec/pypi-packages huggingface dataset:
graphreveal 1.2.0
Small graphs database and search system
Requires Python: >=3.10
Keywords: database, graph-theory, graphs

# GraphReveal

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/graphreveal)](https://pypi.org/project/graphreveal/)
[![PyPI - Version](https://img.shields.io/pypi/v/graphreveal)](https://pypi.org/project/graphreveal/)
[![Test](https://github.com/mdbrnowski/GraphReveal/actions/workflows/test.yml/badge.svg)](https://github.com/mdbrnowski/GraphReveal/actions/workflows/test.yml)

Have you ever needed an example of a graph that, e.g., is Hamiltonian, has exactly 8 vertices, and can be drawn on a plane without intersecting edges? Or wondered how many graphs of size 10 are bipartite, have no isolated vertices, and have exactly two components?

This package aims to answer some of your questions. You can search through all graphs with some reasonable order (currently 9 is the maximum) using a very simple DSL (*domain-specific language*).

## Installation

Make sure that you have Python in a sufficiently recent version. To install the package using `pip`, you can use the following command:

```shell
pip install graphreveal
```

## Basic usage

Firstly, you should create the database:

```shell
graphreveal create-database
```

This process should take less than two seconds and will create a database of graphs with an order no greater than 7. To use a larger database, add the `--n 8` or `--n 9` flag to this command (it should take no more than half an hour).

### Some examples

```shell
graphreveal search "10 edges, bipartite, no isolated vertices, 2 components"
```

```shell
graphreveal count "5..6 vertices, connected"
```

```shell
graphreveal count "5 vertices, connected, not (eulerian | planar)"
```

Command `search` will print a list of graphs in [graph6](https://users.cecs.anu.edu.au/~bdm/data/formats.html) format.
You can use [houseofgraphs.org](https://houseofgraphs.org/draw_graph) to visualize them.
Command `count` will simply output the number of specified graphs.

### List of available properties

* [N] `vertices` (alternatives: `verts`,`V`, `nodes`)
* [N] `edges` (alternative: `E`)
* [N] `blocks` (alternative: `biconnected components`)
* [N] `components` (alternative: `C`)
* `acyclic` (alternative: `forest`)
* `bipartite`
* `complete`
* `connected`
* `cubic` (alternative: `trivalent`)
* `eulerian` (alternative: `euler`)
* `hamiltonian` (alternative: `hamilton`)
* `no isolated vertices` (alternatives: `no isolated v`, `niv`)
* `planar`
* `regular`
* `tree`

As [N], you can use a simple number or range (e.g., `3-4`, `3..4`, `< 5`, `>= 2`).
You can also negate any property using `!` or `not`.
Use `|` for alternatives (disjunction) and parentheses `()` for grouping.
Conjunction (`,` or `;`) binds tighter than `|`.
hypergas 0.6.0
Python package for hyperspectral satellite imaging of trace gases
Requires Python: >=3.12

.. image:: https://raw.githubusercontent.com/SRON-ESG/HyperGas/main/doc/fig/logo.png
   :alt: HyperGas Logo
   :width: 500

========
HyperGas
========

The HyperGas package is a python library for retrieving trace gases enhancements from hyperspectral satellite data and writing it to different formats (NetCDF, PNG, and HTML).
HyperGas also supports generating plume masks and calculating gas emission rates.

Installation
============

The documentation is available at https://hypergas.readthedocs.io/.
accelerator-commissioning 1.0.0
A Python Simulated Commissioning toolkit for synchrotrons (inspired by https://github.com/ThorstenHellert/SC)
Requires Python: >=3.9
Keywords: Accelerator, Commissioning, Synchrotron

# pySC

Python Simulated Commissioning toolkit for synchrotrons.

## Installing

```bash
pip install accelerator-commissioning
```

## Importing specific modules

Intended way of importing a pySC functionality:

```
from pySC import SimulatedCommissioning
from pySC import generate_SC

from pySC import ResponseMatrix

from pySC import orbit_correction
from pySC import measure_bba
from pySC import measure_ORM
from pySC import measure_dispersion

from pySC import pySCInjectionInterface
from pySC import pySCOrbitInterface

# the following disables rich progress bars (doesn't work well with )
from pySC import disable_pySC_rich
disable_pySC_rich()
```


## Acknowledgements

This toolkit was inspired by [SC](https://github.com/ThorstenHellert/SC) which is written in Matlab.
osef 3.4.0
Osef python library.
Requires Python: >=3.8

# OSEF library

Library containing utilities to read and parse a stream, live or recorded, retrieved from
**Shift**.

The stream is in the **OSEF** format (**O**pen **SE**rialization **F**ormat):
it's an Outsight-defined serialisation binary format used to encode data streaming out of Shift. 
It is based on *TLV-encoding*.

For the full documentation, see: [Developer documentation](https://outsight-tech.gitlab.io/common/osef-python-library/).  
You can contact us @ https://support.outsight.ai

## Installation
Install from PyPi using pip:
```bash
pip install osef
``` 
## Usage

Open and parse an osef file or stream: 

```python
import osef

osef_path = "path/to/my/file.osef"
# or osef_path="tcp://192.168.2.2:11120"

for frame_dict in osef.parse(osef_path):
    print(frame_dict)
```

Additional parameters:
- `first`/`last`: the first and the last frame to parse
- `auto_reconnect`: enable parser auto_reconnection (default: `True`)
- `real_frequency`: If False, parse data as fast as your computer can. If True, process the data as the same pace as the real time stream from Shift (default: `False`)
- `lazy`: If lazy, the dict only unpack the values when they are accessed to save up resources (default: `True`)


To find more code samples, see [Outsight Code Samples repository](https://gitlab.com/outsight-public/outsight-code-samples/-/tree/master).

## Development

1. The repository uses LFS to store some large OSEF samples for the tests. You need to install `git-lfs` and then run the following commands to get the files.
```bash
git lfs pull
```

2. Install project and dependencies.
  - create and activate venv (`python -m venv venv`, then `source venv/bin/activate`)
  - `pip install -e .` to install the project
  - `pip install -r test_requirements.txt` to install dev dependencies (formatter, linter, unit tests dependencies)

3. **Linting**. Code is compatible with python 3.8+, pylint is set to ensure compatibility with python 3.8. To quickly run black + pylint,
```bash
./devops/local_lint.sh
```

4. **Unit tests**. We use pytest. Some tests might take time (about a couple of minutes)
```bash
pytest tests/
```
pounce-agent-data 2.0.0
Python SDK for the Pounce v2 Entity API — search, look up, and enrich 59M+ verified B2B companies.
Requires Python: >=3.9
Keywords: agents, ai, api, b2b, companies, pounce, sdk

# pounce-agent-data

Python SDK for the **Pounce v2 Entity API** — search, look up, and enrich 59M+ verified B2B companies.

## Installation

```bash
pip install pounce-agent-data
```

## Quick Start

```python
from pounce_agent_data import PounceClient

client = PounceClient(api_key="your_key")

# Search companies
results, rate = client.search(q="AI companies", country="CH", limit=10)
for company in results["items"]:
    print(company["canonical_name"], company["primary_domain"])

# Lookup by domain
company, rate = client.lookup("stripe.com")
print(company["canonical_name"], company["trust_tier"])

# AI semantic search (2 credits)
results, rate = client.semantic_search("fintech startups in Switzerland")

# Full company profile
detail, rate = client.detail(entity_id=12345)
```

## Authentication

Pass your API key directly or set the `POUNCE_API_KEY` environment variable:

```bash
export POUNCE_API_KEY=your_key
```

```python
client = PounceClient()  # reads from env
```

## API Methods

| Method | Credits | Description |
|--------|---------|-------------|
| `search()` | 1 | Filter companies by keyword, country, category |
| `semantic_search()` | 2 | AI-powered natural language search |
| `lookup(domain)` | 1 | Find a company by domain |
| `detail(entity_id)` | 1 | Full company profile |
| `bulk_lookup(domains)` | 1/found | Bulk lookup up to 100 domains |
| `match_score(a, b)` | 3 | Similarity score between two companies |
| `stats()` | 0 | Public platform statistics |

## Rate Limits

Every response includes rate limit info:

```python
results, rate = client.search(q="test")
print(rate.remaining)      # calls remaining this month
print(rate.credits_used)   # credits consumed by this call
```

## Plans

| Plan | Monthly Calls | Rate/Min |
|------|--------------|----------|
| Free | 100 | 30 |
| Developer ($39/mo) | 5,000 | 60 |
| Business ($149/mo) | 25,000 | 300 |
| Enterprise ($499/mo) | 200,000 | 1,000 |

## Links

- [API Documentation](https://pounce.ch/developers)
- [Get an API Key](https://pounce.ch/settings/api)
iguazio 0.0.5
Python SDK for the Iguazio Platform management API
Requires Python: >=3.11
Keywords: iguazio, igz

# iguazio - Management API SDK

Python SDK for Iguazio 4 Management API

## Installation

```console
pip install iguazio
```

## License

`iguazio` is distributed under the terms of the [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0) license.

## Documentation

TBD
param-manager 0.3.9
Biblioteca para gerenciamento de parâmetros com padrão Singleton,cache e armazenamento local usando TinyDB.
Requires Python: <=3.14,>=3.8

# Biblioteca ParamManager

## Descrição
Biblioteca Python orientada a objetos que implementa o padrão Singleton para interagir com a API de parâmetros. A biblioteca oferece funcionalidades de cache, armazenamento local com TinyDB e fallback automático em caso de indisponibilidade da API.

## Funcionalidades

- **Padrão Singleton**: Garante que exista apenas uma instância da classe de acesso à API
- **Cache**: Armazena resultados em memória por até 1 hora para reduzir chamadas à API
- **Armazenamento Local**: Usa TinyDB para persistir dados localmente
- **Fallback Automático**: Utiliza dados locais quando a API está indisponível
- **Recuperação de Parâmetros**: Permite buscar todos os parâmetros de um app ou um parâmetro específico

## Instalação

```bash
pip install param-manager
```

## Uso Básico

```python
from param_manager import ParamManager

# Obter a instância do gerenciador
param_manager = ParamManager.get_instance()

# Recuperar todos os parâmetros de um app
params = param_manager.get_all_params('nome_do_app')

# Recuperar um parâmetro específico
param = param_manager.get_param('nome_do_app', 'NOME_PARAMETRO')

# Limpar o cache para um app específico
param_manager.clear_cache('nome_do_app')

# Obter informações sobre o cache atual
cache_info = param_manager.get_cache_info()
```

## Configuração Avançada

```python
# Configurar com URL de API personalizada, duração de cache e timeout
param_manager = ParamManager.get_instance(
    api_url="http://minha-api.exemplo.com",
    cache_duration=1800,  # 30 minutos
    timeout=10  # 10 segundos
)
```

## Comportamento de Fallback

Quando a API está indisponível, a biblioteca automaticamente:
1. Tenta acessar a API
2. Em caso de falha, busca dados do armazenamento local
3. Retorna os dados mais recentes disponíveis localmente

## Estrutura de Arquivos

- `param_manager.py`: Implementação principal da biblioteca
- `test_param_manager.py`: Testes unitários para validar o funcionamento
- `README.md`: Documentação da biblioteca
- `requirements.txt`: Dependências necessárias

## Dependências

- Python 3.8+
- requests
- tinydb