semvec/pypi-packages huggingface dataset:
dissect.apfs 1.0.2.dev1
A Dissect module implementing a parser for the APFS file system, a commonly used Apple file system
Requires Python: >=3.10.0

# dissect.apfs

A Dissect module implementing a parser for the APFS file system, a commonly used Apple file system. For more
information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/dissect.apfs/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.apfs` is available on [PyPI](https://pypi.org/project/dissect.apfs/).

```bash
pip install dissect.apfs
```

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.
pysme-astro 0.6.23
Spectroscopy Made Easy
Requires Python: >=3.9

![Python application](https://github.com/MingjieJian/SME/workflows/Python%20application/badge.svg)
[![Documentation Status](https://readthedocs.org/projects/pysme-astro/badge/?version=latest)](https://pysme-astro.readthedocs.io/en/latest/?badge=latest)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5547527.svg)](https://doi.org/10.5281/zenodo.5547527)

# PySME

Spectroscopy Made Easy (SME) is a software tool that fits an observed
spectrum of a star with a model spectrum. Since its initial release in
[1996](http://adsabs.harvard.edu/abs/1996A%26AS..118..595V), SME has been a
suite of IDL routines that call a dynamically linked library, which is
compiled from C++ and fortran. This classic IDL version of SME is available
for [download](http://www.stsci.edu/~valenti/sme.html).

In 2018, we began began reimplmenting the IDL part of SME in python 3,
adopting an object oriented paradigm and continuous itegration practices
(code repository, build automation, self-testing, frequent builds).

# Installation

A stable version is available on pip `pip install pysme-astro`, and it is recommended to install this verion.

If you are interested in the latest version you can do so by cloning this git.
```bash
# Clone the git repository
git clone https://github.com/MingjieJian/SME.git
# Move to the new directory
cd SME
# Install this folder (as an editable module)
pip install -e .
```
See also the [documentation](https://pysme-astro.readthedocs.io/en/latest/usage/installation.html).

# Poster

A poster about PySME can be found here: [Poster](http://sme.astro.uu.se/poster.html)

# GUI

A GUI for PySME is available in its own repository [PySME-GUI](https://github.com/MingjieJian/PySME-GUI).

# Windows

Unfortunately PySME is not supported in Windows right now. While there is a SME C libary for Windows, it is not compatible with the Python C Extension inteface on Windows as it was compiled with a different compiler. Therefore if you want to use PySME you would need to compile the SME library with the same compiler.
django-admin-changeform-actions 0.5.4
Reuse model admin changelist actions on changeform pages
Requires Python: >=3.8

# django-admin-changeform-actions

[![Run pytest](https://github.com/cb109/django-admin-changeform-actions/actions/workflows/pytest.yml/badge.svg)](https://github.com/cb109/django-admin-changeform-actions/actions/workflows/pytest.yml)
[![Run tox](https://github.com/cb109/django-admin-changeform-actions/actions/workflows/tox.yml/badge.svg)](https://github.com/cb109/django-admin-changeform-actions/actions/workflows/tox.yml)

Replicates the admin
[actions](https://docs.djangoproject.com/en/dev/ref/contrib/admin/actions/)
dropdown (available on a model's `changelist` page) on each model
instance's `changeform` page.

<img src="https://raw.githubusercontent.com/cb109/django-admin-changeform-actions/refs/heads/main/docs/changeform_actions_ui.png" width="800">

Instead of targetting a selection the action will target the current
model instance only.

## Installation

Install the package:

```bash
pip install django-admin-changeform-actions
```

Modify your Django project like:

```py
# settings.py

INSTALLED_APPS = [
  "changeform_actions",  # Must be placed before Django's admin app!
  ...
  "django.contrib.admin",
]
```

```py
# urls.py

urlpatterns = [
  path("", include("changeform_actions.urls"))
]
```

```py
# admin.py

from changeform_actions import ChangeFormActionsMixin

class MyModelAdmin(ChangeFormActionsMixin, admin.ModelAdmin):
    actions = [...]
