semvec/pypi-packages huggingface dataset:
matiz 0.1.4
Serves modern approach to data structures definition - with a minimal boilerplate.
Requires Python: >=3.7
Keywords: dataclasses,dataclass,yang,validation,yaml,raw,binary,encoding,decoding

## matiz

Python's 3.7 dataclasses got maried with pyyaml.

## Installation:
```sh
pip install matiz
```

## Usage example:

```py
import dataclasses
import matiz
from matiz import fields

@dataclasses.dataclass
class Some(matiz.ObsoleteAble):
    id: int = fields.Integer()
    mac: str = fields.MacAddress()
    ip: str = fields.IPv4()
    version: int = fields.Integer(default=411)

```
Now the `Some` object can be created as a pure python object (thanks to `dataclass`)
it is equipped with `__init__`, `__repr__`, `__eq__` and some other methods. 

```py
>>> obj = Some(123, 'aa:bb:cc:11:22:33', '192.168.11.6')
>>> obj
Some(id=123, mac='aa:bb:cc:11:22:33', ip='192.168.11.6', version=411)

>>> print(obj)
!iz/Some
id: 123
ip: 192.168.11.6
mac: aa:bb:cc:11:22:33
version: 411
```

It's attributes are regular python attributes:
```py
>>> obj.id
123

>>> obj.mac
'aa:bb:cc:11:22:33'

>>> obj.ip
'192.168.11.6'

>>> obj.version = 0  # can be assigned
>>> print(repr(obj))
Ints(id=123, mac='aa:bb:cc:11:22:33', ip='192.168.11.6', version=0)
```

It can be also deserialized from yaml directly to the custom object:

```py
>>> yaml_string = """
!iz/Some
id: 22001
ip: 12.13.14.15
mac: aa:bb:cc:11:22:33
version: 0
"""

>>> import yaml
>>> obj2 = yaml.load(yaml_string, Loader=yaml.Loader)
>>> repr(obj2)
Some(id=22001, mac='aa:bb:cc:11:22:33', ip='12.13.14.15', version=0)

```

*To be further documented...*
libopl 0.1.2
Library And Tool To Manage Open-PS2-Loader USB-Drives & Games

# libOPL - Poor-Python OPL-Manager & Library
This Repository containes the code for "popl". Popl is a simple Python implementation
of the "OPL Manager". While popl is the cli frontend, it's sub-classes can also
be used as a library to parse the "ul.cfg", split games to ul-format, download artwork, fix filenames, etc.

