semvec/pypi-packages huggingface dataset:
python-cq 0.13.0
CQRS library for async Python projects.
Requires Python: <3.15,>=3.12
Keywords: cqrs

# python-cq

[![PyPI - Version](https://img.shields.io/pypi/v/python-cq.svg?color=4051b5&style=for-the-badge)](https://pypi.org/project/python-cq)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-cq.svg?color=4051b5&style=for-the-badge)](https://pypistats.org/packages/python-cq)

**python-cq** is a Python package designed to organize your code following CQRS principles. It builds on top of [python-injection](https://github.com/100nm/python-injection) for dependency injection.

## What is CQRS?

CQRS (Command Query Responsibility Segregation) is an architectural pattern that separates read operations from write operations. This separation helps to:

- **Clarify intent**: each operation has a single, well-defined responsibility
- **Improve maintainability**: smaller, focused handlers are easier to understand and modify
- **Simplify testing**: isolated handlers are straightforward to unit test

CQRS is often associated with distributed systems and Event Sourcing, but its benefits extend beyond that. Even in a local or monolithic application, adopting this pattern helps structure your code and makes the boundaries between reading and writing explicit.

## Prerequisites

To get the most out of **python-cq**, familiarity with the following concepts is recommended:

- **CQRS** and the distinction between Commands, Queries and Events
- **Domain Driven Design (DDD)**, particularly aggregates and bounded contexts

This knowledge will help you design coherent handlers and organize your code effectively.

## Message types

**python-cq** provides three types of messages to model your application's operations:

- **Command**: represents an intent to change the system's state. A command is handled by exactly one handler and may return a value for convenience.
- **Query**: represents a request for information. A query is handled by exactly one handler and returns data without side effects.
- **Event**: represents something that has happened in the system. An event can be handled by zero, one, or many handlers, enabling loose coupling between components.

## Installation

Requires Python 3.12 or higher.
```bash
pip install python-cq
```
Topsis-Punya-102303567 1.0.0
A Python package to implement TOPSIS

# Topsis-Punya-102303567

This is a Python package to implement the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS).

## Installation

```bash
pip install Topsis-Punya-102303567
```

## Usage

You can use this package via the command line:

```bash
topsis <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

### Example

```bash
topsis data.csv "1,1,1,2" "+,+,+,-" result.csv
```

## Parameters

1.  **InputDataFile**: Path to the CSV file containing the data. The file should have a header row and the first column should be the object/alternative names (which will not be used in calculation). The rest of the columns must be numeric.
2.  **Weights**: Comma-separated weights for each criterion (e.g., "1,1,1,2").
3.  **Impacts**: Comma-separated impacts for each criterion ('+' for beneficial, '-' for non-beneficial) (e.g., "+,+,+,-").
4.  **OutputResultFileName**: Path for the output CSV file which will contain the original data along with the Topsis Score and Rank.

## License

MIT
hsi-preprocessing-toolkit 2.2.2
HSI Preprocessing Toolkit
Requires Python: >=3.13

# HSI Preprocessing Toolkit


[![PyPI - Version](https://img.shields.io/pypi/v/hsi-preprocessing-toolkit.svg)](https://pypi.org/project/hsi-preprocessing-toolkit)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/hsi-preprocessing-toolkit)](https://pypi.org/project/hsi-preprocessing-toolkit)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hsi-preprocessing-toolkit.svg)](https://pypi.org/project/hsi-preprocessing-toolkit)
![GitHub Created At](https://img.shields.io/github/created-at/songyz2019/hsi-preprocessing-toolkit)
![GitHub License](https://img.shields.io/github/license/songyz2019/hsi-preprocessing-toolkit)

![](asset/screenshot.jpg)

HSI Preprocessing Toolkit (HPT, formerly HDR2MAT) is a hyperspectral image preprocessing toolset that:
1. Read the raw data directly from HSI cameras, and convert it into `.mat` file
2. Read the `.mat` file
3. Preview HSI and convert it to RGB `.png` file
4. Crop, rotate, transform the HSI and preview in realtime
5. Select spectrals of interest visually and save them into a `.mat` file
6. Mix multiple HSI images with layers.
7. Generate Spectral Profiles for visualization.
8. Some other utils


## Usage
### Prerequisites
1. A Chromium-based browser
2. A modern OS

### Manual
1. Download [hpt.cmd](https://github.com/songyz2019/hsi-preprocessing-toolkit/blob/main/script/hpt.cmd) from GitHub release
2. Double click the `hpt.cmd` file. 

> **TIPS**: Make sure you have internet access during the first start

### Install with uv
1. Install [uv](https://docs.astral.sh/uv/) directly or with pip: `pip install uv`
2. Install HPT: `uv tool install hsi-preprocessing-toolkit`
3. Start HPT: `hsi_preprocessing_toolkit`

### Install with pip
1. Install HPT: `pip install hsi-preprocessing-toolkit`
2. Start HPT: `hsi_preprocessing_toolkit`

> **TIPS**: It's not recommend to install CLI tools directly with pip, please use [uv tool](https://docs.astral.sh/uv/guides/tools/) or [pipx](https://pipx.pypa.io/) to install python applications in isolated environments.


## Document


## Credit
1. [uv](https://docs.astral.sh/uv/) for providing a new reliable solution for Python application distribution.  
2. `gradio` for modern Python Data Science UI 
3. `rasterio` for remote sensing data reading
4. `scipy`, `numpy`, `matplotlib` and `einops`
5. For more projects, see `pyproject.toml`


## License

```text
Copyright (C) 2025  songyz2019

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
```
payloop 0.6.0
Payloop Python SDK
Requires Python: >=3.9

# Welcome to Payloop!

### Cost Visibility for AI Agents

Payloop is a lightweight infrastructure layer that gives AI teams real-time visibility into the true costs of deploying agents - across tasks, workflows, and customers. Most teams today can’t see what it actually costs to deploy their agents, making it nearly impossible to manage gross margins or price with confidence.

With just a single line of code, Payloop delivers:
- Cost tracking across OpenAI, Anthropic, Gemini, and more in one place
- Breakdowns by task, agent, and customer in real time
- Confidence to deploy the right pricing model (cost-plus, token-based, outcome-based, etc.) while preserving gross margins

Watch a short demo video: [Payloop Walkthrough Video](https://www.youtube.com/watch?v=Z-GkSl_7imY)

By surfacing exactly what’s driving cost and value, Payloop becomes the source of truth for agent economics - helping founders and operators scale their agents with confidence.

Sign up here: [trypayloop.com](https://trypayloop.com/)

# Installation

    pip install payloop

# Documentation

Our SDK reference provides documentation for:
- Understanding how Payloop works
- Demonstrating how to integrate Payloop into your product
- Code samples to illustrate our SDK and API

Check it out here: [developers.trypayloop.com](https://developers.trypayloop.com)
annadca 0.2.1
Annotation Assisted Direct Coupling Analysis
Requires Python: >=3.10

# ANNotation Assisted Direct Coupling Analisis (annaDCA)
This package contains the methods and scripts to train and sample an RBM model provided with data annotations.

<p align="center">
    <img src="images/labelRBM.png" alt="RBM Model with Annotations" width="300"/>
</p>

## ⬇️ Installation
### Option 1: from PyPI
```bash
python -m pip install annadca
```
### Option 2: cloning the repository
```bash
git clone https://github.com/rossetl/annaDCA.git
cd annaDCA
python -m pip install .
```

## 📘 Usage
After installation, all the main routines can be launched through the command-line interface using the command `annadca`. For now, only the `train` routine is implemented
To see all the training options do
```bash
annadca train -h
```

### ✔️ Input data format

The training routine requires three types of information: the __training sequences__, their __identifiers__ and the assocated __annotations__.

The package supports both binary variables and categorical variables (e.g. amino acid sequences).

These input data can be provided to the routine in two different ways:

- By providing a `csv` file to the `-d` argument that contains identifiers, sequences and annotations. By default, the routine will check for the columns `name`, `sequence` and `label`, but the user can specify different names using the arguments `--column_names`, `--column_sequences` and `--column_labels`.

> [!WARNING]
> The previous method only works for categorical variables. For binary variables, use the following option 

- By providing a `fasta` file (categorical variables) or a plain text file (binary variables) to the `-d` argument and an additional `csv` file to the `-a` argument containing the sequence identifiers and the annotations. Importantly, the sequence identifiers must match with those that are present in the `fasta` file.

To train the model with default arguments and a single csv file, use
```bash
annadca train -d <path_data> -o <output_directory> -l <model_tag>
```

#### Sequence data format
The model supports the following input data format:
- __Binary variables__: plain text format. Each row is one data sample, variables are separated by white spaces
- __Categorical variables__: 
    - [fasta](https://en.wikipedia.org/wiki/FASTA_format) format. Each data poin is a sequence of tokens with an header on top. The header row starts with `>`.
    - `csv` format: the file must contain one column with the aligned training sequences.
instaui-shiki 0.6.4
A Python package for instaui-shiki.
Requires Python: <3.14,>=3.10
Keywords: gui, shiki, syntax-highlighting, ui, web

# instaui-shiki

<div align="center">

English| [简体中文](./README.md)

</div>

## 📖 Introduction
instaui-shiki is a Python library for syntax highlighting code snippets in the browser using [Shiki](https://github.com/shikijs/shiki).


## ⚙️ Installation

```bash
pip install instaui-shiki
```

## 🖥️ Usage
```python
from instaui import ui
from instaui_shiki import shiki

@ui.page("/")
def test_page():
    shiki("print('foo')")


ui.server(debug=True).run()
```