```

## Development Setup

This project uses [uv](https://docs.astral.sh/uv/) to handle python versions and dependencies.

```bash
uv sync
```

To do a new release, bump the version in `pyproject.toml`, then:
```bash
uv build
uv publish
```

## Tests

```bash
uv run pytest
```

Run test matrix of different python versions VS different django versions:
```bash
uv run tox
```
ssb-datadoc-model 8.0.3
Data Model for use in Statistics Norway's Metadata system
Requires Python: >=3.10

# ssb-datadoc-model

Data Model for use in Statistics Norway's Metadata system

## Purpose

This package contains pydantic models defining the fields and data types used in Statistics Norway's metadata system. The purpose of these models is to:

- Enable validation of user data
- Enable serialization and deserialization of metadata files
- Support versioning of the metadata format
- Enforce consistency across multiple tools

## Release

To release this package, create a branch and run `uv version --bump [patch | minor | major]` depending on your change. Once the branch is merged, a GitHub Actions workflow handles the rest.
pyaga8 0.1.15
Python package for calculating gas properties using the AGA8 equations GERG-2008 and DETAIL
Requires Python: >=3.8
Keywords: AGA8, gas properties, GERG-2008, DETAIL

# pyaga8
Python package for calculating gas properties using the AGA8 equations GERG-2008 and DETAIL, utilizing the Rust port ((https://crates.io/crates/aga8) of NIST's AGA8 code (https://github.com/usnistgov/AGA8).

Link to Github repo: https://github.com/equinor/pyaga8

## Description

`pyaga8` is a Python package that provides bindings for the AGA8 algorithm (GERG-2008 and DETAIL equations). The core functionality is implemented in Rust for performance, and it is exposed to Python using the `pyo3` library.

`pyaga8` is used by the `pvtlib` package: https://pypi.org/project/pvtlib/
`pvtlib` include methods built on top of the pyaga8 functions, such as gas properties from PT (pressure, temperature), PH (pressure, enthalpy), PS (pressure, entropy) and rhoT (density, temperature). 
Link to example: https://github.com/equinor/pvtlib/blob/main/examples/gas_properties_from_aga8.py

## Installation

You can install the package using `pip`:

```sh
pip install pyaga8
promptbind 0.2.2
Add your description here
Requires Python: >=3.10

# PromptBind

PromptBind lets you bind prompts to functions and methods with a small decorator and TOML sidecar files. It keeps prompts close to your code, supports optional Jinja2 rendering, and allows hot-swapping prompt keys at runtime.

## Installation

```bash
pip install promptbind
```

## QuickStart

1) **Create a prompt file** next to your Python module (same name, `.toml` extension):

```toml
# example.toml
[greet]
prompt = "Hello, {{ name }}!"
use_jinja2 = true

[farewell]
prompt = "Goodbye."
use_jinja2 = false
```

2) **Bind prompts to functions** with the decorator. By default the prompt key is the function `__qualname__`, but you can override it with `key=...`.

```python
# example.py
from promptbind import with_prompt, PromptEntry

@with_prompt()
def greet(prompt: PromptEntry) -> str:
    return prompt.render(name="Ada")

@with_prompt(key="farewell")
def bye(prompt: PromptEntry) -> str:
    return prompt.render()

if __name__ == "__main__":
    print(greet())  # -> Hello, Ada!
    print(bye())    # -> Goodbye.
```

3) **Patch prompt keys at runtime** if you want to swap to another entry in the same TOML file:

```python
from promptbind import set_prompt_key_patch, unset_prompt_key_patch

set_prompt_key_patch(greet, "farewell")  # greet now uses the farewell prompt
print(greet())  # -> Goodbye.
unset_prompt_key_patch(greet)            # revert to original key
```

## How it works

- A `.toml` file lives next to each Python file and stores prompt entries.
- `with_prompt` checks the TOML at import time, injects the matching `PromptEntry`, and routes calls to your function with `prompt` as the first argument (methods get `self`/`cls` first, then `prompt`).
- `PromptEntry.render(**kwargs)` renders with Jinja2 when `use_jinja2 = true`; otherwise it returns the raw string (passing kwargs in that case is a no-op).

## Thread safety note

`set_prompt_key_patch`/`unset_prompt_key_patch` mutate shared process-wide state. Avoid calling them concurrently across threads, or you may observe races where a call picks up the wrong prompt key. If you must patch in a multithreaded context, guard these calls with your own locking.

## Minimal project layout

```
project/
├─ example.py
└─ example.toml
```

That is all you need to start binding prompts to your code. See `test/example.py` and `test/example.toml` in the repo for a runnable sample.
tranche 0.4.0
ConfigParser with layered precedence, provenance, comment-preserving writes, and safe expressions.
Requires Python: >=3.10
Keywords: config, configparser, layered, provenance, numpy, safe-eval

