semvec/pypi-packages huggingface dataset:
Geminis 0.1.49
AI-powered Python fuzzer using Gemini and Atheris to automatically generate and execute fuzzing harnesses.
Requires Python: >=3.11


## Geminis:
This project creates a LLM-assisted Python fuzzing harness generator designed to leverage large language models like Gemini to automatically build fuzzing harnesses for target Python functions. It uses Google’s Atheris fuzzing engine to dynamically generate and test code, with the aim of uncovering bugs or vulnerabilities in software.

# Usage:
  geminis \
    --src-dir /path/to/code  
    --output-dir /path/to/logs   
    --prompts-path /path/to/prompts.yaml   
    --api-key /path/to/api.txt  
    --prompt prompt-id (base if using given yaml prompts)  
    --mode functions(classes)  
    --debug Outputs detailed debug statements  
    --smell Uses optional radon code smell using the maintainability index  

# Workflow:
  1. Load API key (enviorment variable, file, raw string), verify model.
  2. Discover .py files; parse target snippets.
  3. (Optional) Filter by maintainability index by radon.
  4. Build prompt with Atheris docs + code; send to Gemini.
sorunlib 0.1.32
OCS Control Programs for running the observatory.
Requires Python: >=3.10

========
sorunlib
========

| |pypi| |versions| |license|
| |tests| |pre-commit| |coverage| |docs|

Overview
--------

A high level library for running observatory operations. `sorunlib` handles
connecting to and controlling multiple OCS Agents, sending the appropriate
commands for orchestrating observations for a single telescope platform.

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

Install and update using pip::

    $ pip install -U sorunlib

Install optional dependencies with::

    $ pip install -U sorunlib[dev]
    $ pip install -U sorunlib[docs]
    $ pip install -U sorunlib[dev,docs]

Documentation
-------------

The sorunlib documentation can be built using Sphinx. Be sure to install the
optional "docs" dependencies when installing above. Then run::

  $ cd docs/
  $ make html

You can then open ``docs/_build/html/index.html`` in your preferred web
browser. You can also find a copy hosted on `Read the Docs`_.

.. _Read the Docs: https://sorunlib.readthedocs.io/en/latest/

Tests
-----

The tests can be run using pytest, and should be run from the ``tests/``
directory::

    $ cd tests/
    $ python3 -m pytest

Contributing
------------

For guidelines on how to contribute to sorunlib see `CONTRIBUTING.rst`_.

.. _CONTRIBUTING.rst: https://github.com/simonsobs/sorunlib/blob/main/CONTRIBUTING.rst

License
-------

This project is licensed under the BSD 2-Clause License - see the
`LICENSE.txt`_ file for details.

.. _LICENSE.txt: https://github.com/simonsobs/sorunlib/blob/main/LICENSE.txt


.. |coverage| image:: https://codecov.io/github/simonsobs/sorunlib/graph/badge.svg?token=701SYU7A4I
    :target: https://codecov.io/github/simonsobs/sorunlib

.. |docs| image:: https://readthedocs.org/projects/sorunlib/badge/?version=latest
    :target: https://sorunlib.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. |license| image:: https://img.shields.io/pypi/l/sorunlib
   :target: LICENSE.txt
   :alt: PyPI - License

.. |pre-commit| image:: https://results.pre-commit.ci/badge/github/simonsobs/sorunlib/main.svg
   :target: https://results.pre-commit.ci/latest/github/simonsobs/sorunlib/main
   :alt: pre-commit.ci status

.. |pypi| image:: https://img.shields.io/pypi/v/sorunlib
   :target: https://pypi.org/project/sorunlib/
   :alt: PyPI - Version

.. |tests| image:: https://github.com/simonsobs/sorunlib/actions/workflows/pytest.yml/badge.svg
    :target: https://github.com/simonsobs/sorunlib/actions/workflows/pytest.yml
    :alt: GitHub Actions Workflow Status

.. |versions| image:: https://img.shields.io/pypi/pyversions/sorunlib
   :alt: PyPI - Python Version
behaverse-data-loader 0.0.9.dev5
Behaverse package.
Requires Python: >=3.10

# Behaverse Data Loader

