semvec/pypi-packages huggingface dataset:
simple-coroutine 0.1.5
A simplified interface for managing coroutines with callback entry to monitor progress
Requires Python: <4.0,>=3.11
Keywords: coroutines, async, asyncio, callback

# CoroutineSession

`CoroutineSession` is a designed to manage and execute asyncio tasks with optional progress tracking and callbacks. It supports running tasks with a concurrency limit and batching delay.

## Features

- Add and manage asyncio tasks.
- Execute tasks with a specified maximum number of concurrent tasks.
- Delay between batches of tasks for better control over execution.
- Optional callback functions to handle task completion and progress updates.
- Progress tracking with individual task shares for better granularity.

## Installation

This class is part of a Python project and requires Python 3.7 or later. Ensure you have `pydantic` installed:

```bash
pip install simple-coroutine
```

```python
import asyncio
from simple_coroutine.manager import CoroutineSession

async def sample_task(task_id):
    await asyncio.sleep(2)  # Simulate a task taking some time
    return f"Task {task_id} completed"

async def main():
    session = CoroutineSession(
        max_concurrent_tasks=2,
        batch_delay=5,
        callback=lambda index, result: print(f"Task {index} result: {result}"),
        progress_callback=lambda index, progress, total: print(f"Task {index} progress: {progress}, Total: {total}")
    )

    tasks = [sample_task(i) for i in range(5)]
    session.add_task_set(tasks)
    
    results = await session.run_tasks()
    print("All tasks completed:", results)

    async for progress in session.progress_generator():
        print(f"Progress: {progress}%")

if __name__ == "__main__":
    asyncio.run(main())
```
hack4u2i3 0.5.0
Una bibilioteca para consultar cursos de hack4u.

# Hack4u Academy Courses Library

Una biblioteca Python para consultar curos de la academia Hack4u.

## Cursos disponibles:

- Introduccion a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación

Instala el paquete usando `pip3`:

```python3
pip install hack4
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
    print/course)
```

### Obtener un curso por nombre

```python
from hack4u import ger_course_by_name 
course = get_course_by_name("Introducción a Linux")
print(course)

### Calcular duración total de los cursos

```python3
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
mak-automation-framework 1.0.0
Automation framework using Playwright Python
Requires Python: >=3.6

# Automation Framework using Playwright Python

This project contains a custom automation framework built using Playwright and Python for web automation.

## Features

- **Base Page**: Contains base functionalities and configurations for tests.
- **Utilities**: Various utility functions for common operations.
- **Conftest**: Configuration settings for pytest.
- **Requirements**: List of dependencies required by the framework.
- **pytest.ini**: Configuration file for pytest.

## Installation

To install and use this framework in your projects, follow these steps:


