semvec/pypi-packages huggingface dataset:
rabbitmq-pdfparser 1.0.1
Asynchronous job library that consume RabbitMQ for PDF urls and publish pdf text back.
Requires Python: >3.6.*, <4


# rabbitmq_pdfparser

rabbitmq_pdfparser is asynchronous job library that consume RabbitMQ for PDF urls and publish pdf text back to RabbitMQ. It stops when queue is empty.

## Installation

You can install this library easily with pip.
`pip install rabbitmq-pdfparser` 

## Usage

Data must send to source queue should this format: 

`{"id": "foo", "url": "http://example.com/foo/bar.pdf"}`


### As a library
```py
import os
import asyncio
from rabbitmq_pdfparser import consume

if __name__ == '__main__':
    logger = logging.getLogger("rabbitmq_pdfparser")
    logger.setLevel(os.environ.get('LOG_LEVEL', "DEBUG"))
    handler = logging.StreamHandler()
    handler.setFormatter(
        logging.Formatter(
            os.environ.get('LOG_FORMAT', "%(asctime)s [%(levelname)s] %(name)s: %(message)s")
        )
    )
    logger.addHandler(handler)

    config = {
      "mq_host": os.environ.get('MQ_HOST'),
      "mq_port": int(os.environ.get('MQ_PORT')), 
      "mq_vhost": os.environ.get('MQ_VHOST'),
      "mq_user": os.environ.get('MQ_USER'),
      "mq_pass": os.environ.get('MQ_PASS'),
      "mq_source_queue": os.environ.get('MQ_SOURCE_QUEUE'),
      "mq_target_exchange": os.environ.get('MQ_TARGET_EXCHANGE'),
      "mq_target_routing_key": os.environ.get('MQ_TARGET_ROUTING_KEY')
    }

    loop = asyncio.get_event_loop()
    loop.run_until_complete(
        consume(
          loop=loop,
          consumer_pool_size=10,
          config=config
        )
    )

loop.close()
```

