semvec/pypi-packages huggingface dataset:
phylodeep-data-bdei 0.4
Data needed for CI computation with Birth-Death Exposed-Infectious (BDEI) model in [PhyloDeep](https://github.com/evolbioinfo/phylodeep).
Requires Python: >=3.8
Keywords: phylodeep, confidence intervals, birth-death exposed-infectious

# PhyloDeep Data BDEI

This package contains data needed for CI computation with Birth-Death Exposed-Infectious (BDEI) model in [PhyloDeep](https://github.com/evolbioinfo/phylodeep).
pybayesprism 0.1.0
Python implementation of BayesPrism
Requires Python: >=3.8

This is a Python implementation of [BayesPrism](https://github.com/Danko-Lab/BayesPrism).


Usage
```python

import os
import pandas as pd
from pybayesprism import process_input, prism, extract

os.system("curl -L -O https://github.com/ziluwang829/pyBayesPrism/raw/main/data/data.tar.gz")
os.system("mkdir -p BP_data")
os.system("tar -xzvf data.tar.gz -C BP_data")

bk_dat = pd.read_csv("BP_data/bk_dat.csv", sep=",", index_col=0)
sc_dat = pd.read_csv("BP_data/sc_dat.csv", sep=",", index_col=0)


cell_state_labels = pd.read_csv("BP_data/cell_state_labels.csv", header=None).iloc[:,0].tolist()

cell_type_labels = pd.read_csv("BP_data/cell_type_labels.csv", header=None).iloc[:,0].tolist()

sc_dat_filtered = process_input.cleanup_genes(sc_dat, "count.matrix", "hs", \
                  ["Rb", "Mrp", "other_Rb", "chrM", "MALAT1", "chrX", "chrY"], 5)
                  
sc_dat_filtered_pc = process_input.select_gene_type(sc_dat_filtered, ["protein_coding"])

my_prism = prism.Prism.new(reference = sc_dat_filtered_pc, 
                          mixture = bk_dat, input_type = "count.matrix", 
                          cell_type_labels = cell_type_labels, 
                          cell_state_labels = cell_state_labels, 
                          key = "tumor", 
                          outlier_cut = 0.01, 
                          outlier_fraction = 0.1)

bp_res = my_prism.run(n_cores = 36, update_gibbs = True)     

theta = extract.get_fraction(bp_res, "final", "type")
```
phylodeep-data-bd 0.6
Data needed for CI computation with Birth-Death (BD) model in [PhyloDeep](https://github.com/evolbioinfo/phylodeep).
Requires Python: >=3.8
Keywords: phylodeep, confidence intervals, birth-death

# PhyloDeep Data BD

This package contains data needed for CI computation with Birth-Death (BD) model 
with incomplete sampling in [PhyloDeep](https://github.com/evolbioinfo/phylodeep).
po-meta-magic 0.1.7
A Python package for extracting and processing text from images.
Requires Python: >=3.6

# `po_meta_magic`

## Overview

`po_meta_magic` is a Python package designed for extracting and processing text from images based on metadata and bounding box information. It includes functionalities for validating inputs, extracting text from specific regions of an image, formatting dates, and ensuring only allowed characters are included in the output.

## Installation
To install the package, use pip:

```bash
pip install po-meta-magic
```

### Parameters

- **image** (`PIL.Image.Image`):
  The image object from which text will be extracted.

- **meta_data** (`dict`):
  A dictionary where keys represent metadata types and values are dictionaries containing:
  - **bbox**:
    Bounding box coordinates as a tuple `(x_min, y_min, x_max, y_max)`.
  - **key**:
    The key or text to find and extract.
  - **date_format** (optional, `str`):
    Format for dates if the value is a date.
  - **optional_key_match** (optional, `bool`):
    If `True`, key is not required to be present in the text.
  - **allowed_chars** (optional, `str`):
    Characters to be kept in the text (e.g., `0-9A-Za-z`).
automated-rhythm-generation 0.0.1
ARG: Automated Rhythm Generation. Let's generate rhythm game maps automatically!
Requires Python: >=3.8

# Automated Rhythm Generation

ARG: Automated Rhythm Generation.

Let's generate rhythm game maps automatically!

## Features

### Neural Networks

- RhythmGen: Generate rhythm sequence from music piece.
  - [x] RGGRU: RhythmGen with CNN feature extractor and GRU. (`460K`)
  - [x] RGGRUAT: RhythmGen with CNN feature extractor, GRU, and multi-head attention. (`720K`)
  - [x] RGTR: RhythmGen with CNN feature extractor and Transformer. (`15M`)
  - [x] RGRoFormer: RhythmGen with CNN feature extractor, Transformer and RoPE. (`420K`)
  - [ ] Others: RhythmGen with other architectures.
- RhythmRec: Reconstruct music piece from rhythm sequence.
  - [ ] No, we didn't implement this yet.

### Utils

- RhythmAnnotation (`ryan`): Rhythm annotation tool and format. See [ryan](https://github.com/JacobLinCool/rhythm-rs/blob/main/tja/examples/ryan.rs) for more details.

## Installation

```sh
pip install automated-rhythm-generation
```

## Training

```py
from arg import Trainer

trainer = Trainer(
    "RGGRU", # Model architecture
    "JacobLinCool/taiko-2023-1.1", # Dataset
    difficulty="hard",
    num_epochs=300,
    learning_rate=0.001,
    batch_size=32,
    max_length=10.0,
)

trainer.train(
    push="JacobLinCool/RhythmGenGRU-1-hard",
    hf_token=HF_TOKEN,
)
```

Or you can use the command line interface:

```sh
python -m arg.train RGGRU JacobLinCool/taiko-2023-1.1 --difficulty hard --push JacobLinCool/RhythmGenGRU-1-hard
```

## Inference

```py
from arg import RGGRU, generate_tja
import librosa

model = RGGRU.from_pretrained("JacobLinCool/RhythmGenGRU-1-hard")

audio, sr = librosa.load("path/to/music.mp3", sr=16000)
seq = model.predict(audio)
tja = generate_tja(seq)

with open("path/to/output.tja", "w") as f:
    f.write(tja)
```

Or you can use the command line interface:

```sh
python -m arg.infer RGGRU JacobLinCool/RhythmGenGRU-1-hard path/to/music.mp3
```

## Others

To see the model architecture: `python -m arg.model.RGGRU`, `python -m arg.model.RGRoFormer`, etc.
certificate-generator 0.3
A package to generate certificates with a given name and a logo in the top middle.
Requires Python: >=3.6

# Certificate Generator

A Python package to generate certificates with a given name and a logo in the top middle.

## Features

- Generate certificates with a specified template.
- Add a custom logo to the top middle of the certificate.
- Customize the font and color of the text.
- Save generated certificates as PNG files.

## Installation

You can install the package from PyPI using pip:

```bash
pip install certificate_generator
```

## Usage

### Basic Usage

To generate certificates, you need a template image, a font file, and a logo image. Here's an example of how to use the package:

```python
from certificate_generator import CertificateGenerator

template_path = 'path/to/template.png'
font_path = 'path/to/font/GreatVibes-Regular.ttf'
logo_path = 'path/to/logo.png'

generator = CertificateGenerator(template_path, font_path, logo_path)

# Example names
names = ["Alice", "Bob", "Charlie"]

for name in names:
    generator.create_certificate(name)
```

### Command Line Usage

You can also generate certificates using the command line. Make sure you have a `names.txt` file with each name on a new line:

```bash
generate-certificates
```

### Customization

You can customize the font size and color when creating the `CertificateGenerator` instance:

```python
generator = CertificateGenerator(template_path, font_path, logo_path, font_size=150, font_color="#000000")
```


### Output Directory

By default, the certificates are saved in an `out` directory. You can specify a different output directory:

```python
generator.create_certificate(name, output_dir="./custom_output/")
```


## Contributing

Contributions are welcome! Please open an issue or submit a pull request on GitHub.

## License

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

## Author

[Tushar Nankani](https://github.com/tusharnankani/) - Main author of the basic script

[Asib Hossen](https://github.com/asibhossen897)

## Acknowledgements

- [Pillow](https://python-pillow.org/) - The friendly PIL fork.
drakpdb 0.2.2
Helper library to generate DRAKVUF profiles.
Requires Python: >=3.8

# drakpdb

Helper library to generate [DRAKVUF](https://github.com/tklengyel/drakvuf) profiles.

## Installation

```
pip3 install -r requirements.txt
```

## Example
### Generating profile from kernel (with LibVMI)

1. Get PDB name and GUID/Age using `vmi-win-guid`
   ```
   # vmi-win-guid name windows7-sp1
   Windows Kernel found @ 0x2610000
           Version: 64-bit Windows 7
           PE GUID: 4ce7951a5ea000
           PDB GUID: 3844dbb920174967be7aa4a2c20430fa2
           Kernel filename: ntkrnlmp.pdb
           ...
   ```

2. Download PDB and parse it to a json profile 
   ```
   python3 drakpdb.py fetch_pdb ntkrnlmp.pdb 3844dbb920174967be7aa4a2c20430fa2
   python3 drakpdb.py parse_pdb ntkrnlmp.pdb > ntkrnlmp.json
   ```

### Generating profile from DLL

1. Use [symchk.py from moyix/pdbparse](https://github.com/moyix/pdbparse/blob/master/examples/symchk.py) to obtain PDB
2. Use:
   ```
   python3 drakpdb.py parse_pdb dllname.pdb > dllname.json
   ```
fastapi-request-limit 0.1.4
A FastAPI decorator for rate limiting requests based on specified parameters.
Requires Python: >=3.7


## Installation

```bash
pip install fastapi-request-limit
```

### Usage

Here's how you can use the `request-limit` decorator in a FastAPI application:~

```python
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from fastapi_request_limit import request_limit

app = FastAPI()

@app.post("/", response_class=JSONResponse)
@request_limit(seconds=5, data=["foo", "bar"])
async def root(foo: str, bar: int, request: Request):
    return JSONResponse(content={"message": f"Request accepted for {foo} and {bar}"})
```

### Parameters
- *seconds (int)*: The number of seconds required between requests with the same parameter values.
- *data (List[str])*: A list of parameter names to use for rate limiting.
lancedb-tables 0.1.3
An embedded streaming OLAP data pipeline with LanceDB
Requires Python: >=3.12

# lancedb-tables
`lancedb-tables` is a python package wrapper over LanceDB that makes it easy to create and update LanceDB tables into embedded streaming OLAP data pipeline designs.

Since Lance is designed to be mutable, it is possible to create an embedded streaming pipeline using the same data source. The main advantage of this streaming approach is that it doesn't require any parquet glob file management. This reduces the complexity of setting up streaming to the same as batch processing. The other main benefit is that LanceDB leverages the [Apache Arrow Standard](https://arrow.apache.org/overview/) which makes integrations into ETL pipelines using 
[Polars](https://lancedb.github.io/lancedb/python/polars_arrow/#from-polars-dataframe) and [DuckDB](https://lancedb.github.io/lancedb/python/duckdb/) simple.

## Install with pip
`pip install lancedb-tables`

## Install from source
1. Clone the repository
2. This repository uses rye to manage dependencies and the virtual environment. To install rye, refer to this link for instructions [here](https://rye-up.com/guide/installation/). 
3. Once rye is installed, run `rye sync` to install dependencies and setup the virtual environment, which has a default name of `.venv`. 
4. Activate the virtual environment with the command `source .venv/bin/activate`.
my-schwab 1.1.5
A Python package to interact with the Charles Schwab API.
Requires Python: >=3.10

# Schwab

## About

The `my-schwab` API client is a Python package that provides a convenient way to interact with the Schwab API. It allows you to access your Schwab account information, fetch account details, place orders, and retrieve order history. With this client, you can easily integrate Schwab functionality into your Python applications and automate trading strategies. It provides a simple and intuitive interface, making it easy to get started with the Schwab API. Start using the `my-Schwab` API client today and take control of your Schwab account programmatically.

## Installation

You can install the `my-schwab` package using pip. Open your terminal and type:

```bash
pip install my-schwab
```


```python
from schwab import Client

# fetch will fetch your current account and positions
client = Client(fetch=True)

client.place_order('AAPL', qty=1, order_type='limit', side='buy')
orders = client.get_orders()

transactions = client.get_transactions()
```

## License

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