```bash
pip install automation_framework
harmonyTS 0.1.5
Harmony is a unified framework for data visualization, analysis and interpretation of scRNA-seq data measured across discrete time points
Requires Python: >=3.6

Harmony
------

Harmony is a unified framework for data visualization, analysis and interpretation of scRNA-seq data measured across discrete time points.Harmony constructs an augmented affinity matrix by augmenting the kNN graph affinity matrix with mutually nearest neighbors between successive time points. This augmented affinity matrix forms the basis for generated a force directed layout for visualization and also serves as input for computing the diffusion operator which can be used for trajectory detection using Palantir


#### Installation and dependencies
1. Harmony has been implemented in Python3 and can be installed using:

        $> pip install harmonyTS
        $> pip install palantir

2. Harmony depends on a number of `python3` packages available on pypi and these dependencies are listed in `setup.py`
All the dependencies will be automatically installed using the above commands

3. To uninstall:
		
		$> pip uninstall harmonyTS

4. If you would like to determine gene expression trends, please install <a href="https://cran.r-project.org"> R <a> programming language and the R package <a href="https://cran.r-project.org/web/packages/gam/">GAM </a>. You will also need to install the rpy2 module using 
	
		$> pip install rpy2
		
5. If you would like to speed-up the analysis in case of big datasets, you can run the main functions of this package on a CUDA GPU. To do so please install `rapids-0.17` as well as `cupy>=9.0`.
		

#### Usage

A tutorial on Harmony usage and results visualization for single cell RNA-seq data can be found in this notebook: http://nbviewer.jupyter.org/github/dpeerlab/Harmony/blob/master/notebooks/Harmony_sample_notebook.ipynb

The datasets generated as part of the manuscript and harmozined using Harmony are available for exploration at: [endoderm-explorer.com](https://endoderm-explorer.com)


#### Citations
Harmony was used to harmonize datasets across multiple time points in our manuscript characterizing mouse gut endoderm development.  This manuscript is available at [Nature](https://www.nature.com/articles/s41586-019-1127-1). If you use Harmony for your work, please cite our paper.
nettensorpat 2024.7.13
NetworkTensorPattern is a Python package for finding patterns in tensors.
Requires Python: >=3.7
Keywords: NetworkTensorPattern, NetPat

# 🧬 Network Tensor Pattern

A python package implementation to the C codebase of the paper [A Local Tensor Clustering Algorithm to Annotate Uncharacterized Genes with Many Biological Networks](https://publications.waset.org/abstracts/155115/a-local-tensor-clustering-algorithm-to-annotate-uncharacterized-genes-with-many-biological-networks) with the addition of a second method of Global Tensor Clustering.

---

# 🔔 Requirements

⚙️ OS Supported:

| Windows | 🟢 |
| --- | --- |
| Linux | 🟢 |
| MacOS | 🟢 |

⚠️ Requires Python ≤ 3.11 due to setuptools being deprecated after 3.12

- Consider installing a python environment manager i.e. Anaconda/Miniconda to install Python ≤ 3.11

⚠️ GCC is required in order to compile the C source files and headers into a C Python Extension.

💻 Windows Only:

- Consider [installing MingW via Sourceforge](https://sourceforge.net/projects/mingw/files/Installer/mingw-get-setup.exe/download) (as its website is down as of March 2021)

---

# 🏃 Package Compilation

To compile the C headers and source code:

```bash
python setup.py pnt --compile
```

This should generate a file with our C Python Extensions called `Tensor_Python.so` under  `./src/patnetstensor`

To install the python package:

```bash
pip3 install .
```

---
chord-matrix 0.1.1
A package to generate a matrix for chord diagrams
Requires Python: >=3.6

# chord-matrix

## Overview
`chord-matrix` is a Python package designed to process gene expression data and generate a co-occurrence matrix. This matrix can then be utilized to create chord diagrams, providing a visual representation of the co-occurrences between different gene mutations.

## Features
- **Data Processing**: Reads gene expression data from a TSV file and filters it based on specific criteria.
- **Co-occurrence Matrix**: Creates a matrix showing the co-occurrence of gene mutations across samples.
- **Details Calculation**: Computes various statistics, including odds ratios and tendencies for mutual exclusivity or co-occurrence.
- **Output**: Generates a detailed output file including the co-occurrence matrix and the computed statistics.

## Installation

### Prerequisites
Ensure you have Python 3.6 or higher installed on your system.

### Using pip
You can install `chord-matrix` using pip:

```bash
pip install chord-matrix
```

## The logic behind

### Data Reading and Filtering
The input data file is read and filtered based on a specific status (RMG_53). Only the necessary columns (UPN, AF, and SYMBOL) are retained, and duplicates are removed. 
Customize the filtering according to your requirements.

### Matrix Creation
The filtered data is used to create a pivot table where rows represent gene symbols and columns represent patient id(UPN). The presence of a mutation is indicated by 1, and the absence by 0.

### Why use the dot product?
To generate the co-occurrence matrix, we use matrix multiplication (dot product) of the gene-patient matrix with its transpose. This process is fundamental in identifying how many times pairs of genes co-occur across all patients.

The dot product of two binary vectors (gene presence/absence vectors) results in a scalar value representing the number of times both genes are mutated in the same patient. By performing this operation for each pair of genes, we can construct a full co-occurrence matrix that quantifies the co-occurrences of all gene pairs across the dataset.

### Details Calculation
The package calculates several statistics for each pair of genes, including:

* Both: Number of samples with both genes mutated.
* A Not B: Number of samples with only gene A mutated.
* B Not A: Number of samples with only gene B mutated.
* Neither: Number of samples with neither gene mutated.
* Log2 Odds Ratio: Log2 of the odds ratio indicating the tendency for co-occurrence or mutual exclusivity.
pyleiter 0.2.1
Simple task manager
Requires Python: <4.0,>=3.10

# Pyleiter
Simple task manager for a Python project.

## Installation
Use your favorite virtualenv and python package manager. For instance, using pip:

```bash
pip install pyleiter
```

## Configuration and usage

Make sure your project has a 'pyproject.toml' file and add a section like the one below:

```toml
[tool.pyleiter.commands]
format = { command = "ruff format src", help = "Applies ruff format to project"}
lint = { command = "ruff check src", help = "Runs project formatter and linter" }
```

Where each line corresponds to a command you want to register for your program.

After that, you can use pyleiter with the registered commands:

```bash
pyleiter format
```

## Why use it?

Simply because every project requires simple maintenance scripts, and it is often done without a standardized way for Python projects.
By using a tool that leverages `pyproject.toml`, we can keep the configuration centralized.

## Similar (and better) projects

- https://github.com/nat-n/poethepoet
- https://github.com/omnilib/thx
pyodide-unix-timezones 1.0.0
Helper package to install unix timezone data on Pyodide

# Pyodide Unix Timezones Package

This package installs Unix style timezone data into /usr/share/zoneinfo of a pyodide instance.

To install the data just import the `unix_timezones` package.

It won't overwrite any existing data, so it is safe to use under node.js etc.
Lecaps 1.0.0
Cotizar tasas implícitas de Lecaps
Requires Python: >=3.6

# LECAPS 

Lecaps es una libreria que tiene como finalidad calcular a tiempo real las tasas implicitas que otorgan las Letras Capitalizables del Tesoro de la Republica Argentina 🇦🇷 

## Versiones: 

- `1.0.0`: Letras Capitalizables al 13/07/2024. 

## Instalacion: 

``` python 
pip install Lecaps

