semvec/pypi-packages huggingface dataset:
viz-image-unobfuscate 0.1.3
Unobfuscate Viz-style manga images.
License: MIT
Requires Python: >=3.10,<4.0
Keywords: viz,manga,unobfuscate,image

# Viz Manga Unobfuscator

Viz manga pages are delivered to the browser as obfuscated images and the client JS is responsible for unobfuscating those images for the viewer to read. This program reproduces the unobfuscate logic to produce a readable image.

`obfuscated image:`
![obfuscated image](https://github.com/minormending/viz-image-unobfuscate/blob/main/images/raw1.jpg)

`unobfuscated image:`
![obfuscated image](https://github.com/minormending/viz-image-unobfuscate/blob/main/images/page1.jpg)

The image Exif metadata stores a hex digest to unobfuscate the image. Using the each byte value of the digest with it's position in the digest, we can select the appropriate tile in the obfuscated image and put it in the proper place in the unobfuscated image.  

DISCLAIMER: I am not licensed or affiliated with Viz Media and this repository is meant for informational purposes only.

# Installation 
```
pip install viz-image-unobfuscate 
```


# Usage
```
usage: unobfuscate.py [-h] obfuscated_image unobfuscated_image

Unobfuscate manage page image.

positional arguments:
  obfuscated_image    Path to the obfuscated image.
  unobfuscated_image  Output path to the obfuscated image.

options:
  -h, --help          show this help message and exit
```

# Example
```
>>> python unobfuscate.py raw1.jpg page1.jpg

Successfully unobfuscated image at: page1.jpg
```

# Docker
```
>>> docker build -t viz .
>>> docker run -v /home/user/images/:/app/images viz images/raw1.jpg images/page1.jpg

Successfully unobfuscated image at: images/page1.jpg
```
nekoite-be-core 0.1.4
A backend core utility library.
License: MIT
Requires Python: >=3.7

# Nekoite Backend Core

[![pypi](https://img.shields.io/pypi/v/nekoite-be-core)][pypi-url]
[![build](https://github.com/nekoite/nekoite-be-core/actions/workflows/build.yml/badge.svg)][github-build-url]

[pypi-url]: https://pypi.org/project/nekoite-be-core/
[github-build-url]: https://github.com/nekoite/nekoite-be-core/actions/workflows/build.yml

## Usage

Requires python 3.7 or newer.

```text
pip install nekoite-be-core
```

There are some [examples](examples/) to look at.

Basically, choose an adapter (or build on your own), create
some views and routes, and give it to the function `register_routes`.

```python
routes = {"/a": AView, ...}
adapter = SomeAdapter(*args)
register_routes(adapter, routes)
```

## Modules

### View

Extend the class `ViewBase`. Override the function `handle_req`.
You can specify the `request_schema` and `response_schema`, and if they
are not specified or `None`, then the request or response format will
not be checked. `method` can be a string or list of strings indicating
the HTTP methods accepted by this view.

```python
class TestView(ViewBase):
    request_schema = {"id": fields.Integer(required=True)}
    response_schema = {"id": fields.Integer(), "timestamp": fields.Integer()}
    methods = ["GET", "POST"]

    def handle_req(self, req: t.Dict[str, t.Any]) -> t.Any:
        return {
            "id": req["id"],
            "timestamp": int(time()),
        }
```

### Fields

You can import `fields` from this package. It includes some field type
defined in `marshmallow`, and the `Nested` type is rewritten to accept dict
as parameter.

The detailed usage of the types in `fields` can be found on
[the homepage of marshmallow][marshmallow-hp].

```python
from nekoite_be_core import fields

# ...
request_schema = {
    "id": fields.Integer(required=True),
    ...
}
```

[marshmallow-hp]: https://marshmallow.readthedocs.io/en/stable/index.html
arps 0.0.7rc10
Multi-Agent System framework for managing resource with simulator for self-evaluation
License: MIT
Requires Python: >3.7.0, <3.10.0

ARPS: Framework to create and deploy Multi-Agents
=====================

ARPS is an acronym that comes from the simplest definition of a
software agent is:

* Autonomous: the ability to run without human interaction

* Reflexive: the ability to act upon events

* Proactive: the ability to make its own decisions

* Social: ability to interact with other agents to better achieve its
  objectives

# Description

ARPS is a framework to create Multi-Agent System (MAS). It provides a
Discrete Event Simulation component to evaluate the agents'
behaviour in a controlled environment before deployment in a actual environment.

This framework does not impose any agent model for implementation.

# Developing

See [CONTRIBUTING](CONTRIBUTING.md)

# Example

See how this [example](https://gitlab.com/arps/arps_example_0) uses the ARPS framework
to monitor computational resources

-----------------

* See [wiki](https://gitlab.com/arps/arps/wikis/home) for more information
pt-helper 0.1.1
pt_helper - boilerplate code for training, logging and evaluation in PyTorch.
License: MIT
Requires Python: >=3.7
Keywords: artificial-intelligence,deep-learning,pytorch,ml,torchinfo,model

# `pt_helper` - PyTorch
A python package containing the basic boilerplate code for training and evaluation of PyTorch models. The main purpose of this package is to remove writing the same code for training/inference again and again for different projects. 

Apart from training and evaluation, it also contains other helper functions to perform logging stats in the console as well as Keras like model summaries using [torchinfo](https://github.com/TylerYep/torchinfo) package.

## Install
```pip install pt_helper```
crossplain 0.6.0
Small layer on top of crossplane that uses plain Python objects instead of dicts. Includes intuitive ways to modify the config.
License: MIT
Requires Python: >=3.10,<4.0

# crossplain

A small layer atop NGINX's [crossplane](https://github.com/nginxinc/crossplane) that uses Python objects instead of dicts from JSON.

[![PyPI](https://img.shields.io/pypi/v/crossplain)](https://pypi.org/project/crossplain)

<!-- TODO: #1 documentation -->