![tranche logo](https://raw.githubusercontent.com/xylar/tranche/main/docs/logo/tranche_logo_small.png)

# tranche

ConfigParser with layered precedence, provenance, comment-preserving writes, and safe expressions.

The name **tranche** comes from the French word for *slice* — a nod to how the
library lets you cut cleanly through multiple configuration layers to get a
single, effective view of your settings.

## Documentation

Full docs: https://xylar.github.io/tranche/

## Install

- From PyPI (no NumPy):

```bash
pip install tranche
```

- With NumPy extras (to enable safe NumPy expressions):

```bash
pip install tranche[numpy]
```

- From source (local checkout):

```bash
pip install .
```

## Quick start

```python
from tranche import Tranche

config = Tranche()
config.add_from_file("defaults.cfg")
config.add_user_config("user.cfg")

# Simple values
value = config.get("core", "option")

# Expression (literal backend chosen automatically)
points = config.getexpression("plot", "ticks")

# NumPy expression (auto-selects safe backend because allow_numpy=True)
arr = config.getexpression("plot", "bins", allow_numpy=True)

# Or via convenience helper
arr2 = config.getnumpy("plot", "bins")

# Provenance
info = config.explain("plot", "bins")
print(info)
```

## Security notes

- Expressions default to `backend="literal"` for safety.
- The `safe` backend only allows a small AST subset and a very small set of symbols.
- NumPy is opt-in via `allow_numpy=True` and the `numpy` extra.

## Extensibility

You can add your own safe symbols:

```python
import math
config.register_symbol("sqrt", math.sqrt)
```

## Links

- Docs: https://xylar.github.io/tranche/
- Source: https://github.com/xylar/tranche
- Issues: https://github.com/xylar/tranche/issues

## License

BSD-3-Clause
nzmath 3.0.3
Python calculator on number theory
Requires Python: >=3.9

NZMATH 3.0.3 (Python Calculator on Number Theory)
===================================================

Introduction
------------

NZMATH is a Python calculator on number theory.  It is freely available and distributed under the BSD license.  All programs are written only by Python so that you can easily see their algorithmic number theory.  You can get NZMATH with a single command::

    % python -m pip install -U nzmath

Here % is the command line prompt of Windows or Unix/macOS.

This release contains several program corrections and additions obtained by writing a programming "notebook" of the book 'Lectures on Elementary Number Theory' (TAKAGI, Teiji) in Python-NZMATH language.  The "notebook" itself is also available together with NZMATH calculator.  It is designed for beginning students of algorithmic number theory to self-study Number Theory, Programming and scientific English together.  It is possible only by running and reading the programs.  You can get the `notebook here`_.

.. _`notebook here`: https://sourceforge.net/projects/nzmath/files/nzmath-enttakagi/

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

Detailed `tutorial on installing packages`_ will help you to install
NZMATH on your machine.

.. _`tutorial on installing packages`: https://packaging.python.org/en/latest/tutorials/installing-packages/

First, you must have Python 3.9 or later.  Ensure you can run Python
from the command line::

    % python --version

Python is available from https://www.python.org/ .

Next, ensure you can run pip from the command line::

    % python -m pip --version

Usually, you must have appropriate write permission.  Then, ensure pip,
setuptools, and wheel are up to date::

    % python -m pip install -U pip setuptools wheel

Only when you worry about garbage of previous NZMATH, clean it::

    % python -m pip uninstall nzmath

Finally, install NZMATH from PyPI::

    % python -m pip install -U nzmath

This final step, you may install from local archives.  For that, you
need to download sdist and/or wheel::

    nzmath-3.0.3-tar.gz
    nzmath-3.0.3-py3-none-any.whl

in advance.  You can get them at SourceForge_.

.. _SourceForge: https://sourceforge.net/projects/nzmath/files/nzmath/

You can also find them at PyPI_.

.. _PyPI: https://pypi.org/project/nzmath/

Now, go to the directory archives are put, and install NZMATH::

    % python -m pip install -U nzmath-3.0.3.tar.gz

by using sdist.  You may use wheel nzmath-3.0.3-py3-none-any.whl or
both.  See the `tutorial on installing packages`_ in detail.

Usage
-----

NZMATH is provided as a Python library package named 'nzmath', so
please use it as a usual package.  For more information please refer
Tutorial_.

.. _Tutorial: https://nzmath.sourceforge.io/tutorial.html

Feedback
--------

Your feedbacks are always welcomed.  Please consider to join the
`mailing list`_.

.. _`mailing list`: https://nzmath.sourceforge.io/ml.html

Copyright
---------

NZMATH is distributed under the BSD license.  Please read LICENSE.txt_.

.. _LICENSE.txt: https://nzmath.sourceforge.io/LICENSE.txt
preheat-open 2.7
Python wrapper for Neogrid Technologies' REST API
Requires Python: >=3.10

# PreHEAT Open Python Package

This is the open Python package designed to wrap [Neogrid's REST API](https://neogrid-technologies.gitlab.io/neogrid-api/).

For a quick introduction on how to use the package, see the [quick start guide](https://gitlab.com/neogrid-technologies-public/preheat-open-python/-/blob/master/docs/source/tutorials/quick_start.ipynb).

## Installation and configuration

### Simple installation:
Install the package directly from [PyPi](https://pypi.org/project/preheat-open/) using:

    pip install preheat_open

### Configuring the toolbox
First, make sure that you have created an API key for your user. This can be done on your [user profile page in the PreHEAT App](https://app.neogrid.dk/v2/#!/app/user/profile).

Your API key may be set within the code code itself. We do however recommend to use a YAML configuration file. This user configuration file should be located in the following directories:

| OS      | User level (recommended)                  | Machine level                  |  
|---------|-------------------------------------------|--------------------------------|
| Windows | C:/Users/[your user]/.preheat/config.yaml | (unsupported)                  |
| Linux   | ~/.preheat/config.yaml                    | /etc[/opt]/preheat/config.yaml |


The default content of a YAML configuration file is given here. The API key can be pasted under neogrid_api -> token.

```
cache:
  directory: null
  size_limit: null
  time_to_live: null
  type: null
logging:
  format: '%(asctime)-23s  %(levelname)-8s  %(name)-32s  %(message)-80s'
  level: 20
neogrid_api:
  token: ''
  url: https://api.neogrid.dk/public/api/v1
personal:
  email: ''
  name: ''
  runtime_mode: 10
  timezone: Europe/Copenhagen
```

For information about the additional fields, please check the [quick start guide](https://gitlab.com/neogrid-technologies-public/preheat-open-python/-/blob/master/docs/source/tutorials/quick_start.ipynb).

## Additional Information
You can find additional information about the [PreHeat REST API here](https://neogrid-technologies.gitlab.io/neogrid-api/).
[Neogrid Technologies company homepage](https://neogrid.dk/)

## Contributions

We encourage pull requests if you have developed new interesting features.

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
pygithub-assist 0.1.0
Internal package to automatically create GitHub issues
Requires Python: >=3.8

# github_issue_creator

Version: 0.1.0

## Overview

A lightweight internal Python package to create GitHub issues using PyGithub.
Designed for private distribution inside your company.

## Installation (from git)
```bash
pip install git+https://github.com/your-company/github_issue_creator.git
```

## Quick example
```python
from github_issue_creator import create_issue

resp = create_issue(
    repo_owner="Lokesh-techy",
    repo_name="django-testing",
    title="Automated Issue Creation Test",
    body="Issue body text",
    assignees=["Lokesh-techy"],
    labels=["bug"],
)
print(resp)
```

## Token
Set the GitHub token as an environment variable:
```bash
export GITHUB_ISSUE_CREATION_TOKEN=ghp_...
```

## Notes
- This package depends on `PyGithub`.
- For internal distribution, push this repo to a private GitHub or upload the built wheel to your private PyPI.
lokesh-github-issue-creator 0.1.0
Internal package to automatically create GitHub issues
Requires Python: >=3.8

# github_issue_creator

Version: 0.1.0

## Overview

A lightweight internal Python package to create GitHub issues using PyGithub.
Designed for private distribution inside your company.

## Installation (from git)
```bash
pip install git+https://github.com/your-company/github_issue_creator.git
```

## Quick example
```python
from github_issue_creator import create_issue

resp = create_issue(
    repo_owner="Lokesh-techy",
    repo_name="django-testing",
    title="Automated Issue Creation Test",
    body="Issue body text",
    assignees=["Lokesh-techy"],
    labels=["bug"],
)
print(resp)
```

## Token
Set the GitHub token as an environment variable:
```bash
export GITHUB_ISSUE_CREATION_TOKEN=ghp_...
```

## Notes
- This package depends on `PyGithub`.
- For internal distribution, push this repo to a private GitHub or upload the built wheel to your private PyPI.