```

## Usos

### Lista de Letras

Dentro de la libreria se incluye un lista con las `lecaps` vigentes a la fecha. La misma se invoca con `lista_lecaps`


``` python 
lecaps_vigentes = lista_lecaps
print(lecaps_vigentes)

```

### Funciones.

Dentro de la libreria especificada cada `lecap` es una clase. De esta manera, cada una de ellas posee los siguientes atributos: 

- `vencimiento`: Fecha de vencimiento. *(Incluye diferencias en dias)*
- `amortizacion`: Precio Final. 

``` python 
# Tomamos como ejemplo la S14O4

S14O4 = S14O4
print(S14O4.vencimiento)
print(S14O4.amortizacion)

```

### Funciones


Asimismo, cada `Lecap` posee dos metodos `info` y `Tasas`.

Dentro del método `info`, se incluye un resumen del `vencimiento` y `amortizacion` de la `lecap`. 

``` python 
# Tomamos como ejemplo la S14O4

S14O4_info = S14O4.info()
print(S14O4_info)

```
Dentro del método `Tasa` se calculan las variables a saber: 

- `TNA`: Tasa Nominal Anual. 
- `TEA`: Tasa Efectiva Anual.
- `TEM`: Tasa Efectiva Mensual.
- `REN`: Rendimiento a vencimiento. 
- `DUR`: Cantidad de meses a fecha de vencimiento. Base de 360 dias.

Para dicho cálculo se deberá ingresar el precio como párametro. El output es un Diccionario.

``` python 
# Tomamos como ejemplo la S14O4

S14O4_tasas = S14O4.Tasas(110.3)
print(S14O4.tasas)

```

### Funciones: 

Se incluyen: 

- `days360(end_date = YYYY-MM-DD, today = None)`: Calcula la diferencia de dias en base 360. Si `today`es `None`toma la fecha que arroja la funcion `get_start_date()`
- `lecaps_vigentes(lecaps_nombres = lista_lecaps)`: Arroja tickets de lecaps vigentes. 
- `imprimir_tasa_lecaps(lecaps_nombres = lista_lecaps, precios = None)`: Arroja la `TNA`, `TEM` o `TEA`. Se debe incluir un vector de Precios. 
- `curva_de_tasas(lecaps_list = lista_lecaps, precios = None)`: Arroja la curva de tasas. Se debe incluir un vector de precios. 

``` python 
precios = [107.60, 105.670, 107.400, 105.280, 102.750, 117.10, 112.950, 103.71, 101.100, 131.150, 115.500, 108.7]

# Lista
lecaps_vigentes()

# Tasas
imprimir_tasa_lecaps(precios)

