semvec/pypi-packages huggingface dataset:
bids-qc 0.1.0
A package to view Nifti files in a BIDS dataset and generate QC plots.
Requires Python: >=3.10

# CPAC-QC Plotting App

![CPAC-QC](static/cpac-qc.png)

## Overview

The CPAC-qc Plotting App is a tool designed to generate quality control plots for the CPAC (Configurable Pipeline for the Analysis of Connectomes) outputs. This app helps in visualizing and assessing the quality of neuroimaging data processed through CPAC.

## Features

- Generate bulk or subject specific plots

## Requirements
- A html viewing tool or extension
- BIDS dir with `.nii.gz` images in it.

## Installation
```bash
pip install bids_qc
```

## Usage
```bash
bids_qc -d path/to/bids_dir -o path/to/output-qc-dir -n number-of-procs
```
altrustworthyai 0.7.1
ALT-AI provides a suite of tools for the explanation, visualization, and understanding of complex machine learning models.


The AffectLog’s Trustworthy AI (ALT-AI) provides a suite of tools for the explanation, visualization, and understanding of complex machine learning models. It acts as a bridge between raw model output and actionable insights, making it easier for data scientists and stakeholders to interpret model predictions, understand feature importance, and evaluate model fairness and performance across different segments.

https://github.com/AffectLog360/altrustworthyai
rajniwebdeveloper 0.1.2
All tools From Rajni web developer
Requires Python: >=3.7

# rajniwebdeveloper/rajniwebdeveloper/README.md

# Rajni Web Developer

## Overview

The Rajni Web Developer project is designed to extract case details and current status from a web table. It utilizes web scraping techniques to gather information and presents it in a structured JSON format.

## Installation

To use this project, ensure you have Python installed on your machine. You can clone the repository and install the required dependencies using pip.

```bash
git clone <repository-url>
cd rajniwebdeveloper
pip install -r requirements.txt
```

## Usage

To run the application, navigate to the `court_challan` directory and execute the `app2.py` script. The script will extract the relevant data from the specified web table and print it in JSON format.

```bash
cd court_challan
python app2.py
```

## License

This project is licensed under the MIT License. See the LICENSE file for more details.
sdx-topology-validator 1.1.8
Validates the converted topology against the given OpenAPI specifications

# sdx_topology_validator

## Introduction

This Validates the topology against the given OpenAPI specification.   

## Installation Steps

pip install sdx-topology-validator  

This installs the module "sdx-topology-validator".  

### Prerequisites

All the Prerequisite pip modules like PyYAML, jsonschema, jsonref will be automatically installed when you run the above command "pip install sdx-topology-validator".  

## Usage

The module "sdx-topology-validator" consists of functions 'load_openapi_schema', 'resolve_references', 'get_validator_schema', 'validate'.  

Import 'validate' function from the module "sdx-topology-validator".  

The function named 'load_openapi_schema' that takes a single parameter 'file_path', which is the yaml_spec_file(validator.yaml) which consists of OpenAPI specification and returns 'openapi_spec' the loaded YAML content as a dictionary.  

The function named 'resolve_references' that takes a single parameter 'openapi_spec', resolves any JSON references in the OpenAPI specification, ensuring that all $ref fields are fully expanded.  

The function named 'get_validator_schema' that takes a single parameter, which is the value returned by the function 'resolve_references'.   This function extracts and returns the JSON schema used for validating the request body of the /validator endpoint from the OpenAPI specification.  

The function named 'validate' that take one parameter: data.  
The first parameter 'data' takes json data as input and validates the given data against the provided JSON schema and returns the result of the validation.     

Note: 'validator.yaml' the yaml_spec_file is packaged with 'sdx-topology-validator' module, so no need of having it from the user side.  

Example of usage:    
from sdx_topology_validator import validate      
validation_result = validate(data)
gscrew 1.1.0
A Python module to manipulate generalized Screws and Coscrews in Geometric Algebra (real Clifford algebra).
Requires Python: >=3.7

