semvec/pypi-packages huggingface dataset:
happydata 0.1.0
data loading,writing, transforming without third party library
Requires Python: >=3.12

# happydata
happy data loading,writing, transforming without third party library



## Installation
```bash
pip install happydata
```

## Usage
```python
from happydata import *
import io

class User:
    def __init__(self, name:str, age:int):
        self.name = name
        self.age = age
tmp_path = 'test_users.jsonl'
# jsonl
write_jsonl([User('name', 18), User('张三', 19)], tmp_path)
assert load_jsonl(tmp_path) == [{'name': 'name', 'age': 18}, {'name': '张三', 'age': 19}]

# jsonl.gz
records = load_jsonl_gz('test_users.jsonl.gz')
write_jsonl_gz(records, 'test_users.jsonl.gz')
# lines
for line in read_lines('test_users.jsonl'):
    print(line)
write_lines(lines, 'test_users.jsonl')

# tar.gz
for item, f in read_tar_gz(tmp_path):
    print(item.name)
    bs= f.read()
write_tar_gz(records, {
    'test.txt': io.BytesIO(b'hello'),
    }, 'test.tar.gz')

# zip
for name, f in read_zip(tmp_path):
    print(name)
    bs = f.read()
write_zip({
    'test.txt': io.BytesIO(b'hello'),
    }, 'test.zip')

# dir
files = load_dir('test_dir')

# commands:
state,stdout,stderr = run('ls')

# transform:
groupby([{'name': 'name', 'age': 18}, {'name': '张三', 'age': 19}], 'name')

```
cakelens-v5 0.1.2
Add your description here
Requires Python: >=3.11

# cakelens-v5 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/LaunchPlatform/cakelens-v5/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/LaunchPlatform/cakelens-v5/tree/master)
Open-source AI-gen video detection model

## Installation

Install the package with its dependencies:

```bash
pip install cakelens-v5
```

## Command Line Interface

The package provides a command line tool `cakelens` for easy video detection:

### Basic Usage

```bash
# Using Hugging Face Hub (recommended)
cakelens video.mp4

# Using local model file
cakelens video.mp4 --model-path model.pt
```

### Options

- `--model-path`: Path to the model checkpoint file (optional - will load from Hugging Face Hub if not provided)
- `--batch-size`: Batch size for inference (default: 1)
- `--device`: Device to run inference on (`cpu`, `cuda`, `mps`) - auto-detected if not specified
- `--verbose, -v`: Enable verbose logging
- `--output`: Output file path for results (JSON format)

### Examples

```bash
# Basic detection (uses Hugging Face Hub)
cakelens video.mp4

# Using local model file
cakelens video.mp4 --model-path model.pt

# With custom batch size and device
cakelens video.mp4 --batch-size 4 --device cuda

# Save results to JSON file
cakelens video.mp4 --output results.json

# Verbose output
cakelens video.mp4 --verbose
```

### Output

The tool provides:
- Real-time prediction percentages for each label
- Final mean predictions across all frames
- Option to save results in JSON format
- Detailed logging (with `--verbose` flag)
teapy 0.9.0
A blazingly fast datadict library
Requires Python: >=3.8

# Teapy
[![Build](https://github.com/teamon9161/teapy/workflows/Build/badge.svg)](https://github.com/teamon9161/teapy/actions)
[![PyPI](https://img.shields.io/pypi/v/teapy)](https://pypi.org/project/teapy)
[![codecov](https://codecov.io/gh/teamon9161/teapy/branch/master/graph/badge.svg?token=WK0F7P1VC6)](https://codecov.io/gh/teamon9161/teapy)

## Blazingly fast datadict library in Python

Teapy is a high-performance data dictionary library implemented in Rust, designed for blazingly fast operations. It offers the following features:
* Lazy evaluation
* Handling of NaN values
* Multi-threaded processing
* Support for any dimensionality

## Setup
Install the latest teapy version with:
`pip install teapy`


## Basic Usage

### Creating Expressions
```Python
# Expressions can be created in various ways
import numpy as np
import pandas as pd
import polars as pl
import teapy as tp

e1 = tp.Expr([1, 2, 3])  # Create from list
e2 = tp.Expr((1, 2, 3))  # Create from tuple
e3 = tp.Expr(np.array([1, 2, 3]), 'e3')  # Create from numpy.ndarray, name is e3
e4 = tp.Expr(pd.Series([1, 2, 3]))  # Create from pandas.Series
e5 = tp.Expr(pl.Series([1, 2, 3]))  # Create from polars.Series
```
### Creating DataDicts
```Python
# DataDicts can be created in different ways
dd1 = tp.DataDict({'a': [1, 2], 'b': [2, 3]}, c=[3, 4])  # Create from dictionary
dd2 = tp.DataDict([tp.Expr([1, 2], 'a'), tp.Expr([2, 3], 'b')])  # Create from list of expressions
dd3 = tp.DataDict(a=[1, 2], b=[2, 3], c=np.array([3, 6, 2]))  # Create by specifying key-value pairs
```

### Evaluating Expressions and DataDicts
```Python
# Evaluating Expressions
e = tp.Expr([1, 2, 3]).mean()
e.eval()  # Execute the expression
e.view  # View the memory of the array
e.eview()  # Execute the expression and view the memory of the array
e.value()  # Execute the expression and copy the memory of the array to a new numpy.ndarray

# Evaluating DataDicts
dd = tp.DataDict({'a': [1, 2]*10, 'b': [2, 3]*10}, c=[3, 4])
dd = dd.select([
    dd['a'].ts_mean(3).alias('d'), 
    dd['b'].ts_std(4).alias('e')
])
dd.eval(['d', 'e'])  # Evaluate specific keys in parallel
dd.eval()  # Or evaluate all expressions in parallel
print(dd['d'])

```
maptrans 0.3.0
Map Transform tool
Requires Python: >=3.10

# Map Transform tool

copy idea from <https://epsg.io/>
but API from <https://www.maptiler.com/>

## Install

```sh
pip install maptrans
```

## Usage

make some data in csv like `sample.csv`

```csv
X,Y,H
20510210.743588,4058386.735392,155.55
20510196.183790,4057723.195846,123.45
```

transform by running command

```sh
mt --key <YOUR-KEY> --input sample.csv
```

> Get your FREE key from MapTiler

Default transform `CGCS2000 Zone 20` to `WGS 84`  
You can change the EPSG code

```sh
mt --key <YOUR-KEY> --input <INPUT-FILE> \
    --start <START-CODE> --to <TO-CODE>
```

- `START-CODE`: 4498 (CGCS2000 Zone 20) as default
- `TO-CODE`: 4326 (WGS 84) as default

get more details from <https://epsg.io/>