semvec/pypi-packages huggingface dataset:
bionmf 0.0.5
NMF solver for gene programs.

# Installation

```bash
$ pip install bionmf
```

# Usage

```python
from bionmf import BioNMF       # Import model

model = BioNMF()
nmf = model.fit(                # NMFInfo object, see below for properties
    adata,                      # AnnData object
    rank_range = range(2, 3),
    n_runs = 3,
    cutoff = 0.95
)

adata = model.get_adata()       # Return AnnData object
                                # Stores cell-factors under .obsm['X_nmf']
                                # Stores gene-factors under .varm['factors']

genes = model.program_genes()   # Get differential expressed genes per program
model.plot_cophcorr("cc.html")  # Cophenetic correlation for each tested rank
```

# Documentation

```python
BioNMF(
    random_state,               # Initial random state
    **kwargs                    # Arguments for sklearn.decomposition.NMF
).fit(
    adata,                      # Accepts AnnData and DataFrame (must be cells as rows)
    rank_range,                 # Range of rank values to test
    n_runs,                     # Number of runs (random intializations) for each rank
    cutoff                      # Cophenetic correlation cutoff
)                               # -> returns NMFInfo object

NMFInfo(                        # Properties accessed as nmf.rank, nmf.W, etc.
    rank,                       # Chosen (best) rank
    W,                          # (genes by factors) matrix -> gene programs
    H,                          # (cells by factors) matrix -> program assignment
    connectivity_mat,           # (cells by cells) matrix -> program connectivity
    reconstruction_err,         # RMSE of reconstruction
    cophcorr                    # Cophenetic correlation
)
```

# References

Brunet JP, Tamayo P, Golub TR, Mesirov JP. Metagenes and molecular pattern discovery using matrix factorization. Proc Natl Acad Sci U S A. 2004 Mar 23;101(12):4164-9. doi: 10.1073/pnas.0308531101. Epub 2004 Mar 11. PMID: 15016911; PMCID: PMC384712.
youtube-to-docs 0.0.67
Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery
Requires Python: >=3.12

