semvec/pypi-packages huggingface dataset:
activesoft-cli 0.1.5
Python SDK and CLI tool for Activesoft Siga automation
Requires Python: >=3.8
Keywords: activesoft, siga, automation, cli, sdk

# Activesoft Siga CLI

A Python SDK and CLI tool for automating interactions with the Activesoft Siga API. This tool simplifies retrieval of student and responsible party data, and sending messages.

## Installation

Install via pip:

```bash
pip install activesoft-cli
```

Or from source:

```bash
git clone https://github.com/tsuriu/activesoft-cli.git
cd activesoft-cli
pip install .
```

## CLI Usage

The package includes a command-line interface `activesoft-cli`.

### Configuration

You can provide credentials via flags or environment variables:

- `--username` / `SIGA_USERNAME`
- `--password` / `SIGA_PASSWORD`
- `--instituicao` / `SIGA_INSTITUICAO`

The CLI automatically saves your session (cookies) to a local JSON file:
`~/.activesoft_siga_<instituicao>_<username>.json`

Subsequent commands will reuse this session, avoiding full re-authentication. If the session expires, the CLI will automatically attempt to re-login.

You can also specify a custom session path when using the SDK:
```python
client = SigaClient(..., session_path="/path/to/session.json")
```

### Commands

#### Student Management (`students`)

Lists students or retrieves details for a specific student.

```bash
# List students (defaults to 10)
activesoft-cli students

# Fetch details for a specific student ID
activesoft-cli students --id 103
```

#### Responsible Parties (`responsaveis`)

Lists responsible parties or retrieves specific details.

```bash
# List responsible parties (defaults to 21)
activesoft-cli responsaveis --limit 10

# Fetch details for a specific responsible party ID
activesoft-cli responsaveis --id 10188
```

#### Messaging (`send-message`)

Sends a message to a student/responsible party.

```bash
activesoft-cli send-message \
  --student-id 4907 \
  --destinatario-id 13578 \
  --message "Your message here" \
  --title "Aviso"
```

## SDK Usage

You can also use the `SigaClient` directly in your Python scripts.

### Initialization

```python
import asyncio
from activesoft_cli import SigaClient

async def main():
    # Initialize and login
    client = SigaClient(
        username="your-username", 
        password="your-password", 
        instituicao="TEST_INSTITUTION"
    )

    async with client.client: # Close client manually if not using context manager
        if await client.login():
            # List students
            students = await client.list_alunos(limit=10)
            print(students)

if __name__ == "__main__":
    asyncio.run(main())
```

## Requirements

- Python 3.8+
- `httpx`
- `loguru`
- `click`

## License

This project is licensed under the MIT License.
device-doctor 1.0.0
Read-only system diagnostics dashboard with AI-powered explanations
Requires Python: >=3.8

# Device Doctor - Phase-1 Read-Only Diagnostic Agent

A local, read-only diagnostic agent that analyzes system health and provides clear explanations and safe recommendations.

## Features

- **Read-Only Operations**: Never modifies system state
- **Safe Diagnostics**: Only executes allowlisted commands
- **Clear Explanations**: AI-powered explanations in plain English
- **Safe Recommendations**: Manual actions only, no automated fixes
- **Comprehensive Reporting**: Health scores, issues, and telemetry

## Installation

1. Install dependencies:
```bash
pip install -r requirements.txt
```

## Usage

### Command Line Interface

Run the diagnostic agent:
```bash
python doctor/main.py
```

### Web Dashboard

Start the API server:
```bash
python api_server.py
```

Then open your browser to:
```
http://localhost:8000
```

The dashboard provides a visual interface with:
- Real-time health score visualization
- CPU, Memory, and Disk usage charts
- Symptom detection display
- AI-powered issue explanations and recommendations

## Architecture

```
device-doctor/
├── doctor/
│   ├── main.py                 # Entry point
│   ├── core/                   # Core functionality
│   │   ├── os_detect.py        # OS detection
│   │   ├── command_runner.py   # Safe command execution
│   │   └── telemetry.py        # System metrics collection
│   ├── diagnostics/            # Diagnostic engine
│   │   ├── symptoms.py         # Symptom abstraction
│   │   ├── rules.py            # Diagnostic rules
│   │   └── analyzer.py         # Analysis orchestration
│   ├── ai/                     # AI explanation layer
│   │   ├── prompt.py           # Prompt builder
│   │   ├── schema.py           # Response schema
│   │   └── explainer.py        # AI explainer
│   ├── report/                 # Report generation
│   │   ├── formatter.py        # Report formatting
│   │   └── health_score.py     # Health score calculation
│   └── security/               # Security controls
│       └── allowlist.py        # Command allowlist
```

## Security Model

