semvec/pypi-packages huggingface dataset:
amazon-bedrock-haystack 6.4.0
An integration of AWS S3 and Bedrock as a Downloader and Generator components.
Requires Python: >=3.10

# amazon-bedrock-haystack

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

- [Integration page](https://haystack.deepset.ai/integrations/amazon-bedrock)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/amazon_bedrock/CHANGELOG.md)
---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

To run integration tests locally, you need to authenticate with AWS.
For example, you can do that by exporting the following environment variables:
```
export AWS_ACCESS_KEY_ID=...
export AWS_SECRET_ACCESS_KEY=...
export AWS_SESSION_TOKEN=...
export AWS_DEFAULT_REGION=...
```
datacrunch 1.20.0
datacrunch is now verda
Requires Python: >=3.10

# datacrunch is now verda

This package has been renamed to `verda`. Use `pip install verda` or `uv add verda` instead.

To migrate from `datacrunch`, follow [the migration guide](https://github.com/verda-cloud/sdk-python/blob/master/MIGRATION.md).

New package: https://pypi.org/project/verda/
pyconvertu 1.1.0
From/to Classification Converter
Requires Python: >=3.10
Keywords: data-science, classification, converter, iso-3166-1, iso-3166-1-alpha-3, iso-3166-1-alpha-2, iso-3166-1-numeric

# CONVERTU - From/to Classification Converter

Tools for creating and converting between classification systems.

## Installation

```bash
pip install pyconvertu
```

## Quick example
python:  
```python
from convertu import cconv

print(cconv(to="iso3", text=["Czech Republic", "Slovakia"]))
```
bash:  
```bash
cconv -t iso3 'Czech Republic' 'Slovakia'
echo -e "Czech Republic\nSlovakia" | cconv -t iso3
```

## User Reference

```python
cconv(
    data=[...], json_file='...', info=False, dump=False,
    to="...", text="..." | ["...", "..."], *args, **kwargs
)
```

Convert text into a target classification using a JSON mapping, or return mapping/metadata (info/dump modes).

**Parameters:**  

`data` : *list[dict]*, optional  
A complete classification mapping provided directly as a list of dictionaries. If supplied without `json_file`, this data will be used in-memory for conversions without reading from disk.

`json_file` : *str*, optional  
Path to the classification JSON file. If not provided, the default bundled `classification.json` is used. When `data` is not supplied, this file is loaded and used as the source mapping. When `data` is supplied along with `json_file`, the data is written to `json_file`.

`info` : *bool*, default = *False*  
If *True*, return only metadata/sources entries. No conversion.

`dump` : *bool*, default = *False*  
If *True*, return the full mapping (filtered of metadata/sources). No conversion.

`to` : *str*  
Target field name to return from matched records (e.g., "iso3").

`text` : *str* | *list[str]*  
One string or a list of strings to convert. A single string input yields a single string output; a list yields a list.

**Classification passed via `data`**

The JSON must follow the same structure as the bundled classification.json.

```
[
    {
        "regex":    "^(.*afgh.*|\\s*AFG\\s*|\\s*AF\\s*|\\s*4\\s*)$",
        "name_en":  "Afghanistan",
        "name_fr":  "Afghanistan (l')",
        "iso3":     "AFG",
        "iso2":     "AF",
        "isoN":     "4"
    },
    ...
    {
        "metadata": {
            "name_en": "English short name",
            "name_fr": "French short name",
            "iso3": "alpha-3 code",
            "iso2": "alpha-2 code",
            "isoN": "numeric"
        }
    },
    {
        "sources": [
            "[https://www.iso.org/iso-3166-country-codes.html](ISO 3166 COUNTRY CODES)",
            "[https://en.wikipedia.org/wiki/List_of_alternative_country_names](ALTERNATIVE NAMES)"
        ]
    }
]
```

## License

MIT License — see the [LICENSE](LICENSE) file.
abstractsemantics 0.0.2
Semantics registry (predicates/types) for AbstractFramework.
Requires Python: >=3.10

# AbstractSemantics (`abstractsemantics`)

Central, editable semantics registry (predicates + entity types) for AbstractFramework, with helpers to build a compact JSON Schema for knowledge-graph (KG) assertion structured outputs.

This package intentionally contains **definitions**, not storage:
- prefix mappings (CURIE namespaces)
- predicate allowlists (optional inverse pointers)
- entity-type allowlists

## Status

Small, dependency-light package (only PyYAML) with a tiny public API:
- the default registry is shipped as package data (`abstractsemantics/semantics.yaml`; in this repo: `src/abstractsemantics/semantics.yaml`)
- the loader returns immutable dataclasses (`SemanticsRegistry`)
- the v0 schema builder produces a deterministic JSON Schema dict

## Install

From PyPI:

```bash
pip install abstractsemantics
```

From source (editable, with test deps):

```bash
pip install -e ".[dev]"
```

Requires Python `>=3.10` (see `pyproject.toml`).

## Quickstart

Load the default registry and build the v0 structured-output schema:

```python
from abstractsemantics import load_semantics_registry, build_kg_assertion_schema_v0

reg = load_semantics_registry()
print(len(reg.predicates), len(reg.entity_types))

schema = build_kg_assertion_schema_v0(registry=reg, include_predicate_aliases=True)
```

Use a custom registry YAML (must exist on disk):

```bash
export ABSTRACTSEMANTICS_REGISTRY_PATH=/absolute/path/to/semantics.yaml
```

```python
from abstractsemantics import load_semantics_registry

reg = load_semantics_registry()  # loads from ABSTRACTSEMANTICS_REGISTRY_PATH if set
```

Note: `load_semantics_registry()` only requires at least 1 predicate, but `build_kg_assertion_schema_v0()` requires both predicate ids **and** entity-type ids (it raises `ValueError` if `entity_types` is empty).

## Intended consumers (external)

This package is designed to be consumed by:
- AbstractRuntime (validation at ingestion boundary)
- AbstractFlow (UI dropdowns + authoring support)
- AbstractMemory (storage/query on top of validated semantics)

## Documentation

Start with:
- `docs/getting-started.md` (recommended entrypoint)
- `docs/README.md` (documentation index)
- `docs/architecture.md` (what exists in this repo, with diagrams)
- `docs/registry.md` (registry YAML format)
- `docs/schema.md` (KG assertion JSON Schema + `$ref`)
- `docs/faq.md` (common questions and troubleshooting)

## Project

- Changelog: `CHANGELOD.md`
- Contributing: `CONTRIBUTING.md`
- Security: `SECURITY.md`
- Acknowledgments: `ACKNOWLEDMENTS.md`

## License

MIT (see `LICENSE`).
abstractagent 0.3.1
Agent implementations using AbstractRuntime and AbstractCore
Requires Python: >=3.10

# AbstractAgent

Agent patterns (ReAct / CodeAct / MemAct) built on **AbstractRuntime** (durable execution) and **AbstractCore** (tools + LLM integration).

Start here: [`docs/getting-started.md`](docs/getting-started.md) (then [`docs/README.md`](docs/README.md) for the full index)

## Documentation

- Getting started: [`docs/getting-started.md`](docs/getting-started.md)
- API reference: [`docs/api.md`](docs/api.md)
- FAQ / troubleshooting: [`docs/faq.md`](docs/faq.md)
- Architecture (diagrams): [`docs/architecture.md`](docs/architecture.md)
- Changelog: [`CHANGELOG.md`](CHANGELOG.md)
- Contributing: [`CONTRIBUTING.md`](CONTRIBUTING.md)
- Security: [`SECURITY.md`](SECURITY.md)
- Acknowledgements: [`ACKNOWLEDMENTS.md`](ACKNOWLEDMENTS.md)

## What you get

- **ReAct**: tool-first Reason → Act → Observe loop
- **CodeAct**: executes Python (tool call or fenced ` ```python``` ` blocks)
- **MemAct**: memory-enhanced agent using runtime-owned Active Memory
- **Durable runs**: pause/resume via `run_id` + runtime stores
- **Tool control**: explicit tool bundles + per-run allowlists
- **Observability**: durable ledger of LLM calls, tool calls, and waits

## Installation

From source (development):

```bash
pip install -e .
```

With dev dependencies:

```bash
pip install -e ".[dev]"
```

From PyPI:

```bash
pip install abstractagent
```

Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:

```bash
python -c "import importlib.metadata as md; print(md.version('abstractagent'))"
```

## Quick start (ReAct)

```python
from abstractagent import create_react_agent

agent = create_react_agent(provider="ollama", model="qwen3:1.7b-q4_K_M")
agent.start("List the files in the current directory")
state = agent.run_to_completion()
print(state.output["answer"])
```

## Persistence (resume across restarts)

By default, the factory helpers use an in-memory runtime store. For resume across process restarts,
pass a persistent `RunStore`/`LedgerStore` (example below uses JSON files).

```python
from abstractagent import create_react_agent
from abstractruntime.storage.json_files import JsonFileRunStore, JsonlLedgerStore

run_store = JsonFileRunStore(".runs")
ledger_store = JsonlLedgerStore(".runs")

agent = create_react_agent(run_store=run_store, ledger_store=ledger_store)
agent.start("Long running task")
agent.save_state("agent_state.json")

# ... later / after restart ...

agent2 = create_react_agent(run_store=run_store, ledger_store=ledger_store)
agent2.load_state("agent_state.json")
state = agent2.run_to_completion()
print(state.output["answer"])
```

More details: [`docs/persistence.md`](docs/persistence.md)

## CLI

This repository still installs a `react-agent` entrypoint, but it is **deprecated** and only prints a migration hint
(see `src/abstractagent/repl.py` and `pyproject.toml`).

Interactive UX lives in **AbstractCode**.

## License

MIT (see `LICENSE`).
ibm-watsonx-gov 1.4.1
IBM watsonx.governance SDK
Requires Python: <3.14,>=3.11

---

## Welcome to `ibm-watsonx-gov`

---

`ibm-watsonx-gov` is a python SDK for IBM watsonx.governance providing capabilities to evaluate metrics, prompt templates, get model insights and perform model risk evaluation.

### Getting Started

You can explore the library capabilities from the [sample notebooks](https://github.com/IBM/ibm-watsonx-gov/tree/samples/notebooks). You can also refer to the [library documentation](https://ibm.github.io/ibm-watsonx-gov).

**Important Notice:** IBM is not responsible for any existing vulnerabilities within the third-party dependencies that are required to install the ibm-watsonx-gov python package.

**License** This library is delivered under the [International License Agreement for Non-Warranted Programs](https://www.ibm.com/support/customer/csol/terms/?id=L-RPBG-A5UA3C&lc=en).
QWnet 2.0.2
A unified Quantum Walk simulation package
Requires Python: >=3.8

# QWnet Package

This package provides a unified interface for various Quantum Walk simulations.

## Installation

```bash
pip install QWnet
```

## Usage

```python
import QWnet as qw

# 1D/2D/3D Lattice Walks
qw.run_simulation('1d', steps=100)
qw.run_simulation('2d', steps=50)
qw.run_simulation('3d', steps=20)

# Graph Walks
qw.run_simulation('ChawlaQW', file_path='graph.edgelist', steps=100)
qw.run_simulation('QPageRank', steps=20, alpha=0.85)
qw.run_simulation('HadamardQW', steps=100, top_p=0.05)
qw.run_simulation('SzegedyQW', steps=10)
qw.run_simulation('directSumQW', initial_state='uniform', coin_type='fourier')
```
writer 1.28.0
An open-source, Python framework for building feature-rich apps that are fully integrated with the Writer platform.
Requires Python: <4.0,>=3.9.2
Keywords: data apps, gui, ui, framework, writer framework

## What is Writer Framework?

Writer Framework is an open-source framework for creating AI applications. Build user interfaces using a visual editor; write the backend code in Python.

Writer Framework is fast and flexible with a clean, easily-testable syntax. It provides separation of concerns between UI and business logic, enabling more complex applications.

## Quick Start

### Installation

Writer Framework works on Linux, Mac, and Windows. It supports Python versions 3.9.2 through 3.12.

```sh
pip install writer
```

### Create and Run Your First App

```sh
# Create a demo app
writer hello

# Create a new app
writer create my_app

# Edit your app (opens visual editor)
writer edit my_app

# Run your app
writer run my_app
```

The `writer edit` command opens the visual editor in your browser where you can build your UI by dragging and dropping components.

## Documentation

For comprehensive guides, tutorials, and API reference, visit the [official documentation](https://dev.writer.com/framework/quickstart).

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md)

## About Writer

Writer is the full-stack generative AI platform for enterprises. Quickly and easily build and deploy generative AI apps with a suite of developer tools fully integrated with our platform of LLMs, graph-based RAG tools, AI guardrails, and more. Learn more at [writer.com](https://www.writer.com?utm_source=github&utm_medium=readme&utm_campaign=framework).

## License

This project is licensed under the Apache 2.0 License.
differt-core 0.7.0
Core backend of DiffeRT implemented in Rust
Requires Python: >=3.11
Keywords: ray tracing, differentiable, propagation, radio, jax

<div align="center">
<img src="https://raw.githubusercontent.com/jeertmans/DiffeRT/main/static/logo_250px.png" alt="DiffeRT logo"></img>
</div>

<div align="center">

# DiffeRT-core

[![Latest Release][pypi-version-badge]][pypi-version-url]
[![Python version][pypi-python-version-badge]][pypi-version-url]
[![Documentation][documentation-badge]][documentation-url]

</div>

This package contains the core backend of
[DiffeRT](https://pypi.org/project/DiffeRT/),
implemented in Rust for performance.

As a result, both `differt` and `differt-core` will
share the same version, and `differt` directly depends on `differt-core`.

However, you can decide to only install `differt-core`
if you want to use features that are specific to this package.

The installation procedure, contributing guidelines, and documentation,
are shared with the
[main DiffeRT package](https://github.com/jeertmans/DiffeRT).

[pypi-version-badge]: https://img.shields.io/pypi/v/DiffeRT-core?label=DiffeRT-core&color=blueviolet
[pypi-version-url]: https://pypi.org/project/DiffeRT-core/
[pypi-python-version-badge]: https://img.shields.io/pypi/pyversions/DiffeRT-core?color=orange
[documentation-badge]: https://readthedocs.org/projects/differt/badge/?version=latest
[documentation-url]: https://differt.readthedocs.io/latest/?badge=latest