`behaverse-data-loader` is a Python package to seamlessly access [BDM](https://behaverse.org/data-model)-formatted behavioral datasets.

## Installation

To install the package, run:

```bash
pip install -U behaverse-data-loader
```

## Usage

See [behaverse.org/data-loader](https://behaverse.org/data-loader) for more information on how to use the package.

## License

TODO

## Contributing


### Development

Before starting development, you need [`uv`](https://github.com/astral-sh/uv) to install the dependencies:


```bash
uv sync
source .venv/bin/activate
```

### Documentations

To generate documentations, run the following commands from the project root directory:

```bash
cd docs
quartodoc build && quartodoc interlinks && quarto preview
```

The documentations will be available in the `docs/_site/` directory.



## Acknowledgements

TODO

## Citation

TODO
elphmod 0.32
Python modules for electron-phonon models
Requires Python: >=3.5

# Python modules for electron-phonon models

elphmod is a collection of Python modules to handle coupled tight-binding and
mass-spring models derived from first principles. It provides interfaces with
popular simulation software such as Quantum ESPRESSO, Wannier90, EPW, RESPACK,
and i-PI. It helps calculate dispersions, spectra, and response functions and
can be used to build and study distorted structures on supercells.

* `el` - tight-binding models from Wannier90
* `ph` - mass-spring models from Quantum ESPRESSO
* `elph` - electron-phonon coupling from EPW
* `elel` - Coulomb interaction from RESPACK
* `MPI` - work distribution and shared memory
* `bravais` - lattices, symmetries, and interpolation
* `dispersion` - diagonalization on paths and meshes
* `dos` - 2D tetrahedron methods
* `diagrams` - susceptibilities, self-energies, etc.
* `occupations` - step and delta smearing functions
* `md` - charge-density-wave dynamics using i-PI
* `eliashberg` - parameters for McMillan's formula
* `plot` - BZ plots, fatbands, etc.
* `misc` - constants, status bars, parsing, etc.
* `models` - nearest-neighbor models for testing

## Installation

You can install the latest version of elphmod from PyPI:

    python3 -m pip install elphmod

Or from the conda-forge channel on Anaconda Cloud:

    conda install conda-forge::elphmod

elphmod can optionally be run in parallel via MPI (with shared-memory support).
Using APT and pip, you can install the corresponding dependencies as follows:

    sudo apt install libopenmpi-dev
    python3 -m pip install mpi4py --no-binary=mpi4py

You can also download the complete repository, perform an editable installation,
and install the requirements of examples and documentation:

    git clone https://github.com/janberges/elphmod
    python3 -m pip install -e elphmod
    python3 -m pip install -r elphmod/examples/requirements.txt
    python3 -m pip install -r elphmod/doc/requirements.txt

## Documentation

The documentation can be found at <https://io.janberges.de/elphmod>.

Please also have a look at the examples directory.

## Reference

elphmod is stored on Zenodo: <https://doi.org/10.5281/zenodo.5919991>.

## Licence

This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program. If not, see <https://www.gnu.org/licenses/>.

Copyright (C) 2017-2025 elphmod Developers
nucleai 0.0.1
AI support for fusion experiments - feature extraction, embeddings, and natural language data analysis
Requires Python: >=3.12

# nucleai

**AI Support for Fusion Experiments**

`nucleai` is a codegen-first library designed to empower fusion research with advanced AI capabilities. It provides a comprehensive workflow for extracting features from fusion data, generating rich descriptions, and creating vector embeddings for both feature images and text.

## Key Features

- **Natural Language Interface**: Ask questions about data and test hypotheses using natural language.
- **Data Search & Retrieval**: Advanced search capabilities using text and feature shapes.
- **Analysis & Display**: Automated analysis and visualization of experimental data.
- **Feature Extraction**: Automated extraction of significant features from experimental fusion data.
- **Vector Embeddings**: Generation of embeddings for feature images and text descriptions to enable semantic understanding.
- **Codegen-First Design**: Built to be driven by AI agents and code generation tools, allowing users to request complex, novel plots and processing pipelines on demand.

## Getting Started

(Instructions for installation and usage will be added here)
dissect.ntfs 3.16.dev1
A Dissect module implementing a parser for the NTFS file system, used by the Windows operating system
Requires Python: >=3.10

# dissect.ntfs

A Dissect module implementing a parser for the NTFS file system, used by the Windows operating system. For more
information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/dissect.ntfs/index.html).

## Requirements

This project is part of the Dissect framework and requires Python.

Information on the supported Python versions can be found in the Getting Started section of [the documentation](https://docs.dissect.tools/en/latest/index.html#getting-started).

## Installation

`dissect.ntfs` is available on [PyPI](https://pypi.org/project/dissect.ntfs/).

```bash
pip install dissect.ntfs
```

This module is also automatically installed if you install the `dissect` package.

## Build and test instructions

This project uses `tox` to build source and wheel distributions. Run the following command from the root folder to build
these:

```bash
tox -e build
```

The build artifacts can be found in the `dist/` directory.

`tox` is also used to run linting and unit tests in a self-contained environment. To run both linting and unit tests
using the default installed Python version, run:

```bash
tox
```

For a more elaborate explanation on how to build and test the project, please see [the
documentation](https://docs.dissect.tools/en/latest/contributing/tooling.html).

## Contributing

The Dissect project encourages any contribution to the codebase. To make your contribution fit into the project, please
refer to [the development guide](https://docs.dissect.tools/en/latest/contributing/developing.html).

## Copyright and license

Dissect is released as open source by Fox-IT (<https://www.fox-it.com>) part of NCC Group Plc
(<https://www.nccgroup.com>).

Developed by the Dissect Team (<dissect@fox-it.com>) and made available at <https://github.com/fox-it/dissect>.

License terms: AGPL3 (<https://www.gnu.org/licenses/agpl-3.0.html>). For more information, see the LICENSE file.
depzip 0.8
A small library for zipping Python application dependencies
Requires Python: <3.15,>=3.14

The `depzip` library can be used for zipping dependencies of Python applications.

This library uses the [sys.modules](https://docs.python.org/3.14/library/sys.html#sys.modules) dictionary to discover dependencies and the [ctypes.util.dllist](https://docs.python.org/3.14/library/ctypes.html#ctypes.util.dllist) function to discover DLLs loaded by dependencies.

## Installation

This library can be installed using `pip`:
```
python -m pip install depzip
```

## Usage

Here is a Python script showing how to use `depzip` to copy the dependencies of a Python application using `matplotlib`, `numpy`, and `PySide6` into a file called `bundle.zip`:
```
import depzip

depzip.bundle(
    applications=[
        "app",
        "pyside6-uic",
    ],
    modules=[
        "app",
        "PySide6.QtUiTools",
    ],
    includes=[
        "Lib\\site-packages\\matplotlib\\mpl-data",
        "Lib\\site-packages\\numpy.libs",
        "Lib\\site-packages\\pyside6-uic",
        "Lib\\site-packages\\PySide6\\plugins\\platforms\\qwindows.dll",
        "Lib\\site-packages\\PySide6\\plugins\\styles\\qmodernwindowsstyle.dll",
        "Lib\\site-packages\\PySide6\\uic.exe",
    ],
    excludes=[
        "python.exe",
        "pythonw.exe",
    ],
    output="bundle.zip",
)
```

The source code of this script can be found in [examples/bundle.py](https://github.com/pavel-demin/depzip/tree/main/examples/bundle.py).

The provided executable file `run.exe` can be used to run a Python application. It initializes Python and runs a module with the same name as the executable file. For example, to run a Python module named `app`, the executable file `run.exe` should be renamed to `app.exe`.

The source code of the executable file `run.exe` can be found in [examples/run.c](https://github.com/pavel-demin/depzip/tree/main/examples/run.c).

The `applications` parameter is a list of application names that is used to automatically copy `run.exe` to executable files with names in this list.

The `modules` parameter is a list of Python modules used by the applications. These modules are copied to the output file along with all their dependencies.

The `includes` parameter is a list of additional files and directories to be copied to the output file.

The `excludes` parameter is a list of files that should not be copied to the output file.

The `output` parameter is the name of the output file.
piculet 2.0
XML/HTML scraper using XPath queries.
Requires Python: ~=3.10
Keywords: html, xml, json, xpath, jmespath, scrape

Piculet
=======

Piculet is a module for extracting data from HTML/XML and JSON documents.
The queries are written in XPath for HTML/XML, and in JMESPath for JSON.

The documentation is available on: https://piculet.readthedocs.io/

The source code can be obtained from: https://github.com/uyar/piculet

License
-------

Copyright (C) 2014-2025 H. Turgut Uyar <uyar@tekir.org>

Piculet is released under the LGPL license, version 3 or later.
Read the included `LICENSE.txt`_ file for details.

.. _LICENSE.txt: https://github.com/uyar/piculet/blob/master/LICENSE.txt
ingeniamotion 0.10.1
Motion library for Novanta servo drives
Requires Python: >=3.9

Ingeniamotion
=============

![GitHub branch status](https://img.shields.io/github/checks-status/ingeniamc/ingeniamotion/master?label=Tests)
[![PyPi](https://img.shields.io/pypi/v/ingeniamotion.svg)](https://pypi.python.org/pypi/ingeniamotion)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ingeniamotion?color=2334D058)

[![CC by-nc-sa](https://img.shields.io/badge/License-CC%20BY--NC--ND%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-nc-nd/4.0/)

Ingeniamotion is a library that works over ingenialink and aims to simplify the interaction with Ingenia's drives.

[![Ingenia Servodrives](https://github.com/ingeniamc/ingenialink-python/blob/master/docs/_static/images/main_image.png?raw=true)](http://www.ingeniamc.com)

Requirements
------------

* Python 3.9 or higher
* [WinPcap](https://www.winpcap.org/install/) 4.1.3

Installation
------------

The recommended way to install is by using pip, i.e:
```bash
pip install ingeniamotion
```

Virtual environment management with Poetry
------------------------------------------

Install poetry:
```bash
pip install poetry
```

Use an environment with a certain Python version:
```bash
poetry env use 3.12
```

Install the required dependencies:
```bash
poetry install --all-groups
```

To install *FSoE* (optional):
```bash
poetry install --extras fsoe
```


Generate documentation
----------------------

To produce the documentation, run the following command:
```bash
poetry run poe docs
```

Run PyTest
----------

Create *tests/setups/tests_setup.py* file with configuration file.

This file is ignored by git and won't be uploaded to the repository.
Example of a setup:

```python
from pathlib import Path

from summit_testing_framework.setups import LocalDriveConfigSpecifier

DEN_NET_E_SETUP = LocalDriveConfigSpecifier.from_ethercat_configuration(
    identifier="den-net-e",
    dictionary=Path("C://Users//some.user//Downloads//den-net-e_eoe_2.7.3.xdf"),
    config_file=Path("C://Users//some.user//Downloads//den_net_e.xcf"),
    firmware=Path("C://Users//some.user//Downloads//den-net-e_2.7.3.lfu"),
    ifname="\\Device\\NPF_{675921D7-B64A-4997-9211-D18E2A6DC96A}",
    slave=1,
    boot_in_app=False,
)

TESTS_SETUP = DEN_NET_E_SETUP
```

For more information, check `summit-testing-framework` documentation.

Run tests selecting the markers that you want and are appropriate for your setup.
Beware that some tests may not be appropriate for the setup that you have and may fail.

```bash
poetry run poe tests -m {markers}
```
cmpparis-parser 0.1.2
A lightweight BOD parsing library for CMP
Requires Python: >=3.7

# CMP Paris Parser (Light)

Une bibliothèque légère et optimisée pour le parsing de documents BOD (Business Object Documents) Infor M3.

Cette version est une extraction de la librairie principale `cmpparis`, conçue pour être utilisée dans des environnements contraints comme **AWS Lambda**.

## Fonctionnalités

*   **Parsing XML vers CSV** : Transforme les flux XML complexes en structures plates.
*   **Configuration Flexible** : Utilise des fichiers YAML/JSON pour définir les mappings XPath.
*   **Transformers** : +40 fonctions de transformation de données (dates, nombres, chaînes).
*   **Zéro Dépendance Lourde** : Ne dépend que de `pyyaml`. Pas de pandas, boto3, ou drivers DB.

## Installation

```bash
pip install cmpparis-parser
```

## Utilisation Rapide

```python
from cmpparis_parser import BODParser, BODConfigLoader

# 1. Charger la configuration
config = BODConfigLoader.from_yaml("config.yaml")

# 2. Parser le contenu XML
parser = BODParser()
csv_output = parser.parse_and_convert(xml_content, config)

# 3. Utiliser le CSV
print(csv_output)
```

## Documentation

Documentation complète disponible sur : [http://cmp-docs-internal.s3-website.eu-west-3.amazonaws.com/parser](http://cmp-docs-internal.s3-website.eu-west-3.amazonaws.com/parser)
fiberpy 0.2.3
Computional methods for fiber-reinforced composites
Requires Python: >=3.12

# Computational methods for fiber-reinforced composites

This package provides several computational models for fiber-reinforced composites (thermoplastics reinforced by glass fibers, for instance).

- Compute the 4th-order fiber orientation tensor from the 2nd-order one (linear, quadratic, hybrid, orthotropic closure models...)
- Compute the effective thermomechanical properties from the microstructure definition (Mori-Tanaka, orientation averaging...)
- Compute fiber orientation tensor evolution using the Folgar-Tucker model or its variants (RSC model...)

<p align="center">
  <img src="https://user-images.githubusercontent.com/4027283/60251521-f4d52000-98c8-11e9-804e-e3a1d031286d.png" width="800">
</p>

Documentation is available [here](https://fiberpy.readthedocs.io).

## Installation

To install `fiberpy`, run

```sh
pip install -U fiberpy
```

## Testing

To run the `fiberpy` unit tests, run

```sh
pytest
```

## License

`fiberpy` is published under the [MIT license](https://en.wikipedia.org/wiki/MIT_License).
cmpparis-db 1.0.0
Database utilities for cmpparis libraries (MongoDB, SQL Server, ODBC)

# cmpparis-db

Database utilities for cmpparis libraries (MongoDB, SQL Server, ODBC).

## Installation

```bash
pip install cmpparis-db
```

## Features

- MongoDB document management
- SQL Server connectivity
- ODBC support
- Unified SQL factory

## Usage

```python
from cmpparis_db import DocumentDBManager, MSSQL

# MongoDB
db = DocumentDBManager("mongodb://localhost", "mydb")

# SQL Server
sql = MSSQL("server", "database")
```
BBAWSLightsailMiniV1a 0.332.1
Buzzerboy Architecture for Deploying Web Applications on AWS LightSail
Requires Python: >=3.8

# AWS Infrastructure with CDKTF (Python)

This project uses the **Cloud Development Kit for Terraform (CDKTF)** with **Python** to define and deploy AWS infrastructure using named AWS profiles via `~/.aws/credentials` and `~/.aws/config`.

---

## ✅ Prerequisites

### 1. Install Required Tools

Make sure the following tools are installed:

* **Node.js** (v16 or later)
* **npm**
* **Terraform CLI**
* **Python 3.7+**
* **AWS CLI**

#### macOS Example:

```bash
brew install node
brew install terraform
brew install python
brew install awscli
```

### 2. Install CDKTF CLI

```bash
npm install -g cdktf-cli
```

### 3a. Configure AWS CLI (Option 1 - Use AWS Provided Tooling)

```bash
aws configure --profile myprofile
```

This creates or updates the following files:

`~/.aws/credentials`:

```ini
[myprofile]
aws_access_key_id=YOUR_ACCESS_KEY
aws_secret_access_key=YOUR_SECRET_KEY
```

`~/.aws/config`:

```ini
[profile myprofile]
region=us-west-2
output=json
```


### 3b. Configure AWS CLI (Option 2 - Use Open Source AWS Login - Recommended)


#### 3b - 1. Clone the code repo from Fahad Zain Jawaid
```bash
git clone https://github.com/fahadzainjawaid/awsIdentityTools
```

You can follow the ReadMe on the repo above to get latest usage and setup guides.

---

## 🚀 Getting Started

### 1. Install the package

```bash
pip install pip install BBAWSLightsailMiniV1a
```

### 2. Set Up Python Environment & Install Dependencies

```bash
python3 -m venv .venv
source .venv/bin/activate
export PIPENV_VERBOSITY=-1
pip install -r requirements.txt
```

### 3. Install AWS Provider Bindings

```bash
cdktf get
```

### 4. Synthesize Terraform Configuration

```bash
cdktf synth
```

### 5. Review the Plan

```bash
cdktf plan
```

### 6. Deploy the Infrastructure

```bash
cdktf deploy
```

### 7. Destroy the Infrastructure (if needed)

```bash
cdktf destroy
```

## 🛠 Useful Commands

| Command         | Description                     |
| --------------- | ------------------------------- |
| `cdktf get`     | Install provider bindings       |
| `cdktf synth`   | Generate Terraform JSON config  |
| `cdktf plan`    | Preview planned changes         |
| `cdktf deploy`  | Deploy infrastructure to AWS    |
| `cdktf destroy` | Destroy deployed infrastructure |

---

## 📁 .gitignore Suggestions

```gitignore
.venv/
cdktf.out/
.terraform/
__pycache__/
*.pyc
```

---

## 📝 Notes

* To install additional Python packages:

  ```bash
  pip install <package>
  pip freeze > requirements.txt
  ```

* To suppress pipenv verbosity in environments where pipenv is used:

  ```bash
  export PIPENV_VERBOSITY=-1
  ```

---

## 📚 References

* [CDK for Terraform Documentation](https://developer.hashicorp.com/terraform/cdktf)
* [AWS Provider Docs](https://registry.terraform.io/providers/hashicorp/aws/latest/docs)