semvec/pypi-packages huggingface dataset:
auto1-etl-challenge 1.1.0
Auto1 ETL Challenge
Keywords: auto1,challenge_me,etl pipeline

# Auto1 ETL Challenge

A simple ETL pipepline that serves the purpose of a challenge for [AUTO1](https://www.auto1.com/en/home), a company that is Europe's largest wholesale platform for used cars.

Developed by Muhammad Aqib - inbox.aqib@gmail.com

# Contents

- `auto1_etl_challenge` contains the project directory.
- `auto1_etl_challenge\etl.py` is the main module that has `EtlPackageAuto1` class with associated methods.
- `auto1_etl_challenge\utils.py` holds utilites that assists in performing etl operations.
- `auto1_etl_challenge\transformations.py` module for defining custom exceptions for the required columns.
- `auto1_etl_challenge\constants.py` holds classes for different constant values.
- `files` is a directory for storing files for testing purpose, specifically raw, staging and transformed files.

# How To Use

### Package Installation

[auto1-etl-challenge](https://pypi.org/project/auto1-etl-challenge/)

Install the package in the virtual environment

```sh
pip install auto1-etl-challenge
```

### Code Guidelines

- Create a python file and import `EtlPackageAuto1` class from the package.
- Provide source file path in the constructor.
- Call `load` and `transform` method.

```python
from auto1_etl_challenge import EtlPackageAuto1 #import EtlPackageAuto1 class form package

EtlPackageAuto1(r'files\challenge_me.txt') #stores path of the source file
EtlPackageAuto1.load(EtlPackageAuto1.dataFile) # loads data and create staging file with cleaned data
result = EtlPackageAuto1.transform(EtlPackageAuto1.dataFile) # transform data, create transformed file and return list matrix
```

### Output

- Staging and transformed files are created in the same directory as source file.
- List of lists is returned where first list is header while the following lists contain the values (row-wise).


[Github](https://github.com/muhammad-aqib/auto1_etl_challenge)
wikipedia-searcher 0.0.5
A script that scrapes wikipedia
Requires Python: >=3.9

# wikipedia-searcher

**wikipedia-searcher** is a library for scraping wikipedia information.

```python
>>> from wikisearch.wikisearcher import WikiSearcher
>>> searcher = WikiSearcher()
>>> searcher.search('React.js')
'React (also known as React.js or ReactJS) is a free and open-source front-end JavaScript library[3] for building user interfaces or UI components.'
```

If a search has has many options it returns a dictionary with a list of articles. You can can also pass the article to search.

```python
>>> from pprint import pprint
>>> search_result = searcher.search('The Hills')
>>> pprint(search_result)
>>> {'Places': [<wikisearch.article.ArticleLink object at 0x00000208A22EFAC0>,
            <wikisearch.article.ArticleLink object at 0x00000208A22EF7F0>,
            <wikisearch.article.ArticleLink object at 0x00000208A22EF6A0>,
            <wikisearch.article.ArticleLink object at 0x00000208A22EF400>,
            <wikisearch.article.ArticleLink object at 0x00000208A22EF3D0>,
            <wikisearch.article.ArticleLink object at 0x00000208A22EF370>],
 'Popular culture': [<wikisearch.article.ArticleLink object at 0x00000208A22EF940>,
                     <wikisearch.article.ArticleLink object at 0x00000208A22EF880>],
 'See also': [<wikisearch.article.ArticleLink object at 0x00000208A22EF340>,
              <wikisearch.article.ArticleLink object at 0x00000208A22EF8E0>]}
>>> article = search_result['Places'][0]
>>> article.name
'Santa Monica Mountains'
>>> article.link
'/wiki/Santa_Monica_Mountains'
>>> searcher.search(article)
'The Santa Monica Mountains is a coastal mountain range in Southern....'
```

## How to Install

Requests is available on PyPI:

```
$ pip install wikipedia-searcher
```
Pyphonic 0.9.1
Make a VST using Python
Requires Python: >=3.6
Keywords: VST,Audio,MIDI,Realtime,AI,Deep Learning

# Pyphonic

Pyphonic is a library (and a [separate standalone VST plugin](https://github.com/tomgrek/PyphonicCPP)) that receives blocks of audio and midi data from a VST plugin in realtime, processes them, and returns new audio and midi data to the VST which can output it through a DAW like Ableton or FL Studio.

You define a callback like so:

```python
class DopeSynth:
    def __init__(self):
        # Do any setup
    def __call__(audio, midi, bpm, chunk_size):
        # do some processing
        return audio, midi
```

then (while the VST is running somewhere):

```python
from Pyphonic import Pyphonic
p = Pyphonic(DopeSynth)
p.connect() # Establish first-time connection to the VST
p.go() # Start streaming
```

## Usage

Start your DAW and load in the plugin, or open the standalone executable plugin.

In some other Python process (e.g. a Jupyter notebook), run the snippet above. It'll just return the audio and midi data as-is.

In the snippet,

`audio`: a 1d numpy array of size 2 channels * chunk_size, `float32`. You can reshape it to `(2, chunk_size)`.

`midi_data`: a 1d numpy array of size 300. A midi message is 4 bytes so this translates to 75 messages per chunk (10ms or so). Pyphonic uses the library mido to parse these messages.

`bpm`: the BPM coming from the DAW, e.g. `128`. 

`chunk_size`: Size of a block of data sent to the callback (e.g. `512`). This can be adjusted by the user in their DAW if they're fiddling with latency.

Your callback must return a tuple of (2d numpy array of shape `(2, chunk_size)`, 1d numpy array of size 300). Each 32-bit float in the audio tuple should be between -1 and +1.

## Remote use

You can specify `host` and `port` when initializing Pyphonic. This might be useful if say you have
a laptop for music making and another computer on a home network with a GPU that you use for deep learning.

```python
p = Pyphonic(dope_synth, host="192.168.1.102", port=11586)
```

## Limitations

* 16-bit audio only. Things were a little slow with 24-bit.
* Stereo (2 channel) audio is assumed.
* The built plugin (provided [here](https://github.com/tomgrek/PyphonicCPP)) doesn't output MIDI because I noticed some DAWs had issues with plugins that output both audio and midi. You can change the settings with JUCE's ProJucer and recompile, or bug me to upload the compiled midi-outputting (or dual output) version.

## Building

From the top level dir: `python -m build`.
Then to upload to PyPI: `python -m twine upload dist/*`.