semvec/pypi-packages huggingface dataset:
Kuyruk 10.2.1
Simple task queue
Keywords: rabbitmq distributed task queue

.. image:: https://raw.githubusercontent.com/cenkalti/kuyruk/master/docs/_static/lemur.png
   :alt: Kuyruk Logo

Kuyruk
======

.. image:: https://github.com/cenkalti/kuyruk/actions/workflows/build.yml/badge.svg?branch=master
   :target: https://github.com/cenkalti/kuyruk/actions

.. image:: https://coveralls.io/repos/github/cenkalti/kuyruk/badge.svg?branch=master
   :target: https://coveralls.io/github/cenkalti/kuyruk?branch=master

.. image:: https://img.shields.io/pypi/v/kuyruk.svg?branch=master
   :target: https://pypi.org/project/Kuyruk/


Kuyruk is a simple and easy way of distributing tasks to run on servers.

It uses `RabbitMQ <http://www.rabbitmq.com>`_ as message broker and
depends on `amqp <http://amqp.readthedocs.org/>`_
which is a pure-Python RabbitMQ client library.
Compatible with Python 3.10+.


Where is the documentation?
---------------------------
Here it is: http://kuyruk.readthedocs.org
opp-py 0.1.1
ODIN Provenance Passport — Python instrumentation + CLI
Requires Python: >=3.10
Keywords: provenance, ai, model passport, odin, ope, c2pa, policy

# OPP Python SDK (`opp_py`)

Instrumentation + CLI for ODIN Provenance Passport (OPP).

## Features
- `@stamp(step_type, attrs=..., inputs=..., outputs=...)` decorator emits start/end signed receipts.
- Automatic input/output content IDs (CIDs) via optional callables.
- Fallback lightweight OPE client (no external `odin-sdk` required) using env Ed25519 seed.
- Graph + Passport generation (`opp graph`, `opp passport`).
- Policy evidence aggregation & breach summary (`opp policy`).
- Optional C2PA bridge (`opp.c2pa.embed_bundle_cid`) to embed bundle CID into images (extra deps).

## Install (editable dev)
```bash
pip install -e packages/opp_py
```

Required env for stamping (generate a random 32‑byte seed once):
```bash
export OPP_GATEWAY_URL=http://127.0.0.1:8080
export OPP_SENDER_PRIV_B64=<base64url_32byte_seed>
export OPP_SENDER_KID=opp-sender
```

Generate a seed (PowerShell):
```powershell
$bytes = New-Object byte[] 32; [Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes); \
$seed = [Convert]::ToBase64String($bytes).TrimEnd('=') -replace '\+','-' -replace '/','_'; $seed
```

## Decorator Usage
```python
from opp.decorators import stamp

@stamp(
		"train.v1",
		attrs={"model":"resnet"},
		inputs=lambda args, kwargs: {"hyperparams": kwargs.get("hp")},
		outputs=lambda ret: {"metrics": ret.get("metrics")}
)
def train(data, *, hp):
		# ... training ...
		return {"metrics": {"accuracy": 0.93}}

train([], hp={"lr":1e-3})
```

Emitted start receipt includes `inputs_cid`; end receipt includes `outputs_cid` and `status`.

## CLI
```bash
opp graph --trace TRACE --gateway $OPP_GATEWAY_URL         # build minimal graph
opp validate --trace TRACE --gateway $OPP_GATEWAY_URL      # continuity + basic validation
opp passport --trace TRACE --gateway $OPP_GATEWAY_URL      # rich model/data passport JSON
opp policy --trace TRACE --gateway $OPP_GATEWAY_URL        # summarized policy evidence + breaches
```

## Passport Fields (excerpt)
```jsonc
{
	"trace_id": "...",
	"receipts": 12,
	"steps": ["ingest.v1","train.v1"],
	"dataset_roots": ["sha256:..."],
	"model_id": "model-123",
	"metrics": {"accuracy": 0.93},
	"safety_flags": {"pii_redacted": true},
	"policy_engines": ["opa"],
	"policy_breaches": [{"rule":"no_public_data","outcome":"deny"}]
}
```

## Policy Evidence
If receipts carry a normalized `policy` object with `engine` + `decisions[]`, breaches are auto‑derived when an outcome is not in `{allow, pass, ok}`.

## Optional C2PA Bridge
```bash
pip install c2pa Pillow
python examples/c2pa_embed.py image.png
```
Adds a custom assertion with the `bundle_cid` to the image manifest.

