semvec/pypi-packages huggingface dataset:
pytart 0.1.4
Vulkan-based GPGPU engine
Requires Python: >=3.9

# Tart

Tart is a GPGPU framework written in Vulkan.
It is designed to reduce the required boilerplate for harnessing Vulkan's compute capabilities,
while still not compromising in flexibility or feature set.

## Building

Regardless of interface, you will need gcc, g++, python3 headers, a vulkan driver, and CMake.
On Ubuntu and other Debian-based distros, these can be installed by running:
```bash
sudo apt install build-essential python3-dev 
```

The vulkan driver will depend on your device, but most should be accessible through mesa:
```bash
sudo apt install mesa-vulkan-drivers
```

For NVIDIA GPUs, driver install will depend on your GPU architecture. I do not yet have instructions for that.

### Python bindings
To install the python bindings, ensure GCC and CMake are installed.
Then do the following to install and run the python unit tests.:
```bash
git clone https://codeberg.org/softcookiepp/tart.git --recurse-submodules
pip install ".[test]"
```

### C++ library
To build tart with no statically linked compilers:
```
mkdir build
cd build
cmake ..
make
```

To build tart with compilers included (currently only glslang):
```
mkdir build
cd build
cmake -DTART_ENABLE_SHADER_COMPILERS=1 -DCMAKE_BUILD_TYPE=Release
make
```

## Testing
Unit tests are built along with everything else by default.
Simply execute the following to run them:
```
./run-tests
```