- All commands must be in the allowlist
- No user input modifies commands
- All executions are logged
- Output is sanitized
- Read-only operations only

## Constraints

- No destructive commands
- No write operations to OS
- No sudo, rm, kill, registry edits, or driver changes
- No background services
- No auto-fixes
- AI explains only, never acts

## Phase-1 Status

This is Phase-1 of Device Doctor. It provides:
- System telemetry collection
- Symptom detection
- Rule-based diagnostics
- AI-powered explanations
- Human-readable reports

Phase-2 will add auto-fix capabilities (not implemented in Phase-1).
libemg 3.0.0b2
LibEMG - Myoelectric Control Library
Keywords: emg, myoelectric_control, pattern_recognition, muscle-based input


![LibEMG](docs/source/libemg_logo.png)

The goal of this library is to provide an easy to use and feature-rich API for developing robust real-time EMG-based interactions, and performing thorough offline analysis.

**Authors**: Ethan Eddy, Evan Campbell, Angkoon Phinyomark, Scott Bateman, and Erik Scheme

## Documentation
All documentation can be found at: [Library Documentation](https://libemg.github.io/libemg/)

## Datasets 
All datasets can be found at: [Datasets](https://www.libemg.com/)

## Install 
`pip install libemg`

## Contributing 
We are happy to have people contribute to LibEMG! Make sure that any changes are made off the `latest` branch. This branch should also be the target for any pull request. We will review all pull requests as soon as possible! 

## Questions
Check out our discord server if you have questions, comments, or feature requests: [https://discord.gg/NeqTTXmM4F](https://discord.gg/6D9rPMThxu)

## Citing
We ask that if you leverage this library for any research-related purposes please cite the following publication:

```
@ARTICLE{10214558,
  author={Eddy, Ethan and Campbell, Evan and Phinyomark, Angkoon and Bateman, Scott and Scheme, Erik},
  journal={IEEE Access}, 
  title={LibEMG: An Open Source Library to Facilitate the Exploration of Myoelectric Control}, 
  year={2023},
  volume={11},
  number={},
  pages={87380-87397},
  doi={10.1109/ACCESS.2023.3304544}}
```
reaction-balancer 2.0.9
Balance chemical equations and generate printable forms
Requires Python: >=3.11
Keywords: chemical-equation, chemical-reactions, chemistry, condensed-matter, materials-science, openpyxl, solid-state-chemistry, solid-state-synthesis, stoichiometry, superconductivity, sympy, synthesis-calculation

English | [中文文档](https://github.com/ponyofshadows/balancer/blob/master/README.zh-CN.md)

# reaction-balancer
A precise chemical-equation balancer that uses exact rational arithmetic and CIAAW atomic weights to generate printable recipe sheets (Excel format) from Markdown input.
---

## Features

### 1. Exact scientific computation  
- Uses **CIAAW (2024)** standard atomic weights.  
- All internal math uses **sympy.Rational** (exact fractions), eliminating round-off errors.  
- Linear algebra–based solver ensures **correct balancing** or gives an informative error if impossible.

### 2. Flexible input syntax  
- Supports parentheses and fractional subscripts:  
  - `Ni(NO3)2(H2O)6`  
  - `Fe7/8Se`  
  - `La1.8Sr0.2CuO4.12`  
- Optional basis specification (e.g., <BaTiO>) allows partial balancing, which is useful for sol–gel and oxide-precursor routes.

### 3. Automatic Excel output  
- Produces a **ready-to-print xlsx recipe sheet** with formatted layout.  
- Column widths, styles, and alignment handled automatically—no manual editing required.

### 4. Reproducible and traceable  
- Input is a Markdown document, allowing you to record:  
  - sample IDs  
  - furnace schedule  
  - experimental notes  
- Perfect for lab notebooks and long-term traceability.

### 5. Designed for materials synthesis  
Suitable for:  
- solid-state reactions  
- flux growth  
- hydrothermal / sol-gel precursor balancing  
- cuprates, pnictides, nickelates, chalcogenides, and general inorganic synthesis

---

## Installation
```bash
pip install balancer
```
or if using uv:
```bash
uv tool install balancer
```

## Usage
Run the following command in any directory:
```bash
python -m balancer
# or use uv:
# uv run balancer
```
This program needs an input file (default: `./input.md`).

If `input.md` is not found, a template will be automatically created in the current working directory.

Example input:
![INPUT_EXAMPLE](https://github.com/ponyofshadows/balancer/blob/master/assets/SCREENSHOT_EXAMPLE_INPUT.png)

Corresponding output:
![OUTPUT_EXAMPLE](https://github.com/ponyofshadows/balancer/blob/master/assets/SCREENSHOT_EXAMPLE_OUTPUT.png)

You may also specify an explicit filepath:
```bash
balancer <filepath>
```