semvec/pypi-packages huggingface dataset:
simula-repo-review 0.1.0
Add your description here
Requires Python: >=3.12.9

# Simula Repo Review

Tool to review repositories for compliance with Simula's repository policies.
See https://simulink.simula.no/policy/56 for more information.

## Installation

You can install the package via pip:

```bash
uv pip install
```

## Run checks

**Run only the Simula checks:**
```bash
uv run repo-review gh:ComputationalPhysiology/cardiac-geometries@main --select "SI"
```

**Run all checks:**
```bash
uv run repo-review gh:ComputationalPhysiology/cardiac-geometries@main
```

**Run simula and python checks:**

```bash
uv run repo-review gh:ComputationalPhysiology/cardiac-geometries@main --select "SI,PY,PP"
```

## Learn more

You can read more about the Simula repository policies at https://simulink.simula.no/policy/56. To learn more about repo-review, visit https://repo-review.readthedocs.io/en/latest/.

## License
MIT
gcode-thumbnail-tool 0.1.2
A small tool to analyse and extract thumbnails rendered into GCODE files
Requires Python: >=3.9

# gcode-thumbnail-tool

A small tool to analyse and extract thumbnails rendered into GCODE files.

## Installation

```
pip install gcode-thumbnail-tool
```

## Usage

### As a Python library

```python
import gcode_thumbnail_tool as gtt

path = "/path/to/a/file.gcode"
thumbnails = gtt.extract_thumbnails_from_gcode_file(path)

if result:
    print(
        f'Found {len(result.images)} thumbnails in {args.path}, in format "{result.extractor}":'
    )
    for image in result.images:
        print(f"\t{image.format} @ {image.width}x{image.height}")
else:
    print(f"Didn't find any thumbnails in {args.path}")
```

See `gcode_thumbnail_tool.py:main` and `tests/test_api.py` for more usage examples.

### As a command line tool

<!--INSERT:help-->

```
$ gcode-thumbnail-tool
usage: gcode-thumbnail-tool [-h] [--verbose] {extract,analyse} ...

A small CLI tool to extract thumbnail images from GCODE files.

positional arguments:
  {extract,analyse}
    extract          extracts thumbnails from the provided file as PNGs
    analyse          provides information on the GCODE file's thumbnails

options:
  -h, --help         show this help message and exit
  --verbose, -v      increase logging verbosity
```

<!--/INSERT:help-->

#### `extract`

<!--INSERT:extract-->

```
$ gcode-thumbnail-tool extract --help
usage: gcode-thumbnail-tool extract [-h] [-o OUTPUT] path

positional arguments:
  path                  path to the GCODE file

options:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        output path for the extracted thumbnails
```

<!--/INSERT:extract-->

#### `analyse`

<!--INSERT:analyse-->

```
$ gcode-thumbnail-tool analyse --help
usage: gcode-thumbnail-tool analyse [-h] path

positional arguments:
  path        path to the GCODE file

options:
  -h, --help  show this help message and exit
```

<!--/INSERT:analyse-->

#### Example

<!--INSERT:example-->

```
$ gcode-thumbnail-tool analyse tests/_files/prusa_2.9.3.gcode
Found 4 thumbnails in tests/_files/prusa_2.9.3.gcode, in format "generic":
	PNG @ 16x16
	PNG @ 220x124
	QOI @ 64x64
	JPEG @ 64x64
```

<!--/INSERT:example-->

## Acknowledgements

