semvec/pypi-packages huggingface dataset:
phable 0.1.26
A modern Python toolkit for working with Project Haystack tagged data, Xeto specs, and Haxall
Requires Python: <4,>=3.11

About
-----
Phable is a modern Python toolkit for working with [Project Haystack](https://project-haystack.org/) tagged data, [Xeto](https://github.com/Project-Haystack/xeto?tab=readme-ov-file#overview) specs, and [Haxall](https://haxall.io/). It provides a simple, Pythonic interface for building automation systems, charging station management systems, and other energy management applications that use Project Haystack semantic data models.

**Open source and free** - Phable is permissively licensed under the MIT license.

### Core Capabilities

**Data Types & Serialization**

- Full support for Project Haystack [kinds](https://project-haystack.org/doc/docHaystack/Kinds) (data types)
- Serialize between Python objects and [Zinc](https://project-haystack.org/doc/docHaystack/Zinc) or [JSON](https://project-haystack.org/doc/docHaystack/Json) formats
- Native Python representations for working with semantic data

**Project Haystack Client**

- Read `site`, `equip`, and `point` entities
- Read current values of real-time data points
- Supervisory control of real-time data points
- Read and write history data for data points

**Haxall Client**

- All Project Haystack client features
- Add, update, and remove operations (commit API)
- Evaluate Axon expressions directly from Python

**Xeto**

- Type checking and validation of Haystack records against Xeto specifications via Haxall's CLI

Installation
------------
Phable requires Python 3.11 or higher. Install from PyPI:

```console
$ pip install phable
```

**Time zone support:** Phable uses the `zoneinfo` module for IANA time zone support. On systems without time zone data, you'll need to install `tzdata`:

```console
$ pip install tzdata
```

**Optional dependencies:** For DataFrame support, install with your preferred library:

```console
$ pip install "phable[pandas,pyarrow]"  # For pandas support
$ pip install "phable[polars]"          # For polars support
```

Breaking Changes
----------------
The early focus of this project is to find the best practices for using modern Python with a Haystack server.  This may lead to breaking changes in newer Phable versions.  After there has been sufficient experience with Phable, we plan to release a stable version 1.0.0.

Learn More
----------
Phable's official website located [here](https://phable.dev/) has additional documentation and examples for Phable's API.
mytorch-rnn 0.1.0
A NumPy-based neural network library featuring RNN, GRU cells, CTC loss/decoding, greedy and beam search decoders — built from scratch without PyTorch.
Requires Python: >=3.9

# mytorch-rnn

A lightweight, NumPy-only neural network library implementing recurrent architectures and CTC (Connectionist Temporal Classification) from scratch.

## Features

- **RNN Cell** — vanilla recurrent neural network cell with forward and backward (BPTT) support
- **GRU Cell** — gated recurrent unit with reset, update, and new gates
- **RNN Phoneme Classifier** — multi-layer RNN for sequence classification
- **Character Predictor** — GRU-based character-level prediction with inference utilities
- **CTC Loss** — full CTC forward-backward algorithm with posterior probability computation
- **CTC Decoding** — greedy search and beam search decoders
- **Neural Network Primitives** — Linear layer, Sigmoid, Tanh, Softmax Cross-Entropy loss

## Installation

```bash
pip install mytorch-rnn
```

## Quick Start

```python
import numpy as np
from mytorch import RNNCell, GRUCell
from CTC import CTC, CTCLoss, GreedySearchDecoder, BeamSearchDecoder

# Create an RNN cell
rnn = RNNCell(input_size=10, hidden_size=20)
x = np.random.randn(1, 10)
h = np.zeros((1, 20))
h_next = rnn(x, h)

# Create a GRU cell
gru = GRUCell(input_size=10, hidden_size=20)
x = np.random.randn(10)
h = np.zeros(20)
h_next = gru(x, h)

# CTC greedy decoding
symbols = ["a", "b", "c"]
decoder = GreedySearchDecoder(symbols)

# CTC beam search decoding
beam_decoder = BeamSearchDecoder(symbols, beam_width=3)
```

## Requirements

- Python >= 3.8
- NumPy
at-data-tools 0.1.8
Add your description here
Requires Python: >=3.13

# at-data-tools

Atium Research backtesting and research tools package for quantitative finance data access.

## Overview

`at-data-tools` is a Python library that provides convenient access to quantitative finance datasets stored in a Bear Lake database. It offers functions to load historical market data, alphas, betas, factor models, and other quantitative signals, all returned as Polars DataFrames for efficient data analysis.

## Installation

Install the package using pip:

```bash
pip install at-data-tools
```

Or with uv:

```bash
uv add at-data-tools
```

## Configuration

The package requires AWS credentials to access the S3-backed Bear Lake database. Create a `.env` file in your project root with the following variables:

```env
ACCESS_KEY_ID=your_aws_access_key
SECRET_ACCESS_KEY=your_aws_secret_key
REGION=your_aws_region
ENDPOINT=your_s3_endpoint_url
BUCKET=your_bucket_name
```

## Usage

### Basic Example

```python
import datetime as dt
import at_data_tools as adt

# Load stock prices for a date range
start = dt.date(2023, 1, 1)
end = dt.date(2023, 12, 31)
prices = adt.load_stock_prices(start, end)

# Load alphas for specific signals
signals = ['reversal']
alphas = adt.load_alphas(start, end, signals)

# View the schema of any table
schema = adt.get_stock_prices_schema()
print(schema)
```

## Available Data

### Market Data
- `load_stock_prices(start, end)` - Load historical stock prices
- `load_stock_returns(start, end)` - Load stock returns
- `load_etf_prices(start, end)` - Load ETF prices
- `load_etf_returns(start, end)` - Load ETF returns

### Alpha & Signals
- `load_alphas(start, end, signals)` - Load alpha values for specified signals
- `load_signals(start, end, signals)` - Load raw signal values
- `load_scores(start, end, signals)` - Load signal scores

### Risk Models
- `load_betas(start, end)` - Load market betas
- `load_factor_loadings(start, end)` - Load factor model loadings
- `load_factor_covariances(start, end)` - Load factor covariance matrices
- `load_idio_vol(start, end)` - Load idiosyncratic volatility

### Benchmarks
- `load_benchmark_weights(start, end)` - Load benchmark portfolio weights
- `load_benchmark_returns(start, end)` - Load benchmark returns

### Reference Data
- `load_universe(start, end)` - Load trading universe membership
- `load_calendar(start, end)` - Load trading calendar

### Schema Inspection

Each data loader has a corresponding schema function:
- `get_stock_prices_schema()` - Returns Polars schema for stock prices
- `get_alphas_schema()` - Returns Polars schema for alphas
- And similarly for all other data types...

## Data Types

All functions return `polars.DataFrame` objects for efficient data manipulation. Date parameters accept `datetime.date` objects.

## Requirements

- Python >= 3.13
- polars >= 1.38.1
- bear-lake >= 0.1.5
- python-dotenv >= 1.2.1

## License

Copyright Atium Research. All rights reserved.
sgrf 3.1.0
Static Gestures Recognition Framework
Requires Python: >=3.11

# SGRF library development setup

## Prerequisites

- Python 3.11
- PIP

## Development

### Installation

1. Create/activate virtual environment
2. Install required packages with `pip install -r requirements.txt`

### Create new algorithm

To create a new algorithm, use algorithm creation script: `./scripts/generate_algorithm.py`

### Validate algorithms

To validate algorithms use scripts located in `./validation` directory. Json files with validation results are located
in `./validation/results` directory

## Usage

### Import library

To use library in external project, use `pip install sgrf`.

### Sample use cases

To predict gesture on selected image, run the code below. You can select desired algorithm by using values
on `ALGORITHM` enum. Some algorithms require their own payload (e.g. hand coordinates or background image
without hand). You can import specific payload from `sgrf.algorithms.<alg>.<alg>_payload`.

```python
import cv2
from sgrf import classify
from sgrf.data.algorithm import ALGORITHM
from sgrf.models.image_payload import ImagePayload

image = cv2.imread("resources/image.jpg")
result = classify(algorithm=ALGORITHM.EID_SCHWENKER, payload=ImagePayload(image=image))

print(result)
```

To show image processed by the selected algorithm, run:

```python
import cv2
from sgrf import process_image
from sgrf.data.algorithm import ALGORITHM
from sgrf.models.image_payload import ImagePayload

image = cv2.imread("resources/image.jpg")
processed_image = process_image(algorithm=ALGORITHM.EID_SCHWENKER, payload=ImagePayload(image=image))

cv2.imshow("Image", processed_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
```

To learn your own algorithm's model (e.g. on other image base than ours), run:

```python
import cv2
from sgrf import learn
from sgrf.data.algorithm import ALGORITHM
from sgrf.data.gesture import GESTURE
from sgrf.models.learning_data import LearningData

image = cv2.imread("resources/image.jpg")
acc, loss = learn(algorithm=ALGORITHM.EID_SCHWENKER, target_model_path="models",
                  learning_data=[LearningData(image_path="resources/image.jpg", label=GESTURE.FIVE)] * 10)

print(acc, loss)
```
PyScratches 0.1.1
A Python extension module.
Requires Python: >=3.7

# PyScratches

`PyScratches` is a lightweight utility library for Python that allows you to **repeat actions, wait for time intervals, and execute functions conditionally or repeatedly**. Ideal for simple scripts, quick tests, or basic automation.

## Main Functions

### `repeat(string, times)`

Prints a string multiple times.

**Parameters:**

- `string` (str): The text to print.
- `times` (int): The number of times to print the text.

**Example:**

```python
from pyextension import repeat

repeat("Hello", 3)
# Output:
# Hello
# Hello
# Hello
```

### `wait(seconds)`

Pauses the program execution for a given number of seconds.

Parameters:

seconds (float): Time to wait in seconds.

Example:

```python
from pyextension import wait


wait(2)  # Pauses for 2 seconds
print("Done!")
```

### `forever(func, delay=None)`

Executes a function indefinitely. Optionally, a delay can be added between each execution.

Parameters:

func (callable): The function to execute.

delay (float, optional): Seconds to wait between executions. Default is None.

Example:

```py
from pyextension import forever

def greet():
print("Hello")

forever(greet, delay=1) # Prints "Hello" every second
```

### `when(condition, func)`

Executes a function when a condition becomes True (continuously evaluated).

Parameters:

condition (callable → bool): Condition that is checked repeatedly until True.

func (callable): Function to execute when the condition is True.

Example:

```py
from pyextension import when

x = 0

def cond():
return x > 5

def action():
print("x is greater than 5!")

when(cond, action)
```

### `until(condition, func)`

Executes a function while a condition is True (stops when the condition becomes False).

Parameters:

condition (callable → bool): Condition that is checked continuously.

func (callable): Function to execute when the condition is False.

Example:

```py
from pyextension import until


x = 5


def cond():
    return x > 0


def action():
    print("x is still positive")


until(cond, action)
```

### PyExtension is very simple, but useful for scripts that need to repeat tasks, wait for intervals, or execute functions conditionally without relying on external libraries.