semvec/pypi-packages huggingface dataset:
vswobbly 0.3.0
Wobbly Vapoursynth Functions.
Requires Python: >=3.12

# vs-wobbly

<p align="center">
    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/vswobbly">
    <a href="https://pypi.org/project/vswobbly/"><img alt="PyPI" src="https://img.shields.io/pypi/v/vswobbly"></a>
    <a href="https://github.com/Jaded-Encoding-Thaumaturgy/vs-wobbly/commits/master"><img alt="GitHub commits since tagged version" src="https://img.shields.io/github/commits-since/Jaded-Encoding-Thaumaturgy/vs-wobbly/latest"></a>
    <a href="https://github.com/Jaded-Encoding-Thaumaturgy/vs-wobbly/blob/master/LICENSE"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/vswobbly"></a>
    <a href="https://discord.gg/XTpc6Fa9eB"><img alt="Discord" src="https://img.shields.io/discord/856381934052704266?label=discord"></a>
</p>

A collection of VapourSynth functions for parsing and filtering wobbly files.
Full information on how every function works,
as well as a list of dependencies and links,
can be found in the docstrings of each function and class.
For further support,
drop by `#dev` in the [JET Discord server](https://discord.gg/XTpc6Fa9eB).

## How to install

Install `vswobbly` with the following command:

```shell
pip install vswobbly
```

## How to use

Simplest way to use it is to pass a wobbly file (`.wob`) to `WobblyProcessor.from_file()`,
followed by calling `apply()`.

```python
from vswobbly import WobblyProcessor,

wob = WobblyProcessor.from_file('C:/path/to/wobbly.wob')
clip = wob.apply()
```

If you only need the parsed wobbly data,
you can use `WobblyParser.from_file()`:

```python
from vswobbly import WobblyParser

wob = WobblyParser.from_file('C:/path/to/wobbly.wob')
```

This will return a `WobblyParser` data class,
containing all the relevant data for video processing.
Note that metadata, information about wobbly's UI,
and wibbly parameters are currently excluded.

### Strategies

Different "strategies" can be passed to `WobblyProcessor`
to change how certain problems are handled internally.
This package comes with a handful included.

For example,
automatically handling combed frames
with vinverse:

```python
from vswobbly import WobblyProcessor, DecombVinverseStrategy

wob = WobblyProcessor.from_file(
    'C:/path/to/wobbly.wob',
    strategies=[DecombVinverseStrategy()]
)

clip = wob.apply()
```

Which would then run the [DecombVinverseStrategy](./vswobbly/process/strategies/combed.py) strategy
on all combed frames.

This is written to be really flexible,
and allow users to handle these problems however they see fit.
To implement your own strategy,
create a class and inherit from [AbstractProcessingStrategy](./vswobbly/process/strategies/abstract.py).
Refer to the existing strategies and the docstrings of the abstract class for examples.

Note: For orphan field handling to be handled correctly,
the strategy *must* have 'Orphan' in its name.
ingescape 4.6.2
Ingescape library python3 binding
Requires Python: >=3.7

# Ingescape Python binding

## Dependencies

The Ingescape Python binding relies on the following libraries:

- Python 3.8+
- setuptools, wheel

## Installing

Ingescape python binding is designed to be installed through pip

    python3 -m pip install ingescape

## Using Ingescape with Python

Two examples are provided in the 'examples' directory.

## Compiling the Ingescape Python binding

Ingescape library must be built before compiling the python binding.
The directory in which the library is expected to be built is given by the 'prepare' scripts.
Run the following commands from the Ingescape Python directory :

    python3 -m pip install setuptools wheel
    export PLATFORM="linux" (or "macos", or "windows" according to the platform you are on)
    ./prepare_for_packaging.sh (or prepare_for_packaging.ps1 for Windows Powershell)
    python3 -m pip install .

The last command will build and install the python binding on your environment.
modern-di-fastapi 2.7.0
Modern-DI integration for FastAPI
Requires Python: <4,>=3.10
Keywords: DI, FastAPI, dependency injector, ioc-container, python

"Modern-DI-FastAPI"
==
[![Test Coverage](https://codecov.io/gh/modern-python/modern-di-fastapi/branch/main/graph/badge.svg)](https://codecov.io/gh/modern-python/modern-di-fastapi)
[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
[![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-fastapi.svg)](https://pypi.python.org/pypi/modern-di-fastapi)
[![downloads](https://img.shields.io/pypi/dm/modern-di-fastapi.svg)](https://pypistats.org/packages/modern-di-fastapi)
[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di-fastapi)](https://github.com/modern-python/modern-di-fastapi/stargazers)

Integration of [Modern-DI](https://github.com/modern-python/modern-di) to FastAPI

Usage example: [fastapi-sqlalchemy-template](https://github.com/modern-python/fastapi-sqlalchemy-template)

## 📚 [Documentation](https://modern-di.readthedocs.io)
quartzbio 1.5.0
The QuartzBio Python client
Requires Python: >=3.8

QuartzBio Python Client
=======================

This is the QuartzBio Python package and command-line interface (CLI).


Installation & Setup
--------------------

Install `quartzbio` using `pip`:

    pip install quartzbio


For interactive use, we recommend installing `IPython` and `gnureadline`:

    pip install ipython
    pip install gnureadline


To log in, type:

    quartzbio login


Enter your QuartzBio credentials and you should be good to go!


Install from Git
----------------

    pip install -e git+https://github.com/quartzbio/quartzbio-python.git#egg=quartzbio


Development
-----------

    git clone https://github.com/quartzbio/quartzbio-python.git
    cd quartzbio-python/
    python setup.py develop

    or 

    pip install -e .


Or install `tox` and run:

    pip install tox
    tox


Releasing
---------

You will need to [configure Twine](https://twine.readthedocs.io/en/latest/#installation) in order to push to PyPI.

Maintainers can release quartzbio-python to PyPI with the following steps:

    bumpversion <major|minor|patch>
    git push --tags
    make changelog
    make release



Support
-------

For requests, please email QuartzBio Product Support.


Configuring the QuartzBio Client
-------

The QuartzBio python client can be configured by setting system environment variables.
Supported environment variables are:

`QUARTZBIO_API_HOST`     
- The URL of the target API backend. 
If not specified the value from the local credentials file will be used.

`QUARTZBIO_ACCESS_TOKEN` 
- The OAuth2 access token for authenticating with the API.

**The lookup order for credentials is:**
1. Access Token environment variable
2. API Key environment variable
3. Local Credentials file entry for the specific API host

`QUARTZBIO_LOGLEVEL` 
- The log level at which to log messages.
If not specified the default log level will be WARN.

`QUARTZBIO_LOGFILE`        
- The file in which to write log messages. 
If the file does not exist it will be created. 
If not specified '~/.quartzbio/quartzbio-python.log' will be used by default.

`QUARTZBIO_RETRY_ALL`
- Flag for enabling aggressive retries for failed requests to the API.
When truthy, the client will attempt to retry a failed request regardless of the type of operation.
This includes idempotent and nonidempotent operations:
"HEAD", "GET", "PUT", "POST", "PATCH", "DELETE", "OPTIONS", "TRACE"
If this value is not set it will default to false and retries will only be enabled for idempotent operations.


Documentation
-------------

Project documentation is powered by Sphinx + Sphinx Autobuild.

To build the docs locally and view them in a browser:

    make sphinx-autobuild