# Curva
curva_de_tasas(precios)
```
InlineGPT 0.1.0
A Python package designed to provide direct inline support for developers. It integrates GPT (Generative Pre-trained Transformer) functionality directly into Python applications, enabling developers to handle errors effectively by suggesting appropriate changes.
Requires Python: >=3.6

# InlineGPT

InlineGPT is a Python package that integrates Google's Generative AI models directly into your Python applications to provide inline error handling and suggestions for code corrections.

## Installation

You can install InlineGPT via pip:

```bash
pip install InlineGPT
```

## Getting Started

To use InlineGPT, you need to obtain an API key from [Google AI Studio](https://aistudio.google.com/app/apikey).

### Example Usage

```python
from inline.inlinegpt import InlineGPT
import os

# Initialize your API KEY
gpt = InlineGPT(os.environ.get('G_API_KEY')) 

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
    gpt.get_solution("test.py", e)

```

### Output

The `get_solution` method analyzes the code in `file_name` and the provided `error_message`, then generates a response suggesting how to resolve the error using Google's Generative AI models.

## Contributing

We welcome contributions to InlineGPT! Please fork the repository and submit pull requests to contribute.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Issues

If you encounter any issues with InlineGPT or have suggestions for improvements, please open an issue on [GitHub](https://github.com/yourusername/InlineGPT/issues).

---

### Additional Notes:

- **Dependencies**: InlineGPT relies on `google.generativeai` for its AI capabilities. Ensure you have the necessary permissions and API key from Google AI Studio.
- **Error Handling**: If the API key is invalid or not provided, InlineGPT will raise an initialization error.
PyFrisk 0.0.3
This is the simplest module for quick work with proxy.
Requires Python: >=3.6
Keywords: proxy ips helping

# PyFrisk
## What is this? ##
This is the simplest module for quick work with proxy and ips. **The module allows you to work with proxy in just one line of** `code`, **without** the need **to manually getting geolocation, splitting ip:port, or getting ip from domain each time**


## Using
Let's import it first:
First, import everything from the library (use the `from `...` import *` construct).

Examples of all operations:

### proxy
Enabling proxy using the `enable_proxy()` function:

`PyFrisk.enable_proxy()`

Changing proxy settings using the `change_proxy(ip, port)` function:


    ip = "127.0.0.1"
    port = "8080"
    Pfrisk.change_proxy(ip, port)


Disabling proxy using the `disable_proxy()` function:

`PyFrisk.disable_proxy()`

### ip
Getting geolocation using the `get_geolocation(ip_address)` function:

    ip_address = "173.194.222.100"
    PyFrisk.get_geolocation(ip_address)

Getting ip from domain using the `get_ip_from_domain(domain_name)` function:

    domain_name = "google.com"
    PyFrisk.get_ip_from_domain(domain_name)

### helper
Getting free proxy using the `get_free_proxies()` function:

`PyFrisk.get_free_proxies()`

Splitting ip:port using the `split_ip_port(ip_port_str)` function:

`PyFrisk.split_ip_port(ip_port_str)`

## Developer ##
My youtube: [link](http://www.youtube.com/@AkaruiNeko/) 

My nickname: akaruineko
karrotcapital.spiderswap 1.0.2
A package for interacting with the SpiderSwap API
Requires Python: >=3.6

# karrotcapital.spiderswap

Welcome to the `karrotcapital.spiderswap` package, a community-developed tool by Karrot Capital designed to interact seamlessly with the SpiderSwap API on the Solana blockchain. This package provides a robust and user-friendly set of functions to facilitate token swaps and transaction management.

## Installation

Install the package using pip:

```bash
pip install karrotcapital.spiderswap
```

## Getting Started

### Initialization

First, initialize the Spiderswap class with your API key:

```python
from karrotcapital.spiderswap import Spiderswap

spiderswap = Spiderswap('your-api-key')
```

### Functions Overview
Token Swaps
- getSwapRaw
- getSwap

Transaction Management
- createTransaction
- sendTransaction

Quote Retrieval
- getQuoteRaw
- getQuote

## Documentation
For detailed information on how to use each function, including installation instructions, usage examples, and API references, please visit our comprehensive documentation at [Karrot Capital Documentation](https://docs.karrot.capital/).

Thank you for using the `karrotcapital.spiderswap` package. We hope it helps you integrate with the SpiderSwap API effortlessly and effectively. Happy coding!
satcompression 0.0.3
A python package to compress sat data
Requires Python: <4.0,>=3.9

# satcompression
Efficient decomposition of satellite images in a Quad-Tree structure


## Installation

```bash
pip install satcompression
```

## Usage

Compression and decompression of satellite images using the Quad-Tree structure.

```python
import satcompression
import rasterio as rio

