semvec/pypi-packages huggingface dataset:
docker-wrap 0.0.1
A drop-in wrapper for docker-compose that runs pre/post scripts
Requires Python: >=3.6

# Docker-Wrap

A drop-in wrapper for `docker-compose` that runs pre/post up and pre/post build scripts.

I frequently have scripts I want to run before/after `docker-compose`
build/up.  This wrapper creates a standard way to run everything by
just wrapping `docker-compose` and passing through all arguments.  You
use it wherever you normally use `docker-compose`.  You could even
symlink it as docker-compose in your /usr/local/bin.

The wrapper is smart enough to run your pre-build, even when build is
triggered by an `up` command.

The pre-build script runs before `Dockerfile` is loaded, so you can
*generate* your `Dockerfile` from your pre-build script.

If you're just pulling an image and not building a new image, the
pre/post build script does not run.

## Install

If you want to install system-wide but also have edits you make here reflected in that system-wide install:

    python3 -m setup develop


Or just install it like you normally would:

    python3 -m setup install

Eventually, this will work, but I haven't uploaded it to PyPi yet:

    pip3 install docker-wrap

## Use

For any service, add an associative array `x-wrap` with one or more
keys whose values are associative arrays named `build` or `use`.
Those associative arrays should contain `pre` or `post` keys whose
values are paths to scripts to run.  See the example below.

`docker-wrap` will run any `pre` script before it runs your command,
then run any `post` script.  A future feature will that be if a `pre`
script prints a valid yaml structure, `docker-wrap` will use that
script as the `docker-compose.yml` for running the command.

`docker-wrap` passes all arguments on to `docker-compose`.

Something like this would work:

    docker-wrap up foo

## Sample docker-compose.yml

    version: "3.9"
    services:
      foo:
        x-wrap:
            build:
              pre: pre-build.sh bar baz
        build: bar


The default directory for running `pre-build.sh` will be the `foo`
directory.  If you set context, it will be the context.

## Features Roadmap

    [X] Pre/post build scripts
    [X] Allow pre script to replace Dockerfile
    [ ] Allow pre script to replace docker-compose
    [X] Pre/post up scripts
    [ ] Use wrap instead of x-wrap
    [ ] pip installable

## Contributing

Activity is in the [GitHub
Repo](https://github.com/jvasile/docker-wrap.git) and you can always
pop in to [chat.opentechstrategies.com](chat.opentechstrategies.com)
as well.

Please run the [python qa
script](https://code.librehq.com/james/quest-for-awesome) on the code
before submitting a PR.  That script just runs black, isort, mypy, and
tests (tho we have no tests yet).

## License and Copyright

Copyright 2020 James Vasile, published under the terms of AGPLv3 or
later.
fast-norbert 1.0.2
Accelerated Wiener filter

# Fast Norbert

Fast Norbert is an optimized fork of https://github.com/sigsep/norbert.

## Performance

This is time (in seconds) that the filtering process takes on a single core:

| Test case | Original Norbert | Fast Norbert |
| ----------| ---------------- |--------------| 
| song 1 | 19.3 | **7.5** |
| song 2 | 27.5 | **10.9** |

# Norbert filter

Wiener filter is a very popular way of filtering multichannel audio for several applications, notably speech enhancement and source separation.

This filtering method assumes you have some way of estimating power or magnitude spectrograms for all the audio sources (non-negative) composing a mixture. If you only have a model for some _target_ sources, and not for the rest, you may use `fast_norbert.residual_model` to let Norbert create a residual model for you.

Given all source spectrograms and the mixture Time-Frequency representation, this repository can build and apply the filter that is appropriate for separation, by optimally exploiting multichannel information (like in stereo signals). This is done in an iterative procedure called _Expectation Maximization_, where filtering and re-estimation of the parameters are iterated.

From a beginner's perspective, all you need to do is often to call `fast_norbert.wiener` with the mix and your spectrogram estimates. This should handle the rest.

From a more expert perspective, you will find the different ingredients from the EM algorithm as functions in the module `fast_norbert.norbert`.

## Installation

`pip install fast_norbert`

## Usage

Asssuming a complex spectrogram `X`, and a (magnitude) estimate of a target to be extracted from the spectrogram, performing the multichannel wiener filter is as simple as this:

```python
import fast_norbert

x = stft(audio)
v = model(x)
y = fast_norbert.wiener(v, x)
estimate = istft(y)
```

## Authors

Artyom Palvelev (this repo) <br>
Antoine Liutkus, Fabian-Robert Stöter (original repo)

## License

MIT
teamverify 0.0.6
Automated reasoning tool for competitive Pokemon teambuilding
Requires Python: >=3.6

# TeamVerify : A Team Analysis tool for Competitive Pokemon

TeamVerify is a Competitive Pokemon teambuilding companion tool based on automated reasoning. 

## Installation

Before installing TeamVerify, you need to have Java installed. The reasoner underneath TeamVerify was written in Java, so the program will crash if it tries to run without Java.

TeamVerify is listed on the PyPI repository. Therefore, it is an easy install for anyone already running Python. Ensure you have a working distribution of Python 3.6 or higher then run the following command in a terminal window:
```
pip install teamverify
```
TeamVerify also needs to run a first-time setup script to populate its knowledge base. Once TeamVerify is installed simply run this command in a terminal window.
```
teamverify-fts
```
We also advise that you re-run this command whenever Smogon implements a major tier shift. TeamVerify's knowledge base only contains a subset of all Pokemon, so it may fall out-of-date as Pokemon shift into and out of OU.


## Usage
```
teamverify {txt/pokepaste} {outputfile}
```
Once installed, teamVerify can be invoked with the above command to the command line. TeamVerify works on one OU team at a time and produces console output as well as output to a text file. {txt/pokepaste} is a mandatory argument and should be the filename of a .txt file containing the team or a link to pokepast.es. {outputfile} is also a mandatory argument and should be the name of the output file you want created (output will have .txt appended to it, so don't include a file extension).
another-pid 0.0.3
Another PID controller package
Requires Python: >=3.6

# another-pid
Just Another PID controller.


# Usage
Initialize the PID controller.
```python
from another_pid import PID

pid = PID(0.5, 0.8, 1.2, time_interval=0.5, set_point=10)
```

Use the PID controller in a system.
```python
# initial value.
value = 0

while True:
  # use the value in a system.
  value = a_system(value)
  
  value = pid.next_value(value)
```