semvec/pypi-packages huggingface dataset:
dqm-ml-pytorch 1.1.6
Python library designed to provide core dqml domain gap metrics, as well as common API shared by metrics
Requires Python: >=3.10
Keywords: ml, metrics, data

# DQM-ML PyTorch

An extension for DQM-ML V2 providing advanced metrics that require PyTorch and deep learning models.

## Features

* Domain Gap Analysis: Measures statistical distance between source and target distributions using:
  * `fid` (Frechet Inception Distance)
  * `klmvn_diag` (KL-Divergence)
  * `mmd_linear` (Maximum Mean Discrepancy)
  * `wasserstein_1d`

## Requirements

* `torch`
* `torchvision`
* `scipy`
dqm-ml-images 1.1.6
Python library designed provide core dqm-ml metrics without huge dependencies, as well as common API shared by metrics
Requires Python: >=3.10
Keywords: ml, metrics, data

# DQM-ML Images

An extension for DQM-ML V2 providing metrics and feature extraction specifically for image data.

## Features

* Luminosity: Mean gray level calculation.
* Contrast: RMS contrast.
* Blur: Variance of Laplacian (sharpness measurement).
* Entropy: Information entropy of image histograms.

## Requirements

* `opencv-python`
* `pillow`
* `numpy`
dqm-ml-job 1.1.6
Python library designed provide pipelining tools dqm-ml library to compute data quality metrics for Machine Learning
Requires Python: >=3.10
Keywords: ml, metrics, data

# DQM-ML Job

This package provides the orchestration engine for DQM-ML V2. It handles the lifecycle of data processing, from loading to metric computation and output writing.

## Key Components

### `DatasetPipeline`

The main orchestrator that:

* Loads the configuration.
* Discovers plugins via entry points.
* Executes the streaming loop.
* Manages memory and I/O efficiency.

### Protocols

* `DataLoader`: A factory for creating data selections (e.g., Parquet, CSV loaders).
* `DataSelection`: Represents a specific subset of data and provides an iterator over batches.
* `OutputWriter`: Persists computed features or metrics to disk.

## Built-in Loaders

* `parquet`: Optimized loading using PyArrow.
* `csv`: Flexible loading using Pandas.
dqm-ml-core 1.1.6
Python library designed provide core dqml metrics without huge dependencies, as well as common API shared by metrics
Requires Python: >=3.10
Keywords: ml, metrics, data

# DQM-ML Core

This package defines the foundational API and core metrics for the DQM-ML V2 framework.

## Key Concepts

### `DatametricProcessor`

The base class for all metrics and feature extractors. It supports a streaming architecture by splitting computation into two phases:
1. Batch Level: `compute_batch_metric()` updates intermediate statistics for a single chunk of data.
2. Dataset Level: `compute()` aggregates these statistics into final scores.

## Included Metrics

* Completeness: Analyzes null/missing values.
* Representativeness: Statistical distribution analysis (Chi-Square, KS, etc.).

## For Developers

To create a new metric:
1. Subclass `dqm_ml_core.api.data_processor.DatametricProcessor`.
2. Define `needed_columns()`, `generated_features()`, and `generated_metrics()`.
3. Implement the streaming logic in `compute_batch_metric()` and `compute()`.
cfpackages 0.1.3
一个供我自己使用的实用的 python 第三方库
Requires Python: >=3.6

