semvec/pypi-packages huggingface dataset:
gunicorn-flask-swagger-example 0.0.2
Simple example using Flask and Swagger powered by gunicorn.
Requires Python: >=3.7

# gunicorn-flask-swagger-example

## Downloads
```
git clone https://github.com/danielef/gunicorn-flask-swagger-example.git
```

## Development
First, create a virtual environment as follows:
```
cd gunicorn-flask-swagger-example
virtualenv -p python3.7 env
source env/bin/activate
```

Then, install using `pip`:
```
pip install .
```

And run it with:
```
gsfe
```

Display all the options with `-h`:
```
$ gfse -h
usage: gfse [-h] [-b HOST] [-p PORT] [-v] [-r]

optional arguments:
  -h, --help            show this help message and exit
  -b HOST, --host HOST  APIn Host
  -p PORT, --port PORT  API Port
  -v, --verbose         API debug
  -r, --use-reloader    API use reloader
 ```
 
 ## Running with gunicorn
 
 ```
 gunicorn -w 4 gfse.app:app
 ```
hte 0.0.28
Extracting content from spesific address books

# historical-text-extraction (hte)
[![PyPI version](https://badge.fury.io/py/hte.svg)](https://badge.fury.io/py/hte)

Package to extract text from historical documents. The package is written for personal use. 

## Installation

The current release from the PyPI repository:

``` bash
pip install hte
```

The development version from [GitHub](https://github.com/) with:

``` bash
pip install git+ssh://git@github.com/eirikberger/hte.git
```
Note that it is nessecary with a SSH key for this approach to work. 

## Using it

Import the package.

``` python
from hte import digitize
```

The basic setup is the following:

``` python
# Define class
book = digitize.Book("data/finnmark_1968.pdf", "books")

# Run methods on the class
book.CreateFolderStructure()
book.PdfImport(page_info=False, from_page=21, to_page=263)
book.Split(multiple_columns=True)
book.RunOCR(type="splits", export_image=False)
book.CombineCleanGroup(ocr_grouping=True, group_type='norway')
book.RegexStructure("norway")
```

Make sure to install the correct language package for Tesseract. 

``` bash
# Check languages already installed: 
tesseract --list-langs

# Languages available for installation
apt-cache search tesseract-ocr

# Install the Norwegian language pack
sudo apt-get install tesseract-ocr-nor
```

## Extracting headers

Start by converting XML files using the Pascal VOC data format to JSON. These files can be created by using the free software [`labelImg`](https://github.com/heartexlabs/labelImg). 

``` python
import os 
import hte.headers as hteheaders
os.chdir('/home/eirikb/Desktop')
```

``` python
header = Headers('train', 2022)
header.runbbxConverting()
```

Then convert the json file to csv. 

``` python
hteheaders.convertFromJson('/home/eirikb/Desktop/training_xml/json-bbox', 'xml')
```

Finally, read the concent of the boxes. 

``` python
hteheaders.ReadBoxes('json-bbox/xml.csv', 'hordaland', 'train', print_images=True)
``` 

## Downloade more content
These functions create a list of relevant content from the API of the Norwegian National Library and then downloads a high resolution pdf version.

``` python
import os
import hte.NB as NB
os.chdir('/home/eirikb/Desktop/')

ListOfBooks = NB.ListNB(1920, 1930, 'skatteligning', 'digitidsskrift')
ListOfBooks = NB.ListOfBooks[0:1]
```
modbus-configuretools-xzf8971 1.6.0
A package to read/write registers on a temperature sensor with python.
Requires Python: >=3.7

# temperature_sensor_reader
This is a temperature sensor package designed for modbus. Implemented in pymodbus only. PyPI website: https://pypi.org/project/modbus-configuretools-xzf8971/
## Install
from pypi:  
```bash
pip install modbus-configuretools-xzf8971  
```
from github:  
```bahs
pip install git+https://github.com/xzf89718/temperature_sensor_reader
```
## Jiandarenke modbus RS485 as example  
### Before run scripts
Check the COM and chmod  
```bash
chmod 666 \dev\ttyUSBx
```
### Import modules  
```python
from modbus_configuretools import temperature_sensor.RS485_Jiandarenke as RS485_JDRK  
from modbus_configuretools import temperature_sensor.JDRKAddressConfig as Config
```
### Configure parameters for Jiandarenke RS485 sensor
It's OK to set None for unkown value
```python
# Modify these config values 
# Please configure these value in temperature_sensor before read or write values  
# SLAVEID must be specified. If SLAVEID is none, set to 1  
# ADDRESS_HUMIDITY = 0x0000  
# ADDRESS_TEMPERATURE_DEW_POINT = 0x0001  
# ADDRESS_TEMPERATURE = 0x0002  
# ADDRESS_TEMPERATURE_CALI = 0x0050  
# ADDRESS_HUMUDITY_CALI = 0x0051  
# ADDRESS_SLAVEID = 0x07D0  
# ADDRESS_BAUDRATE = 0x07D1  
# TEMPERATURE_CALI = 164  
# HUMIDITY_CALI = 7  
# SLAVEID = 1
# BAUDRATE = 1
myconfig = Config(ADDRESS_HUMIDITY, ADDRESS_TEMPERATURE_DEW_POINT, ADDRESS_TEMPERATURE, ADDRESS_SLAVEID, ADDRESS_BAUDRATE, ADDRESS_TEMPERATURE_CALI, ADDRESS_HUMUDITY_CALI, TEMPERATURE_CALI, HUMIDITY_CALI, SLAVEID, BAUDRATE)
```
### Calibration of sensor. Not necessary calibration every time  
```python
sensor.CalibrationJiandarenke(myconfig)  
```
### Set slaveID and baudrate
Please make sure only 1 sensor connect to the modbus bus
```python
sensor.WriteSlaveIDAndBaudrate(myconfig)
```
### Init and read measured values from sensor  
```python
# Create a wrapper for JDRK sensor  
sensor = RS485_JDRK(port="/dev/ttyUSB0")  
# Init and connect client
sensor.InitClient()  
# Read slaveID and baudrate  
slaveID, baudrate = sensor.ReadSalveIDAndBaudrate(myconfig)  
# Read temperature, dew point, humidity in one request  
# Only correct for specified sensor
temperature, dew_point_temperature, humidity = sensor.ReadTemperatureAndHumidity(myconfig)  
# Read temperature only  
temperature = sensor.ReadTemperature(myconfig)  
# Read dew point temperature  
dew_point_temperature = sensor.ReadTemperatureDewPoint(myconfig)  
# Read humidity only  
humidity = sensor.ReadTemperature(myconfig)  
```
### Close the sensor
```python
sensor.close()
```
sensors-control-gpio-xzf8971 2.3.0
This is a repository desgined for the arduino 37 sensors bundle for raspberry pi 4. This package implemented in raspberry pi 4B GPIO with RPi.GPIO.
Requires Python: >=3

# sensors-control-gpio
This is a repository desgined for the arduino 37 sensors bundle for raspberry pi 4. This package implemented in raspberry pi 4B GPIO with RPi.GPIO.
# Get started
```bash
pip install sensors-control-gpio-xzf8971
```
# AHT20
## How to
For help infromation
```bash
python -m AHT20_sensor_control --help
```
```bash
# Open I2C bus1. Save data into example.log. Measure data every 60s. 
python -m AHT20_sensor_control -n 1 -o example.log -t 60 
# Enable CRC8 check. Only save data when crc check is OK
python -m AHT20_sensor_control -n 1 -o example.log -t 60 -c
```
# DHT11
## How to
```bash
python -m DHT11_sensor_control -p pin -b adafruit 
```