semvec/pypi-packages huggingface dataset:
type-analyzer 0.1.2
Functions for introspecting Python type hints.
Requires Python: <3.15,>=3.12

# type-analyzer

[![CI](https://github.com/100nm/type-analyzer/actions/workflows/ci.yml/badge.svg)](https://github.com/100nm/type-analyzer)
[![PyPI - Version](https://img.shields.io/pypi/v/type-analyzer.svg?color=blue)](https://pypi.org/project/type-analyzer)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/type-analyzer.svg?color=blue)](https://pypistats.org/packages/type-analyzer)
[![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)

## Installation

⚠️ _Requires Python 3.12 or higher_

```bash
pip install type-analyzer
```

## Quick start

### matching_types

```python
from type_analyzer import MatchingTypesConfig, matching_types

# ----- Union type -----

matching_types(str | int)
# => (str, int)

# ----- Generic type alias -----

type StringOr[T] = str | T

config = MatchingTypesConfig(with_type_alias_value=True)
matching_types(StringOr[int], config)
# => (StringOr[int], str, int)

# ----- Generic classes -----

class A[T]:
    ...

class B[T]:
    ...

class C[T1, T2](A[T1], B[T2]):
    ...

config = MatchingTypesConfig(with_bases=True)
matching_types(C[str, int], config)
# => (C[str, int], A[str], B[int])
```
dt-pose-format 0.7.5
Library for viewing, augmenting, and handling .pose files
Requires Python: >=3.8
Keywords: Pose Files, Pose Interpolation, Pose Augmentation

# Pose Format

## Publishing
```bash
pip3 install --upgrade build twine pyopenssl cryptography requests-toolbelt
rm -rf dist
python3 -m build
python3 -m twine upload dist/*
```
token-service-toolcase 0.1.0
A lightweight tool to fetch Azure AD access tokens.
Requires Python: >=3.10

# token-service-toolcase

`token-service-toolcase` is a lightweight and developer-friendly Python utility designed to fetch OAuth2 access tokens from Azure Active Directory (Azure AD) using the Client Credentials flow.

This package is ideal for microservices, backend applications, internal tools, automation scripts, or any environment where a secure and minimal method of retrieving access tokens is required—without bringing in heavy Azure SDK dependencies.

---

## Features

- ✔ Minimal API surface — easy to integrate  
- ✔ Stateless: no environment variable dependency  
- ✔ No Azure CLI or SDK required  
- ✔ Pure Python implementation using `requests`  
- ✔ Consistent error handling with clear messages  
- ✔ Fully unit-tested (mocked, no network calls)  
- ✔ Compatible with serverless functions, containers, and CI/CD pipelines  

---

## Installation

Install the latest version from PyPI:

```bash
pip install token-service-toolcase
```

## Usage

```python
from token_service_toolcase import TokenService

service = TokenService(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
    tenant_id="YOUR_TENANT_ID",
    scope="https://graph.microsoft.com/.default",
    token_url=f"https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/token",
    grant_type="client_credentials"
)

access_token = service.get_access_token()
print("Access Token:", access_token)
```
pyukkonen 0.0.1
A high-performance C++ Suffix Tree implementation with Python bindings
Requires Python: >=3.6

# pyukkonen

Running Ukkonen's Suffix Tree algorithm in C++ via Python.

## Installation

```bash
pip install pyukkonen
```

## usage

```python
import pyukkonen
tree = pyukkonen.SuffixTree("banana")
tree.print_tree()
```
playtest2 0.0.6
Python port of uzabase/playtest2
Requires Python: >=3.9
Keywords: automation, gauge, gauge-python, testing

# playtest2

[![PyPI - Version](https://img.shields.io/pypi/v/playtest2.svg)](https://pypi.org/project/playtest2)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/playtest2.svg)](https://pypi.org/project/playtest2)

-----

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Development](#development)
- [License](#license)

## Installation

### Prerequisites

* [Gauge](https://docs.gauge.org/getting_started/installing-gauge)

### Setting up Gauge with playtest2

1. Create a new dedicated virtual environment for Gauge in a **separate** directory from your E2E test project:

```console
$ mkdir /path/to/gauge-project  # Specify your own path here
$ cd /path/to/gauge-project
$ python -m venv .venv --upgrade-deps
$ source .venv/bin/activate
```

2. Install playtest2 in the virtual environment:

```console
(.venv) $ python -m pip install playtest2
```

## Usage

### Gauge Configuration

Edit `python.properties` in `env/default/` (Or run experimental command `playtest2 setup`).

```
STEP_IMPL_DIR = /**absolute**/path/of/gauge-project/.venv/lib/python3.x/site-packages/playtest2
```

Create `playtest2.properties` in `env/default/`.

```
SUT_BASE_URL = http://127.0.0.1:8000
```

On activating the virtual environment for Gauge, run `gauge` command in your E2E test project:

```console
(.venv) $ cd /path/to/e2e/project
(.venv) $ gauge run specs
```

### Spec example

```markdown
# サンプルアプリのテスト

## GETリクエストが送れる

* パス"/"に
* メソッド"GET"で
* リクエストを送る

* レスポンスのボディが
* JSONのパス"$.message"に対応する値が
* 文字列の"Hello World"である
```

## Development

Prerequisites: **Hatch** ([Installation](https://hatch.pypa.io/latest/install/))

### Lint

```bash
hatch fmt && hatch run types:check
```

### Test

```bash
hatch test --randomize --doctest-modules
```

## License

`playtest2` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
opusfilter 3.3.1
Toolbox for filtering parallel corpora
Requires Python: >=3.8

# OpusFilter

OpusFilter is a tool for filtering and combining parallel corpora.

Features:

* Corpus preprocessing pipelines configured with [YAML](https://yaml.org/)
* Simple downloading of parallel corpora from [OPUS](http://opus.nlpl.eu/) with [OpusTools](https://github.com/Helsinki-NLP/OpusTools)
* Implementations for many common text file operations on parallel files
* Memory-efficient processing of large files
* Implemented filters based e.g. on language identification, word aligment, n-gram language models, and multilingual sentence embeddings
* Extendable with your own filters written in Python

OpusFilter has been presented in [ACL 2020 system demonstrations](https://www.aclweb.org/anthology/2020.acl-demos.20).

## Installing

Install the latest release from PyPI:

* `pip install opusfilter` or `pip install opusfilter[all]` (include optional Python libraries)

Install from source:

* `pip install .` or `python setup.py install`

### Troubleshooting

OpusFilter should generally work fine on Python 3.8 to 3.13. In the case of troubles, try installing the exact versions in `requirements.txt`:

* `pip install -r requirements.txt`

## Documentation

The complete OpusFilter documentation is available from [helsinki-nlp.github.io/OpusFilter](https://helsinki-nlp.github.io/OpusFilter/).

You can also build the documents from the source:

* `pip install -r docs/requirements.txt` or  `pip install .[docs]`
* `sphinx-build docs docs-html`

## Changelog

A changelog is available in [docs/CHANGELOG.md](docs/CHANGELOG.md).

## Citing

If you use OpusFilter in your research, please cite our [ACL 2020 paper](https://www.aclweb.org/anthology/2020.acl-demos.20):

```bibtex
@inproceedings{aulamo-etal-2020-opusfilter,
    title = "{O}pus{F}ilter: A Configurable Parallel Corpus Filtering Toolbox",
    author = {Aulamo, Mikko and Virpioja, Sami and Tiedemann, J{\"o}rg},
    booktitle = "Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations",
    month = jul,
    year = "2020",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/2020.acl-demos.20",
    doi = "10.18653/v1/2020.acl-demos.20",
    pages = "150--156"
}
```

A full bibliography of papers cited in the documentation and code can be found from [docs/references.bib](docs/references.bib).

## Contributing

See [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
synagent 0.0.1
Utility for reaction modeling using graph grammar
Requires Python: >=3.11

SynAgent
========

SynAgent is a proof-of-concept agent that orchestrates multiple Syn™ ecosystem
packages: **SynKit**, **SynRBL**, **SynTemp**, **SynCat**, **SynRFP**, and
**SynRXN**.  It wraps each package into a standard tool interface and
provides a simple agent core that sequences these tools for end-to-end
reaction informatics workflows.

Features
--------

- **SynRBL**: Rule- and MCS-based reaction rebalancing.
- **SynKit**: Reaction canonicalization and mechanistic transition graphs.
- **SynTemp**: High-accuracy reaction template extraction with consensus atom mapping.
- **SynCat**: Graph-based reaction classification via cross-attention models.
- **SynRFP**: Mapping-free, permutation-invariant reaction fingerprints.
- **SynRXN**: Reproducible reaction datasets and splits.

Structure
---------

- ``synagent/``: Core package providing the agent (``agent.py``), registry
  (``registry.py``) and tool wrappers.
  - ``tools/``: Implementations of each tool wrapper and a base protocol.
- ``README.md``: This document describing the package.

Usage
-----

1. **Register tools**: Instantiate a :class:`~synagent.registry.ToolRegistry`
   and register imported tool instances from :mod:`synagent.tools`.
2. **Create an agent**: Instantiate :class:`~synagent.agent.AgentCore`
   with the registry.
3. **Build a plan**: Create a list of
   :class:`~synagent.agent.PlanStep` objects specifying tool names and
   their parameters.
4. **Run the plan**: Call ``agent.run(plan)`` to execute tool calls
   sequentially.

Example
~~~~~~~

```python
from synagent import ToolRegistry, AgentCore, PlanStep
from synagent.tools import synrbl_balance, synkit_canonicalize

# 1. Register tools
registry = ToolRegistry()
registry.register(synrbl_balance)
registry.register(synkit_canonicalize)

# 2. Initialize agent
agent = AgentCore(registry)

# 3. Build plan
plan = [
    PlanStep("synrbl.balance", {"reaction": "CC=O>>CC(=O)O"}),
    PlanStep("synkit.canonicalize", {"reaction": "CC=O>>CC(=O)O", "with_mt_graph": False}),
]

# 4. Run
result = agent.run(plan)
print(result)
```

Notes
-----

- The actual Syn™ packages must be installed in your environment for the
  wrappers to work.
- Each tool uses lazy imports to avoid unnecessary dependencies until
  invoked.
- Error handling is basic; real-world agents should implement more
  robust failure recovery and logging.

License
-------

This repository is released under the Apache 2.0 License, consistent
with the licensing of the underlying Syn packages.
ojt-task-cli 0.0.7
A command-line interface for managing tasks with projects and priorities.
Requires Python: >=3.6


# Task CLI

A command-line interface (CLI) tool for managing tasks with support for projects, priorities, and persistence.

## Features
- **Add Tasks**: Create new tasks with optional project and priority.
- **List Tasks**: View all tasks, or filter by project/priority.
- **Complete Tasks**: Mark tasks as done.
- **Delete Tasks**: Remove tasks permanently.
- **Export Tasks**: Export tasks to a CSV file.
- **Persistence**: Tasks are saved to a JSON file.

## Usage


### Add Task
Create a new task.
```bash
# Simple
python3 task.py add "Buy milk"

# With Project and Priority
python3 task.py add "Finish Report" --project Work --priority High

# Recurring Task (Daily, Weekly, etc.)
python3 task.py add "Daily Standup" --recurrence daily

# With Due Date
python3 task.py add "Submit Assignment" --due-date 2023-12-31
```

### List Tasks
View tasks with optional filters.
```bash
# List all
python3 task.py list

# Filter by Project
python3 task.py list --project Work

# Filter by Priority
python3 task.py list --priority High
```

### Update Task
Modify an existing task.
```bash
# Update Title and Priority
python3 task.py update <id> --title "New Title" --priority Low

# Update Recurrence
python3 task.py update <id> --recurrence weekly

# Relist a Task (Move from Done -> Pending)
# This increments the 'Relist' counter
python3 task.py update <id> --status pending

# Update Due Date
python3 task.py update <id> --due-date 2024-01-15
```

### Complete Task
Mark a task as done.
```bash
python3 task.py done <id>
```
*Note: If the task is recurring, a new pending task will be automatically created.*

### Delete Task
Permanently remove a task.
```bash
python3 task.py delete <id>
```


### Export Tasks
Export tasks to a CSV file.
```bash
# Export to default file (tasks.csv)
python3 task.py export

# Export to specific file
python3 task.py export my_tasks.csv
```

## Running Tests
```bash
python3 -m unittest discover tests
```
bib-humans 0.1.0
Synthetic humans data generator
Requires Python: >=3.9

the library provides different scopes of information
Father Objects

a set of classes that represent biblical fathers, such as Abraham, Isaac and Jacob.

import humans

abraham = humans.Abraham()
print(abraham.__dict__)

List of Humans

on a broader scope, the library traces different categories of humans, such as fathers, mothers and children.

import humans

all_mothers = humans.mothers
print(all_mothers)