# youtube-to-docs
[![PyPI version](https://img.shields.io/pypi/v/youtube-to-docs.svg)](https://pypi.org/project/youtube-to-docs/)

Click on the image below to see a demo of YouTube to docs:

<div align="center">
  <a href="https://www.youtube.com/watch?v=H6Jw10bmMcI">
    <img src="https://img.youtube.com/vi/H6Jw10bmMcI/0.jpg" alt="Watch the video" width="300" />
  </a>
</div>

Convert YouTube videos into structured docs, summaries, audio, and visual assets for easier discovery.

View all available CLI options:

```bash
uvx youtube-to-docs --help
```

### Optional Features

To keep the installation light, some features are optional. You can enable them by specifying "extras":

- `audio`: Required for TTS and audio processing (uses `yt-dlp`).
- `video`: Required for video generation (uses `static-ffmpeg`).
- `workspace`: Required for Google Drive integration.
- `m365`: Required for Microsoft SharePoint/OneDrive integration.
- `aws`: AWS Bedrock support.
- `azure`: Required for Azure OpenAI models.
- `gcp`: Required for Google Gemini and Vertex AI models (uses `google-genai`).
- `all`: Installs everything.

**Example: Run with audio and video support**
```bash
uvx --with "youtube-to-docs[audio,video]" youtube-to-docs ...
```

**Example: Run with everything**
```bash
uvx --with "youtube-to-docs[all]" youtube-to-docs ...
```

*Note: The commands above require `uv`. You can install it via:*
*   **macOS/Linux**: `curl -LsSf https://astral.sh/uv/install.sh | sh`
*   **Windows**: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`

Install as a Gemini CLI extension:

```bash
gemini extensions install https://github.com/DoIT-Artificial-Intelligence/youtube-to-docs.git
```

*Created with the help of AI. All artifacts have been checked and work as expected.*
atp-tennis-scraper 0.1.2
A Python package for scraping ATP tennis rankings.
Requires Python: >=3.7

# 🎾 ATP Tennis Scraper

![license](https://img.shields.io/badge/license-MIT-green) ![pypi](https://img.shields.io/pypi/v/atp-tennis-scraper)

ATP Tennis Scraper is a Python package that fetches and displays the top ATP-ranked players from the official [ATP Tour website](https://www.atptour.com/en/rankings/singles). The scraper extracts player rankings, names, points, age, and nationality.

---

## 📦 Installation

To install the package, simply run:

```bash
pip install atp-tennis-scraper
```

### Usage

To get all urls use:

```python
from atp_tennis_scraper import display_top_10

display_top_10()
```
## Running Tests

To run the tests locally:

1. Clone the repository:

```bash
git clone https://github.com/Semne77/atp_tennis_scraper.git
cd atp-tennis-scraper
```

2. (Optional but recommended) Create and activate a virtual environment:

```bash
python3 -m venv venv
source venv/bin/activate
```

3. Install dependencies:

```bash
pip install -r requirements.txt
```

4. Run the tests from the **project root directory** (the folder containing `tests/` and `atp_tennis_scraper/`):

```bash
pytest -q
```

On the first run, HTTP responses will be recorded using VCR.  
Subsequent runs will replay recorded responses (no internet connection required).
ai-crypto-tool 0.1.0
Autonomous AI agents that own wallets and transact on EVM chains
Requires Python: >=3.11
Keywords: agent, ai, claude, crypto, defi, ethereum, web3

# AI Crypto Tool

Autonomous AI agents that own wallets and independently transact on EVM chains (Ethereum, Base, Arbitrum, Polygon), powered by Claude API.

## Features

- **HD Wallets** — BIP-44 derivation with Fernet+PBKDF2 encrypted key storage
- **Multi-chain** — Ethereum, Base, Arbitrum, Polygon with failover RPC
- **DeFi Protocols** — Uniswap V3 swaps, Aave V3 lending
- **Safety First** — Spending limits, slippage guards, human approval, audit log
- **AI Agent Loop** — Perceive → Reason (Claude) → Act → Reflect
- **16 Tools** — Balances, swaps, lending, portfolio, memory — all exposed to Claude

## Install

```bash
pip install ai-crypto-tool
```

## Quick Start

```bash
# Show config
ai-crypto info

# Create a wallet
ai-crypto wallet create my-wallet -p "strong-password"

# Start an agent
export ANTHROPIC_API_KEY=sk-ant-...
ai-crypto agent start --wallet my-wallet -p "strong-password"
```

## Architecture

```
EventMonitor → PERCEIVE (balances, events, portfolio)
                  ↓
              REASON (Claude + tool-use)
                  ↓
              ACT (Guardian safety checks → execute → audit)
                  ↓
              REFLECT (update portfolio, log metrics)
                  ↓
              sleep → loop
```

## Security

- Keys encrypted at rest (Fernet + PBKDF2, 600k iterations)
- Per-transaction, hourly, and daily USD spending caps
- Human-in-the-loop approval for high-value transactions
- Slippage protection on all swaps
- Append-only audit log

## License

MIT
psql-temp 1.0.0
PostgreSQL Flask default templates - College Management, Auth Log, Admission, Custom
Requires Python: >=3.8

# psql-temp

**PostgreSQL Flask Default Templates** - Ready-to-use templates for Flask applications with PostgreSQL.

*Developed BY Tamilselvan Cyber security Researcher*

## Templates

1. **College Management System** - Departments, students, faculty management
2. **Authentication Log Management** - Login/logout, auth logs, activity tracking
3. **College Admission Registrations** - Courses, applicants, application forms
4. **Custom Template** - Choose options 1-3, add custom fields, generate template

## Installation

```bash
cd psql
pip install -e .
```

## Usage

### Interactive CLI

```bash
psql-temp
```

- Select template 1-4
- For **Custom (4)**: Choose from options 1, 2, 3; enter `0` to add custom options; `Y` to create

### Direct Template Selection

```bash
psql-temp 1 -o ./my_project     # College Management
psql-temp 2 -o ./auth_project   # Auth Log
psql-temp 3 -o ./admission      # Admission
psql-temp --custom              # Custom builder
```

### Run Templates (in package directory)

```bash
python run_template.py college_management
python run_template.py auth_log
python run_template.py admission
```

### Python Usage

```python
from psql_temp import create_app
from psql_temp.db import get_db_connection

app = create_app('college_management')  # or 'auth_log', 'admission', 'custom'
```

## Environment

Copy `.env.example` to `.env`:
```
DATABASE_URL=postgresql://user:password@localhost:5432/dbname
FLASK_SECRET_KEY=your-secret-key
```
pymt-topography 0.2.1
PyMT plugin for Topography data component
Requires Python: >=3.12
Keywords: bmi, csdms, pymt, topography, dem

===============
pymt_topography
===============


.. image:: https://img.shields.io/badge/CSDMS-Basic%20Model%20Interface-green.svg
        :target: https://bmi.readthedocs.io/
        :alt: Basic Model Interface

.. image:: https://img.shields.io/pypi/v/pymt_topography
        :target: https://pypi.org/project/pymt_topography
        :alt: PyPI

.. image:: https://img.shields.io/conda/vn/conda-forge/pymt_topography.svg
        :target: https://anaconda.org/conda-forge/pymt_topography
        :alt: conda-forge

.. image:: https://img.shields.io/badge/recipe-pymt_topography-green.svg
        :target: https://anaconda.org/conda-forge/pymt_topography

.. image:: https://github.com/pymt-lab/pymt_topography/actions/workflows/test.yml/badge.svg
        :target: https://github.com/pymt-lab/pymt_topography/actions/workflows/test.yml
        :alt: Build/Test CI

.. image:: https://readthedocs.org/projects/pymt-topography/badge/?version=latest
        :target: https://pymt-topography.readthedocs.io/en/latest/?badge=latest
        :alt: Documentation Status


PyMT component for accessing land elevation data.


* Free software: MIT License
* Documentation: https://pymt-topography.readthedocs.io.




========== ====================================
Component  PyMT
========== ====================================
Topography `from pymt.models import Topography`
========== ====================================

---------------
Installing pymt
---------------

Installing `pymt` from the `conda-forge` channel can be achieved by adding
`conda-forge` to your channels with:

.. code::

  conda config --add channels conda-forge

*Note*: Before installing `pymt`, you may want to create a separate environment
into which to install it. This can be done with,

.. code::

  conda create -n pymt python=3
  conda activate pymt

Once the `conda-forge` channel has been enabled, `pymt` can be installed with:

.. code::

  conda install pymt

It is possible to list all of the versions of `pymt` available on your platform with:

.. code::

  conda search pymt --channel conda-forge

--------------------------
Installing pymt_topography
--------------------------

Once `pymt` is installed, the dependencies of `pymt_topography` can
be installed with:

.. code::

  pip install bmi-topography

To install `pymt_topography`,

.. code::

  pip install pymt_topography
syntropy-ai 0.2.1
Universal AI Observability and Security Agent — trace, guard, and govern LLM calls across every provider.
Requires Python: >=3.9
Keywords: agents, ai, anthropic, bedrock, gemini, guardrails, langchain, llamaindex, llm, mistral, observability, openai, tracing

# Syntropy Python SDK

Trace, guard, and govern your AI agents with zero-effort integration.

## Installation

```bash
pip install syntropy-ai
```

## Quick Start

```python
from syntropy import Syntropy

client = Syntropy(
    api_key="syn_your_key_here",
    base_url="https://ingest.syntropy.dev",
    agent_id="my-agent",
)

# Trace an LLM call (buffered, non-blocking)
client.trace(
    prompt="What is the capital of France?",
    response="The capital of France is Paris.",
    model="gpt-4o",
    tokens_in=12,
    tokens_out=8,
    latency_ms=340,
)

# Synchronous trace (blocks until confirmed)
result = client.trace_sync(
    prompt="Hello",
    response="Hi there!",
    model="gpt-4o-mini",
)
print(result.success, result.trace_id)
```

## OpenAI Integration

Auto-trace all `chat.completions.create()` calls:

```python
import openai
from syntropy import Syntropy
from syntropy.integrations.openai import wrap_openai

syn = Syntropy(api_key="syn_...", agent_id="my-agent")
client = wrap_openai(openai.OpenAI(), syntropy=syn)

# This call is now auto-traced — no code changes needed:
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)
```

## Async Support

```python
from syntropy.client import AsyncSyntropy

async def main():
    client = AsyncSyntropy(
        api_key="syn_...",
        base_url="https://ingest.syntropy.dev",
        agent_id="my-agent",
    )

    result = await client.trace(
        prompt="Hello",
        response="Hi!",
        model="gpt-4o",
    )
    print(result.success)
    await client.close()
```

## Batch Tracing

```python
client.trace_batch([
    {"agent_id": "agent-1", "prompt": "Q1", "response": "A1", "model": "gpt-4o"},
    {"agent_id": "agent-2", "prompt": "Q2", "response": "A2", "model": "gpt-4o"},
])
```

## Configuration

| Option | Default | Description |
|--------|---------|-------------|
| `api_key` | required | Your Syntropy API key |
| `base_url` | `http://localhost:4000` | Ingestion service URL |
| `agent_id` | `""` | Default agent ID |
| `flush_interval` | `2.0` | Seconds between buffer flushes |
| `batch_size` | `50` | Max traces per batch |
| `max_queue_size` | `10000` | Max buffered traces |
| `enabled` | `True` | Set `False` to disable tracing |