`gcode-thumbnail-tool` is based on the [Slicer Thumbnails OctoPrint Plugin](https://github.com/jneilliii/OctoPrint-PrusaSlicerThumbnails) by jneilliii.
Big thanks to him and all the contributors!
dharitri-sdk-cli 0.0.4
DharitrI Smart Contracts Tools
Requires Python: >=3.10

# Description
Python Command Line Tools for interacting with Multivers<sup>X</sup>.

## Documentation
[docs.dharitri.org](https://docs.dharitri.org/sdk-and-tools/sdk-py/)

## CLI
[CLI](CLI.md)

## Distribution
[pipx](https://docs.dharitri.org/sdk-and-tools/sdk-py/installing-drtpy/) [(PyPi)](https://pypi.org/project/dharitri-sdk-cli/#history)

## Development setup

Clone this repository and cd into it:

```
git clone https://github.com/TerraDharitri/drt-py-sdk-cli.git
cd drt-py-sdk-cli
```

### Virtual environment

Create a virtual environment and install the dependencies:

```
python3 -m venv ./venv
source ./venv/bin/activate
pip install -r ./requirements.txt --upgrade
```

Install development dependencies, as well:

```
pip install -r ./requirements-dev.txt --upgrade
```

Allow `pre-commit` to automatically run on `git commit`:
```
pre-commit install
```

Above, `requirements.txt` should mirror the **dependencies** section of `pyproject.toml`.

If using VSCode, restart it or follow these steps:
 - `Ctrl + Shift + P`
 - _Select Interpreter_
 - Choose `./venv/bin/python`.

### Using your local `drtpy`

If you want to test the modifications you locally made to `drtpy`, set `PYTHONPATH` with the path to your local repository path.

For example, if you cloned the repository at `~/drt-py-sdk-cli`, run:

```
export PYTHONPATH="~/drt-py-sdk-cli"
```

Then `drtpy` will use the code in your local repository.
simplexpy 1.0.1
A comprehensive toolbox for structural engineering calculations
Requires Python: >=3.12.10
Keywords: structural-engineering, foundation-design, eurocode, civil-engineering, structural-analysis, concrete-design, geotechnical, construction

<p>
    <a href="https://strusoft.com/software/3d-structural-analysis-software-fem-design/" target="_blank">
        <p align="center">
            <img src="https://raw.githubusercontent.com/ms-structural/company-assets/refs/heads/master/simplex/img/simplex_text_blue.png" alt="isolated" width="600" style="centre"/>
        </p>
    </a>
</p>

---

The **Simplex Python SDK** is a library designed to facilitate structural engineering computations, including foundation design, soil modeling, load analysis, and more. It provides a robust API for interacting with engineering data, performing calculations, and generating results in compliance with Eurocode standards.

## Getting Started

Assuming that you have a supported version of Python installed, you can first set up your environment with:

```bash
python -m venv .venv
...
cd .venv/bin/activate
```

Then, you can install simplexpy from PyPI with:

```bash
python -m pip install simplexpy
```

## Documentation

Simplex has usage and reference documentation at [simplex-docs.onstrusoft.com](https://simplex-docs.onstrusoft.com/)

#

Prefer a UI? The Simplex web apps are backed by the same API and can be easier for quick checks, exploratory design, visualization, or when you don't need full scripting.

- [Simplex Beam](https://strusoft.com/software/simplex-beam-design-software/)
- [Simplex Foundation](https://strusoft.com/software/simplex-foundation-design-software/)
gvp 0.1.0
The Volcanoes of the World database is a catalog of Holocene and Pleistocene volcanoes, and eruptions from the past 12,000 years.
Requires Python: >=3.11
Keywords: gvp, volcano, volcanism, observatory, volcanoes, volcanic, unrest, database, holocene

# Global Volcanism Program (GVP)
Unofficial python package for Global Volcanism Program (GVP). Current database which is used in the package is Global Volcanism Program - Volcanoes of the World v5.3.2; 30 September 2025.

GVP Homepage: https://volcano.si.edu/

## Install

Using `pip`:
```python
pip install gvp
```

Using `uv`:
```python
uv add gvp
```

## Download Database
Available databases: holocene, pleistocene, and changelogs. Each database will be downloaded as an Excel file. The Excel files have also been fixed to prevent warnings when opened in Microsoft Excel.

### Import GVP module
```python
import gvp
from gvp.download import download

## Check GVP Module version
print(gvp.__version__)
```
`verbose` default parameter is set to `False`

### Download Holocone
```python
download(database="holocene", verbose=True)
```

### Download Pleistocene
```python
download(database="pleistocene", verbose=True)
```

### Download Changelogs in Markdown and Excel
```python
download(database="changelogs", verbose=True)
```

## Full code example
```python
import gvp
from gvp.download import download

download(database="holocene", verbose=True)
download(database="pleistocene", verbose=True)
download(database="changelogs", verbose=True)
```
wagtail-localize-ai 0.2.0
LiteLLM powered machine translator for wagtail-localize
Requires Python: >=3.9

# Wagtail Localize AI Translator
A machine translator for Wagtail Localize that uses LiteLLM for translation

## Prerequisites
- Python 3.9+
- a Wagtail project with Wagtail Localize correctly configured


## Dependencies
- [Wagtail Localize](https://github.com/wagtail/wagtail-localize)
- [litellm](https://github.com/BerriAI/litellm)

## Installation
Install the package using pip:

```bash
pip install wagtail-localize-ai
```
In your `settings.py` file,
- Add `wagtail_localize_ai` to your `INSTALLED_APPS`
- Add `wagtail.contrib.settings` to your `INSTALLED_APPS` (used to setup model and prompt)
- Setup `WAGTAILLOCALIZE_MACHINE_TRANSLATOR` like this:
    ```python
    WAGTAILLOCALIZE_MACHINE_TRANSLATOR = {
        "CLASS": "wagtail_localize_ai.translator.AITranslator",
    }
    ```

Then, run `python manage.py migrate wagtail_localize_ai` to create the required database tables

### Setting up providers

To set up providers add to your `settings.py` file a dict called `AI_PROVIDERS`.  
Each provider is a key, the value will be a dict of kwargs that will be passed to the completion function.
You can also add a `_name` key to provide a verbose name of the provider.

You can find all providers and their kwargs in the [litellm documentation](https://docs.litellm.ai/docs/providers)

Here are some examples for the most popular providers:

#### OpenAI
```python
AI_PROVIDERS = {
    "openai": {
        "_name": "OpenAI",
        "api_key": "sk-...",
        "base_url": "https://api.openai.com/v1", # Optional
        "organization": "org-...", # Optional
    }
}
```

#### Anthropic
```python
AI_PROVIDERS = {
    "anthropic": {
        "_name": "Anthropic",
        "api_key": "sk-...",
    }
}
```

#### Azure OpenAI
```python
AI_PROVIDERS = {
    "azure": {
        "_name": "Azure OpenAI",
        "api_key": "sk-...",
        "base_url": "https://...",
        "api_version": "2023-03-15-preview", # Optional
    }
}
```

#### Azure AI
```python
AI_PROVIDERS = {
    "azure_ai": {
        "_name": "Azure AI",
        "api_key": "sk-...",
        "base_url": "https://...",
    }
}
```

#### Vertex AI
```python
AI_PROVIDERS = {
    "vertex_ai": {
        "_name": "Vertex AI",
        "vertex_project": 'project-...',
        "vertex_location": 'europe-west8',
    }
}

# Load the google cloud
with open("path/to/vertex_ai_service_account.json") as f:
    AI_PROVIDERS["vertex_ai"]["vertex_credentials"] = json.load(f)
```

## Usage
You can set the provider, model and prompt from the AI Translator page reachable from the Settings menu entry.  
You can also see the token usage from the Logs pagea in the Reports menu entry.


## License
This project is released under the [BSD license](LICENSE).

## Contributors

<a href="https://github.com/infofactory/wagtail-localize-ai/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=infofactory/wagtail-localize-ai" />
</a>
umlcharter 1.1.6
Python package for quick diagrams creation without a need to learn new DSL
Requires Python: >=3.9

![pypi](https://img.shields.io/pypi/v/umlcharter.svg)
![versions](https://img.shields.io/pypi/pyversions/umlcharter.svg)
![PyPI - Downloads](https://img.shields.io/pypi/dm/umlcharter)

# umlcharter
Python package for quick diagrams creation without a need to learn a new DSL.

The goal of this package is to provide a tool for convenient and quick creation of the diagrams as a code
in the popular DSLs (PlantUML, Mermaid, D2, etc) using simple python constructions.

This package focuses on not to provide the full coverage for the all the things these DSLs are supporting, but rather on
the simplicity, speed and ease of diagrams creation.

For the examples of how this package can be used and the list of exactly supported DSLs, 
please check the documentation:
- [Sequence Diagrams](https://github.com/mikalaiyurkin/umlcharter/blob/master/docs/sequence_diagram/README.md)
- [State & Activity Diagrams (Flowcharts)](https://github.com/mikalaiyurkin/umlcharter/blob/master/docs/graph_diagram/README.md)
mfoutparser 1.5.1
Parser for STAR format mfout file generated by the program ModelFree
Requires Python: >=3.12

# mfoutparser
by Arthur G. Palmer, III and Michelle L. Gill

A series of python subroutines to read and extract information from the STAR format mfout file generated by the program ModelFree.

Unlike the BMRB STAR format, the format used by ModelFree uses the data_name field, rather than the save_name field and also allows nested loops. (The mfout file has loops nested to a depth of two only).

## Local Demo

Once `mfoutparser` has been installed, the `examples` directory can be copied to the current path using the following shell command:

```
python -c 'import mfoutparser as mf; mf.copy_examples()'
```

## Compatibility

`mfoutparser` has been tested on python 3.12. It requires the
Numpy (tested on version 1.26.4) and Pandas (tested on version 2.2.2)
libraries. IPython notebook (tested on version 8.27.0) is required to run the
demonstration notebook located in the `examples` directory. Matplotlib
is required if plotting of the data is desired.

## Installation

`mfoutparser` can be installed with the [pip](https://pypi.python.org/pypi/mfoutparser) package managers or using python's `setuptools`. See the [installation instructions](https://github.com/agpalmeriii/mfoutparser/blob/master/INSTALL.md) for more information.
thzpy 0.2.1
Data proccessing for THz-TDS. A scientific computing package for the processing of terahertz time-domain spectroscopy data. Includes modules for time-domain, transfer functions, frequency-domain, and data formatting.
Requires Python: >=3.7

# THzPy

THzPy is a scientific computing library for processing terahertz time-domain spectroscopy data.

The aim of this library is simplify and speed up the analysis of THz-TDS data, as well as promote the standardisation
of processing methods between research groups and industry.

Development of this package is ongoing, we are in the process of adding features and support for a wider range of
experimental setups and processes.
If you encounter any bugs or there are any specific features you would like to see added please get in touch.

## Features

- Windowing and filtering.
- Extraction of optical constants.
- Spectral feature extraction. (UPCOMING)
- Support for the DotTHz file format. (see `examples/basic_thz.py` for a possible application)

## Usage

The package can be installed via pip:

```shell
pip install thzpy
```

The package then presents various functions to use like so:

```python
from thzpy.timedomain import common_window
from thzpy.transferfunctions import uniform_slab

# Apply the same hanning window to all datasets with a half-width of 15 ps.
reference, baseline = common_window([reference, baseline],
                                    half_width=15, win_func="hanning")

# Calculate buffer material properties.
buffer = uniform_slab(reference_thickness,
                      reference, baseline,
                      upsampling=3, min_frequency=0.2, max_frequency=3,
                      all_optical_constants=True)
```             

Please see the examples folder for full demonstrations of how to use the package.

## Documentation

[GitHub](https://github.com/dotTHzTAG/thzpy)

## Authors

- [@JasperWB](https://www.github.com/JasperWB) - primary development
- [@hacknus](https://github.com/hacknus) - .thz file handling
- [@dotTHzTAG](https://www.github.com/dotTHzTAG) - various contributions

## Feedback

If you have any feedback, please reach out to us at jnw35@cam.ac.uk

## License

[LGPLv3](https://www.gnu.org/licenses/lgpl-3.0.html)