semvec/pypi-packages huggingface dataset:
scriptifier 0.0.14
A Python package that allows to run a function in a separated script, seamlessly.
License: MIT
Keywords: scriptify,processify,processifier,subprocess,multiprocessing,memory,leak

# scriptifier
`scriptifier` is a Python package that allows to run a function in a separated script, seamlessly. 

## Install
PyPI: `pip install scriptifier`<br/>

## Usage
```python
from scriptifier import scriptifier

def func_1(in):
    (...)
    return out

scriptified_func_1 = scriptifier.run_as_script(func_1)
out = scriptified_func_1(in)
```

- Each argument must be **pickleable**<br/>
- Each return value must be either:
  - pickleable
  - a `tf.keras.Model` object
  - an iterable whose elements are `tf.keras.Model` objects

## Features
- Tested on Windows and Linux
- Supports overlapping/parallel calls<br/>
- Supports functions from imported packages and modules<br/>
- Doesn't rely on `multiprocessing` package<br/>
- Doesn't rely on a queue for the returns (which would add a limit the size)<br/>


## Possible uses
- Memory leaks managemenet (100% of the memory allocated within the function will be freed once it ends)<br/>
- Function specific resource usage monitoring<br/>
fastapi-operation-id 0.1.0
A FastAPI utility for cleaner operation ids
License: MIT
Requires Python: >=3.6,<4.0

# FastAPI Operation ID
##### A FastAPI utility for cleaner operation ids

## Usage
FastAPI Operation ID contains a single function, `clean_ids`.
```python
from fastapi import FastAPI
from fastapi_operation_id import clean_ids

app = FastAPI()


@app.get("/home")
def hello_world():
    return "Hello, world"

clean_ids(app)
```

Before `clean`, the operation id would is `hello_world_home_get`.

After `clean_app`, the operation id is `hello_world`.

## Why
Code generation on OpenAPI often use a route's operationId as the function name.
FastAPI defaults to operation IDs that, while descriptive, make poor function names.
FastAPI Operation ID changes the operation IDs to be human friendly.
ffmpy3 0.2.4
A simple asynchronous Python wrapper for ffmpeg
License: MIT
Keywords: ffmpeg ffprobe wrapper audio video transcoding

.. image:: https://img.shields.io/pypi/v/ffmpy3.svg
    :target: https://pypi.python.org/pypi/ffmpy3
    :alt: Latest version

.. image:: https://travis-ci.org/wchill/ffmpy3.svg?branch=master
    :target: https://travis-ci.org/wchill/ffmpy3
    :alt: Travis-CI

.. image:: https://readthedocs.org/projects/ffmpy3/badge/?version=latest
    :target: http://ffmpy3.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status


ffmpy3
======
ffmpy3 is a fork of ffmpy, a simplistic `FFmpeg <http://ffmpeg.org/>`_ command line wrapper. ffmpy implements a Pythonic interface for executing FFmpeg via command line and uses Python's `subprocess <https://docs.python.org/3/library/subprocess.html>`_ module for synchronous execution. Asynchronous execution using `yield from` or `await` is also supported using Python's `asyncio.subprocess <https://docs.python.org/3/library/asyncio-subprocess.html>`_ module.

Installation
------------
You guessed it::

  pip install ffmpy3

Quick example
-------------
The following code snippet executes FFmpeg synchronously, taking ``input.mp4`` from the current directory as the input. It remuxes the contents of ``input.mp4`` into a new file called ``output.avi`` which is saved in the current directory.

.. code:: python

  >>> import ffmpy3
  >>> ff = ffmpy3.FFmpeg(
  ...     inputs={'input.mp4': None},
  ...     outputs={'output.avi': None}
  ... )
  >>> ff.run()

The following code snippet does the same thing as above, but executes FFmpeg asynchronously.

.. code:: python

  >>> ff = ffmpy3.FFmpeg(
  ...     inputs={'input.mp4': None},
  ...     outputs={'output.avi': None}
  ... )
  >>> ff.run_async()
  >>> await ff.wait()

Documentation
-------------
http://ffmpy3.rtfd.io

See `Examples <http://ffmpy3.readthedocs.io/en/latest/examples.html>`_ section for usage examples.

License
-------
ffmpy3 is licensed under the terms of the MIT license.
fmri-anonymizer 0.2.11
Anonymize your DICOM and NIFTI files with this tool easily.
License: MIT
Requires Python: >=3.7

# fMRI Anonymizer

This project contains a series of scripts that perform 2 essential steps:

1. De-Identification
2. De-Facing

The main purpose of this project is to have an "all-purpose" application that can automatize the whole anonymization process on MRI, fMRI data. This includes DICOM, and NIFTI formats. 

