semvec/pypi-packages huggingface dataset:
terma-cli 1.0.2
A lightweight CLI tool that converts natural language instructions into terminal commands.
Requires Python: >=3.9

![logo](src/media/logo.png)
# Terma-CLI

A lightweight Python CLI tool that converts natural language instructions into terminal commands.

## Overview

**Terma-CLI** lets you describe what you want to do in plain English, and your configured AI provider (OpenAI, Anthropic, or Google GenAI) will translate it into a valid terminal command.

## Features

- Convert natural language directly into executable commands
- Multiple AI provider support:
  - **OpenAI**
  - **Anthropic**
  - **Google GenAI**
- AI agent configuration via `terma config`
- Persistent settings stored automatically at `~/.config/terma/config.json`
- Simple CLI tool created with **Python** + **Typer**

## Installation

### Globally

You can install Terma-CLI through PyPI:
```bash
pip install terma-cli
```

### Locally
```bash
git clone https://github.com/ShlokShar/terma.git
cd terma
pip install -e .
```

## Usage

### Basic Syntax
```bash
terma <command> <args>
```

## Configuration

Terma-CLI uses a simple config system to set your AI provider, API key, and model. Configuration is **required** prior to executing the natural language command.

### Supported config commands

| Command | Description |
|---------|-------------|
| `terma config provider <provider>` | Set the AI provider (e.g., `openai`, `anthropic`, `google`) & API key |
| `terma config provider <provider> --api-key <key>` | Set provider and API key in one line |
| `terma config api-key` | Set the API key separately |
| `terma config model <model-name>` | Sets the model (e.g., `gpt-4-nano`, `claude-haiku-4-5`, etc.) |
| `terma config peek` | View Terma's current configuration |

## Natural Language Execution

Translate any natural language instruction into a real command:
```bash
terma exec <instruction>
```

## Example Commands

**Input:**
```bash
terma exec check node version
```

**Output:**
```bash
node --version
```

---

**Input:**
```bash
terma exec make a new directory called logs and move all .txt files into it
```

**Output:**
```bash
mkdir logs && mv *.txt logs/
```

*(Actual output may differ depending on the AI provider/model.)*

## Config File Path

Terma automatically stores configuration settings at:
```
~/.config/terma/config.json
```

You do not need to create this manually.

## License

This project is licensed under the **MIT License**.

## Contributing

Feel free to open issues, submit PRs, or propose features.

## Roadmap

- Command history log for past AI-generated commands
- More provider-specific settings
- Optional safety/output confirmation mode

## Author

