semvec/pypi-packages huggingface dataset:
ai-image-master 1.0.1766489723
Generate branded links and HTML anchors for https://supermaker.ai/image/
Requires Python: >=3.6

# ai-image-master

Generate branded links and HTML anchors for [https://supermaker.ai/image/](https://supermaker.ai/image/).

## Installation

```bash
pip install ai-image-master
```

## Usage

### Generate Links

```python
from ai_image_master import build_link

# Basic link
url = build_link()

# Link with UTM parameters
url = build_link(
    utm_source="github",
    utm_medium="readme",
    utm_campaign="launch"
)

# Link with path
url = build_link(path="features", utm_source="blog")
```

### Generate HTML Anchors

```python
from ai_image_master import generate_anchor

# Basic anchor
html = generate_anchor("Click here")

# Custom attributes
html = generate_anchor(
    text="Visit website",
    utm_source="twitter",
    utm_medium="social",
    utm_campaign="promotion",
    css_class="btn btn-primary"
)
```

## Official Website

[https://supermaker.ai/image/](https://supermaker.ai/image/)
scrapy-item-ingest 0.2.7
Scrapy extension for database ingestion with job/spider tracking
Requires Python: >=3.7
Keywords: scrapy, database, postgresql, web-scraping, data-pipeline

# Scrapy Item Ingest

A tiny, straightforward addon for Scrapy that saves your items, requests, and logs to PostgreSQL. No boilerplate, no ceremony.

## Install

```bash
pip install scrapy-item-ingest
```

## Minimal setup (settings.py)

```python
ITEM_PIPELINES = {
    'scrapy_item_ingest.DbInsertPipeline': 300,
}

EXTENSIONS = {
    'scrapy_item_ingest.LoggingExtension': 500,
}

# Pick ONE of the two database config styles:
DB_URL = "postgresql://user:password@localhost:5432/database"
# Or use discrete fields (avoids URL encoding):
# DB_HOST = "localhost"
# DB_PORT = 5432
# DB_USER = "user"
# DB_PASSWORD = "password"
# DB_NAME = "database"

# Optional
CREATE_TABLES = True     # auto‑create tables on first run (default True)
JOB_ID = 1               # or omit; spider name will be used
```

Run your spider:

```bash
scrapy crawl your_spider
```

## Troubleshooting

- Password has special characters like `@` or `$`?
  - In a URL, encode them: `@` -> `%40`, `$` -> `%24`.
  - Example: `postgresql://user:PAK%40swat1%24@localhost:5432/db`
  - Or use the discrete fields (no encoding needed).

## Useful settings (optional)

- `LOG_DB_LEVEL` (default: `DEBUG`) — minimum level stored in DB
- `LOG_DB_CAPTURE_LEVEL` — capture level for Scrapy loggers routed to DB (does not affect console)
- `LOG_DB_LOGGERS` — allowed logger prefixes (defaults always include `[spider.name, 'scrapy']`)
- `LOG_DB_EXCLUDE_LOGGERS` (default: `['scrapy.core.scraper']`)
- `LOG_DB_EXCLUDE_PATTERNS` (default: `['Scraped from <']`)
- `CREATE_TABLES` (default: `True`) — create `job_items`, `job_requests`, `job_logs` on startup
- `ITEMS_TABLE`, `REQUESTS_TABLE`, `LOGS_TABLE` — override table names

## Links

- Docs: https://scrapy-item-ingest.readthedocs.io/
- Changelog: docs/development/changelog.rst
- Issues: https://github.com/fawadss1/scrapy_item_ingest/issues

## License

MIT License. See [LICENSE](LICENSE).
tlg-canon 1.0.0
Browse TLG canon data and indices
Requires Python: >=3.13

# About

This Python package facilitates the browsing of the indices of the old TLG CD-ROMs. It expects that texts have been processed by the `tlgu` package ([tlgu homepage](https://tlgu.carmen.gr/), [rehosted code](https://github.com/cltk/grc_software_tlgu)), which offers a variety of ways to convert the Beta Code of the original files into Unicode text files.

# Disclaimer

This repository makes no claim to ownership of the contents of the original TLG CD-ROM, which are owned by the University of California, Irvine. It is an independent effort to facilitate study of texts and does not represent or imply endorsement by the University of California, Irvine or the TLG project.

# Usage overview

The main entry point is the utility functions in `src/tlg_indices/utils.py`, which expose prebuilt indices and convenience lookups. The quickest way to see how to call these helpers is in `examples.py`, which demonstrates:

- Reading index data (epithets, geographies, dates, and author/work mappings).
- Looking up authors by epithet or geography, and reversing those lookups.
- Looking up works by author and retrieving a single work title.
- Sorting and querying date ranges using `ParsedDate` and `get_dates_in_range()`.

For a runnable walkthrough, open `examples.py` and follow the patterns there.
rich-soup 0.1.0
Parse entire web pages into JSON/Markdown.
Requires Python: >=3.11

# Rich Soup
Inspired by BeautifulSoup. Instead of parsing static HTML and using tags, it fully renders the page and the entire DOM (including JS/CSS & slop) using Playwright. Then, it uses semantics; i.e: avg font size versus larger font sizes, lines, gaps, spacing, hierachy/reading order; etc, to reconstruct the page into a clean JSON/Markdown format.
Currently, the options are either:

- BeautifulSoup; static only, messy.
- Playwright; lower level, manual.

- Rich Soup builds on Playwright to give the DX of BeautifalSoup but can render properly like Playwright.

Primarily intended for document-like pages; i.e: Microsoft Learn, whitepapers (PDF-like), Wiki-like sites. Best part is it uses the layout, not tags, and it's not static! It can extract from garbled DOMs with hundreds of divs and hydration from React and Astro islands and Tailwind, etc etc, perfectly fine.
openquake.gem-taxonomy-data 1.4.3
Openquake Gem Taxonomy Data - taxonomy data and python classes to access it.
Requires Python: >=3
Keywords: GEM, taxonomy, standard, openquake

# Openquake GEM Building Taxonomy Data

## GEM Building Taxonomy dataset and python classes to access it.

This package provide GEM Building Taxonomy dataset for [oq-gem-taxonomy](https://github.com/gem/oq-gem-taxonomy) package from GEM Taxonomy specifications (repository: [gem_taxonomy/](https://github.com/gem/gem_taxonomy/))

## Licensing

- **Code**: Licensed under the [GNU Affero General Public License v3.0](https://github.com/gem/oq-gem-taxonomy-data/blob/v1.4.3/LICENSE).
- **Data**: Licensed under the [Creative Commons Attribution Share Alike 4.0 International](https://github.com/gem/oq-gem-taxonomy-data/blob/v1.4.3/DATA_LICENSE).

Please refer to the respective license files for more details.
genestore 0.11.0
Python bindings for genegraph-storage. Store your numpy data in Lance format
Requires Python: >=3.12
Keywords: vector-search, spectral-analysis, graph-signal, similarity-search, machine-learning

# pygenestore

Store your `numpy` arrays at scale using the Lance format. Handles millions of rows as far as the memory goes.

## Usage

It is possible to create multiple storages by passing different directories to `create_storage`.

It is possible to store different arrays in the same storage, just set different names.

### Default API (blocking)
```python
import numpy as np
import genestore

# Configure storage
builder = genestore.store_array("./lance_data")
builder.with_max_rows_per_file(500_000)
builder.with_compression("zstd")

# Build storage instance
storage = builder.build()

# Create data (2D float64 numpy array)
np.random.seed(42)
x = np.random.randn(1000, 128).astype(np.float64)

# Store (blocking)
path = storage.store(x, "my_dataset")
print("Stored at:", path)

# Load (blocking)
y = storage.load("my_dataset")
print("Loaded shape:", y.shape)

# Verify roundtrip
assert np.allclose(x, y)
assert np.array_equal(x, y)
print("✓ Data verification passed")
```


### Async API
```python
import numpy as np
import genestore
import asyncio

async def main():
    # Create a storage builder and configure it
    builder = genestore.create_storage(f"./lance_data")
    builder.with_max_rows_per_file(500000)
    builder.with_compression("zstd")

    # Build the storage instance
    storage = builder.build()

    # Create a numpy array (dense matrix)
    np.random.seed(42)  # For reproducibility
    data = np.random.randn(1000, 128).astype(np.float64)

    # Store the array (await the async call)
    path = await storage.aio.store(data, "my_dataset")
    print(f"Storage at: {path}")

    # Load the array back using the NAME (not path)
    loaded_data = await storage.aio.load("my_dataset")
    print(f"Loaded shape: {loaded_data.shape}")

    # Verify the data
    assert np.allclose(data, loaded_data)
    print("✓ Data verification passed!")

if __name__ == "__main__":
    asyncio.run(main())

```

## Tests


```bash
pip install -r requirements-dev.txt
pytest tests/
```
docker-image-exporter 1.0.0
Export and import Docker images between machines
Requires Python: >=3.13

# Docker Image Exporter/Importer

Herramienta modular para exportar e importar imágenes Docker entre máquinas sin
internet.

## Características

- 🚢 Exporta todas las imágenes Docker manteniendo tags
- 📦 Crea archivos comprimidos para transferencia fácil
- 🔄 Importa imágenes conservando nombres y tags originales
- 📊 Logging detallado y barras de progreso
- 🧩 Diseño modular con funciones puras

## Instalación

```bash
# Clonar e instalar
git clone <repo>
cd docker-image-exporter

# Instalar con uv
uv pip install -e .

# Para desarrollo (opcional)
just setup  # Instala dependencias de desarrollo
```

## Uso

### Scripts de Línea de Comandos

```bash
# Exportar todas las imágenes
export-docker-images --output-dir ./mis_imagenes

# Exportar y crear archivo comprimido
export-docker-images --output-dir ./mis_imagenes --create-archive

# Importar imágenes
import-docker-images --input-dir ./mis_imagenes

# Importar desde archivo comprimido
import-docker-images --archive docker_images_backup.tar.gz
```

### Como Biblioteca

```python
from docker_exporter import export_all_images, import_all_images

# Exportar imágenes
result = export_all_images("./output_dir")
print(f"Exportadas {result['successful']}/{result['total']} imágenes")

# Importar imágenes
result = import_all_images("./input_dir")
print(f"Importadas {result['successful']}/{result['total']} imágenes")
```

## Desarrollo

### Comandos de Desarrollo (usando Justfile)

```bash
# Instalar dependencias de desarrollo
just setup

# Ejecutar pruebas
just test           # Todas las pruebas
just test-cov        # Con cobertura (100% ✅)
just test-utils      # Pruebas de módulo específico

# Calidad de código
just lint            # Verificar estilo
just format          # Formatear código
just type            # Verificar tipos (solo código principal)
just check           # Lint + Type checking

# Workflow de desarrollo
just dev            # test + lint-fix + format
just ci              # Pipeline completo (test + lint + type + build)
```

### Construcción y Publicación

```bash
# Construir paquete
just build          # Wheel + sdist
just build-wheel     # Solo wheel
just build-sdist     # Solo sdist

# Validar lanzamiento
just release-check   # Pruebas + lint + type + build + validación de paquete

# Publicar
just publish-test    # A Test PyPI
just publish-prod    # A PyPI de producción
just release         # Lanzamiento completo
```

### Herramientas Utilizadas

- **Just**: Automatización de tareas de desarrollo
- **Ruff**: Formateo y linting (archivos de código + tests)
- **MyPy**: Verificación de tipos (solo código principal)
- **Pytest**: Suite de pruebas con 100% de cobertura
- **Twine**: Validación de paquetes antes de publicación
pydbx-hng 2.0.3
A contract-driven Python toolkit for structured, explicit, and predictable database operations.

# pydbx

A contract-driven Python toolkit for structured, explicit, and predictable database operations.
StratumDB provides a clear abstraction layer that separates intent, schema, and execution, enabling maintainable workflows and future-proof onboarding for collaborators.
Designed for reliability, transparency, and modular DB interaction.