semvec/pypi-packages huggingface dataset:
arrayloaders 0.0.3
Modlyn.
Requires Python: <3.13,>=3.11

# `arrayloaders`

This package still is in an early version. To use it, see:

- [Training example](https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/UMQFXo0vs0Z6)
- [Benchmark](https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/2C0ghWpz0auc)

## Contributing

Please run `pre-commit install` and `gitmoji -i` on the CLI before starting to work on this repository!
neurogenesis 0.0.1
A simple machine learning library for educational and experimantal purposes.
Requires Python: >=3.0

# 🧠 Neurogenesis

**Python Version:** 3.11.9  
**Status:** ⚠️ Pre-Alpha (Under Active Development)

Neurogenesis is a lightweight, educational machine learning library built from scratch in Python. Its primary aim is to focus on simplicity to aid in learning and to provide a platform for experimentation of unique ideas without having to face complex production-grade codebases of popular libraries which are highly optimized for performance.

> 🚧 **Disclaimer:**  
> Neurogenesis is currently in its early development stages. Expect incomplete features, bugs, and minimal optimization. Restructuring, refactoring, and formal documentation are planned for future releases.

---

## ✅ Algorithms Implemented (v0.0.1)

- K-Nearest Neighbors (KNN)
- Linear Regression
- Logistic Regression
- Naive Bayes
- Support Vector Machine (SVM) – Binary Classification
- Decision Tree
- Random Forest

---

## 📌 Planned for v1.0.0

- KNN  
- Linear Regression  
- Logistic Regression  
- Naive Bayes  
- SVM  
- Decision Tree  
- Random Forest  
- K-Means Clustering  
- AdaBoost  
- Artificial Neural Networks (ANN)  
- Convolutional Neural Networks (CNN)  

---

## 🚀 Installation

Install Neurogenesis via pip:

```bash
pip install neurogenesis
```

## ⚙️ How to use
Here's a basic example using the RandomForest classifier:

```python 
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from neurogenesis.models import RandomForest

data = datasets.load_breast_cancer()
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

clf = RandomForest(n_trees=3)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
acc = accuracy(y_test, y_pred)

print("Accuracy:", np.sum(y_true == y_pred) / len(y_true))

```

🧪 Make sure your data (X_train, y_train, X_test, y_test) is preprocessed and in the correct format (e.g., NumPy arrays).

## 📄 License

This project is licensed under the **GNU General Public License v3.0**.  
You may redistribute, modify, and/or use the code under the terms of this license.

Please see the full license text online:  
🔗 https://www.gnu.org/licenses/gpl-3.0.en.html

> ⚠️ Note: Any derivative works must also be licensed under GPLv3 or a compatible license.

## 🙋‍♂️ Contributing

Contributions, bug reports, and feature requests are welcome!  
If you'd like to improve the library, fix a bug, or suggest a new algorithm, feel free to open an issue or submit a pull request.

