semvec/pypi-packages huggingface dataset:
IFE-Surrogate 0.2.2
A machine learning library intended for surrogate modeling tasks.
Requires Python: <3.13,>=3.9

#  IFE Surrogate GP

A flexible and extensible library for Gaussian Processes, built with performance and modularity in mind.  

---

##  Features

-  **High-performance kernels** (JAX-compatible)  
-  **Composable API** for building custom models  
-  **Multiple optimizers** (Optax, Scipy, etc.)  
-  **Automatic hyperparameter handling**  
-  **Built-in training workflows**  

---

##  Installation

```bash
pip install ife_surrogate
```


---

##  Usage

### Quickstart

```python
import ife_surrogate


dataset = np.load("some_data.npy", allow_pickle=True).item()
X, Y, f = dataset["X"], dataset["Y"], dataset["f"]

key = jr.key(seed=42)
(X_train, Y_train), (X_test, Y_test), _= train_test_split(
    X=X, Y=Y, f=f, 
    split=(0.9, 0.1, 0), 
    key= key
)

d = X_train.shape[1]
priors = {"lengthscale": Uniform(1e-0, 1e1), "power": Uniform(1, 2)}
kernel = kernels.Kriging(lengthscale=jnp.ones(d), power=jnp.ones(d), priors=priors)

model = models.WidebandGP(X_train, Y_train, kernel, f)

trainer = trainers.SwarmTrainer(number_iterations=200, number_particles=100)
trainer.train(model)

pred, var = model.predict(X_test)
---

##  Documentation

- [API Reference](#)  
- [Tutorials](#)  
- [Examples](#)  

---

##  Key Components

- **Kernels**  
  - Kriging
  - RBF
  - Matern
  - SumKernel
  - ProductKernel
  - Scale
  - RQ
  - Noise

- **Models**  
  - WidebandGP
  - ScalerGP

- **Trainers*  
  - OptaxTrainer  
  - SwarmTrainer

---

##  Roadmap

- [ ] Add more kernels  
- [ ] GPU/TPU support  
- [ ] Bayesian optimization tools  
- [ ] Interactive visualization  

---

##  Contributing

Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.  

---

##  License

Distributed under the MIT License. See [LICENSE](LICENSE) for more information.  

---

##  Acknowledgements

- JAX team for the amazing ecosystem  
- Prior Gaussian Process libraries for inspiration  

---


## Dependencies
uproot-custom 2.2.0
uproot extension for reading custom classes
Requires Python: <3.14,>=3.9

# Introduction

Uproot-custom is an extension of [Uproot](https://uproot.readthedocs.io/en/latest/basic.html) that provides an enhanced way to read custom classes stored in `TTree`.

## What uproot-custom can do

Uproot-custom can natively read complicated combinations of nested classes and c-style arrays (e.g. `map<int, map<int, map<int, string>>>`, `vector<TString>[3]`, etc), and memberwisely stored classes. It also exposes a way for users to implement their own readers for custom classes that are not supported by Uproot or uproot-custom built-in readers, so that users can read their custom classes seamlessly.

## When to use uproot-custom

Uproot-custom aims to handle cases that classes are too complex for Uproot to read, such as when their `Streamer` methods are overridden or some specific data members are not supported by Uproot.

## How uproot-custom works

Uproot-custom uses a `reader`/`factory` mechanism to read classes:

```mermaid
flowchart TD
    subgraph py["Python field"]
        direction TB
        AsCustom --> fac["Factory (Primitive, STLVector, TString, ...)"]
        fac["Factory (Primitive, STLVector, TString, ...)"] -- Optional --> form(["construct awkward forms"])
        fac --> build_reader(["build corresponding C++ reader"])
        fac --> build_ak(["construct awkward arrays"])
    end

    user_fac["User's Factory"] -. Register .-> fac

    subgraph cpp["C++ field"]
        direction TB
        build_reader --> reader["C++ Reader"]
        reader --> read_bin(["read binary data"])
        read_bin --> ret_data(["return data"])
    end

    ret_data --> raw_data[("tuple, list, numpy arrays, ...")]
    raw_data --> build_ak
