semvec/pypi-packages huggingface dataset:
opatio 0.3.0
A python module for handling OPAT files
Requires Python: >=3.8
Keywords: astrophysics, OPAT, opatcity

# opatIO python module
This module defines a set of tools to build, write, and read OPAT files. 
The OPAT fileformat is a custom file format designed to efficiently store
opacity information for a variety of compositions. 

## Installation
The prefered, stable, way to install opatio is to use the version on pypi
```bash
pip install opatio
```
If you wish to insall from source or for developemnt you can and should clone the git repository instead
You can install this module with pip
```bash
git clone https://github.com/4D-STAR/opat-core
cd opat-core/opatio-py
pip install . # For non development
```
or
```bash
pip install . -e # for development
```

## General Usage
The general way that this module is mean to be used is to first build a schema for the opacity table and then save that to disk. The module will handle all the byte aligment and lookup table construction for you. 

A simple example might look like the following

```python
from opatio import OPAT

opacityFile = OPAT()
opacityFile.set_comment("This is a sample opacity file")
opacityFile.set_source("OPLIB")

# some code to get a logR, logT, and logKappa table
# where logKappa is of size (n,m) if logR is size n and
# logT is size m

card = opacityFile.add_table((X, Z), "data", logR, logT, logKappa, rowName="logR", columnName="logT")
opacityFile.save("opacity.opat")
opacityFile.save_as_ascii("opacity.txt")
```

If you wish you can add more tables to the same card. This means that there can be multiple tables associated to the same indexing vector (for example you might store data and pre calculated interpolation coefficients along side the same data)

```python
opacityFile.add_table((X, Z), "interp", xOrder, yOrder, coeff, rowName="xCoeff", columnName="yCoeff", card=card)
```

Note how here I passed the card as an argument. This means that the same card will be modified and then repushed into the file.

You can also read opat files which have been generated with the loadOpat function

```python
from opatio import read_opat

opacityFile = read_opat("opacity.opat")

print(opacityFile.header)
```

## Converting from OPAL type I
Given the prevelence of OPAL type I tables, we have included a utility function to take care of this conversion for you. Assuming there is some OPAL type I file in your current working directory (in the below example we assume it is called `GS98hz`) then converting is as simple as calling the convert function...

```python
from opatio.convert import OPALI_2_OPAT

OPALI_2_OPAT("GS98hz", "gs98hz.opat")
```

## Problems
If you have problems feel free to either submit an issue to the root github repo (tagged as utils/opatio) or email Emily Boudreaux at emily.boudreaux@dartmouth.edu
cmoat 0.1.4
A toolkit for analysising cancer genomics & proteomics.
Requires Python: >=3.11


# CMoAT (Cancer Multi-Omics Analysis Toolkit)