### Roadmap
- implement enabling of some default extensions for capabilities that are commonly used (partially done)
- make cross-platform, easily installable python bindings (likely will use https://scikit-build-core.readthedocs.io/en/latest/ and https://pybind11.readthedocs.io/en/stable/compiling.html) (in-progress)
- make python bindings for clspv (probably will be a separate project altogether)
- fix bugs and stuff
tempcache 0.0.13
Python library to cache data and function results in temporary files
Requires Python: >=3.10
Keywords: caching, tempfiles

# Python library to cache data and function results in temporary files

This library offers a simple way to cache data and function results using temporary files, including a mechanism for automatic expiration after a certain time.

Dy default, the package uses the `pickle` module to serialize data. Inputs are first serialized and then hashed to create unique cache file names.


> **Note**
For more advanced use cases you may want to look at the `Memory` class
in [joblib](https://github.com/joblib/joblib).


## Basic usage

An instance of the `TempCache` class be used as a decorator
to wrap a function and cache its results.

```python
from tempcache import TempCache

CACHE_MAX_AGE = 86_400  # one day
cache = TempCache("mycache", max_age=CACHE_MAX_AGE)

@cache
def long_running(...):
    ...

result = long_running(...)
```

## Caching results at the call site

You can also use a `TempCache` object to cache a function call directly 
at the call site with the `cache_result` method. 

```python
from tempcache import TempCache

CACHE_MAX_AGE = 86_400  # one day
cache = TempCache("mycache", max_age=CACHE_MAX_AGE)

def long_running(...):
    ...

result = cache.cache_result(long_running, ...)
```


## Custom serialization

In cases where the inputs or result cannot be serialized by `pickle`
you should use a pickler module like `cloupickle`.

```python
import cloudpickle

from tempcache import TempCache

CACHE_MAX_AGE = 86_400  # one day
cache = TempCache("mycache",
                    pickler=cloudpickle,
                    max_age=CACHE_MAX_AGE)
```


## Examples

Examples notebooks are in the `extras` folder.

## Installation

You can install this package with `pip`.

```console
pip install tempcache
```

## Related projects

- [joblib](https://github.com/joblib/joblib)
Computing with Python functions
- [percache](https://pypi.org/project/percache/)
Persistently cache results of callables
- [disckcache](https://pypi.org/project/diskcache/)
Disk and file backed cache library compatible with Django
- [cloudpickle](https://github.com/cloudpipe/cloudpickle)
Extended pickling support for Python objects
- [cached_path](https://github.com/allenai/cached_path)
A file utility for accessing both local and remote files through a unified interface
flywheel-migration 13.10.5
Flywheel Migration Toolkit
Requires Python: ~=3.10.0
Keywords: Flywheel, data, flywheel, migration, toolkit

# Flywheel Migration Toolkit

**flywheel-migration** is a library that provides configurable parsing and
de-identification of foreign data.

## Development

Install the project using [uv](https://docs.astral.sh/uv/) and enable
[pre-commit](https://pre-commit.com/).

```bash
uv sync --all-extras --python 3.10
pre-commit install
```

## Testing

Tests are handled in pre-commit containers using
[qa-ci](https://gitlab.com/flywheel-io/tools/etc/qa-ci).

```bash
uv run pytest
```

To run individual tests natively such as `test_jitter_for_dicom` in
`test_dicom_file_profile.py`

```bash
uv run pytest -vv tests/test_dicom_file_profile.py -sk test_jitter_for_dicom
```

To run all pre-commit hooks, run:

```bash
pre-commit run -a
```

This will execute all hooks defined in [.pre-commit-config.yaml](.pre-commit-config.yaml).

## Release

Releases are handled with qa-ci automation. Head to
[Build >> Pipelines](https://gitlab.com/flywheel-io/public/migration-toolkit/-/pipelines)
page on repository's sidebar, then click on
[Run Pipeline](https://gitlab.com/flywheel-io/public/migration-toolkit/-/pipelines/new).
Select `Variable` in **Variables** dropdown, and entere `REASEASE` as **variable key**.
Set **variable value** to desired version and click on `Run Pipeline`. This will
create a new release MR that can than be reviewed and merged to deploy a new release.

## Documentation

Documentation is automatically handled by `pre-commit` hook `generate_docs`. The
HTML page is built into `public` and deployed to GitLab pages. Documentation is
available at Documentation at
<https://flywheel-io.gitlab.io/public/migration-toolkit/>.
gifnoc 0.6.3
Handle configuration for multiple libraries
Requires Python: >=3.11


# Gifnoc

Gifnoc is a unified configuration system for Python modules.

The main objective of gifnoc is to unify configuration files, environment variables and command-line options, across multiple modules. For example, module A and module B can both define their own configuration models through gifnoc, map some environment variables to keys in that configuration, and then you may configure A and B in the same file.

Gifnoc also aims to validate configuration through a typed model based on dataclasses and implemented by the `serieux` package, a dependency of gifnoc.


## Features

* Typed configuration using dataclasses and `serieux`
* Use a single configuration tree for multiple libraries
* Multiple configuration files can be easily merged
* Easily embed configuration files in each other


## Example

**main.py**

```python
from dataclasses import dataclass, field
import gifnoc

@dataclass
class User:
    name: str
    email: str
    admin: bool

@dataclass
class Server:
    # Server post
    port: int = 8080
    # Server hostname
    host: str = "localhost"
    # List of users
    users: list[User] = field(default_factory=list)

# Define a configuration key
server_config = gifnoc.define("server", Server)

if __name__ == "__main__":
    # Load configuration from the file in $APP_CONFIG, if it exists
    # set_sources overrides any previous configuration
    # Each source can be a dictionary, ${envfile:...}, a Path object
    gifnoc.set_sources("${envfile:APP_CONFIG}")

    # Overlay configuration from environment variables
    # add_overlay adds on top of existing configuration
    gifnoc.add_overlay({
        "server.port": "${env:APP_PORT}",
        "server.host": "${env:APP_HOST}",
    })

    # Overlay configuration with --config, add options with mapping
    # --port will automatically use the type and documentation of Server.port
    gifnoc.cli(mapping={"server.port": "--port"})

    # server_config dynamically updates as sources/overlays are changed
    print("Port:", server_config.port)
    print("Host:", server_config.host)

    # You can apply local changes with a context manager, e.g. for testing:
    with gifnoc.overlay({"server.port": 90909}):
        print("Port:", server_config.port)  # Port: 90909
```


**config.yaml**

```yaml
server:
  port: 1234
  host: here
  users:
    - name: Olivier
      email: ob@here
      admin: true
    # You can write a file path instead of an object
    - mysterio.yaml
```


**mysterio.yaml**

```yaml
name: Mysterio
email: me@myster.io
admin: false
```


**Usage:**

```bash
python main.py --config config.yaml
APP_CONFIG=config.yaml python main.py
APP_PORT=8903 python main.py --config config.yaml
python main.py --config config.yaml --port 8903
```