semvec/pypi-packages huggingface dataset:
rdst 0.1.330
Readyset Data and SQL Toolkit - CLI tool for database diagnostics and query optimization
License: MIT
Requires Python: >=3.10
Keywords: caching, database, diagnostics, optimization, performance, readyset, sql

# RDST - Readyset Data and SQL Toolkit

A command-line tool for database diagnostics, query analysis, performance tuning, and caching optimization with Readyset.

## What is RDST?

RDST helps you:
- Analyze SQL queries for caching opportunities
- Identify slow queries in real-time
- Get optimization suggestions
- Evaluate query compatibility with Readyset cache
- Manage database connection profiles

## Installation

### Using uvx (recommended - no installation required)

Run RDST directly without installing:

```bash
uvx rdst --help
uvx rdst analyze "SELECT * FROM users WHERE id = 1"
```

### Using pipx (persistent installation)

Install globally:

```bash
# Install
pipx install rdst

# Run
rdst --help

# Upgrade to latest version
pipx upgrade rdst
```

### Using pip

```bash
pip install rdst
```

> **After installing**, run `rdst init` to configure your first database connection.

## Quick Start

1. **Initialize RDST:**
   ```bash
   rdst init
   # Or with uvx (no installation needed):
   uvx rdst init
   ```

2. **Configure database connection:**
   ```bash
   rdst configure add-target mydb \
     --host localhost \
     --port 5432 \
     --database myapp \
     --user postgres
   ```

3. **Analyze queries:**
   ```bash
   # Analyze a specific query
   rdst analyze "SELECT * FROM users WHERE active = true"

   # With uvx:
   uvx rdst analyze "SELECT * FROM users WHERE active = true"

   # Analyze with Readyset cache evaluation
   rdst analyze --readyset-cache "SELECT * FROM products ORDER BY created_at"
   ```

4. **Monitor slow queries:**
   ```bash
   rdst top
   # Or: uvx rdst top
   ```

## Commands

All commands can be run with `rdst` (if installed) or `uvx rdst` (no installation):

- `rdst configure` - Manage database targets and connection profiles
- `rdst analyze` - Analyze SQL queries and evaluate caching opportunities
- `rdst top` - Live view of slow queries
- `rdst tune` - Get query optimization suggestions
- `rdst query` - Manage query registry
- `rdst init` - First-time setup wizard
- `rdst version` - Show version information

**Example with uvx:**
```bash
uvx rdst analyze "SELECT * FROM orders WHERE status = 'pending'"
```

## Requirements

- Python 3.11 or higher
- PostgreSQL or MySQL database access

## About Readyset

Readyset is a SQL caching engine that sits between your application and database, automatically caching query results to improve performance. Learn more at [readyset.io](https://readyset.io).

## Documentation

- [Readyset Documentation](https://docs.readyset.io)
- [GitHub Repository](https://github.com/readysettech/readyset)
- [Report Issues](https://github.com/readysettech/readyset/issues)

## License

MIT License - see LICENSE file for details
ilulab 0.0.5
Lightweight Python client for IluLab
License: MIT
Requires Python: >=3.12
Keywords: experiment-tracking, logging, machine-learning, mlops

# IluLab Python Client

Lightweight Python client for tracking ML experiments with IluLab.

## Installation

```bash
pip install ilulab
```

## Quick Start

Set your API token as an environment variable:

```bash
export ILULAB_TOKEN="your_api_token_here"
```

then use the client in your code:

```python
from ilulab import IlulabClient

# Initialize client
client = IlulabClient()

# Create a project
project = client.create_project(
    name="my-ml-project",
    description="Testing ilulab"
)

# Create a run
run = client.create_run(
    project_id=project["id"],
    name="experiment-1",
    tags=["baseline", "resnet"]
)

# Log parameters
run.log_params({
    "batch_size": 32,
    "optimizer": "adam",
    "model": "resnet50"
})

# Log metrics during training
for epoch in range(10):
    # ... training code ...
    loss = 0.5 - epoch * 0.03  # example
    accuracy = 0.6 + epoch * 0.04  # example

    run.log_metrics({
        "train_loss": loss,
        "train_accuracy": accuracy
    }, step=epoch)

# Mark run as completed
run.finish()

# Clean up
client.close()
```

## Using Context Managers

```python
from ilulab import IlulabClient

with IlulabClient() as client:
    project = client.create_project(name="my-project")

    with client.create_run(project["id"], name="experiment-1") as run:
        run.log_param("learning_rate", 0.001)

        for step in range(100):
            run.log_metric("loss", 1.0 / (step + 1), step=step)

        # Automatically marked as completed on exit
        # (or failed if an exception occurs)
```