This application follows a "best-effort" approach in order to comply with [HIPAA regulations](https://www.hhs.gov/hipaa/for-professionals/privacy/laws-regulations/index.html).

## Pre-requisites

Since this is a module that leverages on other packages, there are 2 main dependencies that must be installed within your system prior to install this solution.

You will need:
1. **FSL**: Please follow [this link](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FslInstallation/MacOsX) to install it.
   
   1.1. ***Make sure to install XQuartz before installing FSL. This is mentioned within their site.***
2. **dcm2niix**: This is a dependency used to convert DICOM into NIFTI format.

    2.1. In order to install it, you can safely use ***[brew](https://formulae.brew.sh/formula/dcm2niix)***.
   
    2.2. You can also follow [this tutorial](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage).

## How to install it?

In order to use this package, you will need to use the following command (recommended using it in a separate environment - like conda or venv):

`pip install fmri-anonymizer`

## How to use it?

This is pretty simple, you have 2 ways to use it:

`python -m fmri_anonymizer -i <INPUT_FOLDER> --dicom --anonymize --deface YES -o <OUTPUT_FOLDER>`

Or:

`fmri_anonymizer -i <INPUT_FOLDER> --dicom --anonymize --deface YES -o <OUTPUT_FOLDER>`

Here, a complete example:
```shell
python -m fmri_anonymizer -i "<path_source_dicom_files>" --dicom True --nifti True --deface True --anonymize True -o "<output_path>"
```

## How to get some help?

Simply type:

`python -m fmri_anonymizer -h`



H4ppy H4ck1n6!
upackage 0.3.4
Generate .unitypackage without Unity.
License: MIT
Keywords: upackage

# upackage

[pypi-build-status]: https://img.shields.io/pypi/v/upackage.svg
[travis-ci-status]: https://img.shields.io/travis/AgeOfLearning/upackage.svg

[![pypi][pypi-build-status]](https://pypi.python.org/pypi/upackage)
[![travis][travis-ci-status]](https://travis-ci.org/AgeOfLearning/upackage)

## About

upackage is a python module for generating *.unitypackage from source assets without unity.

## Install

```python
pip install upackage
```

## How to use
Given the following setup:
```
some/path/to/my/content/
some/path/to/my/content/code.dll
some/path/to/my/content/object.prefab
some/path/to/my/content/code.dll.mbd
```

The command will generate a package that installs the content of "some/path/to/my/content/" into "Assets/content/".
It uses the last folder name in the path as the containing folder for the assets.

```python
UPackage.preprocess_assets("some/path/to/my/content")
UPackage.generate_package("some/path/to/my/content", "output.unitypackage")
```

## Command Line Access
The tool also supports CLI access:
```bash
upackage some/path/to/my/content output.unitypackage
```


## MetaFiles
*.meta files will be generated if they do not exist for files & folders.
dacite-ignore-case 1.0.1
Extends dacite.from_dict with a ignore case function
License: MIT
Requires Python: >=3.9.*

# dacite-ignore-case
Initialize dataclasses from dictionaries (based on dacite) but with case ignorance.

## Usage
```python
import dacite_ignore_case
from dataclasses import dataclass


@dataclass
class MyClass:
  myKey: str
  
  
data = {'mykey': 'value'}

c = dacite_ignore_case.from_dict(MyClass, data)
```

## Installation
`pip3 install dacite_ignore_case`
resistics 1.0.0a3
Python package for processing magnetotelluric data
License: MIT
Requires Python: >=3.8.1,<3.10
Keywords: geophysics,magnetotellurics,electromagnetic,resistivity,statistics

## Welcome

[![PyPI Latest Release](https://img.shields.io/pypi/v/resistics.svg)](https://pypi.org/project/resistics/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/resistics)](https://pypi.org/project/resistics/)
[![Documentation Status](https://readthedocs.org/projects/resistics/badge/?version=latest)](https://resistics.readthedocs.io/en/latest/?badge=latest)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/resistics/resistics.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/resistics/resistics/context:python)
[![codecov](https://codecov.io/gh/resistics/resistics/branch/master/graph/badge.svg?token=CXLJC9J7AW)](https://codecov.io/gh/resistics/resistics)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

Resistics is a native Python 3.8+ package for the processing of magnetotelluric
(MT) data. It incorporates robust processing methods and adopts a modular
approach to processing which allows for customisation and future improvements
to be quickly adopted.

## Latest news

Resistics is moving to version 1.0.0 which will be a breaking change versus
the current stable version of 0.0.6. Currently, version 1.0.0 is available as a
pre-release on PYPI.

- Documentation for 1.0.0: https://resistics.readthedocs.io/
- Documentation for 0.0.6: https://resistics.io/

When version 1.0.0 reaches a stable releases the documentation will move to the
main resistics.io site.

## Audience

Resistics is intended for people who use magnetotelluric methods to estimate the
subsurface resistivity. This may be for furthering geological understanding, for
geothermal prospecting or for other purposes.

The package may have utility for the wider electromagnetic geophysics community.

## Getting started

To install the pre-release of version 1.0.0

python -m pip install resistics==1.0.0a0

For the stable 0.0.6 version

python -m pip install resistics

## Support and feature requests

Feel free to submit issues, feature requests or ideas for improvements in the
Github issues section.