## Features
 - Add game images (iso's) to OPL-Drive 
   - Split them to UL-Format if needed/wanted
 - Read, write & merge ul.cfg
 - Download artwork for all games on drive from open API
 - List all games on a OPL-Drive
 - init OPL-Drive with all needed folders
 - Fix game names & artwork for all games on drive


## ToDo / Limitations / Known Bugs:
 - Fix "fix" function - lol
 - Lots of cleanup & error handling
 - Very buggy, alpha state code by a bad non-coder
 - Currently only available for Linux (port yourself)


## Installation
On Linux:
```
 pip3 install libopl
```


## Usage
```
$ opl --help
usage: opl [-h] [-f] {list,add,artwork,fix,init} ...

positional arguments:
  {list,add,artwork,fix,init}
                        Choose your path...
    list                List Games on OPL-Drive
    add                 Add Media Image to OPL-Drive
    artwork             Download Artwork onto opl_drive
    fix                 rename/fix media filenames
    init                Initialize OPL-Drive folder-structure

optional arguments:
  -h, --help            show this help message and exit
```
IndigoPy 0.0.1a2
Basic function is done
Requires Python: >=3

# IndigoPy
This package contains some useful tools in many fields including GUI, mathematical functions, plot and protein. I just wrote what i need and I will keep updating it but it might not be well tested.

Modules below is completed:

* **IndigoPy.Protein.pdb**
* **IndigoPy.Math.Funcmaker**

Modules below is uncompleted but you can use it (be cautious, they may be different in a new version):

* **IndigoPy.Math.coordinates**
* **IndigoPy.Math.plot**

Modules below need some modifications before using:
* **IndigoPy.GUI**
scikit-quantum 0.0.6
Quantum Computing in Python
Requires Python: >=3.0, <4
Keywords: scikit scikit-learn quantum machine learning


![scikit-quantum logo](https://scikit-quantum.com/html/_static/logo.png)

# scikit-quantum

scikit-quantum is a Python module for quantum computing and quantum machine learning built primarily on top of PennyLane and is distributed under the Apache 2.0 license.

scikit-quantum is aimed to provide a user-friendly API while still harnessing the power of a quantum device. The goal is to create a set of tools that are vendor agnostic (although that has limited feasibility at this time), and bring the power of several quantum algorithms to new users.

# Building the Documentation

We use GitHub pages to host our documentation. 

The user-guide and manual for scikit-quantum can be found at: https://scikit-quantum.com

To compile the docs to the `docs` folder run:

> make -f build_tools/build_docs/Makefile html
sql-test 0.1.5b0
Conduct quality assurance testing on database tables
Requires Python: >=3.5

The SQL Test module assists in testing of data between SQL database tables. This is the development version of the module.

Use examples include comparing data in a view to those in a table derived from a star schema, or comparing results from a table derived from an external source to a table built via ETL.

## Main Features

- **Class: SQLTest**
    1. Creates and runs SQL database queries based on attributes provided with class instantiation or custom SQL query string.
    2. Completes five built in tests based on field-type categorizations of `count`, `low_distinct`, `high_distinct`, `numeric`, `id_check`.
    3. Flags fields above a specified difference threshold for "priority review".
    4. Displays a summary of results.
    5. Saves results and summary as specified.

- **Function: compare_tables**
    1. Auto-detects the type of test to be run.
    2. Utilizes methods of SQLUnitTest to complete a full comparison of table values.

- **Function: sql_query**
    1. Conducts basic database queries


## Functionality Overview
The concept behind the testing is that database information can often be segmented by a field, such as dates. Testing can be done by comparing field values across these groupings. For a more detailed description of the available functionality, check out the [development page](https://github.com/rebeccaebarnes/sql_analysis).

### Basic Query

<p align="left">
  <img src="https://raw.githubusercontent.com/rebeccaebarnes/sql_analysis/master/img/rental_view.PNG">
</p>

### Run Test Battery

**Setup Code**
<p align="center">
  <img src="https://raw.githubusercontent.com/rebeccaebarnes/sql_analysis/master/img/compare_tables_code.PNG">
</p>

A summarized version of results (as a DataFrame or image), indicating the percentage difference between table fields (and the test type used), is available via the test battery.

**Visual Summary**
<p align="center">
  <img src="https://raw.githubusercontent.com/rebeccaebarnes/sql_analysis/master/img/results.png">
</p>

## Setup
### First Installation
The files `sql_secrets.py` and `sql_config.py` provide examples of how the SQLAlchemy engines can be configured. These files should be customized for personal use. You can find these files in your Python/environment directory under Lib/site-packages/sql_test/.

When updating these files, **do not** change the name or location of the files. Doing so will cause errors in the future if updating.

## Dependencies
All dependencies are downloaded on installation if not already present. This module utilizes:
- Python v 3.5+
- [SQLAlchemy](https://www.sqlalchemy.org/)
- [pandas](https://pandas.pydata.org/)
- [NumPy](https://numpy.org/)
- [Matplotlib](https://matplotlib.org/)
- [Seaborn](https://seaborn.pydata.org/)
- [cx_Oracle](https://oracle.github.io/python-cx_Oracle/)
- [Psycopg](http://initd.org/psycopg/)

## Acknowledgements
Testing is completed using the [PostgreSQL DVD Rental](http://www.postgresqltutorial.com/postgresql-sample-database/) sample database.