## Airflow & Dagster Examples
See `examples/airflow_dag.py` and `examples/dagster_job.py` for task/op instrumentation and trace continuity.

## Testing
```bash
pytest -q packages/opp_py/tests
```

## Backward Compatibility
New fields are additive; existing receipt payload fields preserved. Hashing uses canonical JSON (stable order, no whitespace).

## License
Apache 2.0
smart-legion-lab-library 1.0.2
Smart Legion Lab Library
Requires Python: >=3.8

# Smart Legion Lab Library <sup>v1.0.2</sup>

---


***

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
gatenet 0.12.6
Python library for gateways, networks, and devices.
Requires Python: >=3.9

# gatenet

[![PyPI](https://img.shields.io/pypi/v/gatenet?style=for-the-badge)](https://pypi.org/project/gatenet/)
[![Docs](https://img.shields.io/badge/docs-latest-blue?style=for-the-badge)](https://gatenet.readthedocs.io/en/latest/)
[![CI](https://github.com/clxrityy/gatenet/actions/workflows/test.yml/badge.svg?style=for-the-badge)](https://github.com/clxrityy/gatenet/actions/workflows/test.yml)
[![Changelog](https://img.shields.io/badge/changelog-blueviolet?style=for-the-badge)](https://gatenet.readthedocs.io/en/latest/changelog.html)

Gatenet is a Python toolkit for networking: diagnostics (ping, traceroute, DNS, ports), simple HTTP/TCP/UDP building blocks, service discovery, and Wi‑Fi hotspot management. It now includes a lightweight hooks system for easy extensibility.

## Install

```bash
pip install gatenet
```

Python 3.10+ • Linux/macOS/Windows (feature availability varies by platform)

## Highlights

- Diagnostics: ICMP/TCP ping, traceroute, port scan, DNS, IP geolocation
- HTTP/TCP/UDP: minimal server/client utilities
- Discovery: pluggable detectors with a registry
- Hotspot: create/manage Wi‑Fi access points (Linux/macOS)
- Hooks: shared event bus across modules (HTTP, clients, discovery, diagnostics)

## Quick start

HTTP server

```python
from gatenet.http_.server import HTTPServerComponent

server = HTTPServerComponent(host="127.0.0.1", port=8080)

@server.route("/status", method="GET")
def status(_req):
    return {"ok": True}

server.start()
```

HTTP client

```python
from gatenet.http_.client import HTTPClient

client = HTTPClient("http://127.0.0.1:8080")
res = client.get("/status")
print(res["data"])  # {"ok": True}
```

TCP / UDP

```python
from gatenet.client.tcp import TCPClient
from gatenet.client.udp import UDPClient

# TCP
tcp = TCPClient("127.0.0.1", 9000)
tcp.connect()
print(tcp.send("ping"))
tcp.close()

# UDP
udp = UDPClient("127.0.0.1", 9001)
print(udp.send("ping"))
udp.close()
```

Diagnostics

```python
from gatenet.diagnostics import ping
from gatenet.diagnostics.traceroute import traceroute

print(ping("1.1.1.1", count=2))
print(traceroute("example.com"))
```

Discovery

```python
from gatenet.discovery.ssh import _identify_service

print(_identify_service(22, "SSH-2.0-OpenSSH_8.9p1"))
```

Hotspot (platform-dependent)

```python
from gatenet.hotspot import Hotspot

hotspot = Hotspot(ssid="GatenetAP", password="SecurePass123!")
if hotspot.start():
    print("running")
    hotspot.stop()
```

Hooks & events

```python
from gatenet.core import hooks, events

hooks.on(events.HTTP_BEFORE_REQUEST, lambda req: print("HTTP", req.command, req.path))
```

## Learn more

- Docs: https://gatenet.readthedocs.io
- Examples: docs Examples page (HTTP, TCP/UDP, discovery, diagnostics, hooks)
- Changelog: https://gatenet.readthedocs.io/en/latest/changelog.html

## Contributing

Run tests locally:

```bash
pytest -q
```

License: MIT
flake8-ruff 0.3.1
A Flake8 plugin that implements miscellaneous checks from Ruff.
Requires Python: >=3.9
Keywords: flake8, ruff

# flake8-ruff

[![image](https://img.shields.io/pypi/v/flake8-ruff.svg)](https://pypi.python.org/pypi/flake8-ruff)

A Flake8 plugin that implements miscellaneous checks from
[Ruff](https://github.com/astral-sh/ruff).

Specifically, this plugin implements checks that are under the `RUF` category
(the rules that do not have a direct equivalent in Flake8).

## Requirements

Python 3.9 and newer is supported.

## Installation

Install from PyPI. For example,

```bash
pip install flake8-ruff
```

Then follow the instructions on the
[Flake8 documentation](https://flake8.pycqa.org/en/latest/index.html) to enable
the plugin.

## Checks

### RUF010 Use explicit conversion flag

Checks for `str()`, `repr()`, and `ascii()` as explicit conversions within
f-strings.

For example, replace

```python
f"{ascii(foo)}, {repr(bar)}, {str(baz)}"
```

with

```python
f"{foo!a}, {bar!r}, {baz!s}"
```

or, often (such as where `__str__` and `__format__` are equivalent),

```python
f"{foo!a}, {bar!r}, {baz}"
```

Derived from
[explicit-f-string-type-conversion (RUF010)](https://docs.astral.sh/ruff/rules/explicit-f-string-type-conversion/).

### RUF018 Avoid assignment expressions in `assert` statements

Checks for named assignment expressions in `assert` statements. When Python is
run with the `-O` option, the `assert` statement is ignored, and the assignment
expression is not executed. This can lead to unexpected behavior.

For example, replace

```python
assert (result := foo()) is not None
```

with

```python
result = foo()
assert result is not None
```

Derived from
[assignment-in-assert (RUF018)](https://docs.astral.sh/ruff/rules/assignment-in-assert/).

### RUF020 `typing.Never | T` is equivalent to `T`

Checks for `typing.Never` and `typing.NoReturn` in union types, which is
redundant.

For example, replace

```python
typing.Never | int | None
```

with

```python
int | None
```

Derived from
[never-union (RUF020)](https://docs.astral.sh/ruff/rules/never-union/).

### RUF025 Unnecessary dict comprehension for iterable; use `dict.fromkeys` instead

Checks for dict comprehensions that create a dictionary from an iterable with a
constant value. Instead, use `dict.fromkeys`, which is more efficient.

For example, replace

```python
{key: 0 for key in keys}
```

with

```python
dict.fromkeys(keys, 0)
```

and

```python
{key: None for key in keys}
```

with

```python
dict.fromkeys(keys)
```

Derived from
[unnecessary-dict-comprehension-for-iterable (RUF025)](https://docs.astral.sh/ruff/rules/unnecessary-dict-comprehension-for-iterable/).
graphius 0.1.0
A Simple Graph Library with Visualization Support
Requires Python: >=3.10

# Graphius
Graphius is a python library for creating and visualizing graphs. It has algorithms for finding shortest paths, minimum spanning trees, and more. You can visualize the graphs and algorithms step by step. You can use graphius with Jupyter notebooks or as a standalone application.

For examples see the [examples](https://github.com/alperenunlu/graphius/blob/master/examples/Examples.ipynb) notebook.

## Installation
```bash
pip install graphius
```
>If you want to use the visualization features you need to install `graphviz`.
See [graphviz.org/download](https://graphviz.org/download/) for installation instructions.

## Usage
```python
from graphius import Graph

adjacency_list = {
    's': [('t', 10), ('y', 5)],
    't': [('x', 1), ('y', 2)],
    'x': [('z', 4)],
    'y': [('t', 3), ('x', 9), ('z', 2)],
    'z': [('s', 7), ('x', 6)]
}

g = Graph(adjacency_list, weighted=True, directed=True)
g.dijkstra('s', visualized=True, gif_path='dijkstra.gif')
```
`dijsktra.gif:`

![dijkstra](https://github.com/alperenunlu/graphius/blob/master/examples/dijkstra.gif?raw=true)


This project is licensed under the MIT License - see the [LICENSE](https://github.com/alperenunlu/graphius/blob/master/LICENSE) file for details
waykey 0.1.0
Wayland automation
Requires Python: >=3.13
Keywords: wayland, automation, input

<div align="center">

# WayKey

![Image](./docs/assets/WayKey.svg)

![CI](https://github.com/Nmstr/WayKey/actions/workflows/run-ruff.yaml/badge.svg)
![GitHub License](https://img.shields.io/github/license/Nmstr/WayKey)

</div>

WayKey is a wayland automation tool.