📧 mzainkhalidofficial@gmail.com  
🔗 [GitHub Issues](https://github.com/ZainKhalidOfficial/neurogenesis/issues)

Thanks to the open-source community for continuous inspiration and learning!
privattacks 1.4
Privattacks is a Python package for evaluating privacy risks in tabular datasets. It provides tools to quantify re-identification and attribute inference vulnerabilities based on combinations of quasi-identifiers an adversary knows about a target. The package supports both high-level and granular analysis, including per-record vulnerability distributions, multiprocessing for efficiency, and flexible input handling via pandas DataFrames and other sources.
Requires Python: >=3.9

# privattacks
Privattacks is a Python package for evaluating privacy risks in tabular datasets. It provides tools to quantify re-identification and attribute inference vulnerabilities based on combinations of quasi-identifiers an adversary knows about a target. The package supports both high-level and granular analysis, including per-record vulnerability distributions, multiprocessing for efficiency, and flexible input handling via pandas DataFrames and other sources.

## Documentation
The documentation is available at [https://privattacks.readthedocs.io](https://privattacks.readthedocs.io).

## Available tools
- Prior vulnerability for re-identification and attribute inference.
- Posterior vulnerability for a given combination of qids and/or sensitive attribute.
- Posterior vulnerability for a subset of all possible combinations of QIDs.
- Parellel code.
- Generate the histogram of vulnerabilities (i.e., vulnerability per record).

## Installation
You can install via PyPI:
```
pip install privattacks
```

or manuallly by copying this repository to your local machine and running:

```
pip install path/to/privattacks
```

To verify if the package was install corretly, you can run tests:

```
cd path/to/privattacks
python -m unittest discover tests
```

## License

This project is licensed under the **MIT License** – see the [LICENSE](LICENSE) file for details.
oneclick-context 0.2.2
One-Click Context Toolkit - visual file trees + AI summaries
Requires Python: <4.0,>=3.10


---

# One-Click Context Toolkit 🗂️✨

[![CI](https://github.com/lucasfuturist/oneclick-context/actions/workflows/ci.yml/badge.svg)](https://github.com/lucasfuturist/oneclick-context/actions/workflows/ci.yml)

*Visual file trees & inline code commentary for any project — in one command.*

---

## Features

| Flag / Sub-feature | What it does |
| :--- | :--- |
| `--fmt text` (default) | Classic Unicode tree in the terminal |
| `--fmt md` | Collapsible Markdown ready for GitHub / PRs |
| `--fmt json` | Machine-readable nested dict |
| `--fmt html` | Expandable `<ul><li>` list for web/docs |
| `--list-scripts .py .ts` | **Prints full source** of matching files |
| `--depth N` | Limit recursion (default = 3) |
| `--suppress node_modules` | Skip noisy folders (case-insensitive) |

---

## Installation

```bash
# recommended
pipx install oneclick-context

# or plain pip
python -m pip install --upgrade oneclick-context
```Requires Python 3.10+.
`pipx` keeps the tool isolated in its own virtual-env & puts `oneclick` on your PATH.

## Quick start

#### 1. Plain-text tree
```bash
oneclick . --depth 2
``````css
├── src
│   └── oneclick_context
├── tests
│   └── test_cli.py
└── pyproject.toml
```

#### 2. Paste-ready Markdown
```bash
oneclick . --depth 2 --fmt md
``````html
<details><summary>📁 my-project</summary>

├── src
│   └── ...
└── pyproject.toml

</details>
```

#### 3. JSON (pipe to `jq`)
```bash
oneclick . --fmt json | jq .
``````jsonc
{
  "type": "dir",
  "name": "my-project",
  "children": [
    { "type": "file", "name": "pyproject.toml", "children": [] }
  ]
}
```

#### 4. HTML
```bash
oneclick . --fmt html > tree.html && start tree.html
```

#### 5. Print out all scripts
```bash
oneclick . --list-scripts .py .ts .yaml > SCRIPTS.md
```
Combine with `depth` / `suppress` flags:
```bash
oneclick . --depth 3 --suppress node_modules dist .git \
          --list-scripts .py .sh
```

## Why?
*   **LLM context compression** — shrink 50 KLOC into a 1-page digest for ChatGPT, Claude, etc.
*   **Lightning-fast code reviews** — drop the Markdown tree in a PR comment.
*   **Docs & onboarding** — generate an instant project map for new teammates.

## Roadmap
- [ ] GPT-powered file summaries (`--summarise`)
- [ ] VS Code extension panel
- [ ] SVG / Graphviz exporter

## Contributing
PRs and issues welcome!
```bash
poetry install
poetry run pytest -q
```
cfgone 0.1.0
Load you config with one line of code
Requires Python: >=3.7


# 🛠️ Cfgone

Minimal Python package that loads your config in one line of code.

## 📦 Installation

```bash
pip install cfgone
```

## ⚡ Quick Start

Create a `config.yaml` file in your current directory:

```yaml
app:
  name: "MyApp"
  port: 8080
  debug: true

database:
  host: "localhost"
  port: 5432
```

Use it in your code:

```python
import cfgone as cfg

print(f"Starting {cfg.app.name} on port {cfg.app.port}")

# Output: Starting MyApp on port 8080
```

## 🧬 Config Inheritance

Split your config into multiple files:

**`base.yaml`**

```yaml
app:
  name: "BaseApp"
  debug: false

database:
  host: "localhost"
```

**`config.yaml`**

```yaml
extends:
  - "base.yaml"

app:
  name: "MyApp"  # overrides base
  port: 8080     # adds new setting

database:
  port: 5432     # merges with base
```

Access your merged config:

```python
import cfgone as cfg

print(cfg.app.name)      # "MyApp"
print(cfg.database.host) # "localhost" (from base.yaml)
```
myocardial-mesh 0.1.1
Ventricular myocardial mesh construction for ECG and FIM simulation
Requires Python: >=3.8
Keywords: mesh, myocardial, ECG, FIM, vtk, pyvista, simulation, biomedical

# purkinje-learning-myocardial-mesh

A Python library for modeling, manipulating, and analyzing Purkinje fiber networks embedded in myocardial meshes — useful in computational cardiology, electrophysiology modeling, and bioengineering research.

---

## Features

- Parse and manipulate myocardial mesh data  
- Integrate Purkinje network geometries  
- Designed for computational simulation environments  
- Structured for maintainability and versioned releases  
- Automated testing with `pytest` and CI-friendly config  

---

## Installation

```bash
pip install myocardial-mesh
```

For development:

```bash
pip install -e ".[dev]"
```

Dependencies and development requirements are managed via `pyproject.toml`.

---

## Usage

Here’s a basic example (assumes functional API in `myocardial_mesh` or similar module):

```python
from myocardial_mesh import load_mesh, attach_purkinje_network

mesh = load_mesh("data/mesh.vtk")
network = attach_purkinje_network(mesh)
network.simulate()
```

---

## Versioning & Release

This project uses `release-please` to automate versioning and changelog generation.  
Follow [Conventional Commits](https://www.conventionalcommits.org/) to trigger releases.

Example commit:

```csharp
feat: add new Purkinje-mesh attachment algorithm
```

---

## License

This project is licensed under the terms of the MIT license.
spinopt 24.7.2
Scipy interface to NLOPT
Keywords: Optimization

# SpiNopt: a Scipy optimization interface to NLOPT

For optimization, everyone starts out with the [Scipy optimization library](https://docs.scipy.org/doc/scipy/tutorial/optimize.html), but, at some point, you might want to try something else.
[NLOPT](https://nlopt.readthedocs.io/en/latest/) is a great library, but can be quite a hassle rewrite your code to use it.

This package provides a Scipy interface to the NLOPT optimization library. It's aim is not to provide a complete ecosystem which different solvers are available, but merely a way to quickly connect the NLOPT solvers, once you already have something set up with Scipy, or are familiar with how to set something up with Scipy.

## Basic example

```python
import numpy as np
from spinopt import NLOptimizer

dim = 3

# Define objective in this way
def my_easy_func(x, grad):
    if grad.size > 0:
        grad[:] = 2 * (x - np.arange(len(x)))
    x = x - np.arange(len(x))
    return x.dot(x)

# Define constraints Scipy style
A = np.ones((1, dim))
b = np.ones((1, 1))
constraints = [{"type": "eq", "jac": lambda w: A, "fun": lambda w: A.dot(w) - b.squeeze()}]

# Initialize optimizer
x0=np.zeros(dim)
opt = NLOptimizer(my_easy_func, x0, constraints=constraints)

# Optimize
res = opt.minimize()
assert res.success
assert np.allclose(res.x, np.arange(dim), atol=1e-5)
```

## Installation

To install from PyPI:

```bash
pip install spinopt
```

To install the latest development version from github:

```bash
pip install git+https://github.com/mvds314/spinopt.git
```

## Development

For development purposes, clone the repo:

```bash
git clone https://github.com/mvds314/spinopt.git
```

Then navigate to the folder containing `setup.py` and run

```bash
pip install -e .
```

to install the package in edit mode.

Run unittests with `pytest`.

## Related software

- [Scipy optimize](https://docs.scipy.org/doc/scipy/tutorial/optimize.html)
- [NLOPT](https://nlopt.readthedocs.io/en/latest/)
py-shr-parser 1.0.0
Python library for parsing Signal Hound SHR files
Requires Python: >=3.8
Keywords: SHR, Signal Hound

===========================
py-shr-parser
===========================

Overview
--------

Provides tools for parsing and handling Signal Hound spectrum sweep and capture
(SHR) files. These files are generated by Spike, Signal Hound's Spectrum Analyzer
Software, and contain metadata and several spectrum sweeps.

BSD-3 license, (C) 2025 WiSELab-CMU

Documentation
-------------
For API documentation, usage and examples, see the files in the "Documentation" directory. 
The ".rst" files can be read in any text editor or being converted to HTML or PDF
using Sphinx_. Examples can be found in the documentation and tests.

.. _Sphinx: https://www.sphinx-doc.org/en/master/

Installation
------------

.. code-block:: none

    pip install py-shr-parser

Basic Example
-------------
This shows how to open an SHR file and load all the sweep data.

.. code-block:: python

    from shr_parser import ShrFileParser
    with ShrFileParser("foo.shr") as parser:
        sweeps = parser.get_all_sweeps()

The above example is very basic. For more advanced examples, please refer to the Documentation.
essentia-tensorflow 2.1b6.dev1389
Library for audio and music analysis, description and synthesis, with TensorFlow support
Keywords: audio music sound dsp MIR


Essentia is an open-source C++ library with Python bindings for audio analysis and audio-based music information retrieval. It contains an extensive collection of algorithms, including audio input/output functionality, standard digital signal processing blocks, statistical characterization of data, a large variety of spectral, temporal, tonal, and high-level music descriptors, and tools for inference with deep learning models. Designed with a focus on optimization in terms of robustness, computational speed, low memory usage, as well as flexibility, it is efficient for many industrial applications and allows fast prototyping and setting up research experiments very rapidly.

Website: https://essentia.upf.edu