semvec/pypi-packages huggingface dataset:
maamgr 0.2.4
Maa based apps Manager
Requires Python: >=3.8

# maamgr

`maamgr` is a command-line tool for managing MAA packages using the Scoop package manager.

## Installation

To install `maamgr`, you need to have Python 3.8 or higher installed. You can install `maamgr` using pip:

```sh
pip install maamgr
```

## Usage

`maamgr` provides several commands to manage MAA packages. Below are the available commands and their usage:

### maamgr

This is the main command to initialize and manage MAA packages.

```sh
maamgr [OPTIONS] NAME
```

#### Options

- `-u, --update`: Check for updates.

#### Arguments

- `NAME`: The name of the MAA package to manage.

### maamgr cat

Displays the contents of the MAA package.

```sh
maamgr cat
```

### maamgr start

Starts the MAA package.

```sh
maamgr start PATH
```

#### Arguments

- `PATH`: The path to the executable file of the MAA package.

### maamgr patch

Patches and saves data between files using path-based operations.

```sh
maamgr patch ARGS...
```

#### Arguments

- `ARGS`: Variable number of strings in the format `source->destination` where source and destination can include:
  - File paths with optional key paths (e.g., `path/to/file:key1/key2`)
  - Variable substitution using `{{var}}` syntax (e.g., `{{CONFIG}}/file.json`)

#### Examples

```sh
maamgr patch 'source.json:data->{{CONFIG}}/dest.json:new_data'
maamgr patch 'file1.json->file2.json'
maamgr patch 'file1.json:key1/key2->file2.json:new_key'
```

### maamgr kv

Patches a specific key-value pair in a file.

```sh
maamgr kv PATH KEY VALUE
```

#### Arguments

- `PATH`: The path to the file.
- `KEY`: The key to patch.
- `VALUE`: The new value to set.

## License

This project is licensed under the MIT License. See the `LICENSE` file for details.
bunnycdn-storage-handler 0.1.1
A Python client for BunnyCDN Storage API
Requires Python: >=3.6

# BunnyCDN Storage Python Client

A Python client for interacting with BunnyCDN Storage API. This package provides a simple interface to upload, download, and manage files on BunnyCDN Storage.

## Installation

```bash
pip install bunnycdn-storage-handler
```

## Configuration

Before using the client, you need to set up your API key, storage zone, and pull zone. You can do this in one of the following ways:

### Method 1: Environment Variables

Set the following environment variables in your system:

- `BUNNYCDN_API_KEY`: Your BunnyCDN API key.
- `BUNNYCDN_STORAGE_ZONE`: Your BunnyCDN storage zone name.
- `BUNNYCDN_PULL_ZONE`: Your BunnyCDN pull zone name.

You can set environment variables in your terminal like this:

```bash
export BUNNYCDN_API_KEY='your_api_key'
export BUNNYCDN_STORAGE_ZONE='your_storage_zone'
export BUNNYCDN_PULL_ZONE='your_pull_zone'
```

### Method 2: Direct Initialization

Alternatively, you can pass the API key and zone names directly when initializing the `BunnyCDNStorage` client:

```python
from bunnycdn_storage import BunnyCDNStorage

# Initialize the client with your credentials
storage = BunnyCDNStorage(
    api_key='your_api_key',
    storage_zone='your_storage_zone',
    pull_zone='your_pull_zone'
)
```

## Usage

```python
from bunnycdn_storage import BunnyCDNStorage

# Initialize the client
storage = BunnyCDNStorage()

# Upload a file
cdn_url = storage.upload_file("path/in/storage/", file_content, "filename.txt")

# Download a file
status = storage.download_file("path/to/file.txt", "local/destination/path")

# Check if file exists
exists = storage.object_exists("path/to/file.txt")

# Delete a file
status = storage.delete_object("path/to/file.txt")
```

## Features

- Upload files to BunnyCDN Storage
- Download files from BunnyCDN Storage
- Check if files exist
- Delete files from storage
- Automatic CDN URL generation