# CFPackages
供[我自己](https://github.com/chengfeng30121)使用的实用的`Python 第三方库`! 
## 依赖
1. [colorama](https://pypi.org/project/colorama/)
2. [prompt_toolkit](https://pypi.org/project/prompt-toolkit/)
3. [questions](https://pypi.org/project/questionary/)
4. [requests](https://pypi.org/project/requests/)
## 使用
1. 安装 
    ``` bash
    pip install cfpackages
    ```
2. 导入
    ``` python
    import cfpackages
    ```
3. 更新
    ``` bash
    pip install cfpackages --upgrade
    ```
4. 取消更新提示
    ``` bash
    export cfpackages.check_update=False
    # or
    export cfpackages.check_update=0
    ```
    或 Windows 下
    ``` cmd
    set cfpackages.check_update=False
    REM or
    set cfpackages.check_update=0
    ```
    或者直接打开 `cfpackages/__init__.py`, 修改脚本, 将尾部的 `if` 代码块删除.
fathomnet 1.10.0
fathomnet-py is a client-side API to help scientists, researchers, and developers interact with FathomNet data.
Requires Python: >=3.8.1

# fathomnet-py

<div align="center">

[![image](https://img.shields.io/pypi/v/fathomnet.svg)](https://pypi.python.org/pypi/fathomnet)
[![image](https://img.shields.io/pypi/l/fathomnet.svg)](https://github.com/fathomnet/fathomnet-py/blob/main/LICENSE)
[![CI/CD](https://github.com/fathomnet/fathomnet-py/actions/workflows/cicd.yml/badge.svg)](https://github.com/fathomnet/fathomnet-py/actions/workflows/cicd.yml)
[![Documentation Status](https://readthedocs.org/projects/fathomnet-py/badge/?version=latest)](https://fathomnet-py.readthedocs.io/en/latest/?badge=latest)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)

</div>

**`fathomnet-py`** is a client-side API to help scientists, researchers, and developers interact with [FathomNet Database](https://database.fathomnet.org/) data.

```python
>>> from fathomnet.api import boundingboxes
>>> boundingboxes.find_concepts()
['2G Robotics structured light laser', '55-gallon drum', ...]
>>> from fathomnet.api import images
>>> images.find_by_concept('Nanomia')
[
    AImageDTO(
        id=2274942, 
        uuid='cdbfca66-284f-48ac-a36f-7b2ac2b43533', 
        url='https://database.fathomnet.org/static/m3/framegrabs/MiniROV/images/0056/02_18_37_20.png', 
        ...
    ),
    ...
]
>>> from fathomnet.api import taxa
>>> taxa.find_children('fathomnet', 'Bathochordaeus')
[
    Taxa(name='Bathochordaeus stygius', rank='species'), 
    Taxa(name='Bathochordaeus charon', rank='species'), 
    Taxa(name='Bathochordaeus mcnutti', rank='species')
]
>>> from fathomnet.api import xapikey
>>> xapikey.auth('NuCLjlNUlgHchtgDB01Sp1fABJVcWR')  # your API key here
AuthHeader(
    type='Bearer', 
    token='eyJhbGciOiJI...'
)
```

The `fathomnet-py` API offers native Python interaction with the FathomNet REST API, abstracting away the underlying HTTP requests.

## Installing `fathomnet-py`

`fathomnet-py` is available on PyPI:

```bash
$ python -m pip install fathomnet
```

## Examples

### API Tutorial: [![Tutorial](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/fathomnet/fathomnet-py/blob/main/examples/tutorial.ipynb)

### FathomNet Models: [![Models](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/fathomnet/fathomnet-py/blob/main/examples/models.ipynb)

## API Reference available on [Read the Docs](https://fathomnet-py.readthedocs.io/)
targon-sdk 0.4.0
Targon SDK to interact with Targon rentals and serverless
Requires Python: >=3.9
Keywords: api, sdk, targon

<h1 align="center">
  <img src="https://targon.com/targon-logo.svg" alt="Targon" width="32" style="vertical-align: bottom;">
  Targon SDK
</h1>

<p align="center">
  <strong>Build and deploy serverless Python on GPUs — in seconds, not hours.</strong>
</p>


<p align="center">
   | <a href="#installation"><b>Install</b></a> |
   <a href="#getting-started"><b>Getting Started</b></a> |
   <a href="https://github.com/manifold-inc/targon-sdk/tree/main/examples"><b>Examples</b></a> |
   <a href="https://docs.targon.com/sdk/app"><b>Documentation</b></a> |
</p>


<p align="center">
  <img alt="Status" src="https://img.shields.io/badge/status-stable-brightgreen">
  <a href="https://pypi.org/project/targon-sdk/"><img alt="PyPI" src="https://img.shields.io/pypi/v/targon-sdk?color=blue&label=PyPI"></a>
  <img alt="Python" src="https://img.shields.io/badge/python-3.9+-orange">
  <a href="https://github.com/manifold-inc/targon-sdk/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/manifold-inc/targon-sdk"></a>
</p>



## About

Targon SDK is a Python framework for building and deploying serverless applications on the Targon platform. Define your app, decorate your functions, and deploy — the SDK handles containers, scaling, and infrastructure.

- **Zero infrastructure** — No containers to build, no clusters to manage
- **GPU-first** — H100, H200, and more. Request with `resource="h200-small"`
- **Web endpoints** — `@targon.fastapi_endpoint()` turns functions into APIs
- **Scales to zero** — Pay only when your code runs
- **Custom images** — Build containers in Python with `pip_install()`, `env()`, and more

> **Stability:** The Targon SDK follows semantic versioning. Breaking changes
> are only introduced in major releases.

## Installation

**Requires Python 3.9+**

```bash
pip install targon-sdk
```

**Install from source**
```bash
git clone https://github.com/manifold-inc/targon-sdk.git
cd targon-sdk
pip install -e .
```

## Getting Started

```python
import targon

app = targon.App("hello-world", image=targon.Image.debian_slim())

@app.function(resource=targon.Compute.CPU_SMALL)
def greet(name: str) -> str:
    return f"Hello, {name}!"

@app.local_entrypoint()
def main():
    print(greet.remote("World"))
```

```bash
# Authenticate
targon setup

# Run remotely
targon run hello.py

# Deploy as a service
targon deploy hello.py
```

## Contributing

We welcome contributions! Please see our contributing guidelines before submitting PRs.
1. Fork the repository
2. Create a feature branch
3. Make your changes with tests
4. Submit a pull request


## Changelog
See [CHANGELOG.md](CHANGELOG.md) for release notes.


## License
Apache 2.0 — see [LICENSE](LICENSE) for details.
cuRDF 0.5.1
GPU-accelerated radial distribution functions with NVIDIA ALCHEMI Toolkit-Ops neighbor lists and PyTorch.
Requires Python: >=3.10
Keywords: rdf, radial distribution function, cuda, gpu, pytorch, neighbor list, molecular dynamics, ase, mdanalysis

![cuRDF logo](logo.svg)

---

[![DOI](https://zenodo.org/badge/1085332119.svg)](https://doi.org/10.5281/zenodo.1085332119) [![PyPI](https://img.shields.io/pypi/v/cuRDF.svg)](https://pypi.org/project/cuRDF/)


CUDA-accelerated radial distribution functions using [NVIDIA ALCHEMI Toolkit-Ops](https://github.com/NVIDIA/nvalchemi-toolkit-ops) O(N) neighbor lists and PyTorch. Compatible with ASE Atoms or MDAnalysis Universe objects.

## Benchmarking

![cuRDF benchmark](benchmarks/results/results.png)

cuRDF is benchmarked against other RDF (MDAnalysis) and neighbour list implementations on CPU (AMD Ryzen 9 9950X, 32 threads) and GPU (NVIDIA RTX 5090) for systems of varying sizes at a density of 0.05 atoms/Å³ over 1000 frames.
Benchmarks use random positions in cubic cells sized to maintain a fixed number density (orthorhombic boxes, periodic in all directions).

## Install
Latest release:
```
pip install cuRDF
```
For development:
```
git clone https://github.com/joehart2001/curdf.git
cd curdf
pip install -e .
```

## Quickstart
ASE Atoms object:
```python
from ase.io import read
from curdf import rdf

# Load trajectory or frame e.g. XYZ, extxyz, traj, LAMMPS data/dump
atoms = read("md_run.extxyz")

# Compute RDF between species C and O from 1.0 to 8.0 Å
bins, gr = rdf(
  atoms,
  species_a="C",
  species_b="O", # species b can be the same as species a
  r_min=1.0,
  r_max=8.0,
  nbins=200, # resolution of rdf histogram binning
  method="cell_list", # neighbor list method: "cell_list" (larger systems) or "naive" (smaller systems, less overhead)
  output = "results/rdf.csv" # optional output
)

# Plot RDF
plot_rdf(bins, gr, path="results/rdf.png")
```



MDAnalysis Universe (topology and trajectory):
```python
import MDAnalysis as mda
from curdf import rdf

u = mda.Universe("topology.data", "traj.dcd", atom_style="id type x y z")
bins, gr = rdf(
  u,
  species_a="C",
  species_b="O",
  r_min=1.0,
  r_max=8.0,
)
```

If the topology lacks atom names (only numeric types), supply a mapping:
```python
bins, gr = rdf(
  u, 
  species_a="C", 
  species_b="O", 
  atom_types_map={1: "C", 2: "H"}
)
```

## Validation

RDFs for liquid water (64 atoms, 1 ns) match reference curves for all pairs (cite Darren paper):

<table>
  <tr>
    <td><img src="tests/cuRDF_results/rdf_OO_comparison.svg" alt="O–O RDF" width="250"></td>
    <td><img src="tests/cuRDF_results/rdf_HH_comparison.svg" alt="H–H RDF" width="250"></td>
    <td><img src="tests/cuRDF_results/rdf_OH_comparison.svg" alt="O–H RDF" width="250"></td>
  </tr>
</table>


## Citation
If you use cuRDF in your work, please cite:
```
@software{cuRDF,
  author    = {Hart, Joseph},
  title     = {cuRDF: GPU-accelerated radial distribution functions},
  month     = dec,
  year      = 2025,
  publisher = {Zenodo},
  version   = {0.5.0},
  doi       = {10.5281/zenodo.1085332119},
  url       = {https://doi.org/10.5281/zenodo.1085332119}
}
```
syglass 0.82
syGlass Python API
Requires Python: >=3.4

The Python module ``syglass`` allows scientists and developers alike to create powerful custom workflows to leverage their `syGlass <https://www.syglass.io/>`_ image volumes and annotations.

For documentation, examples, and installation resources please visit https://istovisio.github.io/. Feel free to contact us at info@syglass.io for questions, bug reports, or requests!
simplevgpad 0.1.3
Simple wrapper around vgamepad for easier controller inputs
Requires Python: >=3.8

# simplevgpad

A Python helper library for simplified Xbox controller input using vgamepad.

Defines 2 classes which inherit the vgamepad.VX360Gamepad class, and adds methods to
slightly simplify controller input simulation for simple projects.

## Installation

```bash
pip install simplevgpad
```

## Examples

### controller
```py
from simplevgpad import controller

game = controller()
game.press_a()
game.hold_left_trigger(2)
```

### controller_async
```py
from simplevgpad import controller_async
import asyncio

async def main():
    game = controller_async()
    await game.press_a()

asyncio.run(main())
```
django-flags 5.2.0
Feature flags for Django projects
Requires Python: >=3.10

# Django-Flags

[![Build Status](https://github.com/cfpb/django-flags/workflows/test/badge.svg)](https://github.com/cfpb/django-flags/actions)
[![Ethical open source](https://img.shields.io/badge/ethical-open-%23bb8c3c?labelColor=393162)](https://ethicalsource.dev/principles/)

Feature flags allow you to toggle functionality in both Django code and the Django templates based on configurable conditions. Flags can be useful for staging feature deployments, for A/B testing, or for any time you need an on/off switch for blocks of code. The toggle can be by date, user, URL value, or a number of [other conditions](https://cfpb.github.io/django-flags/conditions/), editable in the admin or in definable in settings.

- [Dependencies](#dependencies)
- [Installation](#installation)
- [Documentation](#documentation)
- [Getting help](#getting-help)
- [Getting involved](#getting-involved)
- [Licensing](#licensing)
- [Credits and references](#credits-and-references)

## Dependencies

- Python 3.10+
- Django 4.2+

## Installation

1. Install Django-Flags:

```shell
pip install django-flags
```

2. Add `flags` as an installed app in your Django `settings.py`:

 ```python
 INSTALLED_APPS = (
     ...
     'flags',
     ...
 )
```

## Documentation

https://cfpb.github.io/django-flags is the full documentation for Django-Flags, and includes how to get started, general usage, and an API reference.

## Getting help

Please add issues to the [issue tracker](https://github.com/cfpb/django-flags/issues).

## Getting involved

General instructions on _how_ to contribute can be found in [CONTRIBUTING](CONTRIBUTING.md).

## Licensing
1. [TERMS](TERMS.md)
2. [LICENSE](LICENSE)
3. [CFPB Source Code Policy](https://github.com/cfpb/source-code-policy/)

## Credits and references

Django-Flags was forked from [Wagtail-Flags](https://github.com/cfpb/wagtail-flags), which was itself forked from [cfgov-refresh](https://github.com/cfpb/cfgov-refresh).
agent-shared-context 0.1.0
Personal work orchestrator. One CLI, one main context, many agents.
Requires Python: >=3.10

# asc

Agent Shared Context. One CLI, one main context, many agents.

asc is a protocol for agents to share context. When an agent finishes work, it registers a zero-loss brief. Your main thread stays coherent across every tool, every agent, every project.

## Install

```
uv tool install agent-shared-context
```

Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code).

## The protocol

When you're done with a task, register a zero-loss brief:

```
echo "<zero-loss-brief>" | asc register --author <name>
```

A zero-loss brief is **complete** (every decision, artifact, loose end), **concise** (dense, not long), and **concrete** (specific paths, names, states — actionable).

That's the protocol. Put it in your CLAUDE.md, your Cursor rules, your AGENTS.md. Any agent that can run a shell command can follow it.

## Commands

```
asc where are we                          # talk to the main thread
asc run claude debug the migration issue  # dispatch an agent
asc run --ro claude research k8s networking  # read-only dispatch
echo "<brief>" | asc register --author gemini  # register a handoff
```

## How it works

- **`asc <message>`** — talk to your main thread. Read-only. It knows everything that's been registered and synthesizes it for you.
- **`asc run <agent> <task>`** — dispatch an agent. It works, then registers a zero-loss brief when done.
- **`asc register --author <name>`** — the universal write API. Any agent, any surface, anywhere.

Context is stored as YAML day files in `~/.asc/days/`. Not per-project. Your entire work environment.

## License

MIT