![GitHub License](https://img.shields.io/github/license/ZhangSamantha9/CMoAT)
[![Pypi Version](https://img.shields.io/pypi/v/cmoat)](https://pypi.org/project/cmoat/)
[![Docs Notion](https://img.shields.io/badge/docs-blue?logo=notion)](https://cmoat.notion.site/CMoAT-Manual-c4ca7801421d4b06b25891988164952c?pvs=4)
![Workflow Status](https://img.shields.io/github/actions/workflow/status/ZhangSamantha9/CMoAT/upload-to-pypi.yml)

CMoAT (Cancer Multi-Omics Analysis Toolkit) is a Python-based toolkit designed for analyzing cancer genomics and proteomics data. The manual provides information on how to use and install the toolkit, as well as its features and functions.


## 1. Usage:
   - CLI (Command Line Interface): After installation, CMoAT can be used via command line in the terminal.
   - GUI (Graphical User Interface): Not implemented yet.

## 2. Installation:
   - CMoAT can be installed using pip with the command: `pip install cmoat`

## 3. Features:
   - Protein Correlation Scatter Plot: Creates scatter plots of two genes' expression with a fitted straight line, including correlation coefficient and p-value.
   - Dual Survival Analysis: Generates survival curves for high (0.75/0.75) and low (0.25/0.25) expression of both genes simultaneously.
   - Expression Boxplot (one gene): Produces a box plot comparing tumor and normal tissue protein expression for a single gene.
   - Single Gene Survival Analysis: Creates monogenic survival curves.
   - Normal Tissue Expression: Generates a bar chart showing the expression of one gene across multiple human normal tissues.
skippy-cov 0.2.2
Selectively run tests based on the current git diff and the collected data from previous tests runs
Requires Python: <4.0,>=3.8
Keywords: python

# skippy-cov

## Overview

`skippy-cov` is a tool that optimizes your Python testing workflow by filtering tests based on code changes. It takes a diff file from git and a `.coverage` database (generated by [`coverage.py`](https://coverage.readthedocs.io/)) to identify and run only the tests relevant to the modified code. This significantly reduces testing time and resources.


## Usage

To use this, you first need to generate the following required files:

* **Run Coverage Analysis:** Generate a `.coverage` database using `coverage.py` via `pytest-cov` with [test contexts](https://pytest-cov.readthedocs.io/en/latest/contexts.html)

```bash
    pytest --cov=myproj --cov-context=test myproj/tests/
```

Then change your code and run

```
pytest --skippy-cov
```

In this case, `skippy-cov` will analyze the changes and run only the tests that are relevant to the modified code.

You can also use `skippy-cov` as a CLI on its own.

```
skippy-cov
```

that will list the tests selected.


## Configuration

The inputs for skippy-cov are the coverage file (default: `.coverage`) and the diff information. By default, the diff is generated in the same way as a pull request (PR) on GitHub: only the changes introduced by your branch compared to the target branch are considered. This is done using the `git diff <target>...HEAD` (triple-dot) syntax.

You can specify the coverage file and a branch or ref to diff against (e.g., the main branch):

```bash
skippy-cov --diff main --coverage-file .coverage
```

or equivalently

```bash
pytest --skippy-cov --skippy-cov-diff main --skippy-cov-coverage-file .coverage
```

You can also provide a diff file:

```bash
git diff > changes.diff
skippy-cov --diff changes.diff --coverage-file .coverage
```

If you omit the `--diff` argument, it will default to the main branch as determined by your `git remote` (usually "main" or "master").

**Advanced:**  
You may pass any valid git diff refspec to `--diff`, including triple-dot syntax (e.g., `main...HEAD` or `origin/master...feature-branch`). If you provide a triple-dot ref, it will be used as-is, giving you full control over the comparison range.

See `skippy-cov --help` for more information.


## Contributing

See `CONTRIBUTING.md` for information on how to contribute to the project.

## License

See `LICENSE` for licensing information.
qtmaterialsymbols 1.0.1
Material Symbols in PySide and PyQt applications
Requires Python: >=3.7
Keywords: PySide, PyQt, Qt, Material Symbols, Icons

# QtMaterialSymbols
Python Qt wrapper for Material Design icons.

## Description
QtMaterialSymbols enables to use [Material Symbols](https://fonts.google.com/icons) font icons in PySide and PyQt applications.

This project is heavily based on [QtAwesome](https://github.com/spyder-ide/qtawesome).

## Installation
You can install QtMaterialSymbols using pip:

```bash
pip install qtmaterialsymbols
```

## Usage
To use Material Symbols in your PySide or PyQt application, you can simply import the `get_icon` function and use it to create icons for your widgets.:

```python
from qtmaterialsymbols import get_icon

icon = get_icon("settings", color="#ffffff")
button = QtWidgets.QPushButton(icon)
```

Please look into signature of `get_icon` function for more details on available parameters.

At this moment it is not possible to use font axis (outlined, rounded, fill etc.). It is available since Qt 6.7 which might limit the usage.
teste-operacoes 0.0.1
Um pacote Python simples para operações de teste.
Requires Python: >=3.8

# teste-operacoes

Este pacote `teste_operacoes_lib` oferece funÃ§Ãµes essenciais para operaÃ§Ãµes matemÃ¡ticas bÃ¡sicas e serve como um exemplo prÃ¡tico de empacotamento em Python.

O pacote `teste_operacoes_lib` Ã© usado para:
	- Realizar operaÃ§Ãµes de adiÃ§Ã£o, subtraÃ§Ã£o, multiplicaÃ§Ã£o e divisÃ£o de nÃºmeros.
	- Demonstrar a estrutura e o processo de criaÃ§Ã£o de um pacote Python distribuÃ­vel.
	- Fornecer um esqueleto funcional para o desenvolvimento de novos pacotes.

## InstalaÃ§Ã£o

VocÃª pode instalar este pacote usando o gerenciador de pacotes [pip](https://pip.pypa.io/en/stable/) diretamente do PyPI (apÃ³s o upload):

```bash
pip install teste-operacoes
Uso
Aqui estÃ£o alguns exemplos de como importar e utilizar as funÃ§Ãµes deste pacote:

Python

# Importa a funÃ§Ã£o de saudaÃ§Ã£o do mÃ³dulo principal do pacote
from teste_operacoes_lib import saudar

# Importa as funÃ§Ãµes de operaÃ§Ãµes matemÃ¡ticas de um submÃ³dulo
from teste_operacoes_lib.operacoes import somar, subtrair, multiplicar, dividir

# Exemplo de chamada da funÃ§Ã£o de saudaÃ§Ã£o
print(saudar())
# SaÃ­da esperada: OlÃ¡ do meu pacote de operaÃ§Ãµes de teste!

# Exemplos de uso das funÃ§Ãµes matemÃ¡ticas
resultado_soma = somar(10, 5)
print(f"10 + 5 = {resultado_soma}")
# SaÃ­da esperada: 10 + 5 = 15

resultado_subtracao = subtrair(20, 8)
print(f"20 - 8 = {resultado_subtracao}")
# SaÃ­da esperada: 20 - 8 = 12

resultado_multiplicacao = multiplicar(4, 6)
print(f"4 * 6 = {resultado_multiplicacao}")
# SaÃ­da esperada: 4 * 6 = 24

try:
    resultado_divisao = dividir(25, 5)
    print(f"25 / 5 = {resultado_divisao}")
    # SaÃ­da esperada: 25 / 5 = 5.0

    # Teste de divisÃ£o por zero para demonstrar o tratamento de erro
    dividir(10, 0)
except ValueError as e:
    print(f"Erro ao tentar dividir por zero: {e}")
    # SaÃ­da esperada: Erro ao tentar dividir por zero: NÃ£o Ã© possÃ­vel dividir por zero.
Autor
Rommano Moreira Mismetti

LicenÃ§a
Este projeto estÃ¡ licenciado sob a LicenÃ§a MIT.

MIT
bbrpy 0.3.5
Better Battery Report for Windows
Requires Python: >=3.12

<div align="center">

<img src="https://raw.githubusercontent.com/pablofueros/better-battery-report/main/assets/banner.png" alt="BBRPY logo" width="600"/>

---

### **✨ Better Battery Report: A Python CLI tool that generates enhanced battery reports for Windows systems ✨**

[![Code Quality](https://github.com/pablofueros/bbrpy/actions/workflows/code-quality.yaml/badge.svg)](https://github.com/pablofueros/bbrpy/actions/workflows/code-quality.yaml)
[![Release](https://github.com/pablofueros/bbrpy/actions/workflows/release.yaml/badge.svg)](https://github.com/pablofueros/bbrpy/actions/workflows/release.yaml)
[![codecov](https://codecov.io/gh/pablofueros/better-battery-report/graph/badge.svg?token=YGVE6SADVQ)](https://codecov.io/gh/pablofueros/better-battery-report)
[![PyPI Latest Release](https://img.shields.io/pypi/v/bbrpy.svg)](https://pypi.org/project/bbrpy/)
[![PyPI Downloads](https://static.pepy.tech/badge/bbrpy)](https://pepy.tech/projects/bbrpy)
![versions](https://img.shields.io/pypi/pyversions/bbrpy.svg)

---

</div>

## 📋 Features

- Display basic battery information
- Generate battery health reports with interactive visualizations
- Export reports as HTML files with Plotly graphs
- Track battery capacity changes over time

## 📦 Installation

Since this is a CLI application, it's recommended to run it using [uvx](https://docs.astral.sh/uv/guides/tools/):

```bash
uvx bbrpy
```

> [!IMPORTANT]
> This will only install the essential dependencies for running the tool, making it lightweight and portable. For extended use, it may be necessary to install extra dependency groups as well.

It can also be installed into a persistent environment and added to the PATH:

```bash
uv tool install bbrpy
```

Alternatively, you can install it globally using pip:

```bash
pip install bbrpy
```

## 💻 Usage

The tool provides two main commands:

### Display Battery Information

```bash
bbrpy info
```

This command shows basic battery information including:

- Report scan time
- Capacity Status (current / design)

### Generate Battery Report

```bash
bbrpy report [--output PATH] [--format FORMAT]
```

Options:

- `--output`, `-o`: Specify the output path for the report (default: "./reports/battery_report")
- `--format`, `-f`: Report format: 'custom' (interactive html), 'standard' (Windows html), or 'raw' (xml data) (default: "custom")

This command:

1. Generates a battery report using powercfg
2. Creates a report in the specified format:
   - `custom`: Interactive visualization of battery capacity history with Plotly
   - `standard`: Default Windows HTML battery report
   - `raw`: XML data used for parsing
3. Opens HTML reports in your default web browser automatically

## 📘 Requirements

- Windows operating system
- Python 3.12 or higher
- Administrative privileges (for powercfg command)

## ⚙️ Technical Details

- `powercfg` Windows command-line tool for battery data
- `pydantic_xml` for the default report serialization
- `plotly` for interactive visualizations
- `pandas` for data processing
- `typer` for CLI interface

## ©️ License

MIT License
yamlcleaner 0.1.2
Un outil CLI pour nettoyer les fichiers YAML en supprimant les commentaires
Requires Python: >=3.7

# yamlcleaner

**yamlcleaner** est un outil en ligne de commande (CLI) pour nettoyer les fichiers YAML en supprimant tous les commentaires.

## Installation

Assurez-vous d'avoir Python 3.7 ou supérieur installé.

Installez les dépendances :

```bash
pip install -r requirements.txt
# ou, si installé via pyproject.toml :
pip install .
```

## Utilisation

Pour nettoyer un fichier YAML :

```bash
yamlcleaner chemin/vers/fichier.yaml
```

Pour nettoyer tous les fichiers d’un dossier (récursivement) :

```bash
yamlcleaner chemin/vers/dossier
```

Par défaut, les fichiers nettoyés sont enregistrés dans le dossier `./cleaned`.  
Vous pouvez spécifier un dossier de sortie avec l’option `-o` :

```bash
yamlcleaner chemin/vers/dossier -o dossier_sortie
```

## Exemple

Avant :

```yaml
# Ceci est un commentaire
nom: Alice # commentaire en ligne
age: 30
```

Après nettoyage :

```yaml
nom: Alice
age: 30
```

## Licence

Voir le fichier [LICENSE.MD](LICENSE.MD).
llm-tools-kit 0.1
wrapper for cased-kit's code analysis toolset
Requires Python: >=3.9

# llm-tools-kit

[![PyPI](https://img.shields.io/pypi/v/llm-tools-kit.svg)](https://pypi.org/project/llm-tools-kit/)
[![Changelog](https://img.shields.io/github/v/release/kgruel/llm-tools-kit?include_prereleases&label=changelog)](https://github.com/kgruel/llm-tools-kit/releases)
[![Tests](https://github.com/kgruel/llm-tools-kit/actions/workflows/test.yml/badge.svg)](https://github.com/kgruel/llm-tools-kit/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/kgruel/llm-tools-kit/blob/main/LICENSE)

wrapper for cased-kit's code analysis toolset

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-tools-kit
```
## Usage

To use this with the [LLM command-line tool](https://llm.datasette.io/en/stable/usage.html):

```bash
llm --tool example_hello "Example prompt goes here" --tools-debug
```

With the [LLM Python API](https://llm.datasette.io/en/stable/python-api.html):

```python
import llm
from llm_tools_kit import example_hello

model = llm.get_model("gpt-4.1-mini")

result = model.chain(
    "Example prompt goes here",
    tools=[example_hello]
).text()
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-tools-kit
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
llm install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```