semvec/pypi-packages huggingface dataset:
png-dilator 0.8.5
Dilate texture with low alpha pixel to prevent "black edge" when rendered by GL
License: MIT

<!--
 * @Author: GT<caogtaa@gmail.com>
 * @Date: 2021-05-07 12:07:31
 * @LastEditors: GT<caogtaa@gmail.com>
 * @LastEditTime: 2021-05-07 12:08:00
-->
Dilate texture with low alpha pixel to prevent "black edge" when rendered by GL
mcpi-extended 1.0
A python library for Minecraft Pi edition.
License: MIT

# Minecraft: Pi edition API Python Library

`mcpi_extended` Python library for communicating with [Minecraft: Pi edition](https://minecraft.net/en-us/edition/pi/).

## Installation

### Windows

```
pip3 install mcpi_extended
```

### Linux / MacOS

```bash
sudo pip3 install mcpi_extended
```

## History

The [Minecraft: Pi edition](https://minecraft.net/en-us/edition/pi/) Python library was originally created by Mojang and released with Minecraft: Pi edition.

Initial supported was provided for Python 2 only, but during a sprint at PyconUK 2014 it was migrated to Python 3 and [py3minepi](https://github.com/py3minepi/py3minepi) was created.

The ability to hack Minecraft from Python was very popular and the [RaspberryJuice](https://github.com/zhuowei/RaspberryJuice) plugin was created for Minecraft Java edition. RaspberryJuice also extended the API adding additional features.

Then a python library called [mcpi](https://github.com/martinohanlon/mcpi) was made that provides support to Python 2 & 3 and supports Minecraft Pi and the java RaspberryJuice.
Documentation for it can be found at [www.stuffaboutcode.com/p/minecraft-api-reference.html](http://www.stuffaboutcode.com/p/minecraft-api-reference.html).

## Sources

This library is a collection of the following sources:

+ [Minecraft: Pi edition](https://minecraft.net/en-us/edition/pi/)
+ [Python 3 Minecraft: Pi edition library](https://github.com/py3minepi/py3minepi)
+ [mcpi](https://github.com/martinohanlon/mcpi)
+ [minecraft-stuff](https://minecraft-stuff.readthedocs.io/en/latest/)

## Licenses

+ mcpi - [LICENSE.txt](https://github.com/martinohanlon/mcpi/blob/master/LICENSE)
+ Minecraft: Pi edition LICENSE - [minecraft-pi-edition-LICENSE.txt](https://github.com/martinohanlon/mcpi/blob/master/minecraft-pi-edition-LICENSE.txt)
loguricorn 0.1.0
A small package for rerouting gunicorn logs to loguru
License: MIT
Requires Python: >=3.10,<4.0
Keywords: loguru,gunicorn,logging

# loguricorn

<p align="center">
    <a href="https://github.com/jmgilman/loguricorn/actions/workflows/ci.yml">
        <img src="https://github.com/jmgilman/loguricorn/actions/workflows/ci.yml/badge.svg"/>
    </a>
    <a href="https://pypi.org/project/loguricorn">
        <img src="https://img.shields.io/pypi/v/loguricorn"/>
    </a>
</p>

> A small package for rerouting [gunicorn][1] logs to [loguru][2]

![Example](example.svg)

This package provides a compatible interface for automatically routing
`gunicorn` logs to the popular `loguru` library.

## Usage

Install the package:

```shell
pip install loguricorn
```

Then pass the custom interface to gunicorn at runtime:

```shell
gunicorn --logger-class loguricorn.Logger tests.app:app
```

All log records will now be routed through the default `loguru.logger`.

## Configuration

It's possible to customize the `loguru.logger` instance before `gunicorn`
initializes itself. Simply add your changes in a configuration file and pass it
to gunicorn at runtime:

```python
import sys

from loguru import logger

logger.remove()
logger.add(
    sys.stderr,
    colorize=True,
    format="<green>{time}</green> <level>{message}</level>",
)
```

```shell
gunicorn -c conf.py --logger-class loguricorn.Logger tests.app:app
```

It's recommended to import any customizations from your main application and
use them in the configuration in order to obtain a consistent log record format
across the entire execution.

## Testing

Testing is done by starting `gunicorn` in a subprocess with the custom logger
enabled and validating that the emitted logs match the expected format.

Install dev dependencies:

```shell
poetry install
```

Run test:

```shell
poetry run tox .
```

## Contributing

Check out the [issues][3] for items needing attention or submit your own and
then:

1. [Fork the repo][4]
2. Create your feature branch (git checkout -b feature/fooBar)
3. Commit your changes (git commit -am 'Add some fooBar')
4. Push to the branch (git push origin feature/fooBar)
5. Create a new Pull Request

[1]: https://github.com/Delgan/loguru
[2]: https://github.com/benoitc/gunicorn
[3]: https://github.com/jmgilman/loguricorn/issues
[4]: https://github.com/jmgilman/loguricorn/fork
tq-dockie-db 1.0
DockieDb is a simple in-memory document database.
License: MIT
Requires Python: >=3.9

# DockieDb
A simple in-memory document database.

## Installation

Install using `pip install tq-dockie-db`.

## Document Database Primer
Looking at the tests in the `test` folder will give you a good idea on how to use DockieDb. Nevertheless,
this section offers some guidance.

In general, document database objects have the following hierarchy:

`Database ---> Container (1 or more) --->Document (1 or more)`

At the root, there is a Database. A database consists of one or more Containers. A
Container holds one or more Documents. 

If you're coming from a relational background then you can
think of the Database as the schema, a Container as the table, and a Document as a row in the table.

Whereas the rows in the table conform to the same schema, Documents in a Container
are schemaless. In other words you can store Documents of different shapes in the same container.

[This tutorial](https://docs.microsoft.com/en-us/learn/paths/implement-modeling-partitioning-azure-cosmos-db-sql-api/) is a great read for those new to document databases. It does
a better job explaining it than I ever could in this readme.

## Creating Database Objects

### Create a Database
```python
from dockie.core.database import Database

db = Database()
```

### Create a Container
```python
container = db.add_container("items")
```

### Add a Document to the Container
```python
from dockie.core.document import Document

document = Document("item1", {"name": "basketball", "price": 29.99})
container.add_document(document)
```
<mark>A document id must be a string or integer.</mark>

## Retrieving Documents
There are two ways to retrieve a document:

- By its id.
- By querying against one or more non-id attributes.

### Retrieving a Document by ID
```python
from dockie.query.query import DocumentIdQuery

query = DocumentIdQuery()
document = query.execute(container, document_id="item1")
```
### Retrieving a Document by a Non-ID Attribute
Querying by non-ID attributes is accomplished with the [dictquery library](https://pypi.org/project/dictquery/).
```python
from dockie.query.query import DocumentAttributeQuery

query = DocumentAttributeQuery()
document = query.execute(container, query='name=="basketball"')
```

Refer to the tests in this repository for more query examples. Refer to the dictquery
homepage for details on dictquery syntax.

## Persisting the Database
Although DockieDb is an in-memory database, it can be saved and loaded to/from a file.

### Save the Database to File
```python
from dockie.core.persistence import persist_to_file

persist_to_file(db, "db.bak")
```

### Load the Database from File
```python
from dockie.core.persistence import load_from_file

db = load_from_file("db.bak)
```

## Miscellania
### Running Tests
From the project root folder, run `pytest` without any arguments.