semvec/pypi-packages huggingface dataset:
ytdl-archiver 0.2.8
Modern Python CLI for archiving YouTube playlists with media-server metadata support
Requires Python: >=3.14
Keywords: youtube, archive, yt-dlp, media-server, cli

# ytdl-archiver

<p align="center">
  <img src="assets/logo.png" alt="ytdl-archiver" width="600">
</p>

Modern Python CLI for archiving YouTube playlists with media-server-friendly sidecar files.

## Dependencies
- Python 3.14+
- [`uv`](https://docs.astral.sh/uv/)
- FFmpeg on `PATH`
- (Recommended) External JavaScript runtime (`deno` or `Node.js`) for full yt-dlp extraction compatibility
- (Recommended) Firefox recommended for cookie extraction
- (Optional) Rust for setup TUI

## Install
Install with uv (recommended):
```bash
uv tool install ytdl-archiver
```

Or with pip:
```bash
pip install ytdl-archiver
```

From source (development):
```bash
git clone https://github.com/htmlgxn/ytdl-archiver.git
cd ytdl-archiver
uv sync
```

## Quick Start

### 1. Run first-time setup
```bash
ytdl-archiver archive
```

If `~/.config/ytdl-archiver/config.toml` is missing, setup runs automatically on non-help commands and generates:
- `~/.config/ytdl-archiver/config.toml`
- `~/.config/ytdl-archiver/playlists.toml`

You can also run setup directly:
```bash
ytdl-archiver init
```

### 2. Define playlists
Edit `~/.config/ytdl-archiver/playlists.toml`:

```toml
[[playlists]]
id = "UUxxxxxxxxxxxxxxxxxxxxxx"
path = "Music/Example Channel"
name = "Example Music Channel"

[playlists.download]
format = "bestaudio"
write_subtitles = false
write_thumbnail = true
```

Notes:
- `[[playlists]]` entries are loaded from the `playlists` array.
- If both `playlists.toml` and `playlists.json` exist in the config directory, TOML is preferred.
- Playlist download overrides accept canonical snake_case keys and yt-dlp-style aliases (for example `write_subtitles` and `writesubtitles`).

### 3. Run archive
```bash
ytdl-archiver archive
```

## Core Commands
```bash
ytdl-archiver --help
ytdl-archiver archive --help
ytdl-archiver convert-playlists --help
ytdl-archiver init --help
```

## Documentation
- Docs index: `docs/index.md`
- CLI reference: `docs/cli.md`
- Configuration reference: `docs/configuration.md`
- Development/contributing: `docs/development.md`
- Migration notes: `MIGRATION.md`
- Terminal output modes: `docs/terminal-output.md`
revyl 0.1.5
Revyl CLI - AI-powered mobile app testing
Requires Python: >=3.9
Keywords: android, automation, e2e, ios, mobile, revyl, testing

# Revyl Python SDK

Thin Python wrapper for the Revyl CLI and device API commands.

## Install

```bash
pip install revyl
```

## Authenticate

Use either:

```bash
revyl auth login
```

or:

```bash
export REVYL_API_KEY="rev_..."
```

## Quickstart

```python
from revyl import DeviceClient

device = DeviceClient.start(platform="ios", timeout=600)

device.tap(target="Login button")
device.type_text(target="Email", text="user@example.com")
device.type_text(target="Password", text="secret123")
device.tap(target="Submit")
device.screenshot(out="after-login.png")

device.stop_session()
```

## Context Manager (Auto Stop)

```python
from revyl import DeviceClient

with DeviceClient.start(platform="android") as device:
    device.tap(target="Get Started")
    device.swipe(target="feed", direction="down")
```

## Available Device Methods

- `start_session`, `stop_session`, `stop_all`, `list_sessions`, `use_session`, `info`, `doctor`
- `tap`, `double_tap`, `long_press`, `type_text`, `swipe`, `drag`
- `screenshot`, `install_app`, `launch_app`

All action methods support either:
- grounded targeting via `target="..."`, or
- raw coordinates via `x=...` and `y=...`

## Low-level CLI Access

```python
from revyl import RevylCLI

cli = RevylCLI()
version = cli.run("version")
sessions = cli.run("device", "list", json_output=True)
```
clarity-api-sdk-python 0.3.30
A Python SDK to connect to the CTI Clarity API server.
Requires Python: >=3.11

# Clarity API SDK for Python

[![PyPI - Downloads](https://badge.fury.io/py/clarity-api-sdk-python.svg)](https://pypi.org/project/clarity-api-sdk-python/)
[![Downloads](https://pepy.tech/badge/clarity-api-sdk-python)](ttps://test.pypi.org/project/clarity-api-sdk-python/)
![python](https://img.shields.io/badge/python-3.11%2B-blue)

A Python SDK for connecting to the CTI API server, with structured logging included.

## Installation

```bash
pip install clarity-api-sdk-python
```

## Logging

Logging support is built with [structlog](https://pypi.org/project/structlog/).

Set the root logger by setting the environment variable `LOG_LEVEL`. Otherwise, the default root logging is set to `INFO`.

```python
"""Example"""

import logging

from cti.logger import initialize_logger, get_logger, ExternalLoggerConfig

initialize_logger(
    external_logger_configurations=[
        ExternalLoggerConfig(name="urllib3"),
        ExternalLoggerConfig(name="httpcore"),
        ExternalLoggerConfig(name="httpx"),
        ExternalLoggerConfig(name="httpx_auth"),
        ExternalLoggerConfig(name="httpx_retries"),
    ],
    handlers=[logging.FileHandler("app.log")]
)

logger_a = get_logger("logger_a")
logger_b = get_logger("logger_b", "WARNING")

# root_logger = logging.getLogger()
# root_logger.setLevel("DEBUG")

logger_a.info("This is info message from logger_a")
logger_a.critical("This is critical message from logger_a")

# Dynamically change the log level of logger_a to WARNING
print("\nChanging logger_a level to WARNING...\n")
logging.getLogger("logger_a").setLevel(logging.WARNING)

logger_a.info("This info message from logger_a should NOT be visible.")
logger_a.warning("This is a new warning message from logger_a.")

logger_b.info("This info message from logger_b should NOT be visible.")
logger_b.warning("This is warning message from logger_b")

# the value will be redacted
logger_b.info("password", extra={"aws_access_key_id", "AKIAIOSFODNN7EXAMPLE"})
```

## Model

Pydantic models.

## API

### Singleton async client

```python
import asyncio
from cti.api.session import initialize_async_client, close_async_client

async def main():
    await initialize_async_client()
    # ... your application logic ...
    await close_async_client()

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

# In other modules
from cti.api.session import get_async_client

async def fetch_data():
    client = get_async_client()
    response = await client.get(...)
    return response.json()
```
clippt 0.1.5
CLI slideshows in Python and Textual.
Requires Python: >=3.13

# clippt

CLI slideshows in Python and Textual.

## Installation

```shell
uv tool install clippt
```

## Running

Usage: clippt [OPTIONS] SOURCE

Options:
  --disable-footer  Disable footer.
  -c, --continue    Continue from last slide.

## Configuration

TOML / JSON / YAML format, to be described

## Examples

Syntax highlighting in many languages:

```shell
uv run clippt examples/fibonacci/
```
typedef-data-intelligence 0.7.0
Unified lineage management and AI-powered analytics platform for dbt projects
Requires Python: >=3.12
Keywords: analytics, data-engineering, dbt, lineage, tui

# typedef Data Intelligence

Unified lineage management and AI-powered analytics platform for dbt projects.

## Features

- **Interactive TUI**: Terminal-based interface for exploring data lineage
- **AI-Powered Analysis**: Semantic analysis of your dbt models using LLMs

## Requirements

- Python 3.12+
- API keys: `ANTHROPIC_API_KEY` and `OPENAI_API_KEY`
- A dbt project with compiled artifacts (`dbt compile`)
- Snowflake access

## Installation

```bash
pip install typedef-data-intelligence
```

## Quick Start

1. **Initialize** - Run the setup wizard to configure your environment:

   ```bash
   typedef init
   ```

2. **Sync** - Load your dbt project into the Knowledge Graph:

   ```bash
   typedef sync
   ```

3. **Chat** - Start the interactive AI assistant:

   ```bash
   typedef chat
   ```

## Documentation

For detailed documentation, architecture guides, and API reference, see the [GitHub repository](https://github.com/typedef-ai/data-intelligence).

## Support

- [Issues](https://github.com/typedef-ai/data-intelligence/issues)
- [typedef.ai](https://typedef.ai)
telemetry-server 4.4.1
Telemetry server for Autoboat

# Autoboat Telemetry Server

A lightweight Flask-based web server to collect, display, and manage telemetry data from the Virginia Tech Autoboat project.

## Project Structure

```txt
autoboat_telemetry_server/
├── __init__.py                   # App factory
├── models.py                     # Database models
├── types.py                      # Custom types and enums
├── lock_manager.py               # Read-write lock manager
├── routes
    ├── __init__.py               # Routes initialization
    ├── autopilot_parameters.py   # Autopilot parameters routes
    ├── boat_status.py            # Boat status routes
    ├── waypoints.py              # Waypoints management routes
    ├── instance_manager.py       # Instance management routes

instance/
    ├── config.py                                   # Configuration file
    ├── app.db                                      # Database file
```

## Quick Start

### Installation

```bash
pip install -e .
```

### Running the server

1. Production ([Gunicorn](https://gunicorn.org/)):

    ```bash
    gunicorn "autoboat_telemetry_server:create_app()"
    ```

2. Development (Flask):

    ```bash
    flask run
    ```

## Server (Long term)

### Installation

```bash
git clone https://github.com/autoboat-vt/telemetry_server
cd telemetry_server
./server_files/install.sh
```