semvec/pypi-packages huggingface dataset:
Matrix-Alt-Cameras 0.0.1
Extension for the Matrix-Alt-Core package to add camera functionality
Requires Python: >=3.9

# Matrix-Alt-Cameras

**Matrix-Alt-Cameras** is an extension package to the [Matrix-Alt-Core](https://pypi.org/project/Matrix-Alt-Core/) framework, designed to add camera capabilities to your Alt Agents with minimal setup. 
---

## 🚀 Quick Start

Here's a basic example using an OpenCV-compatible webcam:

```python
from Alt.Core.Agents import Agent
from Alt.Cameras.CameraUsingAgent import CameraUsingAgentBase
from Alt.Cameras.Captures.OpenCVCapture import OpenCVCapture
import cv2

class CamTest(CameraUsingAgentBase):
    def __init__(self):
        super().__init__(capture=OpenCVCapture("test", 0))

    def runPeriodic(self):
        super().runPeriodic()
        cv2.putText(self.latestFrameMain, "This test will be displayed on top of the frame", (10, 20), 1, 1, (255, 255, 255), 1)

    def getDescription(self):
        return "test-read-webcam"

if __name__ == "__main__":
    from Alt.Core import Neo

    n = Neo()
    n.wakeAgent(CamTest, isMainThread=True)
    n.shutDown()
```
Alt-Cameras 0.0.1
Contains apis to read from various cameras
Requires Python: >=3.9

# Matrix-Alt-Cameras

**Matrix-Alt-Cameras** is an extension package to the [Matrix-Alt-Core](https://github.com/Team488/Alt/Alt-Core) framework, designed to add camera capabilities to your Alt Agents with minimal setup. This module enables you to easily attach one or more camera streams (e.g., OpenCV, RealSense, OAK-D) to your agents, process frames in real-time, and integrate vision into autonomous systems.

Created by **FRC Team 488** (*Subteam: The Matrix*), this package extends the flexibility of the Alt framework to support robust camera-based tasks like localization, vision tracking, or display overlays.

---

## 🚀 Quick Start

Here's a basic example using an OpenCV-compatible webcam:

```python
from Alt.Core.Agents import Agent
from Alt.Cameras.CameraUsingAgent import CameraUsingAgentBase
from Alt.Cameras.Captures.OpenCVCapture import OpenCVCapture
import cv2

class CamTest(CameraUsingAgentBase):
    def __init__(self):
        super().__init__(capture=OpenCVCapture("test", 0))

    def runPeriodic(self):
        super().runPeriodic()
        cv2.putText(self.latestFrameMain, "This test will be displayed on top of the frame", (10, 20), 1, 1, (255, 255, 255), 1)

    def getDescription(self):
        return "test-read-webcam"

if __name__ == "__main__":
    from Alt.Core import Neo

    n = Neo()
    n.wakeAgent(CamTest, isMainThread=True)
    n.shutDown()
```

MIT License

Copyright (c) 2025 The Matrix 488

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.
katzenpost-thinclient 0.0.3
A thinclient for the Katzenpost client daemon
Requires Python: >=3.8


# katzenpost_thinclient

*A thin client for sending and receiving messages via a Katzenpost mix network.*

This pypi package provides a thin client library for interacting with a
Katzenpost mixnet.

A mix network is a type of anonymous communications network.

A thin client library is code you can use as a depencency in your
application so that it can anonymously interact with services on the
mix network. The Katzenpost client daemon is a multiplexing client;
many applications on the same device can use their thin client
libraries to connect to the daemon and interact with mixnet services
concurrently.



# Contributions

This is a work in progress and we'll require feedback from developers to make improvements.
Pull requests welcome:

https://github.com/katzenpost/thin_client



# Documentation

Here's our python API docs:
https://katzenpost.network/docs/python_thin_client.html

Here's our thin client integration guide:
https://github.com/katzenpost/website/blob/main/content/en/docs/client_integration.md



# Installation

Install katzenpost using pip:

```bash
pip install katzenpost_thiclient
```

or

```bash
pip install -e .
```



# Running Code Examples

In the `tests/` directory AND the `examples/` directory you'll find
some simple python examples that use this library. However both of
them refer to the path to the katzenpost docker mixnet's client2's
thinclient's config, like so:

```python

docker_mixnet_thinclient_cfg = "../../katzenpost/docker/voting_mixnet/client2/thinclient.toml"
```

These examples are meant to be runned after starting a katzenpost docker mixnet.
Firstly, start the docker mixnet. For details instructions, go here: https://katzenpost.network/docs/admin_guide/docker.html
We'll be working with the Katzenpost monorepo to get the docker mixnet started: https://github.com/katzenpost/katzenpost

```bash

cd katzenpost/docker
make start wait run-ping
```

Once our docker mixnet is fully started up then we can start the client2 daemon:

```bash

cd katzenpost/client2
make warpedclientdaemon
cd cmd/kpclientd
./kpclientd -c ../../../docker/voting_mixnet/client2/client.toml
```

The above client2/client.toml should have been created by the docker Makefile
(via the `make start` command above) which sets up a new docker mixnet. Next we can
finally run our test and examples:


```bash

pytest
```

and

```bash

cd examples
python fetch_pki_doc.py
# blah blah informative output
python echo_ping.py
# blah blah informative output
```


# Additional Code Examples

We have two working example python programs that use this
thin client library:

1. stats - terminal application that prints the current mixnet status
   https://github.com/katzenpost/status

2. worldmap - renders an image of the mixnet transposed over a worldmap
   https://github.com/katzenpost/worldmap


# Compatibility

Works with Katzenpost v0.0.49 or later.



# License

AGPLv3