# Load an image
with rio.open('path/to/image.tif') as src:
    image_meta = src.meta
    image_data = src.read()

# Compress the image
image_data_compress = satcompression.compress_and_encode_image_data(
    image_data=image_data, detail_error_threshold=20
)

# Decompress the image
image_data_decompress = satcompression.reconstruct_image_data(
    data=image_data_compress, dtype=image_data.dtype, nchannels = image_data.shape[0]
)
```

![image](docs/images/visual_comparison.png)

Obtain the pseudo-mtf from the quadtree structure.

```python
import satcompression
import matplotlib.pyplot as plt

with rio.open('path/to/image.tif') as src:    
    image_data = src.read()

mtf_values1, x_axis1 = satcompression.quadtree_mtf(image_data, 10, detail_error_threshold=20)
mtf_values2, x_axis2 = satcompression.quadtree_mtf(image_data, 10, detail_error_threshold=10)
mtf_values3, x_axis3 = satcompression.quadtree_mtf(image_data, 10, detail_error_threshold=5)

plt.plot(x_axis1, mtf_values1, label="Detail Error Threshold: 0.002")
plt.plot(x_axis2, mtf_values2, label="Detail Error Threshold: 0.001")
plt.plot(x_axis3, mtf_values3, label="Detail Error Threshold: 0.0005")
plt.legend()
plt.ylim(0, 1.2)
plt.title("Pseudo-MTF obtained from the quadtree decomposition")
plt.show()
```

![image](docs/images/mtf_comparison.png)

Obtain the classification of the quadtree nodes.

```python
import satcompression

with rio.open('path/to/image.tif') as src:    
    image_data = src.read()

satcompression.create_classification_map(image_data, detail_error_threshold=20)
```

![image](docs/images/classification_map.png)
Nebula-web 0.1.0
A custom web server framework
Requires Python: >=3.12

# Nebula

Nebula is a lightweight web server framework, designed to simplify web application development with Python.

## Features

- **Routing**: Simple and intuitive URL routing.
- **Views and Templates**: Support for rendering views and templates.
- **Form Handling**: Built-in form handling and validation.
- **Database Integration**: Integration with sqlite3 databases for data storage.
zrcl 0.4.5
Zack's common reusable library
Requires Python: >=3.8

[![Upload Python Package](https://github.com/ZackaryW/zrcl2/actions/workflows/python-publish.yml/badge.svg)](https://github.com/ZackaryW/zrcl2/actions/workflows/python-publish.yml)

# zrcl
zack's reusable common library

* a library that contains reusable utilities to make my life easier
* 2 is only the repo-serial, I will still use `zrcl` as the package name
* package does not install any dependencies by default, it is up to the user to install them
* all functions are properly type hinted and docstringed

## Install
stable
```bash
pip install zrcl
```

or
```bash
pip install git+https://github.com/ZackaryW/zrcl2.git
```

beta
> branch using beta
```bash
pip install git+https://github.com/ZackaryW/zrcl2.git@beta
```

## Project Structure
* `beta_` means this is not finalized and not properly tested
* `ext_` means this is an extension to the original package (util functions for qol)
* `tool_` means this is an executable tool
* `app_` means this contains utils for an app (by default assume Windows is the sole working platform)
if exclusively specified as `app_win_` or `app_linux_` or `app_mac_` then it is for the respective platform

## Additional
* `zrcl` command is available and can be used to pass command and parameters for other tools
merge-kicad-sym 0.1.1
A script to merge KiCad symbol libraries.
Requires Python: >=3.6

# merge-kicad-sym

A script to merge KiCad symbol libraries.

## Installation

```sh
pip install merge-kicad-sym
```

## Usage

```sh
usage: merge-kicad-sym [-h] [--overwrite-footprint-lib-name OVERWRITE_FOOTPRINT_LIB_NAME] target_lib source_lib

Combine two KiCad symbol libraries.

positional arguments:
  target_lib            Path to the target KiCad symbol library file that the source library will be merged into.
  source_lib            Path to the source KiCad symbol library file that will be merged into the target library.

options:
  -h, --help            show this help message and exit
  --overwrite-footprint-lib-name OVERWRITE_FOOTPRINT_LIB_NAME
                        String to overwrite the footprint library this symbol refereces to.

```