semvec/pypi-packages huggingface dataset:
Seqript 1.0.0
Seqript is a recursive structured command engine.
License: MIT
Requires Python: <4,>=3.11
Keywords: sequential, sarallelscript, Tarcadia

# Seqript (Sequence + Script)

A lightweight framework for executing structured scripts with nested operations.

## Features
- Define scripts as nested JSON structures
- Register custom engines for different operations
- Environment variable expansion support
- Sequential and parallel execution modes
- Extensible through engine contributions

## Documentation
- [Quick Start](@doc/quick_start.md)
- [Usage Guide](@doc/usage.md)
- [Project Structure](@doc/structure.md)

## Installation
`pip install seqript` (TODO: Add actual installation method)

## Example
```json
{
  "seq": [
    {"comment": "Starting operations"},
    {"sleep": 1},
    {"par": [
      {"cmd": ["echo", "Task 1"]},
      {"cmd": ["echo", "Task 2"]}
    ]}
  ]
}
```

# Project Structure

## Core Components
- `Seqript`: Main class that parses and executes scripts
- Engines: Modular operations (`cmd`, `seq`, `par`, etc.)
- Variable Expansion: `${var}` substitution system

## File Organization
```
seqript/
├── init.py
├── seqript.py # Main class
├── util/
│   └── expand_variable.py
└── engine/
    ├── init.py
    ├── cmd.py # Command execution
    ├── nop.py # No operation
    ├── par.py # Parallel execution
    ├── seq.py # Sequential execution
    └── contrib/ # Additional engines
        ├── sleep.py
        └── comment.py
```

## Extension Points
1. Add engines to `engine/contrib/`
2. Override default engines during initialization
3. Extend variable expansion patterns## Extension Points


# Usage Guide

## Script Structure
Scripts are JSON objects where each key represents an engine:
```json
{
  "engine_name": engine_specific_configuration
}
```

## Environment Variables
Use `${VAR}` syntax in strings for variable expansion:
```json
{
  "cmd": ["echo", "${MESSAGE}"],
  "env": {"MESSAGE": "Hello"}
}
```

## Custom Engines
Register additional engines during initialization:
```python
from seqript import Seqript

def custom_engine(seqript, **kwargs):
    print(f"Custom engine called with {kwargs}")

seqript = Seqript(engines={
    "custom": custom_engine,
    **Seqript._DEFAULT_ENGINES
})
```

# Quick Start

## Basic Usage

1. Create a script file (`example.json`):
```json
{
  "seq": [
    {"comment": "My first script"},
    {"sleep": 2},
    {"cmd": ["echo", "Hello World"]}
  ]
}
```

2. Execute it:
```python
from seqript import Seqript

seqript = Seqript(name="example")
with open("example.json") as f:
    seqript(**json.load(f))
```

## Available Engines
- `seq`: Sequential execution
- `par`: Parallel execution
- `cmd`: Command execution
- `nop`: No operation
- `sleep`: Delay execution
- `comment`: Print message
ip5100-wrapper 1.0.2
A Python wrapper for controlling IP5100 ASpeed encoders and decoders via Telnet
License: MIT
Requires Python: >=3.13

# IP5100 Wrapper

A Python wrapper for controlling IP5100 ASpeed encoders and decoders via Telnet.

## Installation

```bash
pip install ip5100-wrapper
```

## Features

- Control IP5100 encoders and decoders via Telnet
- Support for both encoder and decoder operations
- Automatic device type detection
- Comprehensive API for all device functions
- Debug mode for detailed operation logging

## Basic Usage

```python
from IP5100 import IP5100_Device

# Create a device instance
device = IP5100_Device("192.168.1.100", port=24, login="root", debug=False)

# Get device information
print(device)  # Prints device name, alias, IP, MAC, type, and version

# Get device status
print(device.get_version())
print(device.get_alias())
print(device.get_ip_mode())
print(device.get_multicast_ip())

# Control device
device.set_alias("My Device")
device.reboot()
```

## Device Types

The wrapper automatically detects if the device is an encoder or decoder based on the model prefix:
- `IPE` prefix: Encoder
- `IPD` prefix: Decoder

## Encoder-Specific Features

```python
# Set input source (HDMI1, HDMI2, USB-C)
device.set_input("hdmi1")

# Set audio source (auto, hdmi, analog)
device.set_audio_source("hdmi")

# Get audio information
print(device.get_audio_input_info())
print(device.audio_specs)

# EDID management
device.edid_read()
device.edid_write(edid_data)
device.edid_reset()
```

## Decoder-Specific Features

```python
# Connect to encoder
device.set_source(mac="00:11:22:33:44:55")

# Video wall configuration
device.set_video_wall_v1(rows=2, columns=2, row_location=0, column_location=0)
device.set_video_wall_scale(1.5)
device.set_video_wall_rotate(90)

# Audio control
device.set_audio_out_source("native")
device.set_audio_hdmi_mute(False)

# Get status
print(device.get_audio_output_info())
print(device.get_video_output_info())
```

## Advanced Features

- HDCP control (1.4 and 2.2)
- Serial port configuration
- CEC commands
- Video wall configuration
- Audio routing and control
- Factory reset
- Network configuration

## Debug Mode

Enable debug mode to get detailed information about each operation:

```python
device = IP5100_Device("192.168.1.100", debug=True)
result = device.get_version()
print(result)  # Includes function name, command, and response
```

## Error Handling

All methods return a dictionary with status and message:

```python
result = device.set_alias("New Name")
if result["status"] == "success":
    print("Operation successful")
else:
    print(f"Error: {result['message']}")
```

## License

MIT License