**Shlok Sharma**  
GitHub: [@ShlokShar](https://github.com/ShlokShar)

## Related Projects

- **insectool** — A lightweight Python web scanner for identifying common web vulnerabilities
pyspelling 2.12.1
Spell checker.
Requires Python: >=3.9
Keywords: spelling

[![Donate via PayPal][donate-image]][donate-link]
[![Coverage Status][codecov-image]][codecov-link]
[![PyPI Version][pypi-image]][pypi-link]
[![PyPI - Python Version][python-image]][pypi-link]
[![License][license-image-mit]][license-link]
# PySpelling

## Overview

PySpelling is a module to help with automating spell checking in a project with [Aspell][aspell] or
[Hunspell][hunspell]. It is essentially a wrapper around the command line utility of these two spell checking tools, and
allows you to setup different spelling tasks for different file types. You can apply specific and different filters and
options to each task. PySpelling can also be used in CI environments to fail the build if there are misspelled words.

Aspell and Hunspell are very good spell checking tools. Aspell particularly comes with a couple of filters, but the
filters are limited in types and aren't extremely flexible. PySpelling was created to work around Aspell's and
Hunspell's filtering shortcomings by creating a wrapper around them that could be extended to handle more kinds of file
formats and provide more advanced filtering. If you need to filter out specific HTML tags with specific IDs or class
names, PySpelling can do it. If you want to scan Python files for docstrings, but also avoid specific content within the
docstring, you can do that as well. If PySpelling doesn't have a filter you need, with access to so many available
Python modules, you can easily write your own.

## Documentation

Extension documentation is found here: https://facelessuser.github.io/pyspelling/.

## License

MIT

[aspell]: http://aspell.net/
[hunspell]: https://hunspell.github.io/

[codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/pyspelling/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
[codecov-link]: https://codecov.io/github/facelessuser/pyspelling
[pypi-image]: https://img.shields.io/pypi/v/pyspelling.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
[pypi-link]: https://pypi.python.org/pypi/pyspelling
[python-image]: https://img.shields.io/pypi/pyversions/pyspelling?logo=python&logoColor=aaaaaa&labelColor=333333
[license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
[license-link]: https://github.com/facelessuser/pyspelling/blob/main/LICENSE.md
[donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
[donate-link]: https://www.paypal.me/facelessuser
lpkit 0.2.1
Ferramenta para visualização gráfica e resolução de modelos de Programação Linear em duas variáveis, incluindo simplex e zona viável.
Requires Python: >=3.7
Keywords: linear-programming, optimization, simplex, operations-research, mathematical-optimization, visualization


# LPKit 📊

[![PyPI](https://img.shields.io/pypi/v/lpkit.svg)](https://pypi.org/project/lpkit/)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)

**LPKit** é uma biblioteca Python para visualização e resolução de modelos de Programação Linear.

Ideal para fins didáticos, acadêmicos ou aplicações simples com:

✅ Região factível (método gráfico)  
✅ Vetor gradiente e curvas de nível  
✅ Método Simplex  
✅ Ponto ótimo e valor da função objetivo  

---

## ✨ Instalação

```bash
pip install lpkit
```

Ou para desenvolvimento local:

```bash
git clone https://github.com/pedroeckel/lpkit.git
cd lpkit
pip install -e .
```

---

## 🚀 Exemplo de uso: método gráfico e Simplex

```python
from lpkit import solve_with_graphics

model_text = '''
Max Z = 5*x1 + 2*x2
x1 <= 3
x2 <= 4
x1 + 2*x2 <= 9
x1 - 2*x2 <= 2
x1 >= 0
x2 >= 0
'''

solve_with_graphics(model_text, verbose={
    "show_gradient": True,
    "show_level_curves": True,
    "show_objective_value": True,
    "show_vertex_points": True,
    "show_optimal_point": True
})
```

---

## 🧠 Exemplo de uso: método Simplex

```python
from lpkit import solve_with_simplex

model_text = '''
Max Z = 5*x1 + 2*x2
x1 <= 3
x2 <= 4
x1 + 2*x2 <= 9
x1 - 2*x2 <= 2
x1 >= 0
x2 >= 0
'''

solve_with_simplex(model_text, verbose={
    "simplex_tableau": True,
    "entering_leaving": True,
    "pivot": True,
    "basic_vars": True,
    "constraints_validation": True,
    "z_per_iteration": True,
    "history_summary": True
})
```
---

## 📄 Licença

Distribuído sob a [Licença MIT](LICENSE).

---

## 🤝 Contribuindo

Pull requests são bem-vindos!  
Se quiser sugerir melhorias ou reportar bugs, abra uma issue.
turbine-models 0.2.1
Retrieves power curves and key data for commonly used turbine models in industry and R&D community.
Requires Python: <3.14,>=3.10
Keywords: python3, turbine-library, wind-turbines, power-curve, power-curves, data, wind-energy

# NREL Wind Turbine Power Curve Archive

[![PyPI version](https://badge.fury.io/py/turbine-models.svg)](https://badge.fury.io/py/turbine-models)
[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![docs - GitHub Pages](https://img.shields.io/badge/docs-GitHub_Pages-blue)](https://nrel.github.io/turbine-models/)
[![DOI 10.11578/dc.20210112.1](https://img.shields.io/badge/DOI-10.11578/dc.20210112.1-brightgreen?link=https://doi.org/10.11578/dc.20210112.1)](https://doi.org/10.11578/dc.20210112.1)

## Welcome to the repository for the wind turbine power curve archive.

The intention of this repositiory is to provide power curves and key data for commonly used turbine models in industry the R&D community. 

    
## Structure
Tabular power (and thrust when available) curve data is stored in the following folders:
- Distributed Wind Turbines
- Offshore Wind Turbines
- Onshore Wind Turbines

Here you can find .csv files with the following turbine data:
1. Power curve
2. Thrust curve (when available)
3. Cp curve (when available)
4. Ct curve (when available)

## Documentation
Each turbine included in the repository is documented in detail:
https://nrel.github.io/turbine-models/

The name of the turbine on the .csv file with tabular data should match up with a corresponding documentation page.

## Installing via pip

To use the turbine-models data library and helpers in your project, we now support pip installations, so projects
can be configured correctly and still use this data set.

```bash
pip install turbine-models
```

## Installing from Source
1. Using Git, navigate to a local target directory and clone repository:

    ```bash
    git clone https://github.com/NREL/turbine-models.git
    ```

2. Navigate to `turbine-models`

    ```bash
    cd turbine-models
    ```

3. Create a new virtual environment and change to it. Using Conda and naming it `turb_lib`:

    ```bash
    conda create --name turb_lib python=3.11 -y
    conda activate turb_lib
    ```

4. Install turbine-models and its dependencies:
    - for general use:

        ```bash
        pip install .
        ```

    - for general use and running examples:

        ```bash
        pip install ".[examples]"
        ```
    
    - for development dependencies and running tests. Note the `-e` flag which installs turbine-models in-place so you can edit the turbine-models package files: 
        
        ```bash
        pip install -e ".[develop]"
        ```


## Getting started
The [Examples](./examples/) contain Python scripts for common usage scenarios.
provenance-context 0.2.0
Python library for querying RO-Crate provenance metadata from CWL workflow runs. Provides lineage queries, site artifacts, and TOON encoding for LLM prompts.
Requires Python: >=3.8
Keywords: provenance, ro-crate, cwl, lineage, workflow, toon

# provenance-context

Python library for querying RO-Crate provenance metadata from CWL workflow runs. Provides lineage queries, site artifacts, and TOON encoding for LLM prompts.

## Installation

```bash
pip install provenance-context
```

For optional dependencies:

```bash
# Pandas support
pip install provenance-context[pandas]

# TOON encoding support (not available on PyPI, install from GitHub)
pip install git+https://github.com/toon-format/toon-python.git

# Or install both
pip install provenance-context[pandas]
pip install git+https://github.com/toon-format/toon-python.git
```

## Usage

```python
from provenance_context import ProvenanceCrate

# Load a RO-Crate
crate = ProvenanceCrate.from_dir("path/to/crate")
# or
crate = ProvenanceCrate.from_file("path/to/ro-crate-metadata.json")

# Query lineage
lineage = crate.get_file_lineage("output.csv")
site = crate.get_site_artifacts("site_id")
ancestry = crate.get_file_ancestry("output.csv")
descendants = crate.get_file_descendants("input.geojson")

# Encode as TOON for LLM prompts (requires toon-format)
toon_lineage = crate.to_toon_file_lineage("output.csv")
toon_site = crate.to_toon_site_summary("site_id")
```

## Features

- **Lineage Queries**: Query direct lineage, ancestry (upstream), and descendants (downstream) of files
- **Site Artifacts**: Get a site-centric view of provenance data
- **TOON Encoding**: Encode provenance data into TOON format for efficient LLM prompts
- **File Resolution**: Resolve RO-Crate File entities to local filesystem paths
- **Media Type Detection**: Automatically detect file types from metadata or extensions

## Documentation

See `provenance_toon_cheatsheet.md` for detailed usage examples and patterns.

## License

MIT
charmlibs-systemd 1.0.0
The charmlibs.systemd package.
Requires Python: >=3.10

# charmlibs.systemd

The `systemd` library.

To install, add `charmlibs-systemd` to your Python dependencies. Then in your Python code, import as:

```py
from charmlibs import systemd
```

See the [reference documentation](https://documentation.ubuntu.com/charmlibs/reference/charmlibs/systemd) for more.
versapy 1.2.2
Lightweight framework for desktop apps with web UI.
Requires Python: >=3.9


# versapy

### The python module versapy is the main structure of [Versapy](https://github.com/Soli-64/VersaPy), a python desktop app framework.

## <u> About </u>

#### This module manages backend server using FastAPI, Uvicorn and SocketIO. <br/> It reads configs, and run the app using PyWebVIew. <br/> The Building functionnality is only available on Windows for now. 

## <u> Usage </u>

#### This module is auto-installed in your project by the cli [create-versapy](https://github.com/Soli-64/VersaPy/tree/main/cli) while creating your versapy project. <br/> See the [github repo](https://github.com/Soli-64/VersaPy) for more infos and exemples.
pyentrp 2.1.0
A Python library for computing entropy measures for time series analysis.
Requires Python: <4.0,>=3.9

# pyEntropy (pyEntrp)

![py39 status](https://img.shields.io/badge/python3.9-supported-green.svg)
![py310 status](https://img.shields.io/badge/python3.10-supported-green.svg)
![py311 status](https://img.shields.io/badge/python3.11-supported-green.svg)
![py312 status](https://img.shields.io/badge/python3.12-supported-green.svg)
![py313 status](https://img.shields.io/badge/python3.13-supported-green.svg)
![py314 status](https://img.shields.io/badge/python3.14-supported-green.svg)

1. [Quick start](#quick-start)
2. [Usage](#usage)
3. [Contributors and participation](#contributors-and-participation)

pyEntropy is a lightweight library built on top of NumPy
that provides functions for computing various types of entropy for time series analysis.

The library currently supports the following types of entropy computation:

+ Shannon Entropy ```shannon_entropy```
+ Sample Entropy ```sample_entropy```
+ Multiscale Entropy ```multiscale_entropy```
+ Composite Multiscale Entropy ```composite_multiscale_entropy```
+ Permutation Entropy ```permutation_entropy```
+ Multiscale Permutation Entropy ```multiscale_permutation_entropy```
+ Weighted Permutation Entropy ```weighted_permutation_entropy```

## Quick start

Install [pyEntropy](https://github.com/nikdon/pyEntropy) using pip:

```
pip install pyentrp
```

Install [pyEntropy](https://github.com/nikdon/pyEntropy) using poetry:

```
poetry add pyentrp
```

## Usage

```python
from pyentrp import entropy as ent
import numpy as np

ts = [1, 4, 5, 1, 7, 3, 1, 2, 5, 8, 9, 7, 3, 7, 9, 5, 4, 3]
std_ts = np.std(ts)
sample_entropy = ent.sample_entropy(ts, 4, 0.2 * std_ts)
```

## Contributors and participation

[pyEntropy](https://github.com/nikdon/pyEntropy) is an open-source project, and contributions are highly encouraged.
If you would like to contribute, you can:

- [Fork the repository](https://github.com/nikdon/pyEntropy/fork) and submit pull requests with your improvements, bug
  fixes, or new features.
- Report any issues or bugs you encounter on the [issue tracker](https://github.com/nikdon/pyEntropy/issues).
- Help improve the documentation by
  submitting [documentation improvements or corrections](https://github.com/nikdon/pyEntropy/issues?q=is%3Aissue+is%3Aopen+label%3Adocumentation).
- Participate in discussions and share your ideas.

The following contributors have made significant contributions to pyEntropy:

* [Nikolay Donets](https://github.com/nikdon)
* [Jakob Dreyer](https://github.com/jakobdreyer)
* [Raphael Vallat](https://github.com/raphaelvallat)
* [Christopher Schölzel](https://github.com/CSchoel)
* [Sam Dotson](https://github.com/samgdotson)

Contributions are very welcome, documentation improvements/corrections, bug reports, even feature requests :)

If you find [pyEntropy](https://github.com/nikdon/pyEntropy) useful, please consider giving it a star.

Your support is greatly appreciated!
gfys 0.1.2
Make `go test` output readable
Requires Python: >=3.12

[![Latest Version](https://img.shields.io/pypi/v/gfys?label=pypi-version&logo=python&style=plastic)](https://pypi.org/project/gfys/)
[![Python Versions](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fdusktreader%2Fgfys%2Fmain%2Fpyproject.toml&style=plastic&logo=python&label=python-versions)](https://www.python.org/)
[![Build Status](https://github.com/dusktreader/gfys/actions/workflows/publish.yml/badge.svg)](https://github.com/dusktreader/gfys/actions/workflows/publish.yml)

![gfys-logo](https://github.com/dusktreader/gfys/blob/main/gfys.png)

_Because `go test` output is f'ing terrible._

I hate reading output from `go test`. So, I made this.

## Super-quick Start

* Requires Python 3.12 or later
* Installed with pip/uv/whatever. Handiest with uv: `uv tool install gfys`

## Documentation

Just run: `gfys --help`

You'll figure it out.
o2tools 1.0.0
A python package for manipulating O2Jam files.
Keywords: o2jam, parser, opi, opa, ojn, ojm, ojs, ojt, oji, bnd

<p align="center">
  <img src="https://github.com/SweepSweep2/o2tools/blob/main/logo.png?raw=true"/>
</p>

<h2 align="center">O2Tools, a python package for manipulating O2Jam files.</h2>

# Features
- [x] Readable OJN Note Sections
- [x] OJM Sound Extraction (both M30 and OMC)
- [x] Interface/Avatar File Support
- [x] OJN List Support
- [x] Highly Documented
- [x] Easy to Use
- [x] Fully Object-Oriented

# Build Instructions

Install dependencies (build):

    pip install build

Inside the root of the project (where pyproject.toml is located), run:

    python -m build

This will generate the following files (inside the dist directory):

 * A .tar.gz source archive
 * A .whl (wheel) binary distribution

Run the following command (in the dist directory):
    
    pip install [name of wheel file].whl

# Contribution

You can contribute by filling in unknown data in the documentation/code.

# Documentation

The official docs are here: https://o2tools.readthedocs.io

They are not fully finished yet, and are still being worked on.
semantico 0.4.1
Ontologia Core - Camada Semântica (Pure Layer 5) - DSL for Ontology as Code
Requires Python: >=3.13

# Semantico

Ontologia Core - Camada Semântica (Pure Layer 5)

Definição Estrita de Nouns (Objetos), Adjectives (Properties) e Relationships (Links).

## Design Pattern

- Alinhado ao Palantir Foundry Ontology
- Interfaces são Contratos de Dados (Shared Schema)
- Objetos são Active Records inteligentes
- Links são Descritores de Grafo

## Instalação

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

## Dependências

- `registro>=0.7.0` - Sistema de registro de recursos
- `politipo>=0.5.1` - Sistema de tipos de dados
- `malha>=0.6.0` - Kernel de dados unificado
- `pydantic>=2.12` - Validação de dados

## Desenvolvimento

```bash
# Instalar dependências de desenvolvimento
uv pip install -e ".[dev]"

# Executar testes
pytest --cov=src --cov-report=term-missing

# Linting e formatação
ruff check src tests
black src tests
```

## Licença

MIT
python-xmp-toolkit 2.1.0
XMP I/O wrapping Exempi
Keywords: XMP, metadata, multimedia, development, utilities

==================
Python XMP Toolkit
==================

.. image:: actions/workflows/python-package.yml/badge.svg
   :alt: Build status badge
   :target: actions
.. image:: https://img.shields.io/coveralls/python-xmp-toolkit/python-xmp-toolkit/master.svg?maxAge=3600
   :alt: Coverage badge
   :target: https://coveralls.io/r/python-xmp-toolkit/python-xmp-toolkit
.. image:: https://img.shields.io/pypi/v/python-xmp-toolkit.svg?maxAge=3600
   :alt: Version badge
   :target: https://pypi.org/project/python-xmp-toolkit/
.. image:: http://readthedocs.org/projects/python-xmp-toolkit/badge/?maxAge=3600
   :alt: Documentation badge
   :target: http://python-xmp-toolkit.readthedocs.io/


Python XMP Toolkit is a library for working with XMP metadata, as well as
reading/writing XMP metadata stored in many different file formats.

Python XMP Toolkit is wrapping `Exempi <https://libopenraw.freedesktop.org/wiki/Exempi/>`_
(using ctypes), a C/C++ XMP library based on Adobe XMP Toolkit, ensuring that future
updates to the XMP standard are easily incorporated into the library with a minimum
amount of work.

Python XMP Toolkit has been developed by:
 * ESA/Hubble - European Space Agency
 * ESO - European Southern Observatory
 * CRS4 - Centre for Advanced Studies, Research and Development in Sardinia


Documentation
=============
Documentation is available at `python-xmp-toolkit.readthedocs.org
<https://python-xmp-toolkit.readthedocs.org>`_ or can be built using Sphinx: ::

    pip install Sphinx
    sphinx-build docs/ docs/_build/


Testing
=======

Running the tests is as simple as:

.. code:: sh

    python -m pytest
visisipy 0.3.0
Accessible vision simulations in Python.
Requires Python: <3.14,>=3.10

# Visisipy: accessible vision simulations in Python

Visisipy (pronounced `/ˌvɪsəˈsɪpi/`, like Mississippi but with a V) is a Python library for optical simulations of the eye.
It provides an easy-to-use interface to define and build eye models, and to perform common ophthalmic analyses on these models.

## Goals

1. Provide a uniform interface to define, build and analyze various types of eye models, using abstractions that are relevant in a clinical context.
2. Provide a collection of ready-to-use eye models, such as the Navarro model[^navarro], that can be customized at need.
3. Provide an accessible interface to clinically relevant analyses on these models, such as off-axis refraction calculations.
4. Modular design with support for multiple backends, both open-source and commercial.

## Contributing

Visisipy aims to be a community-driven project and warmly accepts contributions.
If you want to contribute, please email us (visisipy@mreye.nl) or [open a new discussion](https://github.com/MREYE-LUMC/visisipy/discussions).

## Installation

Visisipy can be installed through [`pip`](https://pypi.org/project/visisipy/):

```bash
pip install visisipy
```

Visisipy is also available on [Conda Forge](https://anaconda.org/conda-forge/visisipy):

```bash
conda install -c conda-forge visisipy
```

## Example

```python
import visisipy
import matplotlib.pyplot as plt
import seaborn as sns

# Initialize the default Navarro model
model = visisipy.EyeModel()

# Build the model in OpticStudio
model.build()

# Perform a raytrace analysis
coordinates = [(0, 0), (0, 10), (0, 20), (0, 30), (0, 40)]
raytrace = visisipy.analysis.raytrace(coordinates=coordinates)

# Alternatively, the model can be built and analyzed in one go:
# raytrace = visisipy.analysis.raytrace(model, coordinates=zip([0] * 5, range(0, 60, 10)))

# Visualize the model
fig, ax = plt.subplots()
visisipy.plots.plot_eye(ax, model.geometry, lens_edge_thickness=0.5)
ax.set_xlim((-7, 23))
ax.set_ylim((-15, 15))
ax.set_aspect('equal')

sns.lineplot(raytrace, x="z", y="y", hue="field", ax=ax)

plt.show()
```

## Documentation

Read the full documentation at [visisipy.readthedocs.io](https://visisipy.readthedocs.io).

[//]: # (References)
[^navarro]: Escudero-Sanz, I., & Navarro, R. (1999). Off-axis aberrations of a wide-angle schematic eye model. JOSA A, 16(8), 1881–1891. https://doi.org/10.1364/JOSAA.16.001881