semvec/pypi-packages huggingface dataset:
holoscript 1.0.0
Python bindings for HoloScript - VR scene description language
Requires Python: >=3.8
Keywords: 3d, ar, holoscript, metaverse, scene-description, vr, xr

# HoloScript Python Bindings

Python bindings for HoloScript - parse, validate, and generate HoloScript code from Python.

## Installation

```bash
pip install holoscript
```

## Quick Start

```python
from holoscript import HoloScript, parse, validate, generate

# Initialize
hs = HoloScript()

# Parse HoloScript code
ast = hs.parse("""
composition "My Scene" {
  object "Crystal" @grabbable @glowing {
    geometry: "sphere"
    color: "#00ffff"
  }
}
""")

# Validate code
result = hs.validate(ast)
if result.valid:
    print("✅ Valid HoloScript!")
else:
    for error in result.errors:
        print(f"❌ Line {error.line}: {error.message}")

# Generate from natural language
scene = hs.generate("a floating island with glowing crystals")
print(scene.code)

# Create shareable link
share = hs.share(scene.code, title="My VR Scene", platform="x")
print(f"Playground: {share.playground_url}")
print(f"Tweet: {share.tweet_text}")
```

## Features

- **Parsing**: Parse `.hs`, `.hsplus`, and `.holo` files
- **Validation**: Validate syntax with AI-friendly error messages
- **Generation**: Generate HoloScript from natural language
- **Rendering**: Generate preview images/GIFs
- **Sharing**: Create X-optimized shareable links

## For AI Agents (Grok, etc.)

```python
# Grok integration example
from holoscript import HoloScript

hs = HoloScript(api_key="your-api-key")  # Optional for remote rendering

# Generate scene from user prompt
user_prompt = "Create a VR scene with a floating castle"
scene = hs.generate(user_prompt)

# Validate
if hs.validate(scene.code).valid:
    # Create shareable preview
    preview = hs.render(scene.code, format="gif", duration=3000)
    share = hs.share(scene.code, title="Floating Castle", platform="x")
    
    # Return to user
    print(f"Here's your VR scene: {share.playground_url}")
    print(f"Preview: {preview.url}")
```

## API Reference

