semvec/pypi-packages huggingface dataset:
dbapi2abc 1.1.3
Provide an Abstract Base Class for PEP249 compliant databases
Requires Python: >=3.5, <4
Keywords: PEP249,Database,Database API

# dbapi2abc

This package provides abstract classes to present an interface to
[PEP249](https://www.python.org/dev/peps/pep-0249/) compliant database Connection and Cursor objects.

This allows you to use type hints on functions handling database
connections and cursors without needing to specify the specific
backend database engine being used.

```
from dbapi2abc import Connection, Cursor

class MyObject():
    def __init__(self, db: Connection):
        self.db = db

    def run_some_query(self) -> Cursor:
        cur = self.db.cursor()
        cur.execute("SELECT * FROM Table")
        return cur
```
aiogram-oop-framework 0.9.5
An extender for aiogram to make it more OOP
Requires Python: >=3.7

[![Dev Build Status](https://travis-ci.com/drforse/aiogram_oop_framework.svg?branch=master)](https://travis-ci.com/drforse/aiogram_oop_framework)  

# aiogram_oop_framework
An extender for aiogram to make it more OOP

docs: https://aiogram-oop-framework.readthedocs.io/en/latest


## [Live Templates](https://www.jetbrains.com/help/pycharm/using-live-templates.html) for PyCharm
You can find live templates in "misc/idea/live templates"  
To just install them all import all.zip through File | Manage IDE Settings | Import  
To install some of them you should follow these instructions:
1) copy the content of file with template which you want to add
2) go to File | Settings | Editor | Live Templates
3) add Template Group with any name you want (not required)
4) add Live Template to the group you created (or Python group)
5) Paste content to the created Live Template
6) Click edit variables
7) Edit variables as showed below:
    Name|Expression|Default value|Skip if defined   
    ---|---|---|---
    CLASS_NAME|capitalize(fileNameWithoutExtension())|   |as you wish
autochord 0.1.4
Automatic Chord Recognition library
Requires Python: >=3.6

# autochord

<p align="center">
  <img src="https://github.com/cjbayron/autochord/blob/main/images/title.png" width="400"/>
</p>

Automatic Chord Recognition tools

## About

`autochord` is:

&#10004; a [Python library](https://pypi.org/project/autochord/) for automatic chord recognition (using TensorFlow)

&#10004; a [Javascript app](https://cjbayron.github.io/autochord/) for visualization of chord transcriptions:

<p align="center">
  <img src="https://github.com/cjbayron/autochord/blob/main/images/autochord-js.png" width="900"/>
</p>

## Library Usage

To install library, run:
```
$ pip install autochord
```

`autochord` provides a very simple API for performing chord recognition:
```
import autochord
autochord.recognize('audio.wav', lab_fn='chords.lab')
# This gives out a list of tuples in the format:
#  (chord start, chord end, chord name)
# e.g.
# [(0.0, 5.944308390022676, 'D:maj'),
#  (5.944308390022676, 7.476825396825397, 'C:maj'),
#  (7.476825396825397, 18.250884353741498, 'D:maj'),
#  (18.250884353741498, 19.736961451247165, 'C:maj')
#  ...
#  (160.49632653061224, 162.30748299319728, 'N')]
```

Under the hood `autochord.recognize()` runs the NNLS-Chroma VAMP plugin to extract chroma features from the audio, and feeds it to a Bi-LSTM-CRF model in TensorFlow to recognize the chords. Currently, the model can recognize 25 chord classes: the 12 major triads, 12 minor triads, and no-chord ('N').

OPTIONALLY, you may dump the chords in a `.lab` file by using the `lab_fn` parameter. The output file follows the MIREX chord label format.

Upon import `autochord` takes care of setting up the VAMP plugin and downloading the pre-trained chord recognition model.

The measured test accuracy of the TensorFlow model is 67.33%. That may be enough for some songs, but we can explore in the future how to further improve this.

## App Usage

<p align="center">
  <img src="https://github.com/cjbayron/autochord/blob/main/images/autochord-js-ui.png" width="600"/>
</p>

The app is pretty straightforward: you need to load a song, then you can upload a LAB file to visualize its chord labels. You may use the `autochord` Python library for generating this file. Optionally, you may load another LAB file for comparison (e.g. ground-truth labels, LAB file from another model's prediction).

## Future Improvements

- Integrate everything into a full chord recognition app! For that we need to:
	- convert VAMP plugin to JS module
	- model conversion to TensorFlow.js (as of writing, some CRF operations are not supported by TFJS yet)
	- converting all other Python functions to JS equivalent
- Experimenting with other approaches to improve chord recognition accuracy
robonomics-interface-patara 0.1
Robonomics wrapper over https://github.com/polkascan/py-substrate-interface created to facilitate programming with Robonomics
Requires Python: >=3.6

# robonomics-interface
This is a simple wrapper over https://github.com/polkascan/py-substrate-interface used to facilitate writing code for applications using Robonomics.

Robonomics project: https://robonomics.network/

Robonomics parachain dapp: https://parachain.robonomics.network/
_______
# Installation 
```bash
pip3 install robonomics-interface-patara
```
# Usage
*More info may be found in docstrings in the source code*
```python
import robonomics_interface as RI
```
## Initialization
```python
interface = RI.RobonomicsInterface()
```
By default, you will only be able to fetch Chainstate info from Frontier parachain.
You can specify another **node address** (e.g. local), **seed** (more on that [later](#extrinsics)) and custom **registry types**. 


## Simple case: fetch Chainstate
Here, no need to pass any arguments, by
```python
interface = RI.RobonomicsInterface()
```
you will be able to read any Chainstate info from the Frontier parachain:
```python
num_dt = interface.custom_chainstate("DigitalTwin", "Total")
```
you can also specify an argument for the query. Several arguments should be put in a list.

There is a dedicated function to obtain **Datalog**:
```python
record = interface.fetch_datalog(<ss58_address>:str)
```
This will give you the latest datalog record of the specified account with its timestamp. You may pass an index argument to fetch specific record.

## Extrinsics
**Providing seed** (any raw or mnemonic) while initializing **will let you create and submit extrinsics**:
```python
interface = RI.RobonmicsInterface(seed:str = <seed>)
hash = interface.custom_extrinsic("DigitalTwin", "create")
```
hash is the transaction hash of the succeeded extrinsic. You can also specify arguments for the extrinsic as a dictionary.

There are dedicated functions for recording datalog and sending launch commands:
```python
interface.record_datalaog("Hello, Robonomics")
interface.send_launch(<ss58_address>:str, True)
```

This is an evolving package, it may have errors and lack of functionality, fixes are coming.
Feel free to open issues when faced a problem.