semvec/pypi-packages huggingface dataset:
dycw-pre-commit-hooks 0.15.22
Pre-commit hooks
Requires Python: >=3.12

# `pre-commit-hooks`

Pre-commit hooks

## Usage

In `.pre-commit-config.yaml`, add:

```yaml
repos:
  - repo: https://github.com/dycw/pre-commit-hooks
    rev: master
    hooks:
      - id: add-hooks
```

and then run `prek auto-update`.
codelogician 2.0.2
CodeLogician applies neurosymbolic AI to translate source code into precise mathematical logic, striving to create a formal model of the program's behavior that's functionally equivalent to the original source code.
Requires Python: <3.14,>=3.12

# CodeLogician

*CodeLogician* is the neurosymbolic agentic governance framework for AI-powered coding.

*It helps your coding agent think logically about the code it's producing and test cases it's generating.*
The fundamental flaw that all LLM-powered assistants have is the reasoning they're capable of is based on statistics,
while you need rigorous logic-based automated reasoning.

- Generated code is based on explainable logic, not pure statistics
- Generated test cases are generated come with quantitative coverage metrics
- Generated code is consistent with the best security practices leveraging formal verification

To run *CodeLogician*, please obtain an *Imandra Universe API* key available (there's a free starting plan) 
at *[Imandra Universe](https://universe.imandra.ai)* and make sure it's available in your environment as `IMANDRA_UNI_KEY`.

*Three typical workflows*:
1. **DIY mode** - this is where your agent (e.g. Grok) uses the CLI to:
- Learn how to use IML/ImandraX via **`doc`** command (e.g. **`codelogician doc --help`**)
- Synthesizes IML code and uses the **`eval`** command to evaluate it
- If there're errors, use **`codelogician doc view errors`** command to study how to correct the errors and re-evalute the code

2. **Agent/multi-agent mode** - CodeLogician IML Agent is a Langgraph-based agent for automatically formalizing source code into Imandra Modeling Language (IML).
- With `agent` command you can formalize a single source code file (e.g. `codelogician agent PATH_TO_FILE`)
- With `multiagent` command you can formalize a whole directory (e.g. `codelogician agent PATH_TO_DIR`)

3. **Server** 
- This is a "live" and interactive version of the `multiagent` command
- It monitors the filesystem and fire's off formalization tasks on source code updates as necessary
- You can start the server and connect to it with the TUI (we recommend separate terminal screens)


Learn more at *[CodeLogician](https://www.codelogician.dev)!*

To get started, 
```shell
codelogician --help
```
unienv 0.0.1b10
Unified robot environment framework supporting multiple tensor and simulation backends
Requires Python: >=3.10

# UniEnv

Framework unifying robot environments and data APIs. UniEnv provides an universal interface for robot actors, sensors, environments, and data. 

## Tensor library cross-backend Support

UniEnv supports multiple tensor backends with zero-copy translation layers through the DLPack protocol, and allows you to use the same abstract compute backend interface to write custom data transformation layers, environment wrappers and other utilities. This is powered by the [XBArray](https://github.com/UniEnvOrg/XBArray) package.

## Universal Robot Environment Interface

UniEnv supports diverse simulation environments and real robots, built on top of the abstract environment / world interface. This allows you to reuse code across different sim and real robots.

## Universal Robot Data Interface

UniEnv provides a universal data interface for accessing robot data through the abstract `BatchBase` interface. We also provide a utility `ReplayBuffer` for saving data from various environments with diverse data format support, including `hdf5`, memory-mapped torch tensors, and others.

## Installation

Install the package with pip

```bash
pip install unienv
```

You can install optional dependencies such as `gymnasium` (for Gymnasium-compatible environments), `dev`, or `video` by running

```bash
pip install unienv[gymnasium,video]
```

## Local Developments

### Development Environment Setup

To perform development on your local machine, you need to clone the repository and install the package in editable mode.

```bash
git clone https://github.com/UniEnvOrg/UniEnv
cd UniEnv
pip install numpy
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu # You can choose to either install cpu version or cuda version, up to you
pip install jax # same for jax
python -m pip install pytest
python -m pip install tensordict h5py opencv-python
pip install -e .[dev,gymnasium,video]
```

### Before commiting

Make sure all unit tests pass and your added code compiles before commiting or making a PR. You can run the tests with

```bash
pytest
```

## Cite

If you use UniEnv in your research, please cite it as follows:

```bibtex
@software{cao_unienv,
  author = {Cao, Yunhao AND Fang, Kuan},
  title = {{UniEnv: Unifying Robot Environments and Data APIs}},
  year = {2025},
  month = oct,
  url = {https://github.com/UniEnvOrg/UniEnv},
  license = {MIT}
}
```

## Acknowledgements

The idea of this project is inspired by [Gymnasium](https://github.com/Farama-Foundation/Gymnasium) and its predecessor [OpenAI Gym](https://github.com/openai/gym). 
This library is impossible without the great work of DataAPIs Consortium and their work on the [Array API Standard](https://data-apis.org/array-api/latest/). The zero-copy translation layers are powered by the [DLPack](https://github.com/dmlc/dlpack) project.
mithril-client 0.1.0rc2
Mithril CLI and SDK
Requires Python: >=3.10

Mithril CLI and SDK

## Installation

```bash
# For CLI usage
uv tool install mithril-client

# For SDK usage (as a dependency)
uv add mithril-client
```

## CLI Usage

```bash
# Launch a task
ml launch task.yaml -c my-cluster

# Launch with GPU specification
ml launch 'python train.py' --gpus A100:4

# Check status (falls through to sky)
ml status

# Tear down
ml down my-cluster
```

## SDK Usage

```python
from mithril import sky

# All skypilot functionality via fallthrough
task = sky.Task(run="echo hello")
sky.launch(task)
```

## Development

```bash
uv sync --dev
uv run pytest
```

We recommend using [prek](https://prek.j178.dev/) (drop-in replacement for `pre-commit`)
to run the repo’s git hook checks:

```bash
brew install prek
prek install
```
crowdstrike-aidr 0.5.0
Python SDK for CrowdStrike AIDR.
Requires Python: >=3.12

# CrowdStrike AIDR Python SDK

Python SDK for CrowdStrike AIDR.

## Installation

```bash
pip install crowdstrike-aidr
```

## Requirements

Python v3.12 or greater.

## Usage

```python
from crowdstrike_aidr import AIGuard

client = AIGuard(
  base_url_template="https://api.crowdstrike.com/aidr/{SERVICE_NAME}",
  token="my API token"
)

response = client.guard_chat_completions(
    guard_input={
        "messages": [
            {"role": "user", "content": "Hello, world!"}
        ]
    }
)
```

## Timeouts

The SDK uses `httpx.Timeout` for timeout configuration. By default, requests
have a timeout of 60 seconds with a 5 second connection timeout.

You can configure timeouts in two ways:

### Client-level timeout

Set a default timeout for all requests made by the client:

```python
import httpx
from crowdstrike_aidr import AIGuard

# Using a float (total timeout in seconds).
client = AIGuard(
    base_url_template="https://api.crowdstrike.com/aidr/{SERVICE_NAME}",
    token="my API token",
    timeout=30.0,
)

# Using httpx.Timeout for more granular control.
client = AIGuard(
    base_url_template="https://api.crowdstrike.com/aidr/{SERVICE_NAME}",
    token="my API token",
    timeout=httpx.Timeout(timeout=60.0, connect=10.0),
)
```

### Request-level timeout

Override the timeout for a specific request:

```python
# Using a float (total timeout in seconds).
response = client.guard_chat_completions(
    guard_input={"messages": [...]},
    timeout=120.0
)

# Using httpx.Timeout for more granular control.
response = client.guard_chat_completions(
    guard_input={"messages": [...]},
    timeout=httpx.Timeout(timeout=120.0, connect=15.0)
)
```

## Retries

The SDK automatically retries failed requests with exponential backoff. By
default, the client will retry up to 2 times. Set `max_retries` during client
creation to change this.

```python
from crowdstrike_aidr import AIGuard

client = AIGuard(
    base_url_template="https://api.crowdstrike.com/aidr/{SERVICE_NAME}",
    max_retries=5  # Retry up to 5 times.
)
```
sessionViewForClassApiSqlModel 0.1.1
Add your description here
Requires Python: >=3.12

# SQLModel support for classApi

This project provides a simple way to use a SQLModel `Session` inside your classApi views.

First, create your SQLModel engine. Here is a basic example:

```py
# engine.py
from sqlalchemy import create_engine
from sqlmodel import SQLModel

from .model import User  # In this example, User has 3 fields: id, name, and email


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)
```

Then create a new base view using `make_session_view`:

```py
# engine.py
from sqlalchemy import create_engine
from sqlmodel import SQLModel

from sqlmodelclassapi import make_session_view
from .model import User


sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

engine = create_engine(sqlite_url, echo=True)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)

SessionView = make_session_view(engine=engine)  # New base view with session support
```

Now, to create a view, inherit from `SessionView` instead of `BaseView`:

```py
# views.py
class ExampleSessionView(SessionView):
    methods = ["GET", "POST"]

    def get(self, *args):
        statement = select(User)
        results = self.session.exec(statement).all()
        return [
            {"id": user.id, "name": user.name, "email": user.email}
            for user in results
        ]

    def post(self, name: str):
        new_user = User(name=name, email=f"{name.lower()}@example.com")
        self.session.add(new_user)
        self.session.commit()
        self.session.refresh(new_user)

        return {"message": f"User '{name}' created successfully!", "user": new_user}
```

With this setup, all operations in your request run inside the same session, including `pre_{method}` hooks.
latch-eval-tools 0.1.22
Shared eval tools for single-cell bench, spatial bench, and future biology benchmarks.
Requires Python: >=3.10

# latch-eval-tools

Shared eval tools for single-cell bench, spatial bench, and future biology benchmarks.

## Installation

```bash
pip install latch-eval-tools
```

## What is included

- `Eval` / `EvalResult` types
- Built-in graders + `get_grader()`
- `EvalRunner` harness to run an agent against one eval JSON
- `eval-lint` CLI and Python linter APIs

## Quickstart

```python
from latch_eval_tools import EvalRunner, run_minisweagent_task

runner = EvalRunner("evals/count_cells.json")
result = runner.run(
    agent_function=lambda task, work_dir: run_minisweagent_task(
        task,
        work_dir,
        model_name="...your model name...",
    )
)

print(result["passed"])
print(result["grader_result"].reasoning if result["grader_result"] else "No grader result")
```

`EvalRunner.run()` expects an `agent_function(task_prompt, work_dir)` and supports either:
- returning a plain answer `dict`, or
- returning `{"answer": <dict>, "metadata": <dict>}`

If your agent writes `eval_answer.json` in `work_dir`, the runner will load it automatically.

## Graders

Available grader types:

`numeric_tolerance`, `jaccard_label_set`, `distribution_comparison`, `marker_gene_precision_recall`, `marker_gene_separation`, `spatial_adjacency`, `multiple_choice`

```python
from latch_eval_tools.graders import get_grader

grader = get_grader("numeric_tolerance")
result = grader.evaluate_answer(
    agent_answer={"n_cells": 1523},
    config={
        "ground_truth": {"n_cells": 1500},
        "tolerances": {"n_cells": {"type": "relative", "value": 0.05}},
    },
)
print(result.passed, result.reasoning)
```

Built-in harness helpers:

- `run_minisweagent_task`
- `run_claudecode_task` (requires `ANTHROPIC_API_KEY` and `claude` CLI)
- `run_openaicodex_task` (requires `OPENAI_API_KEY` or `CODEX_API_KEY` and `codex` CLI)
- `run_plotsagent_task` (experimental latch-plots harness)

### Linter

Validate eval JSON files:

```bash
eval-lint evals/my_dataset/
eval-lint evals/ --format json
```

```python
from latch_eval_tools.linter import lint_eval, lint_directory

result = lint_eval("evals/test.json")
print(result.passed, result.issues)
```

## Eval JSON shape

```json
{
  "id": "unique_test_id",
  "task": "Task description. Include an <EVAL_ANSWER> JSON template in this text.",
  "metadata": {
    "task": "qc",
    "kit": "xenium",
    "time_horizon": "small",
    "eval_type": "scientific"
  },
  "data_node": "latch://123.node/path/to/data.h5ad",
  "grader": {
    "type": "numeric_tolerance",
    "config": {
      "ground_truth": {"field": 42},
      "tolerances": {"field": {"type": "absolute", "value": 1}}
    }
  }
}
```