See [full documentation](https://holoscript.dev/python) for complete API reference.
zeabur 0.1.1
A Python SDK for the Zeabur platform, generated from the GraphQL schema.
Requires Python: >=3.8
Keywords: zeabur, graphql, sdk

# Zeabur Python SDK

A Python SDK for the Zeabur platform, generated from the GraphQL schema.

## Installation

You can install the SDK using pip:

```bash
pip install zeabur
```

## Usage

First, you need to obtain an API key from the Zeabur dashboard.

### Initialization

```python
from zeabur import Zeabur

# Initialize the client
client = Zeabur(api_key="YOUR_API_KEY")
```

### Async Usage

All methods in the SDK are asynchronous. You need to use `await` to call them.

```python
import asyncio
from zeabur import Zeabur

async def main():
    client = Zeabur(api_key="YOUR_API_KEY")

    # List projects
    projects = await client.projects()
    for edge in projects.edges:
        print(f"Project ID: {edge.node.id}, Name: {edge.node.name}")

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

### Creating a Service

```python
from zeabur import Zeabur, ServiceTemplate

async def create_service():
    client = Zeabur(api_key="YOUR_API_KEY")

    project_id = "YOUR_PROJECT_ID"

    service = await client.create_service(
        name="my-service",
        template=ServiceTemplate.GIT,
        project_id=project_id,
        # ... other parameters
    )
    print(f"Created service: {service.id}")
```

## Development

1. Install dependencies:
   ```bash
   pip install -e .[test]
   ```

2. Generate operations and client code:
   ```bash
   python generate_operations.py
   ariadne-codegen
   ```

3. Run tests:
   ```bash
   pytest
   ```
dihlibs 0.0.94
A helper package for data integrations
Requires Python: >=3.6

# dihlibs

`dihlibs` is a Python package designed to simplify and enhance data integration and handling tasks. Whether you're dealing with data ingestion, preprocessing, transformation, or integration from various sources, `dihlibs` offers a set of tools and utilities to make these tasks more straightforward and efficient.

## Features

- **Data Ingestion**: Easily import data from multiple sources like databases, files, or APIs.
- **Data Transformation**: Transform data with a set of powerful, easy-to-use functions.
- **Integration Utilities**: Seamlessly integrate data from different formats and standards.
- **Preprocessing Tools**: Prepare your data for analysis with preprocessing capabilities.

## Installation

Install `dihlibs` using pip:

```bash
pip install dihlibs
quack-diff 0.0.10
Regression testing tool for modern data warehouses, powered by duck-db
Requires Python: >=3.12
Keywords: data, data-quality, diff, duckdb, regression-testing, snowflake

# quack-diff

[![CI](https://github.com/mattcristal/quack-diff/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/mattcristal/quack-diff/actions/workflows/ci.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/mattcristal/quack-diff/graph/badge.svg)](https://codecov.io/gh/mattcristal/quack-diff)

![quack-diff logo](images/quack_diff.jpg)

The zero-dependency regression testing tool for modern data warehouses.

> [!WARNING]
> ⚠️ This project is high work-in-progress.

---

**Documentation**: [github.io/quack-diff](https://mattcristal.github.io/quack-diff/)

---

## Features

- **DuckDB-First Architecture**: Uses DuckDB as a universal adapter for database connectivity
- **Dialect-Safe Hashing**: Handles NULL values and type mismatches correctly across databases
- **Time-Travel Support**: Compare data against historical snapshots (Snowflake, Delta Lake)
- **CI/CD Ready**: Exit codes for pipeline integration, environment variable configuration
- **User-Friendly**: Rich terminal output with beautiful diff tables

## Installation

```bash
uv add quack-diff
```

## Quick Start

### Basic compare

```bash
# Compare two tables
quack-diff compare --source db1.users --target db2.users --key id

# Compare with threshold (allow up to 1% difference)
quack-diff compare --source prod.orders --target dev.orders --key order_id --threshold 0.01
```

### Time-Travel compare (Snowflake)

```bash
# Compare current data with 5 minutes ago
quack-diff compare \
  --source snowflake.orders \
  --target snowflake.orders \
  --source-at "5 minutes ago" \
  --key order_id
```

### Schema Comparison

```bash
quack-diff schema --source db1.users --target db2.users
```

## Configuration

quack-diff supports configuration via environment variables:

```bash
# Snowflake
export QUACK_DIFF_SNOWFLAKE_ACCOUNT="your-account"
export QUACK_DIFF_SNOWFLAKE_USER="your-user"
export QUACK_DIFF_SNOWFLAKE_PASSWORD="your-password"
```

Or via a `quack-diff.yaml` configuration file:

```yaml
snowflake:
  account: your-account
  user: your-user
  database: your-database

defaults:
  threshold: 0.0
```

## How It Works

quack-diff leverages DuckDB's extension system to connect to external databases:

1. **Attach**: Mount remote databases using DuckDB extensions (snowflake)
2. **Hash**: Generate row-level hashes using dialect-safe SQL (handles NULLs, type coercion)
3. **Compare**: Identify mismatches by comparing hash values
4. **Report**: Display results in beautiful terminal tables

## Development

```bash
# Clone the repository
git clone https://github.com/matteorenoldi/quack-diff.git
cd quack-diff

# Install with dev dependencies
uv sync

# Install pre-commit hooks
uv run prek install

# Run tests
uv run pytest

# Lint
uv run ruff check .
```

## License

MIT License - see [LICENSE](LICENSE) for details.
hello-riken 0.1.0
A simple package that prints Hello Riken
Requires Python: >=3.7

# Hello Riken

A simple Python package that prints "Hello Riken!"

## Installation
```bash
pip install hello-riken
```

## Usage
```python
from helloriken import greet

greet()  # Prints: Hello Riken!
```

## License

MIT
```

---

## Step 4: Create LICENSE (1 minute)

### File 4: `LICENSE`

Just copy this (MIT License):
```
MIT License

Copyright (c) 2025 Riken

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

---

## Your folder structure should look like this:
```
hello-riken/
â”œâ”€â”€ helloriken/
â”‚   â””â”€â”€ __init__.py
â”œâ”€â”€ setup.py
â”œâ”€â”€ README.md
â””â”€â”€ LICENSE
iis-frida 0.1.2
Example Python Module
Requires Python: >=3.10

# Example Package

This is used to upload dummy packages to Pypi.

This is a simple example package. You can use
[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content.

To upload a new package to public pypi repository update the pyproject.toml file and give it a name.

Run these commands to upload

```bash
pip install build twine
twine upload dist/*
```

Twine will ask for token then provide the token from the Pypi account.