semvec/pypi-packages huggingface dataset:
async-param-server 1.1.3
A distributed parameter server for managing configuration across processes
Requires Python: >=3.12

# Parameter Server

Dead simple TCP-based parameter storage that actually works. No cap.

## Quick Start

```bash
# Install dependencies
make install

# Run server
make server
```

Note, it uses example parameter yml file.

## Python Usage

```python
from param_server.client import AsyncParameterClient

async with AsyncParameterClient() as client:
    await client.set("/camera/exposure", 100)
    value = await client.get("/camera/exposure")
    print(f"Exposure: {value}")
```

## Production Setup

### Parameters.yml
Add your production parameters to file `config/params.yml`.

### Docker Compose (recommended)

```bash
# Build container
make docker-build

# Start container
make docker-run

# Stop container
make stop

# Server runs on 0.0.0.0:8888
```

## Configuration (when running without make)

Drop a YAML file with your defaults:

```yaml
camera:
  exposure: 100
  gain: 1.5
  fps: 30

network:
  timeout: 5000
  retries: 3
```

Load it: `--config your-config.yml`

## CLI Commands

```bash
# Basic operations
param-cli set /path/to/param value
param-cli get /path/to/param
param-cli delete /path/to/param
param-cli list --prefix /camera

# Live monitoring
param-cli watch /camera/exposure

# Health check
param-cli ping
```

## Client Libraries

### Async 
```python
from param_server.client import AsyncParameterClient

client = AsyncParameterClient("localhost", 8888)
await client.connect()
await client.set("/test", 123)
value = await client.get("/test")
await client.disconnect()
```

## Features

- Persistent connections (low latency)
- Auto-reconnection (handles network issues)
- Type support: str, int, float, bool
- Concurrent operations
- Tree-like parameter paths
- JSON/tree CLI output formats
- Docker ready

## Port Configuration

Default port is 8888. Change it:

```bash
# Server
param-server --port 9999

# Client
param-cli --port 9999 ping

# Python
AsyncParameterClient("localhost", 9999)

# or 
ParameterClient("localhost", 9999)
```

## Troubleshooting

### Connection refused
```bash
# Check if server is running
param-cli ping

# Check port
netstat -tlnp | grep 8888
```

### Permission denied
```bash
# Use different port
param-server --port 9999
```

### Docker issues
```bash
# Check logs
docker compose logs param-server

# Rebuild
docker compose build --no-cache
```

That's it. Simple as.

@themladypan
awesomepyutil 0.0.2
An awesome Python package
Requires Python: >=3.10
Keywords: NSE, Stock Market, GCP, AWS, AZURE, Snowflake, Office365, Cloud, Data Pipeline, ETL, ELT, SQL, Python

# [AWESOMEPYUTIL](https://pypi.org/project/awesomepyutil/0.0.1/)

Simple python package.

# How To Use The Package

1. Install The Package
    ```shell
    pip install awesomepyutil==0.0.1
    ```
2. Use `Arithmetic Operations`
    ```shell
    from awesomepyutil.arithmetic_ops.arithmetic_operations import func_divide

    out = func_divide(5,2)
    print(f"out: {out}")

    # Out: 2.5
    ```

3. Use `NSE`
    ```shell
    from awesomepyutil.stock_market.nse import NSE
    
    # create NSE Object
    nse = NSE()
    
    # Get daily index gainers
    out = nse.get_index_gainers()
    print(out)
    
    # Get daily index loosers
    out = nse.get_index_loosers()
    print(out)
    
    out = nse.get_marketstate_daily()
    print(f"{out}")
    ```
MIT License

Copyright (c) [2025] [Indranil Pal]

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.
fstk 0.10.0
Fast Switch Time Keeper
Requires Python: >=3

# FSTK

*Fast Switch Time Keeper* - A Time Keeping desktop widget focused on tracking the time spent on (possibly interleaved) daily tasks.
Written in Python and PyQT5/PySide2

## Installation, configuration and use

1\. Create a virtual environment

~~~
virtualenv env -p python3
source env/bin/activate
~~~

2\. Install the package

~~~
pip install fstk
~~~

3\. First start the app with the following command, this will install a finder shortcut.
After the first run the software can be launched from finder

~~~
python -m fstk
~~~
machine-dialect-vm 0.1.0a2
High-performance Rust VM for Machine Dialect™
Requires Python: <=13,>=3.10
Keywords: programming-language, natural-language, markdown, virtual machine, vm

# Machine Dialect™ Rust VM

High-performance register-based virtual machine for executing Machine Dialect™ bytecode.

## Overview

This is the Phase 0 implementation of the Machine Dialect™ Rust VM, providing:

- 256 general-purpose registers
- Type-safe value system (Empty, Bool, Int, Float, String, Function, URL)
- Register-based instruction set
- MIR support (SSA phi nodes, assertions, scopes)
- Runtime operations (arithmetic, logic, comparisons, strings)
- PyO3 bindings for Python integration
- Reference counting memory management

## Building

### Prerequisites

- Rust 1.70+
- Python 3.9+
- maturin (install via `uv sync --all-groups`)

### Build Instructions

From project root:

```bash
./build_vm.sh
```

Or manually:

```bash
cd machine_dialect_vm
maturin develop --features pyo3
```

## Architecture

The VM uses a register-based architecture with:

- **Register File**: 256 registers with type tracking
- **Instruction Set**: ~40 register-based instructions
- **Value System**: Tagged union for efficient value representation
- **Runtime Operations**: Type-safe arithmetic and string operations
- **Memory Management**: Reference counting for strings and objects

## Integration

The VM integrates with the Python frontend via PyO3 bindings, allowing:

1. Python compiler generates MIR
1. MIR is optimized
1. Register-based bytecode is generated
1. Rust VM executes bytecode
1. Results returned to Python

## Performance

Measured performance (via Criterion benchmarks):

- Simple addition: ~1.02 µs per operation
- VM creation: ~3.49 µs
- Target: 5-10x speedup over Python interpreter

Run benchmarks:

```bash
cargo bench --bench basic_benchmark
```

## Status

Phase 0 (MVP) implementation **92% complete**:

### Completed ✅

- Core VM engine with 256 registers
- Full value and type system (including arrays)
- Complete instruction set (38 opcodes)
- All runtime operations (arithmetic, logic, string, array)
- Binary bytecode loader (.mdbc format)
- PyO3 bindings with Python integration
- Python bytecode generator and serializer
- Performance benchmarks
- REPL integration (with fallback)

### Remaining Work

- End-to-end execution validation
- Expanded test coverage
- Production hardening

## Next Steps

Phase 1 will add:

- Type-specialized instructions
- Advanced memory management
- Performance optimizations
- Collection types (arrays, maps, sets)