This library uses [PyPDF2](https://pythonhosted.org/PyPDF2/),  [aio_pika](https://aio-pika.readthedocs.io/en/latest/) and [aiohttp](https://docs.aiohttp.org/en/stable/) packages.


### Standalone
You can also call this library as standalone PDF parser job.  Just set required environment variables and run `rabbitmq_pdfparser`. This usecase perfectly fits when you need run it on cronjobs or kubernetes jobs. 

**Required environment variables:**
- MQ_HOST
- MQ_PORT (optional)
- MQ_VHOST
- MQ_USER
- MQ_PASS
- MQ_SOURCE_QUEUE (Queue that job consume urls)
- MQ_TARGET_EXCHANGE (Exchange that job publish texts)
- MQ_TARGET_ROUTING_KEY (Routing key that job publish texts)
- MQ_QUEUE_DURABLE (optional, default value: True)
- CONSUMER_POOL_SIZE (optional, default value: 10)
- LOG_LEVEL (Logging level. See: [Python logging module docs](https://docs.python.org/3/library/logging.html#logging-levels))

**Example Kubernetes job:** 
 You can see it to [kube.yaml](kube.yaml)
kerndeterminer 0.0.1
Work out how far apart things should be (very quickly)

# Kern determiner
## Work out how far apart things should be (very quickly)

`kerndeterminer` is a Rust-based library for determining a kern
value between two glyphs of a font source file.

*(Don't use it for Latin kerning; it won't work. But it works fine for many other scripts)*

Given a font, two glyphs, and a target distance (and a few other parameters),
`kerndeterminer` will return the kern value which places the contours of the
two glyphs the given distance apart at their closest point. The graphic
below explains the main parameters and the effect of `kerndeterminer`:

![parameters.png](parameters.png)

## How to use

First, create a `KernDeterminer` object. This loads the font, since you'll
probably be making quite a few calls to `determine_kern` and won't want to
load the font each time:

```python
from kerndeterminer import KernDeterminer

kerner = KernDeterminer("MyFont.glyphs")
```

The font source can be any source loadable by the Rust version of Babelfont
(currently Glyphs version 3 files, UFO, and Designspace files).

Next, call the `determine_kern` method on that object:

```python
kern = kerner.determine_kern(
    "JIMi10",  # Left glyph
    "REu1",    # Right glyph
    "Regular", # Master name
    120,       # Target distance
    200,       # Height
    0.8,       # Max tuck
)
```

This will return the optimal kerning value for that pair at the given
parameters. Note:

* The `height` parameter is used to translate the left glyph vertically befor kerning. This is used in Arabic fonts with cursive attachment.
* The `max_tuck` parameter is a ratio of the left glyph's width which forms an upper limit on the kerning value. For example, if `max_tuck` is 0.5, the leftmost point on the right glyph can only be placed so that it is 50% of the way underneath the left glyph:

![maxtuck.png](maxtuck.png)
screen-search 1.1
A small python library use to  Searchs for an image on the screen

screen_search is small python library use to  Searchs for an image on the screen
# install:
to install the library
type in your Terminal
``` bash
pip install screen_search
```
## requirements
screen_search supports Python 2 and 3.
If you are installing screen_search from PyPI using pip:
Windows has no dependencies.
The Win32 extensions do not need to be installed.
OS X needs the pyobjc-core and pyobjc module installed (in that order).
Linux needs the python3-xlib (or python-xlib for Python 2) module installed.
Pillow needs to be installed, and on Linux you may need to install additional libraries to make sure Pillow's PNG/JPEG works correctly.
## Example
this is simple example of looking for a picture on the screen and moving the pointer to it.

``` python
from screen_search import *

# Search for the github logo on the whole screen
# note that the search only works on your primary screen.
search = Search("github.png")


pos = search.imagesearch()

if pos[0] != -1:
    print("position : ", pos[0], pos[1])
    pyautogui.moveTo(pos[0], pos[1])
else:
    print("image not found")
```
zipfly 6.0.5
ZipFly
Keywords: zipfly,Santiago Debus,santiagodebus.com

[![Build Status](https://img.shields.io/circleci/build/github/sandes/zipfly/master)](https://app.circleci.com/pipelines/github/sandes/zipfly)
![GitHub release (latest by date)](https://img.shields.io/github/v/release/sandes/zipfly)
[![Downloads](https://pepy.tech/badge/zipfly)](https://pepy.tech/project/zipfly)

# ZipFly

ZipFly is a zip archive generator based on zipfile.py.
It was created to generate very large ZIP archives for immediate sending out to clients, or for writing large ZIP archives without memory inflation.

# Requirements
Python 3.6+ Added <a href="https://docs.python.org/3/library/zipfile.html#zipfile-objects" target="blank">support</a> for writing to unseekable streams.

# Install
    pip3 install zipfly

# Basic usage, compress on-the-fly during writes
Using this library will save you from having to write the Zip to disk. Some data will be buffered by the zipfile deflater, but memory inflation is going to be very constrained. Data will be written to destination by default at regular 32KB intervals.


`ZipFly` defaults attributes:<br>    
- <b>paths:</b> [ ] <br/>
- <b>mode:</b> (write) w <br/>
- <b>chunksize:</b> (bytes) 32768 <br/>
- <b>compression:</b> Stored <br/>
- <b>allowZip64:</b> True <br/>
- <b>compresslevel:</b> None <br/>
- <b>storesize:</b> (bytes) 0 <br/>
- <b>encode:</b> utf-8 <br/>

<br/>



`paths` <b>list of dictionaries:</b>

|                   |.                          
|----------------   |-------------------------------      
|**fs**             |Should be the path to a file on the filesystem            
|**n** *(Optional)* |Is the name which it will have within the archive <br> (by default, this will be the same as **fs**)

<br>

```python

    import zipfly

    paths = [
        {
            'fs': '/path/to/large/file'
        },
    ]

    zfly = zipfly.ZipFly(paths = paths)

    generator = zfly.generator()
    print (generator)
    # <generator object ZipFly.generator at 0x7f74d52bcc50>


    with open("large.zip", "wb") as f:
        for i in generator:
            f.write(i)

```


# Examples

> <b>Streaming multiple files in a zip with <a href="https://github.com/sandes/zipfly/blob/master/examples/streaming_django.py" target="_blank">Django</a> or <a href="https://github.com/sandes/zipfly/blob/master/examples/streaming_flask.py" target="_blank">Flask</a></b>
Send forth large files to clients with the most popular frameworks

> <b>Create paths</b>
Easy way to create the array `paths` from a parent folder.

> <b>Predict the size of the zip file before creating it</b>
Use the `BufferPredictionSize` to compute the correct size of the resulting archive before creating it.

> <b>Streaming a large file</b>
Efficient way to read a single very large binary file in python

> <b>Set a comment</b>
Your own comment in the zip file
image-processing-test-package 0.0.2
Test version - Image processing. This project belongs to Karina Tiemi Kato, Tech Lead, Machine Learning Engineer, Data Scientist Specialist at Take. This package is a demo for simulation of upload on the Test Pypi website, and it's from class of the Bootcamp developer full stack Python. E-mail:karinatkato@gmail.com.
Requires Python: >=3.8

# Desafio-002 : Pacote de Processamento de Imagens

## Descrição
- Esse projeto consiste na criação de um pacote para python, com base no curso ministrado por Karina Kato.
- É apenas um pacote de exemplo, baseado no [scikit-image](https://scikit-image.org)
- Anotações das aulas podem ser vistas [aqui](anotacoes.md).

---

## Passos para a hospedagem no Pypi
- Primeiro se realiza uma instalação ou upgrade do `pip`, `twine`, `setuptools` e `wheel`
- remova a opção `--user` se não deseja instalar no `user.home` ou esteja usando um `venv`.
```bash
python -m pip install --upgrade pip
python -m pip install --user twine
python -m pip install --user setuptools
python -m pip install --user wheel
```
- Cria-se as distribuições
```bash
python setup.py sdist bdist_wheel
```
- Serão criadas 3 pastas no projeto: 
  - build
  - dist
  - image_processing_package.egg-info
- O próximo passo é o upload no Test Pypi.
```bash
python -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*

```
- O comando para upload no Pypi é:
```bash
python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/*

```
## Instalação
- Para a instalação local, é necessário instalar os requerimentos primeiro.
```bash
pip install -r requirements.txt
 ```

Para a instalação do pacote, basta usar o [pip](https://pip.pypa.io/en/stable/) direcionando para o image-processing-test-package

```bash
pip install image-processing-test-package
```
---
## Uso
- Basta importar os módulos de acordo com o que deseja

```python
from image-processing-test-package.processing import transformation
transformation.resize_image(image1, 0.5)
```
---
## Autor
Adriano Romero

## Licença
[MIT](https://choosealicense.com/licenses/mit/)
LoadPredConverge 0.0.1
Residential electricity forecasting and disaggregation module

# Introuction

In this repository, you can find the functions required for load forecasting in the Converge project. 

This repository contains the following forecasting methods:

* A forecasting approach, using the **skforecast** library, that is based on a [Recursive multi-step forecasting](https://joaquinamatrodrigo.github.io/skforecast/0.4.3/quick-start/introduction-forecasting.html#recursive-multi-step-forecasting) algorithm. This implementation outputs a forecasted value for aggregated solar generation and demand for a desired number of days with a granularity of 30 minutes for each *nmi*.

* A forecasting approach, using the **skforecast** library, that is based on a [Prediction intervals](https://joaquinamatrodrigo.github.io/skforecast/0.4.3/notebooks/prediction-intervals.html)(A prediction interval defines the interval within which the true value of a time-series variable can be expected to be found with a given probability) algorithm. This implementation outputs probabilitic values of expected value, upper bound and lower for aggregated solar generation and demand for a desired number of days with a granularity of 30 minutes for each *nmi*.
django-tabler-ng 0.0.3
Django wit Tabler template
Keywords: django,tabler,dashboard,template,ui

# django-tabler-ng
Django with Tabler template.

This project transforms the [Tabler](https://github.com/tabler/tabler) dashboard
into a Django package. It provides an extensible base template, error page templates,
and the necessary static assets. django-tabler-ng is based on the 
* Tabler release [v1.0.0-beta12](https://github.com/tabler/tabler/releases/tag/v1.0.0-beta12)
* Django release [3.2 LTS](https://www.djangoproject.com/download/)
* Python relase 3.9

# Installation
* `pip install django-tabler-ng`
* Add `django_tabler_ng` to your `INSTALLED_APPS`

# Usage
Once installed, templates inside your application can extend django-tabler-ng's
base template. A quick example:
```
{% extends "django_tabler_ng/base.html" %}

{% block extra_css %}
    {# add your custom css here #}
{% endblock extra_css %}

{% block content %}
    <h1>This is a Heading</h1>
    <p>This is a paragraph</p>
    <p>{{ some_context_variable }}</p>
{% endblock content %}

{% block extra_js %}
<script>
    {# add your custom javascript here #}
</script
{% endblock extra_js %}
```
Need some inspiration? Check out the [templates](https://github.com/tabler/tabler/tree/dev/dist)
provided by the original project.


### Missing a title in the browser window?
django-tabler-ng's base template adds your site's name to the browser's titlebar using Django's
[Sites](https://docs.djangoproject.com/en/3.2/ref/contrib/sites/) framework.
Follow these steps for setup:
* Add a `SITE_ID` value to your application's settings file
* Add `'django.contrib.sites'` to `INSTALLED_APPS`
* Add `'django.contrib.sites.middleware.CurrentSiteMiddleware'` to `MIDDLE_WARE`
* Run `python manage.py migrate` if necessary
* Inside your application's `django_site` database table, update the record that cooresponds to the `SITE_ID`
value with an appropriate name and domain. A custom migration might be helpful.


### Missing a favicon?
To load a favicon, create an `img/` folder inside your application's `static` directory.
Place `favicon.ico` inside, and the icon will be loaded by the base template.


### Custom error views
django-tabler-ng overrides Django's [default error views](https://docs.djangoproject.com/en/3.2/topics/http/views/#customizing-error-views)
by rendering a custom error template. Your application can access these by
adding the following to your applications' `urls.py` file:
```
handler400 = 'django_tabler_ng.views.error400'
handler403 = 'django_tabler_ng.views.error403'
handler404 = 'django_tabler_ng.views.error404'
handler500 = 'django_tabler_ng.views.error500'
```

Inspiration from @rbennett91/django-tabler.
image-processing-final-package 0.0.1
Test version - Image processing. This project belongs to Karina Tiemi Kato, Tech Lead, Machine Learning Engineer, Data Scientist Specialist at Take. This package is a demo for simulation of upload on the Test Pypi website, and it's from class of the Bootcamp developer full stack Python. E-mail:karinatkato@gmail.com.
Requires Python: >=3.8

# Desafio-002 : Pacote de Processamento de Imagens

## Descrição
- Esse projeto consiste na criação de um pacote para python, com base no curso ministrado por Karina Kato.
- É apenas um pacote de exemplo, baseado no [scikit-image](https://scikit-image.org)
- Anotações das aulas podem ser vistas [aqui](anotacoes.md).

---

## Passos para a hospedagem no Pypi
- Primeiro se realiza uma instalação ou upgrade do `pip`, `twine`, `setuptools` e `wheel`
- remova a opção `--user` se não deseja instalar no `user.home` ou esteja usando um `venv`.
```bash
python -m pip install --upgrade pip
python -m pip install --user twine
python -m pip install --user setuptools
python -m pip install --user wheel
```
- Cria-se as distribuições
```bash
python setup.py sdist bdist_wheel
```
- Serão criadas 3 pastas no projeto: 
  - build
  - dist
  - image_processing_package.egg-info
- O próximo passo é o upload no Test Pypi.
```bash
python -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*

```
- O comando para upload no Pypi é:
```bash
python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/*

```
## Instalação
- Para a instalação local, é necessário instalar os requerimentos primeiro.
```bash
pip install -r requirements.txt
 ```

Para a instalação do pacote, basta usar o [pip](https://pip.pypa.io/en/stable/) direcionando para o image-processing-test-package

```bash
pip install image-processing-final-package==0.0.1
```
---
## Uso
- Basta importar os módulos de acordo com o que deseja

```python
from image-processing-test-package.processing import transformation
transformation.resize_image(image1, 0.5)
```
---
## Autor
Adriano Romero

## Licença
[MIT](https://choosealicense.com/licenses/mit/)
ConvergeTry 0.0.1
Residential electricity forecasting and disaggregation module

# Introuction

In this repository, you can find the functions required for load forecasting in the Converge project. 

This repository contains the following forecasting methods:

* A forecasting approach, using the **skforecast** library, that is based on a [Recursive multi-step forecasting](https://joaquinamatrodrigo.github.io/skforecast/0.4.3/quick-start/introduction-forecasting.html#recursive-multi-step-forecasting) algorithm. This implementation outputs a forecasted value for aggregated solar generation and demand for a desired number of days with a granularity of 30 minutes for each *nmi*.

* A forecasting approach, using the **skforecast** library, that is based on a [Prediction intervals](https://joaquinamatrodrigo.github.io/skforecast/0.4.3/notebooks/prediction-intervals.html)(A prediction interval defines the interval within which the true value of a time-series variable can be expected to be found with a given probability) algorithm. This implementation outputs probabilitic values of expected value, upper bound and lower for aggregated solar generation and demand for a desired number of days with a granularity of 30 minutes for each *nmi*.