```

- `reader` is a C++ class that implements the logic to read data from binary buffers.
- `factory` is a Python class that creates, combines `reader`s, and post-processes the data read by `reader`s.

This machanism is implemented basing on `uproot_custom.AsCustom` interpretation. This makes uproot-custom well compatible with Uproot.

> [!TIP]
> Users can implement their own `factory` and `reader`, register them to uproot-custom. An example of implementing a custom `factory`/`reader` can be found in [the example repository](https://github.com/mrzimu/uproot-custom-example).

> [!NOTE]
> Uproot-custom does not provide a full reimplementation of `ROOT`'s I/O system. Users are expected to implement their own `factory`/`reader` for their custom classes that built-in factories cannot handle.

## Documentation

View the [documentation](https://mrzimu.github.io/uproot-custom/) for more details about customizing your own `reader`/`factory`, the architecture of uproot-custom, and build-only dependencies (e.g., `pybind11` is needed only at build time and should not be present in the runtime environment).
rubin-gafaelfawr 15.2.2
Client for Gafaelfawr authentication and identity service.
Requires Python: >=3.13
Keywords: rubin, lsst

# rubin-gafaelfawr

rubin-gafaelfawr is a client for [Gafaelfawr](https://gafaelfawr.lsst.io), which provides authentication and authorization for [Phalanx](https://phalanx.lsst.io/).
This package provides the Python client, Pydantic models, and a testing mock for applications that need to use the Gafaelfawr API directly.

rubin-gafaelfawr is available from [PyPI](https://pypi.org/project/rubin-gafaelfawr/):

```sh
pip install rubin-gafaelfawr
```

For full documentation, see [the Gafaelfawr user guide](https://gafaelfawr.lsst.io/user-guide/).
polyline-ruler 0.0.7
cubao/polyline-ruler is more than mapbox/cheap-ruler
Requires Python: >=3.7

# polyline-ruler

<!--intro-start-->

Init from [mapbox/cheap-ruler](https://github.com/mapbox/cheap-ruler) but more than that.

## Installation

### via pip

```bash
pip install -U polyline-ruler
```

### from source

```bash
git clone --recursive https://github.com/cubao/polyline-ruler
pip install ./polyline-ruler
```

Or

```bash
pip install git+https://github.com/cubao/polyline-ruler.git
```

(you can build wheels for later reuse by `pip wheel git+https://github.com/cubao/polyline-ruler.git`)

<!--intro-end-->

## Usage

See [`tests/test_basic.py`](tests/test_basic.py).

## Tests

```bash
python3 tests/test_basic.py
```
dungeondice 1.3.4
Tools to roll some virtual dice
Requires Python: >=3.8

