semvec/pypi-packages huggingface dataset:
demosaicnet 0.0.14
Minimal implementation of Deep Joint Demosaicking and Denoising [Gharbi2016]

# Deep Joint Demosaicking and Denoising
SiGGRAPH Asia 2016

Michaël Gharbi gharbi@mit.edu Gaurav Chaurasia Sylvain Paris Frédo Durand

A minimal pytorch implementation of "Deep Joint Demosaicking and Denoising" [Gharbi2016]

# Installation

From this repo:

```shell
python setup.py install
```

Using pip:

```shell
pip install demosaicnet
```

Then run the demo script with:

```shell
python scripts/demosaicnet_demo.py output
```

To train a dummy model on the demo dataset provided, run:

```shell
python scripts/train.py --data demosaicnet/data/dummy_dataset --checkpoint_dir ckpt
```

# FAQ

- **How is noise handled? Where is the pretrained model?** The noise-aware model is not implementation, see the earlier Caffe implementation for that <https://github.com/mgharbi/demosaicnet_caffe>
- **How do I train this?** The script `scripts/train.py` is a good start to setup your training job, but I haven't tested it yet, I recommend rolling your own.
dramatiq-kafka 0.1.9
A Kafka broker for Dramatiq.
Requires Python: >=3.8,<4.0

Uses kafka-python package to write a Kafka broker for dramatiq.

```python

import dramatiq

from dramatiq.middleware import AgeLimit, TimeLimit, Callbacks, Pipelines, Prometheus, Retries
from dramatiq_kafka import KafkaBroker

broker = KafkaBroker(
    bootstrap_servers="localhost:9092",
    topic="testdramatiq_topic", # default is `default`
    group_id="testdramatiq_consumergroup", # optional, default is `default`
    middleware=[
        Prometheus(),
        AgeLimit(),
        TimeLimit(),
        Callbacks(),
        Pipelines(),
        Retries(min_backoff=1000, max_backoff=900000, max_retries=96),
    ],
)
dramatiq.set_broker(broker)
```

Use dramatiq to send a message to a Kafka topic (`queue_name`) as usual:

```python
    message = Message(
        queue_name="rita",
        actor_name="email_customer",
        args=("testing@gmail.com",),
        kwargs={},
        options={},
    )

    broker = get_broker()
    broker.enqueue(message)
```

Write tasks as described in django_dramatiq's documentation (i.e. create dramatiq actors in the task.py files) and modify settings as shown in `django_example` to get started. To send messages, view the views.py file for an example
wozoxutils 0.2.6
general-purpose library for Python that contains various commonly used functional modules
Keywords: wozox utils

# wozoxutils [![PyPI](https://img.shields.io/pypi/v/wozoxutils.svg)](https://pypi.org/project/wozoxutils/) [![PyPI - Format](https://img.shields.io/pypi/format/wozoxutils.svg)](https://pypi.org/project/wozoxutils/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/wozoxutils.svg)](https://pypi.org/project/wozoxutils/)
general-purpose library for Python that contains various commonly used functional modules.

## Installation

```shell
pip install wozoxutils
```

## Usage


```python
from wozoxutils import load_json, save_json, load_yaml, save_yaml, calculate_md5_for_file, calculate_md5_for_files

# json
json_obj = {
    'foo': 'bar',
    'int': 1
}
save_json('tests/foo.json', json_obj)
json_obj = load_json('tests/foo.json')
print(json_obj['foo']) # bar
print(json_obj['int']) # 1

# yaml
yaml_obj = {
    'foo': 'bar',
    'int': 1
}
save_yaml('tests/foo.yaml', yaml_obj)
yaml_obj = load_yaml('tests/foo.yaml')
print(yaml_obj['foo']) # bar
print(yaml_obj['int']) # 1

# md5
calculate_md5_for_file('tests/foo.json') # eb7a203770342c5d4336d41cf1d7c05b
calculate_md5_for_files(['tests/foo.yaml', 'tests/foo.json']) # 1e073343d8616c486391901bdd41a7af
```
ABOTP 2.1.1
Advanced bi-directional over TCP and UDP protocol
Requires Python: >=3.10


ABOTP
=====

ABOTP is a Python package that provides a TCP and UDP double-socket protocol for bi-directional communication between clients and servers. It allows sending and receiving byte data over TCP and UDP connections.

Features
--------

- Supports both TCP and UDP communication protocols.
- Provides a server-side implementation (Server) for accepting client connections and handling data transmission.
- Offers a client-side implementation (Client) for connecting to a server and exchanging data.
- Supports sending and receiving lists of byte objects (bytes) as data payloads.
- Provides error handling for socket-related exceptions and connection status errors.
- Works with Python 3.10, 3.11, and 3.12.

Installation
------------

You can install ABOTP using pip::

    pip install ABOTP

Usage
-----

To use ABOTP, import the necessary modules and classes::

    from ABOTP import Server
    from ABOTP import Client
    from ABOTP import By

You can also use the built-in server-side operating capabilities::

    from ABOTP import storage