semvec/pypi-packages huggingface dataset:
gabry-vcf-handler 1.3.0
VCF to .csv handler catered to specific desired fields
License: MIT
Requires Python: >=3.9

# vcf-handler

This repo is an installable python package and command line tool built for creating .csv files of annotated variants from VCF files. 
Currently the main process annotates variants with the following information either found within the VCF or pulled from external sources:
1. Depth of sequence coverage at the site of variation.
2. Number of reads supporting the variant.
3. Percentage of reads supporting the variant versus those supporting reference reads.
4. Gene ID of the variant, type of variation (substitution,
insertion, CNV, etc.) and their effect (missense, silent, intergenic, etc.) using 
the [VEP hgvs API](https://rest.ensembl.org/#VEP)
5. The minor allele frequency of the variant if available.

This process supports handling of multi-allelic sites. No pre-decomposition needed. 

This package is publicly installable from [PyPI](https://pypi.org/project/gabry-vcf-handler/). Once installed, the vcf-handler can be ran by importing the installed package:
```
>>> from vcf_handler.process import process_vcf
>>> process_vcf('test_vcf_data.txt')
INFO:vcf-handling:Checking VCF file
INFO:vcf-handling:Writing annotated variants to output.csv
```

Or, if the repo is cloned to your local environment and you have [PDM installed](https://pdm.fming.dev/latest/), 
running `pdm install` from the root directory will install all dependencies, allowing you to run the tooling from the command line:

`pdm run vcf-handler -i "{path_to_vcf}" -o "{desired_path_out}"`

## Code Walkthrough
The main VCF to CSV runner in this package is `process.py`. Here we pass through a light VCF file formatting check prior to reading in our variants. Reading and writing of variants is managed through generators in order to allow easy scaling in the instance of VCF files that are multiple GBs in size. This low-memory reading and writing can prevent exceeding of resource caps in comparison to methods which read the entire file into memory as a bytes, strings, or dataframes. All reading / writing is managed in `utils/read_write.py`

Once read in, each variant line is cast to a custom Variant class (`utils/Variant.py`) which has a handful of operations performed on it in order to scrape the necessary annotations. These are performed as class methods, and occasionally rely on outside helper functions (`utils/vep_helpers.py`). 

The command line interfacing is managed through the `click` and `argparse` modules, and is all handled in `cli.py`

## Developing

This repo uses [PDM](https://pdm.fming.dev/latest/). Install PDM and then install dependencies with `pdm install`.

Running test suite: `pdm run test`
Running auto-linter: `pdm run lint-fix`

## Releases

This package is published on [PyPI](https://pypi.org/project/gabry-vcf-handler/). In order to create a new release, bump the version in the [pyproject.toml](pyproject.toml) file, create a PR, and merge that change into main. When that change is merged into main, the new version will be automatically recognized and published.
progfiguration 0.0.10
PROGramatic conFIGURATION for your infrastructure
License: MIT
Requires Python: >=3.10

# progfiguration

PROGrammatic conFIGURATION.
I'm tired of writing YAML when what I want to write is Python.

## Development

Make and activate a venv, and install as editable.

```sh
python3 -m venv venv
. venv/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install --editable '.[development]'
```

From there:

* `progfiguration --help` to run the program
* `invoke -l` to list tasks for building documentation, running tests, and making releases

### Building and releasing

We only actually need to build a source version of the package,
because progfiguration expects that your progfigsite package will pull in the source code.
We avoid building the binary version because it takes longer.

### Testing

Run tests with `invoke tests`.
Run with `--slow` to run slow tests too.
Special environment variables:

* `PROGFIGURATION_TEST_VERBOSE=1`: Show verbose output, including stdout/stderr of commands run inside of tests
* `PROGFIGURATION_TEST_DEBUG=1`: Launch a debugger on any test failure or exception
* `PROGFIGURATION_TEST_SLOW_ALL=1`: Run all slow tests (same as `invoke tests --slow`)
* `PROGFIGURATION_TEST_SLOW_PACKAGING=1`: Run just slow tests related to packaging (`progfiguration build`, etc)

## Building the example sites

In the same venv as above:

```sh
# Install the example progfigsite
python3 -m pip install --editable 'tests/data/simple[development]'
# Run the progfigsite itself
progfigsite --help
```

## Making a release

1.  Check out the `master` branch.
    Make sure your checkout is clean, with all changes committed to git and pushed to Github
2.  Set the version in `pyproject.toml` and update `docs/appendix/changelog.rst`.
    Don't commit the change yet.
    We'll read this file to determine the version to tag in git and push to PyPI.
    *   This will require Python 3.11 because we parse the TOML file directly with `tomllib`.
    *   We can't use `progfiguration version` for this because it will return the version as it was at install time.
3.  Run `invoke make-release`

The documentation will be updated with the lastest version number and content as well via Github Actions.
sposong 0.10
Finds similar songs
License: MIT
Keywords: songs


# Finds similar songs

## Tested against Windows 10 / Python 3.10 / Anaconda

## pip install sposong



```python

Args:
	allplaylists (list): A list of Spotify playlist URLs to scrape data from.
	savefolder (str): The folder where the scraped data will be saved as Excel files.
	opera_browser_exe (str): The path to the Opera GX browser executable.
	opera_driver_exe (str): The path to the Opera WebDriver executable.
	userdir (str): The path to the user directory for the Opera browser.

Returns:
	None: The scraped data is saved as Excel files in the specified 'savefolder'.

Example Usage:
	parse_artists(
		allplaylists=[
			'https://open.spotify.com/playlist/3DBZUCUA2w8JcE8mBA0wUB',
			'https://open.spotify.com/playlist/37i9dQZF1DWZLiXDryu4Fe',
			'https://open.spotify.com/playlist/6DSfG4qBWdpaNK9PclUeAI',
			'https://open.spotify.com/playlist/37i9dQZF1DXdSjVZQzv2tl',
			'https://open.spotify.com/playlist/1XhfOTC9d3VwyJrS3EW8iW'
		],
		savefolder="c:\\savedmusic",
		opera_browser_exe=r"C:\Program Files\Opera GX\opera.exe",
		opera_driver_exe=r"C:\ProgramData\anaconda3\envs\dfdir\operadriver.exe",
		userdir="c:\\operabrowserprofile2"
	)

```
llmfast 0.0.2
It's a Python LLM package
License: MIT
Requires Python: >=3.9

# LLMFAST

llmfast is your go-to Python library for simplifying the development of Large Language Model (LLM) applications. With just a few lines of code, you can harness the power of LLMs, saving you time and reducing complexity. Our library offers effortless integration, minimal coding requirements, and full customization to meet your unique needs. It's designed for optimized performance, ensuring smooth application execution, even with extensive language model usage. Explore our comprehensive documentation and examples to kickstart your LLM application development journey with ease. Unlock the potential of LLMs today with llmfast!


### Chatbot

Import the `Chatbot` class: In your Python script, import the `Chatbot` class from `llmfast`. You can do this by adding the following line at the beginning of your code:

```python
from llmfast import Chatbot
```

- Obtain an OpenAI API key: To use the `llmfast` library, you'll need an API key from OpenAI. If you don't have one, sign up on the OpenAI website and obtain an API key.

- Create a `Chatbot` instance: Initialize the Chatbot class with your OpenAI API key and specify the desired role for your chatbot. Here's an example of creating a `Chatbot` instance:

- Replace `"YOUR-OPENAI-API-KEY"` with your actual OpenAI API key, and `"ENTER-YOUR-CHATBOT-ROLE"` with the desired role for your chatbot.

- Deploy the chatbot: Set the `deploy` parameter to `True` when creating the `Chatbot` instance. This will deploy the chatbot and make it available for use.

- To deploy or terminate the deployment of a chatbot created using the `mlfast` library, you can set the `deploy` parameter to `True` or `False` when creating the `Chatbot` instance, respectively.


```python
Chatbot(api_key="YOUR-OPENAI-API-KEY",
        role="ENTER-YOUR-CHATBOT-ROLE",
        deploy=True)
stridessequencefinder 0.10
finds sequences [3, 4, 5] in NumPy arrays [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] - result: [2 7]
License: MIT
Keywords: numpy,numexpr,strides,sequence


# finds sequences [3, 4, 5] in NumPy arrays [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] - result: [2 7]

## Tested against Windows 10 / Python 3.10 / Anaconda

## pip install stridessequencefinder



```python

Find occurrences of a sequence in a 1-dimensional NumPy array using a rolling window approach.

Parameters:
sequence (numpy.ndarray): The sequence to search for.
array (numpy.ndarray): The input array to search within.
numexpr_enabled (bool, optional): Whether to use NumExpr for efficient computation (default is True).

Returns:
numpy.ndarray: An array of indices where the sequence is found in the input array.

Example:
>>> arr = np.array([1, 2, 3, 4, 5, 1, 2, 3, 4, 5])
>>> seq = np.array([3, 4, 5])
>>> indices = find_sequence_in_array(seq, arr)
>>> print(indices)
[2 7]

```
osqur 0.1.0
Quantitative UX Research in Python
License: MIT
Requires Python: >=3.9,<4.0

# Overview
**osqur** (pronounced "Oscar") is a Python module built to facilitate quantitative user experience (UX) research.
It is built on top of pandas 2.0 with `scikit-learn`-like APIs. The package name is an acronym for Open Source Quantiative UX Research.
dkmri-WIN 0.1.3
Reproducible and efficient diffusion kurtosis imaging in Python.
License: MIT

> рџ’Ў Instead of the code in this repository, it is recommended to use the [non-negativity-constrained](https://doi.org/10.1016/j.neuroimage.2019.116405) diffusion kurtosis imaging available in, for example, [DIPY](https://github.com/dipy/dipy).

# `dkmri.py`

`dkmri.py` stands for diffusion kurtosis magnetic resonance imaging in Python. It is a Python package for estimating diffusion and kurtosis tensors from diffusion-weighted magnetic resonance data. The estimation is performed using regularized non-linear optimization informed by a fully-connected feed-forward neural network that is trained to learn the mapping from data to kurtosis metrics. Details can be found in the [arXiv preprint](https://arxiv.org/abs/2203.07327) and [source code](https://github.com/kerkelae/dkmri/blob/main/dkmri/dkmri.py).

This software can be used from the command line or in a Python interpreter.

- The command-line interface does not require any knowledge about Python.
- Python interface is for people comfortable with basic Python programming.

## Installation

First, make sure you have installed [Python](https://www.python.org/downloads/).

If you just want to use the command-line interface, the recommended way of installing `dkmri.py` is to use [pipx](https://github.com/pypa/pipx/#install-pipx):

```
pipx install dkmri
```

pipx automatically creates an isolated environment in which the dependencies are installed.

If you want to use the Python interface, you can use [pip](https://pip.pypa.io/en/stable/) (you should install `dkmri.py` in an isolated environment using [venv](https://docs.python.org/3/library/venv.html) or [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) to avoid dependency issues):

```
pip install dkmri
```

## Usage example

### Command-line interface

The command for using `dkmri.py` is

```
dkmri.py data bvals bvecs optional-arguments
```

where `data`, `bvals`, and `bvecs` are the paths of the files containing the
diffusion-weighted data, b-values, and b-vectors, and `optional-arguments` is
where to define things such as which parameter maps to save.

For example, a command for computing a mean kurtosis map from `data.nii.gz` and
saving it in `mk.nii.gz` could be

```
dkmri.py data.nii.gz bvals.txt bvecs.txt -mask mask.nii.gz -mk mk.nii.gz
```

To see a full description of the arguments, execute the following:

```
dkmri.py -h
```

### Python interface

See the [example notebook](https://github.com/kerkelae/dkmri/blob/main/docs/example.ipynb).

## Support

If you have questions, found bugs, or need help, please open an
[issue on Github](https://github.com/kerkelae/dkmri/issues).

## Citation

If you find this repository useful in work that leads to a scientific publication, please cite the [arXiv preprint](https://arxiv.org/abs/2203.07327).