semvec/pypi-packages huggingface dataset:
utpy 2.4.0
youtube downloader python package
Requires Python: >=3.7

# utpy

simple python library for download youtube video or playlist.

utpy = U (you) - T (Tube) - PY (python)

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install utpy.

```bash
pip install utpy
```

## Usage

```python
import utpy

# Default Settings. The default is like this if you dont define settings.
default_settings = {
    'save_to' : None, # Path to save downloaded video(s) if you want. Read Note (1)
    'file_name' : None, # you can select video files name
    'quality' : None, # Select video quality: 360p or 720p (default: 720p)
    'dl_range' : (), # Define a range to videos in that range in playlist. example: (2, 8) 
    'dl_list' : [], # Select some videos form playlist to download them. example: [5, 7, 8, 12]
    'retries' : 2, # Retries to download video if content not received.
    }

# video or playlist url
url = 'https://www.youtube.com/watch?v=bIGBYOcxMqM' 

# Load utpy!
yt = utpy.Load(url, settings = default_settings)

# return all information as dictionary
yt.data

# download video or videos of playlist
yt.download
```

##### Note (1): Correct save_to formts:

```
{'save_to' : 'D:/path/to/directory'}
or
{'save_to' : r'D:\path\to\directory'}
or
{'save_to' : 'D:\\\path\\\to\\\directory'}
```
test-aide 0.1.1
Package of helper functions to be used for unit testing
Requires Python: >=3.6

# test-aide

----

`test-aide` is a lightweight package containing helper functions to simplify certain aspects of unit testing. See the [documentation](https://test-aide.readthedocs.io/en/latest/) for the full list of features.

The `equality` module contains helpers that simplfy asserting equality when working with `pandas` or `numpy` types, in particular when working with these types nested in other data structures e.g. a dict containing ``pandas.DataFrame`` object(s).

The `functions` module contains helpers that simplfy asserting that a function was called in a particular way. The functions `assert_function_call` and `assert_function_call_count` are available to be used as context managers to test a function is called in a certain way and called a specific number of times respectively.

## Installation

`test-aide` can be installed from PyPI simply with;

 `pip install test-aide`

## Documentation

Documentation for the package can be found on [readthedocs](https://test-aide.readthedocs.io/en/latest/).

To build the html documentation locally, from the `docs` directory run the following;

```shell
make html
```

## Build and test

The test framework we are using for this project is [pytest](https://docs.pytest.org/en/stable/), to run the tests follow the steps below.

First clone the repo and move to the root directory;

```shell
git clone https://github.com/lvgig/test-aide.git
cd test-aide
```

Then install `test-aide` in editable mode;

```shell
pip install -e . -r requirements-dev.txt
```

Then run the tests simply with `pytest`;

```shell
pytest
```

## Contribute

`test-aide` is under active development, we're super excited if you're interested in contributing! 

See the [CONTRIBUTING](https://github.com/lvgig/test-aide/blob/master/CONTRIBUTING.md) file for the full details of our working practices.

For bugs and feature requests please open an [issue](https://github.com/lvgig/test-aide/issues).
podiff2 0.0.1
compare two .po/gettext files for differences
Requires Python: >=3.6
Keywords: po gettext compare diff

# podiff.py
compare two .po/gettext files for differences

This program can be used to see added, deleted, changed, header messages.
It also has an option to display statistics, to show only the number of differences.

## How to use:
* `podiff.py first.po second.po -s`

It only displays statistics

* `podiff.py first.po second.po -a`

It only displays added messages

* `podiff.py first.po second.po -d`

It only displays deleted messages

* `podiff.py first.po second.po -adgs`

Displays these messages added, deleted, changed, and statistics

Enter the command `podiff.py -h` to see all options

This app is based on https://github.com/amandasaurus/podiff
MasterQuote 0.0.1
MasterLink TWSE/TAIFEX API package
Requires Python: >=3.8

# MasterLink TWSE/TAIFEX Python API

This repo hosts sample code to showcase how the Solace Python API could be used. You can find:

1. `/samples` --> runnable code showcasing different message exchange patters with the Python API
1. `/howtos` --> runnable code snippets showcasing how to use different features of the API. All howtos are named `how_to_*.py` with some sampler files under sub folders.
flask-decorator-tools 0.0.8
A package with tools for use with flask
Requires Python: >=3.6

# Flask Tools

This is a library that provides some simple tools for making an API with flask.

## Installation 
```
pip install flask-decorator-tools
```

## Usage

### Serialise and Deserialise
Decorators for flask routes are available for serialisation and deserialisation. To serialise return an object and a response code and the response will be serialised to JSON. If no response code is given a response code of 200 is assumed.
```
@app.route('/test', methods = ['POST'])
@serialise
@authenticate()
def post_form_entry():
    testOutputClass = TestOutputClass()
    return testOutputClass, 200
```
To deserialise a class must be passed to the decorator, the incoming JSON body will then be deserialised to an object that is passed to the route as a parameter. The same applys for deserialising the args for a request. 
```
@app.route('/test', methods = ['POST'])
@deserialise(TestInputClass)
@serialise
@authenticate()
def post_form_entry(testInputClass : TestInputClass):
    print(testInputClass)
    testOutputClass = TestOutputClass()
    return TestOutputClass, 200

@app.route('/test', methods = ['POST'])
@deserialise_args(FormEntryArgs)
@serialise
@authenticate()
def post_form_entry(args : TestInputClass):
    print(args)
    testOutputClass = TestOutputClass()
    return TestOutputClass, 200
```
The python classes that are deserialised to must accept a dictionary in their constructor. It is recommened that the pip package **json-schema-to-class** is used to generate the classes from json schemas.

### Configs
A tool is provided to pass configs from a JSON config file. The configs can be read from a json file like below.
```
{
    "tokens":{
        "token1":100,
        "token2":"2"
    }
    "database":{
        "keys":{
            "first_key":"first",
            "second_key":"second"
        },
        "codes":{
            "first_code":"first",
            "first_code":"second"
        }
    }
}
```
This json object can then have configs read as follows.
```
@parse("configs/config.json","tokens")
@dataclass
class TokensConfig:
  token1: int
  token2: str
tokensConfig = TokensConfig()

@parse("configs/config.json","database.keys")
@dataclass
class DataBaseKeyConfig:
  first_key: str
  second_key: str
dataBaseKeyConfig = DataBaseKeyConfig()

@parse("configs/config.json","database.codes")
@dataclass
class DataBaseKeyConfig:
  first_key: str
  second_key: str
dataBaseKeyConfig = DataBaseKeyConfig()
```
The parse decorator is used in conjunction with the **dataclass** decorator. The parse decorator takes two parameters, the first is the route to the config file to read from and the second is the route through the json config object to the object to fill the class from. It is expected that an instance of the class will be created once.