semvec/pypi-packages huggingface dataset:
picklejar3 0.2.0
A library to store data
License: MIT
Requires Python: >=3.6
Keywords: library,robotics,sensor,data,picklejar

# PickleJar3

**Do not use, under development**

Something I wrote a while ago for storing data. I want to flush it out into
something better.

```python
#!/usr/bin/env python3
import sys
from picklejar3.picklejar import PickleJar


pj = PickleJar()
pj.init("bob.pickle", 3)

for i in range(9):
    pj.push("a", i)

pj.push("b", 3.33)
pj.push("d", -1200)

pj.close()

pj.read("bob.pickle")
print(pj.buffer)
```

# MIT License

**Copyright (c) 2020 Kevin J. Walchko**

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
cv2studio 1.0.2
Chain-based framework to split image processing into components.
License: MIT
Keywords: OpenCV,Computer Vision,Framework,Wrapper,Components

# cv2studio

`cv2studio` is an OpenCV framework that give
you an ability to decompose processing flow into
components.

## Features

- Component-based development
- Channel independence
- Classes wrappers for HighGUI elements of OpenCV
- Channel independence for components

## Getting Started

The main principle behind this framework is decomposition.
Splitting up a code into one-format components make
it highly reusable. It becomes easy to develop
different parts of video/image processing separately and
share it with others.

## Installing

To install the latest release:

```bash
pip install cv2studio
```

## Usage

### Importing

Before using features of the framework
goes importing.

`from cv2studio import App, Component`

### Component creation

To create a component describe a class derived from `Component`.
To use this class it's required to declare the method `process(self, img)`,
where `img` is an image to be process. This function must return an image as well.

```python
class Blur(Component):
    def process(self, img):
        img = cv2.GaussianBlur(img, (5, 5), 5)
        return img
```

This component apply blur to an input image.

### App creation

To create an app that will hold processing components
describe a class derived from 'App' and add components
using `add_component(component)` method.

```python
class VideoApp(App):
    def __init__(self, path):
        App.__init__(self, path, VIDEO)
        # self.add_component(MyComponent())
        self.add_component(Blur())
```

### Running

To run the described app use `main_loop` method.
It will start main processing loop with applying
chain of added component.

```python
app = VideoApp('path/to/video')
app.main_loop()
```

`main_loop` starts a video processing loop. For creating
more complex app see the following examples.

## Testing

To run tests run the following command:

```bash
pytest
```

## Versioning

We use SemVer for versioning. For the versions available,
see the tags on this repository.

## Contributing

Please read CONTRIBUTE.md for details on our code of conduct, and the process for submitting pull requests to us.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.txt) file for details
sqller 1.4.2
ORM library to build SQLite based application in format model/dao/service.
License: MIT
Keywords: orm,sql,sqlite,query,generation

# Sqller

ORM library to build SQLite based application in format model/dao/service.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

## Installing

At first, you need SQLite3 to be installed. Type following in your terminal:

```bash
apt-get install libsqlite3-dev
```

To install the package type the following in your terminal:

```bash
sudo pip install sqller
```

## Running the tests

To run tests type the following in your terminal:

```bash
python3 -m pytest
```

or

```bash
python -m pytest
```

if the previous command doesn't work.

## Usage

The usage of the library in real application consists of the following steps:

- Create a model
- Create a data access object (DAO)
- Create a service
- Use the service

The steps are described below.

### Create model

```python
class Chat(metaclass=sqller.ModelMeta):
    NAME = 'chats'
    FIELDS = [
        Field(name="id", dtype="integer", postfix="PRIMARY KEY"),
        Field(name="type", dtype="text"),
        Field(name="last_name", dtype="text"),
        Field(name="first_name", dtype="text"),
        Field(name="username", dtype="text"),
        Field(name="chat_id", dtype="integer")
    ]
```

### Create DAO

```python
class ChatDAO(metaclass=sqller.DAOMeta):
    MODEL = Chat
```

### Create service

```python
class TelegramService(metaclass=sqller.ServiceMeta):
    DB_PATH = config.DATABASE_PATH
    MODELS = [
        models.Chat,
        models.SelectedCriterion
    ]

    @staticmethod
    def save_chat_info(chat: telebot.types.Chat):
        obj_exist_checker = models.Chat(id=chat.id)
        obj = models.Chat(
            type = chat.type,
            last_name = chat.last_name,
            first_name = chat.first_name,
            username = chat.username,
            chat_id=chat.id
        )
        sql_exists = dao.ChatDAO.sql_exists(obj_exist_checker)
        sql_save = dao.ChatDAO.sql_save(obj)
        exists = TelegramService.execute(sql_exists)[0][0]
        if not exists:
            TelegramService.execute(sql_save)
```

### Use service

```python
TelegramService.save_chat_info(chat)
```

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## Authors

- **Ilya Vouk** - Initial work - [VoIlAlex](https://github.com/VoIlAlex)

See also the list of [contributors](https://github.com/VoIlAlex/sqller/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
RPI-ST7789 0.0.4a0
Library to control an ST7789 240*240 TFT LCD display.
License: MIT

# RPI ST7789


Python library to control an ST7789 TFT LCD display

Designed to work with a ST7789 based 240x240 pixel TFT SPI display.

*Updated to allow spi mode to be set.*

*Some ST7789 display boards have no chip select (cs) pin. The spi mode must be set to 3 for these boards to work.*
*Other boards, including the Pirate Audio boards, work with spi mode set to 0, which is the default for the Pimoroni st7789-python driver.*

*This is an update that allows a mode parameter to be passed to the driver.*

Usage: Create ST7789 LCD display class for a board with no cs pin. For Pirate Audio or boards with a cs pin set mode=0, 
or even delete the "mode=3," line as the default is 0.

```python

import ST7789

disp = ST7789.ST7789(
    port=0,
    cs=ST7789.BG_SPI_CS_FRONT,  
    dc=9,
    rst=25,
    backlight=13,
    mode=3,
    spi_speed_hz=80 * 1000 * 1000
)   

```

Make sure you have the following dependencies:

```

sudo apt-get update
sudo apt-get install python-rpi.gpio python-spidev python-pip python-pil python-numpy
```
Install this library by running:

```
sudo pip3 install ST7789
```

# Licensing & History

This library is a modification of a modification of code originally written by Tony DiCola for Adafruit Industries, and modified to work with the ST7735 by Clement Skau.

To create this ST7789 driver, it has been hard-forked from st7735-python which was originally modified by Pimoroni to include support for their 160x80 SPI LCD breakout.

## Modifications include:

* PIL/Pillow has been removed from the underlying display driver to separate concerns- you should create your own PIL image and display it using `display(image)`
* `mode`, `width`, `height`, `rotation`, `invert`, `offset_left` and `offset_top` parameters can be passed into `__init__` for alternate displays
* `Adafruit_GPIO` has been replaced with `RPi.GPIO` and `spidev` to closely align with our other software (IE: Raspberry Pi only)
* Test fixtures have been added to keep this library stable

Pimoroni invests time and resources forking and modifying this open source code, please support Pimoroni and open-source software by purchasing products from them, too!

Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!

Modified from the Pimoroni st7789-python 'Modified from 'Adafruit Python ILI9341' written by Tony DiCola for Adafruit Industries.' written by Clement Skau.

MIT license, all text above must be included in any redistribution

0.0.3
-----

* option to set spi mode

0.0.2
-----

* Fix for image retention
* Drop defunct parameters

0.0.1
-----

* Initial Release