## License

This project is licensed under the MIT License - see the LICENSE file for details.
julius-nlp-tokenizer 0.1.0
A production-grade tokenizer for LLMs with perfect roundtrip accuracy
Requires Python: >=3.8

# Julius Tokenizer

A high-performance tokenizer optimized for business and financial text processing with perfect roundtrip accuracy.

[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Overview

Julius Tokenizer is a state-of-the-art tokenization library designed specifically for business and financial text. It offers exceptional performance while providing perfect roundtrip accuracy through its innovative reversible mode.

### Key Features

- **Perfect Roundtrip Accuracy**: Optional reversible mode ensures 100% exact text reconstruction
- **Business Domain Optimization**: Specially trained for financial and business terminology
- **Memory Efficient**: Intelligent caching and memory management
- **PyTorch Integration**: Seamless integration with PyTorch and Hugging Face Transformers

## Installation

```bash
# Install from PyPI
pip install julius-nlp-tokenizer

# Or install from the current directory
pip install .

# Or install from a specific path
pip install /path/to/julius_tokenizer
```

## Quick Start

```python
from julius_tokenizer import JuliusTokenizer

# Load the pretrained tokenizer
tokenizer = JuliusTokenizer.from_pretrained("julius_tokenizer/data/models/julius-base")

# Encode text to token IDs
text = "EBITDA increased by 15% in Q3 2023, exceeding our projected KPIs."
tokens = tokenizer.encode(text)
print(f"Token count: {len(tokens)}")
print(f"Tokens: {tokens[:10]}...")

# Decode token IDs back to text
decoded_text = tokenizer.decode(tokens)
print(f"Decoded text: {decoded_text}")
print(f"Perfect roundtrip: {text == decoded_text}")
```

## Example Usage

The package includes an example script that demonstrates how to use the tokenizer:

```bash
python example.py
```

## API Reference

### JuliusTokenizer

The main tokenizer class with the following methods:

#### Loading a Pretrained Tokenizer

```python
tokenizer = JuliusTokenizer.from_pretrained("julius_tokenizer/data/models/julius-base")
```

#### Encoding Text

```python
# Encode a single text
tokens = tokenizer.encode("Your text here")

# Batch encode multiple texts
batch_tokens = tokenizer.batch_encode(["Text 1", "Text 2", "Text 3"])
```

#### Decoding Tokens

```python
# Decode a single sequence of tokens
text = tokenizer.decode([1, 308, 253, 152, 3473])

# Batch decode multiple sequences
texts = tokenizer.batch_decode([[1, 308, 253], [1, 456, 789]])
```

#### Reversible Mode

```python
# Enable perfect roundtrip accuracy
tokenizer.set_reversible_mode(True)

# Disable for slightly faster processing
tokenizer.set_reversible_mode(False)
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
irawatch 0.1.0
IraWatch client for Python
Requires Python: >=3.8

# IraWatch

This is a client library which sends traces to IraWatch collector.

Install 

```bash
pip install setuptools
pip install git+ssh://git@github.com/darylac/irawatch.git
```

```py
import nats

# It is important to have a import statement like this. `from irawatch.trace import Tracer, Span` won't work due to design considerations.
from irawatch import trace

nc = await nats.connect()

# Initialise tracer when application starts up
trace.Tracer(service_name="App A", nats_conn=nc)

# The trace ID must be 16 bytes. UUID4 is 16 bytes, so can be used.
trace_id = uuid.uuid4().bytes

# Every time you want to send a trace, you do the following
span = trace.Span(name="Task A", trace_id=trace_id).start()
time.sleep(2) # some task
await span.stop() # when you invoke stop, it will send the trace to the collector.

span = trace.Span("Task B", trace_id).start()
time.sleep(3)
await span.stop(attributes={"attr1": "val1"}) # the attributes argument takes dict where key is string and value is any valid JSON value
```