semvec/pypi-packages huggingface dataset:
noetl 2.8.4
A framework to build and run data pipelines and workflows.
Requires Python: >=3.12
Keywords: etl, ml, ops, cleansing, data, pipeline, workflow, automation

# NoETL

**NoETL** is an automation framework for orchestrating **APIs, databases, and scripts** using a declarative **Playbook DSL**.

Execution is standardized around an **MCP-style tool model**: consistent tool contracts, structured input/output, and a predictable lifecycle. From an MCP perspective, `tools` include API endpoints, database operations, and scripts/utilities **NoETL** orchestrates and optimizes them via playbooks.

With **NoETL Gateway**, playbooks can be deployed as a **distributed backend**: developers ship business logic as playbooks, and UIs/clients call stable endpoints without deploying dedicated microservices for each workflow.

[![PyPI version](https://badge.fury.io/py/noetl.svg)](https://badge.fury.io/py/noetl)

## Documentation

**https://noetl.dev**

## Distribution channels

- **PyPI**
  - `noetl` (Python): https://pypi.org/project/noetl/
  - `noetlctl` (Rust CLI): https://pypi.org/project/noetlctl/
- **crates.io**
  - `noetl`: https://crates.io/crates/noetl
  - `noetl-gateway`: https://crates.io/crates/noetl-gateway
- **APT (Debian/Ubuntu)**
  - Repo: https://github.com/noetl/apt
- **Homebrew**
  - Tap: https://github.com/noetl/homebrew-tap

## License

MIT License — see [LICENSE](LICENSE) for details.
isage-finetune 0.1.0.4
SAGE Fine-tuning Framework - Trainers and data loaders for LLM fine-tuning
Requires Python: ==3.11.*
Keywords: finetune, training, LoRA, LLM, AI

# sage-finetune

Fine-tuning implementations for the SAGE AI data processing framework.

## Installation

```bash
pip install isage-finetune
```

For LoRA training:
```bash
pip install isage-finetune[peft]
```

## Features

- **LoRA Trainer**: Parameter-efficient fine-tuning with Low-Rank Adaptation
- **Mock Trainer**: Testing trainer for pipeline validation
- **JSON/JSONL Loader**: Flexible data loading for instruction and chat formats

## Quick Start

```python
from sage_finetune import MockTrainer, JSONDatasetLoader

# Load training data
loader = JSONDatasetLoader()
train_data = loader.load("train.jsonl")

# Train (mock for testing)
trainer = MockTrainer()
result = trainer.train(train_data)
print(f"Loss: {result['train_loss']:.4f}")
```

### LoRA Fine-tuning

```python
from sage_finetune import LoRATrainer, LoRAConfig

trainer = LoRATrainer(
    model_name="gpt2",
    lora_config=LoRAConfig(r=8, lora_alpha=16),
)

result = trainer.train(train_dataset)
trainer.save_model("./my_lora_model")
```

## Data Formats

### Instruction Format
```json
{"instruction": "Summarize this text", "input": "Long text...", "output": "Summary..."}
```

### Chat Format
```json
{"messages": [{"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi"}]}
```

## Integration with SAGE

When SAGE is installed, components auto-register with the framework:

```python
from sage.libs.finetune import create_trainer

trainer = create_trainer("lora", model_name="gpt2")
```

## License

Apache 2.0
microservice-api 0.3.3
Lightweight FastAPI microservice for identity and access management, built with asyncpg and Tortoise ORM
Requires Python: >=3.10

# microservice-api

Lightweight FastAPI microservice for identity and access management, built with asyncpg and Tortoise ORM.

## Features

- FastAPI endpoints for auth, users, groups, and permissions
- Async Postgres stack with Tortoise ORM and asyncpg
- JWT-based auth helpers and middleware
- Background worker scaffolding

## Installation

```bash
pip install microservice-api
```

## Quickstart

```bash
uvicorn microservice.main:create_app --factory --reload
```

## Example

Run the minimal example (no DB/auth/worker) from the repo:

```bash
make install
make run
```

Or run it directly:

```bash
./.venv/bin/python examples/run.py
```

## Configuration

Set environment variables in a `.env` file or your shell. Common values include database connection info and JWT secrets.

## Development

```bash
pip install -e .[dev]
pytest
```
audeer 2.4.0
Helpful Python functions
Requires Python: >=3.10
Keywords: Python, tools

======
audeer
======

|tests| |coverage| |docs| |python-versions| |license| 

The Python package **audeer** collects small tools and functions
that deal with common tasks.
For example, it incorporates functions for handling file paths,
using multi-threading, or showing progress bars.

The package is lightweight,
and has the small tqdm_ package
as it's only external dependency.

Have a look at the installation_ and usage_ instructions as a starting point.

Code example,
that lists all WAV files in the ``data`` folder:

.. code-block:: python

    import audeer

    files = audeer.list_file_names("data", filetype="wav")


.. _tqdm: https://tqdm.github.io/
.. _installation: https://audeering.github.io/audeer/installation.html
.. _usage: https://audeering.github.io/audeer/usage.html

.. badges images and links:
.. |tests| image:: https://github.com/audeering/audeer/workflows/Test/badge.svg
    :target: https://github.com/audeering/audeer/actions?query=workflow%3ATest
    :alt: Test status
.. |coverage| image:: https://codecov.io/gh/audeering/audeer/branch/main/graph/badge.svg?token=PUA9P2UJW1
    :target: https://codecov.io/gh/audeering/audeer
    :alt: code coverage
.. |docs| image:: https://img.shields.io/pypi/v/audeer?label=docs
    :target: https://audeering.github.io/audeer/
    :alt: audeer's documentation
.. |license| image:: https://img.shields.io/badge/license-MIT-green.svg
    :target: https://github.com/audeering/audeer/blob/main/LICENSE
    :alt: audeer's MIT license
.. |python-versions| image:: https://img.shields.io/pypi/pyversions/audeer.svg
    :target: https://pypi.org/project/audeer/
    :alt: audeer's supported Python versions
sara-engine 0.1.7
A biologically plausible, lightweight Spiking Neural Network engine (CPU-only, No-BP).
Requires Python: >=3.8

# SARA Engine (Liquid Harmony)

**SARA (Spiking Advanced Recursive Architecture)** is a next-generation AI engine (SNN-based) that mimics the biological brain's "power efficiency, event-driven processing, and self-organization."

It completely eliminates the "backpropagation (BP)" and "matrix operations" that modern deep learning (ANNs) rely on, achieving advanced recognition and learning capabilities using **only sparse spike communication**.

It operates on CPU only, without using any GPU.

Current Version: **v0.1.7**

## Features

* **No Backpropagation**: Learns without error backpropagation, using local learning rules (Momentum Delta) and reservoir computing.
* **CPU Only & Lightweight**: Does not require expensive GPU resources. Runs fast on standard CPU environments.
* **Multi-Scale True Liquid Reservoir**: Three parallel reservoir layers with different temporal characteristics (Decay), with recurrent connections within each layer. Achieves short-term memory using information "echo."
* **Rust Acceleration**: Core computation logic is written in Rust for high performance.

## Installation  
  
```bash
pip install sara-engine
```  
Quick Start  
  
```bash
from sara_engine import SaraGPT

# Initialize the brain
brain = SaraGPT(sdr_size=1024)

# Create an input pattern (SDR)
input_sdr = brain.encoder.encode("Hello SARA")

# Think (Forward pass)
output_sdr, spikes = brain.forward_step(input_sdr)

print(f"Output Active Neurons: {len(output_sdr)}")
```
  
License  
MIT License
ecotorch 0.2.4
A lightweight package to measure the ecological and financial effect of training and evaluation of pytorch projects.
Requires Python: >=3.11

# EcoTorch

A lightweight, plug-and-play tool to measure the ecological impact and efficiency of your PyTorch models.

EcoTorch runs in the background while your models learn or get tested. It tracks exactly how much power your machine uses, figures out your carbon footprint based on your location, and gives you a final efficiency score. It works seamlessly across Mac, Windows, and Linux.

## Installation

You can grab the tool directly from the public Python store. Open your terminal and type:

`pip install ecotorch`


## Quick Start

You do not need to rewrite any of your existing work to use EcoTorch. Just wrap your normal learning or testing loops inside the `TrainTracker` and `EvalTracker`.

### Quick example:

```python
import torch
from ecotorch import TrainTracker, EvalTracker, Mode

# Set up your model and data
model = ...
train_loader = ... 
test_loader = ...
epoch = ...

# Wrap your train loop in the TrainTracker
with TrainTracker(epochs=epoch, model=model, train_dataloader=train_loader) as train_tracker:
    # Training logic...
    initial_loss = 2.5
    final_loss = 0.5

# Final score
score = train_tracker.calculate_efficiency_score(initial_loss=initial_loss, final_loss=final_loss)
print(f"Efficiency Score: {score}")

# You can track evaluation and inference
with EvalTracker(test_dataloader=test_loader, train_tracker=train_tracker) as eval_tracker:
    # Evaluation logic...
    acc = 0.9

# Final score
score = eval_tracker.calculate_efficiency_score(accuracy=acc)
print(f"Efficiency Score: {score}")
```

A fully implemented example is available in [testing.py](testing/testing.py)

## How It Works
When you start the tracker, it automatically:
- Finds your location: It checks where you are in the world to find out how clean your local power grid is.
- Reads the power meter: It taps directly into your machine's graphics chip or Apple brain to read the exact power drops being used.
- Does the math: When the block finishes, it calculates your total energy used (kWh), your emitted carbon (grams of CO2), and a final efficiency score based on how much your model improved versus how much energy it burned.
hardware-connector 0.2.0
AI-powered lab instrument connection assistant
Requires Python: >=3.10
Keywords: hardware, lab, instruments, visa, scpi, oscilloscope, test-equipment

# hardware-connector

AI-powered CLI tool that helps engineers connect to lab instruments. It uses an LLM agent to diagnose connection issues, install dependencies, fix permissions, and generate working Python code — all from your terminal.

## How it works

1. Detects your OS, Python environment, USB devices, and VISA backends
2. Loads device-specific knowledge (pinouts, quirks, known errors)
3. Runs an AI agent loop that iteratively diagnoses and fixes connection issues
4. Outputs working Python code that communicates with your instrument

## Supported devices

| Device | Manufacturer | Type |
|--------|-------------|------|
| DS1054Z | Rigol | Oscilloscope |

More devices coming soon.

## Requirements

- Python 3.10+
- An [Anthropic API key](https://console.anthropic.com/)

## Installation

```bash
pip install hardware-connector
```

## Setup

Set your Anthropic API key:

```bash
export ANTHROPIC_API_KEY='sk-ant-...'
```

## Usage

### Connect to a device

```bash
# Auto-detect connected device
hardware-connector connect

# Specify a device
hardware-connector connect --device rigol_ds1054z

# Auto-confirm all actions (no prompts)
hardware-connector connect --device rigol_ds1054z --yes
```

### Other commands

```bash
hardware-connector list-devices     # Show supported devices
hardware-connector detect           # Show environment info + detected devices
hardware-connector config get       # View configuration
hardware-connector config set model claude-sonnet-4-20250514  # Change LLM model
hardware-connector version          # Print version
```

### Options

| Flag | Description |
|------|-------------|
| `--device`, `-d` | Device identifier (e.g. `rigol_ds1054z`) |
| `--yes`, `-y` | Auto-confirm all actions |
| `--model`, `-m` | LLM model to use |
| `--max-iterations` | Max agent iterations (default: 20) |

## Configuration

```bash
# Disable telemetry
hardware-connector config set telemetry off

# Change default model
hardware-connector config set model claude-sonnet-4-20250514
```

Model resolution order: `--model` flag → `HARDWARE_AGENT_MODEL` env var → config DB → default.

## License

Copyright (c) 2026 Yash Prakash. All rights reserved. See [LICENSE](LICENSE) for details.
pyxecm 3.2.10
A Python library to interact with Opentext Content Management Rest API
Requires Python: >=3.10
Keywords: appworks, archivecenter, contentserver, extendedecm, opentext, otds

# PYXECM

A python library to interact with Opentext Content Mangement REST API.
The product API documentation is available on [OpenText Developer](https://developer.opentext.com/ce/products/extendedecm)
Detailed documentation of this package is available [here](https://opentext.github.io/pyxecm/).

## Quick start - Library usage

Install the latest version from pypi:

```bash
pip install pyxecm
```

### Start using the package libraries

example usage of the OTCS class, more details can be found in the docs:

```python
from pyxecm import OTCS

otcs_object = OTCS(
    protocol="https",
    hostname="otcs.domain.tld",
    port="443",
    public_url="otcs.domain.tld",
    username="admin",
    password="********",
    base_path="/cs/llisapi.dll",
)

otcs_object.authenticate()

nodes = otcs_object.get_subnodes(2000)

for node in nodes["results"]:
    print(node["data"]["properties"]["id"], node["data"]["properties"]["name"])
```

## Quick start - Customizer usage

- Create an `.env` file as described here: [sample-environment-variables](customizerapisettings/#sample-environment-variables)
- Create an payload file to define what the customizer should do, as described here [payload-syntax](payload-syntax)

```bash
pip install pyxecm[customizer]

pyxecm-customizer PAYLOAD.tfvars/PAYLOAD.yaml
```

## Quick start - API 

- Install pyxecm with api and customizer dependencies
- Launch the Rest API server
- Access the Customizer API at [http://localhost:8000/api](http://localhost:8000/api)

```bash
pip install pyxecm[api,customizer]

pyxecm-api
```

## Disclaimer


Copyright © 2025 Open Text Corporation, All Rights Reserved.
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.
pyside-cli 1.2.0b1
A command-line tool for quickly creating and managing PySide6 projects.
Requires Python: >=3.8

# CLI for PySide Template

## Quick Overview

This is a companion CLI for **pyside\_template** (not an official PySide tool).

It helps you quickly create a template project:

```bash
mkdir app && cd app
pip install pyside-cli>=1.0.0
pyside-cli create .           # requires: git
```

You can also build the project or run tests with a single command.

```bash
pyside-cli build --onefile # for build: requires pyside6, nuitka
pyside-cli test            # for testing: requires pytest
```

## Links

-   [PyPI - pyside-cli](https://pypi.org/project/pyside-cli/)
    
-   [pyside\_template](https://github.com/SHIINASAMA/pyside_template)