# GScrew (Generalized Screw Calculus)
[![Documentation Status](https://readthedocs.org/projects/gscrew/badge/?version=latest)](https://gscrew.readthedocs.io/en/latest/?badge=latest)
[![Licence](https://img.shields.io/github/license/GenScrew/GScrew?color=green)](https://github.com/GenScrew/GScrew/blob/master/LICENSE)
[![Build Status](https://github.com/GenScrew/GScrew/actions/workflows/python-publish.yml/badge.svg)](https://github.com/GenScrew/GScrew/blob/master/.github/workflows/python-publish.yml)

## Description
A Python module to manipulate generalized Screws and Coscrews with geometric algebras (real Clifford algebras).

- [readthedocs Documentation](https://gscrew.readthedocs.io/en/latest/)
- [Bug tracker](https://github.com/GenScrew/GScrew/issues)

## Installation
A Pypi package is available, please refer to the [Pypi page](https://pypi.org/project/GScrew/) or enter `pip install gscrew` in a terminal.

## Exemples
First of all, you need to import the modules:
```
import gscrew
from gscrew.geometric_algebra import GeometricAlgebra
from gscrew.screw import Screw
```
The `screw` module also provides a `CoScrew` object and the `comoment` function for calculating the comoment between a coscrew and a screw.

Once these modules have been imported, we can create the geometric algebra in which we will be working. For basic physical applications, a three-dimensionnal algebra should suffice:
```
my_algebra = GeometricAlgebra(3)
locals().update(my_algebra.blades)
```
The second line adds the basis blades to the local variables so that we will be able to create new multivectors just by performing linear combinations of these basis blades. For a 3D algebra, the basis blades are: s, e1, e2, e3, e12, e13, e32, e123.

We can now start working with Screw and CoScrew classes:
```
O = 0 * s  # the origin of the reference frame
S = 1 + (2*e2) + (3*e3)  # the resultant of the screw
M = (e1) + (5*e3)        # the moment of the screw
my_screw = Screw(O, S, M)
```

## Licence
All the code is provided under the GNU General Public Licence v3.0+ (GPLv3+)
keggtools 1.1.0
Enrichment analysis and visualisation toolkit for KEGG pathways
Requires Python: >=3.10

# keggtools

[![Version](https://img.shields.io/pypi/v/keggtools)](https://pypi.org/project/keggtools/)
[![codecov](https://codecov.io/gh/harryhaller001/keggtools/graph/badge.svg?token=3VBDIALBLK)](https://codecov.io/gh/harryhaller001/keggtools)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/keggtools)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/harryhaller001/keggtools/testing.yml)
[![DOI](https://zenodo.org/badge/304011676.svg)](https://doi.org/10.5281/zenodo.14808443)

Library for KEGG pathway enrichment analysis.

Documentation: [https://keggtools.org/](https://keggtools.org/)

PyPi: [https://pypi.org/project/keggtools/](https://pypi.org/project/keggtools/)


## Installation

`keggtools` only supports `python>=3.10`.

Dependencies

* `graphviz`

`python` dependencies

* `requests`
* `pydot`
* `scipy`


Installation `keggtools` package using `pip`:

```bash
python3 -m pip install keggtools
```

To get a more detailed list of install options, please read the `INSTALL.md`

## API

### Download and Parsing


```python
from keggtools import Resolver, IMMUNE_SYSTEM_PATHWAYS

ORGANISM_ID = "hsa"
resolver = Resolver()

# Select first immune system pathway as example
pathway_id = list(IMMUNE_SYSTEM_PATHWAYS.keys())[1]

# Resolve pathway
pathway = resolver.get_pathway(organism=ORGANISM_ID, code=pathway_id)
print(pathway)
```


### Enrichment and Testing

```python
from keggtools import Enrichment

# Add pathway object to list
pathway_list = []

# Init analysis with organism code
analysis = Enrichment(pathways=pathway_list)

# Study genes as list of entrez gene id's
study_genes = []
analysis.run_analysis(gene_list=study_genes)

# to_dataframe method requires pandas installation
result = analysis.to_dataframe()
print(result.head())
```

### Rendering

```python
from keggtools.render import Renderer

# Load and parse pathway
renderer = Renderer(kegg_pathway=pathway)

# Render to dot graph
renderer.render()

# Export to png
renderer.to_file("output.png", extension="png")
```

## Development

### Dev installation

Fast install with `virtualenv` for development.

```bash
python3 -m virtualenv venv
source ./venv/bin/activate
pip install --upgrade pip

# Install from requirements
pip install -r requirements.txt

# Or use makefile
make install
```



### Linting

`ruff` is used for linting and formatting.

```bash
# Run formatter
make format
```

### Static code analysis

Static code analysis using `mypy`.

```bash
# Run static code analysis
make typing
```

### Testing

Run unittest for `keggtools` package. This uses `pytest` and `coverage`.

```bash
# Run unittest for package
make testing
```

### Install package from repo

The package is using the `flit` backend with a `pyproject.toml` and `twine`. To install from repo use

```bash
# Install package from repo
make build
```


### License

MIT
simple-build 0.0.3
A simple build-backend for Python.
Requires Python: >=3.11

# simple-build

A simple build-backend for Python.

The package implements the build backend interface,
defined in <https://peps.python.org/pep-0517>,
and <https://peps.python.org/pep-0660>.

It is very similar to [flit](https://flit.readthedocs.io/) and [hatch](https://hatch.pypa.io/latest/config/build/#build-system),
but it has one key additional feature I required: [pre-write hooks](#pre-write-hooks).
This is bit similar to [hatch's build hook](https://hatch.pypa.io/latest/plugins/build-hook/reference/#hatchling.builders.hooks.plugin.interface.BuildHookInterface),
but offers a lot more freedom to modify the packaged files.

## Usage

Simply add the following to your `pyproject.toml`:

```toml
[build-system]
requires = ["simple-build"]
build-backend = "simple_build.backend"
```

## Features

### modules in `src` folder

The module will be found by the project name (normalising `-` to `_`),
and supports packages in the common `src` folder layout, or at the root of the package.

```toml
[project]
name = "my-project"
```

```plaintext
pyproject.toml
src/
    my_project/
        __init__.py
```

### Dynamic project metadata

The following fields can be set as dynamic values:

```toml
[project]
dynamic = ["version", "description", "authors"]
```

The values are then read from the root file of the package (`__init__.py` or the single module file):

```python
"""My project description."""
__version__ = "0.1.0"
__author__ = "John Doe"
__email__ = "johndoe@email.com"
```

### Git integration

By default the packaging will respect the `.gitignore` file, and exclude all files listed in it.

You can also configure this in the `pyproject.toml`:

```toml
[tool.build.sdist]
use_git = true
include = ["my_file.txt", ...]
exclude = ["my_file.txt", ...]
```

### pre-write hooks

In your `pyproject.toml` you can define a list of hooks that can modify the files before they are written to the sdist or wheel:

```toml
[tool.build]
pre_write_hooks = ["my_hook.py"]
```

A hook file should contain a function with the following signature:

```python
from pathlib import Path
from typing import Literal
from simple_build.analyse import PackageAnalysis

def pre_write_hook(
    type: Literal["sdist", "wheel"], src: Path, module: str | None, analysis: PackageAnalysis
) -> None:
    """A pre-write hook, to modify files before writing them to the sdist or wheel.

    :param path: The path to the temporary folder containing the files that will be written to the sdist/wheel.
        This can be modified in place, including deleting files and adding new ones.
    :param module: The name of the module.
    :param package: The package analysis.
    """
```
closest 0.2.0
Nearest neighbors implementation written in rust.
Requires Python: >=3.8

# closest

## Installation

For rust add the following to your `Cargo.toml`
```toml
closest = "0.1.0"
```

For python.

```shell
pip install closest
```

## Example

A simple nearest neighbors implementation written in rust.

A rust example, this same example can be run with the following command.
```sh
cargo run --example colors
```

```rust
use std::error::Error;

use closest::{Data, KDTree, Point, SquaredEuclideanDistance};

fn main() -> Result<(), Box<dyn Error>> {
    // RGB color coordinates
    let colors = vec![
        Data::new("blue", vec![0., 0., 255.]),
        Data::new("red", vec![255., 0., 0.]),
        Data::new("navy", vec![17., 4., 89.]),
        Data::new("purple", vec![171., 3., 255.]),
        Data::new("light-blue", vec![61., 118., 224.]),
        Data::new("pink", vec![255., 3., 213.]),
        Data::new("yellow", vec![255., 234., 0.]),
        Data::new("green", vec![16., 145., 25.]),
        Data::new("orange", vec![255., 106., 0.]),
    ];
    // Construct the tree from the vector of data points.
    let tree = KDTree::from_vec(colors, 1).unwrap();
    let point = Point::new(vec![237., 139., 69.]); // Light Orange
    let closest_colors =
        tree.get_nearest_neighbors(&point, 2, &SquaredEuclideanDistance::default());
    println!("The nearest colors to light orange.");
    for color in closest_colors {
        println!("color: {}, squared euclidean distance: {}", color.data, color.distance);
    }
    Ok(())
}

// The nearest colors to light orange.
// color: yellow, squared euclidean distance: 14110
// color: orange, squared euclidean distance: 6174
```

And the equivalent python example.

```python
from closest import KDTree

colors = [
        ("blue", [0., 0., 255.]),
        ("red", [255., 0., 0.]),
        ("navy", [17., 4., 89.]),
        ("purple", [171., 3., 255.]),
        ("light-blue", [61., 118., 224.]),
        ("pink", [255., 3., 213.]),
        ("yellow", [255., 234., 0.]),
        ("green", [16., 145., 25.]),
        ("orange", [255., 106., 0.]),
    ];
tree = KDTree(colors)
light_orange = [237., 139., 69.]
print(tree.get_nearest_neighbors(light_orange, 2))
#> [(14110.0, 'yellow'), (6174.0, 'orange')]
```