[![Upload Python Package](https://github.com/jwizzle/dungeondice/actions/workflows/python-publish.yml/badge.svg)](https://github.com/jwizzle/dungeondice/actions/workflows/python-publish.yml)

# Dungeondice

This is a discord bot that aims to become a feature-rich yet easy to use option for rolling dice for TTRPG's online.
I aim to keep the logic of the bot detached from discord integration. So the python package is re-usable in other places.

## Features

- Roll dice in a discord channel
- Roll privately, either telling others you rolled or not. To simulate the feeling of hearing your DM's dice go behind a screen
- Supports both discord slashcommands for features like ephemeral messages, or regular !commands that feel more responsive
- Roll multiple sets in one go `2x2d20`
- Add hints to your dice `d10(piercing)+d8(poison)`
- Add hints to your complete roll `d8(poison) For damage`
- Create complex rolls like `2x2d20(poison)+d8(piercing)-4` to get two total results
```
---------------------------------
2d20(poison)+d8(piercing)-4
Total: 35
Details: [[16, 17]33poison, [6]6piercing, [4]4]
---------------------------------
---------------------------------
2d20(poison)+d8(piercing)-4
Total: 19
Details: [[10, 11]21poison, [2]2piercing, [4]4]
---------------------------------
```

## Installation

```
$ pip install dungeondice
$ DISCORD_TOKEN="$TOKEN" dungeondice
```

## Usage

Run the bot, see the `.help` command for more details.

## Roadmap/TODO

- Start using discord views for nicer layout?
- Templating of rolls per player/discord channel
agentcrawl 0.3.1
Discovery service for AI agents. Find any agent by capability.
Requires Python: >=3.9
Keywords: ai agent discovery mcp a2a llm autonomous multi-agent

# AgentIndex SDK

Find any AI agent by capability. Machine-first discovery.

## Install

```bash
pip install agentindex
```

## Usage

```python
from agentindex import discover, get_agent, configure

# Find agents that can review contracts
results = discover("contract review")

# Filter by protocol
results = discover("data analysis", protocols=["mcp"])

# Filter by quality and category
results = discover("code review", min_quality=0.7, category="coding")

# Get details about a specific agent
agent = get_agent("agent-uuid")

# Configure custom endpoint
configure(endpoint="https://api.agentindex.dev/v1", api_key="agx_...")
```

## What is AgentIndex?

AgentIndex is the most comprehensive index of AI agents. We automatically
crawl and index agents from GitHub, npm, PyPI, HuggingFace, and MCP registries.

Agents query our API to find other agents by capability — no humans involved.

## API

```
POST /v1/discover
{"need": "what you need", "category": "coding", "min_quality": 0.5}

GET /v1/agent/{id}
GET /v1/stats
POST /v1/register
```
geci-janitor 0.16.1
Module to clean and process GECI data
Requires Python: >=3.9

# Janitor <a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>

[![codecov](https://codecov.io/gh/IslasGECI/janitor/branch/develop/graph/badge.svg?token=zXmBXOWRbG)](https://codecov.io/gh/IslasGECI/janitor)
![PyPI - Version](https://img.shields.io/pypi/v/geci-janitor)


## Overview

CLI with tools to process cat data.

## 🏗️ Installation

```shell
pip install geci-janitor
```
governed-http-sdk 0.1.1
Governed HTTP client SDK with Requests-like ergonomics and typed contracts
Requires Python: >=3.10
Keywords: http, sdk, governance, pydantic, requests, fastapi, typed

# governed-http

A lightweight HTTP client with typed request/response contracts, request interception, and built-in request tracing.

It behaves like requests, but adds:

- Optional preflight checks before a request is sent
- Structured decision logging
- Pydantic-based request and response validation
- Dry-run mode (no network call)
- Pluggable transport for testing

Minimal dependencies: standard library + Pydantic.

## Why use this?

Most HTTP clients simply send requests and return responses.

This client adds a control layer:

- Every request can be inspected before execution
- Calls can be blocked based on host or custom rules
- Each request records what was attempted and what happened
- Responses can be validated against typed models

Useful for:

- Restricting outbound API calls
- Enforcing allowed hosts
- Building typed API wrappers
- Testing external integrations deterministically
- Capturing structured request traces

## Installation

```bash
pip install governed-http-sdk
```

## Quick Example

```python
from governed_http import Client

client = Client(
    base_url="https://api.example.com",
    allowed_hosts=["api.example.com"]
)

res = client.get("/status")
print(res.status_code)
```

## Typed Operations

```python
from pydantic import BaseModel
from governed_http import Client, Operation

class CreateThing(BaseModel):
    name: str

class Thing(BaseModel):
    id: int
    name: str

op = Operation(
    method="POST",
    path="/v1/things",
    request=CreateThing,
    response=Thing,
)

client = Client(
    base_url="https://api.example.com",
    allowed_hosts=["api.example.com"]
)

result: Thing = client.call(op, {"name": "example"})
```

The payload is validated before sending.
The response is parsed into a typed model.

## Dry Run (No Network)

```python
preview = client.dry_run_request("GET", "/v1/things")
print(preview)
```

Returns:

- Final URL
- Headers
- Request body
- Preflight decision

## Interceptors

Custom logic can be added before or after a request:

- Allow or deny outbound calls
- Modify headers
- Record additional metadata
- Enforce custom policy rules

## Testing with Mock Transport

The built-in `MockTransport` allows deterministic testing without network access.

## Summary

This package provides:

- A small, dependency-light HTTP client
- Typed request/response validation
- Optional outbound host restrictions
- Structured request tracing
- Pluggable transport for testing

It is designed for applications that need more control and visibility over outbound HTTP calls than a basic client provides.

## Install (editable)

```powershell
Push-Location artifact-verifier
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -e .
Pop-Location
```
pypci-ng 0.3.4
pypci, a pciutils-like library for fetching system PCI/PCI-E information but written mostly in python.
Requires Python: >=3.9
Keywords: pci, system information, pciutils, python, lspci, hardware information, fetching, pcie

# pypci-ng
[![Downloads](https://static.pepy.tech/badge/pypci-ng)](https://pepy.tech/project/pypci-ng)
![PyPI - Version](https://img.shields.io/pypi/v/pypci-ng?label=version)

![Static Badge](https://img.shields.io/badge/Linux-blue)
![Static Badge](https://img.shields.io/badge/Windows-yellow)
![Static Badge](https://img.shields.io/badge/FreeBSD-red)


pypci-ng, a pciutils-like library for fetching system PCI/PCI-E devices but written mostly in python. Currently, this package **ONLY** implements the same functionality as **lspci**, i.e. scanning and listing all PCI/PCI-E devices. More functionalities are under development.


![demo0](https://files.catbox.moe/mku1dg.png)


![demo1](https://files.catbox.moe/scnd3j.png)

## Install
Just install it directly by pip.
```shell
pip install pypci-ng
```
To upgrade pypci:
```shell
pip install pypci-ng --upgrade
```

## Usage
### Use as a command line tool
You can use this tool directly from the command line with the following command, just like lspci.
```shell
pypci
```
Or use -d flag to print driver information.
```shell
pypci -d
```
For more command line flags, see:
```shell
pypci -h
```
Please note that the command line entry for __pypci__ is created by pip, and depending on the user, this entry may not in the __system PATH__. If you encounter this problem, pip will give you a prompt, follow the prompts to add entry to the __system PATH__.

### Use as a Python Package
You can also use this package in Python, here is the demo:
```python
import pypci
pci = pypci.PCI()
vga_devices = pci.FindAllVGA()
nic_devices = pci.FindAllNIC()
```
More functionalities are under development.

## Supported (Tested) OS
* Linux
* Windows 10 and above


## Build from source
### Build tools
Make sure the following Python build tools are already installed.
* setuptools
* build
* twine

### Build package
clone the project, and run:
```shell
python -m build
```
After the build process, the source package and the binary whl package can be found in the dist folder.
skillsmp 1.0.0
Search the SkillsMP marketplace for agent skills
Requires Python: >=3.10

# skillsmp

Search the [SkillsMP marketplace](https://skillsmp.com) for agent skills from the command line.

## Install

Requires [uv](https://docs.astral.sh/uv/getting-started/installation/).

```
uv tool install skillsmp
```

Or run without installing:

```
uvx skillsmp terraform
```

Set your API key in `~/.env` or export it directly:

```
SKILLSMP_API_KEY=your-key-here
```

## Usage

```
skillsmp terraform
skillsmp --limit 5 --sort recent react testing
skillsmp --ai "how to optimize database queries"
```

Use `--json` for structured output or `--plain` for tab-separated lines that pipe to `grep` and `awk`:

```
skillsmp --json deployment
skillsmp --plain react | grep facebook
```

## Search modes

The default keyword search matches your query against skill names and descriptions, sorted by stars. It's fast (~300ms) and supports pagination, but ranks by popularity rather than relevance.

`--ai` runs a vector similarity search powered by [Cloudflare Vectorize](https://developers.cloudflare.com/vectorize/). Each skill's full SKILL.md has been embedded, and your query is compared against those embeddings. This returns ~10 results ranked by relevance score, catching semantically related skills that keyword search misses. Pagination and sorting don't apply. Slower (~4-5s) because the query must be embedded first.

## Flags

```
-a, --ai        AI semantic search
-n, --limit N   Results per page (1-100, default: 10)
-p, --page N    Page number (default: 1)
-s, --sort KEY  Sort by: stars, recent (default: stars)
-j, --json      JSON output
    --plain     Tab-separated, one line per result
-h, --help      Show help
    --version   Show version
```

`--limit`, `--page`, and `--sort` apply to keyword search only.