semvec/pypi-packages huggingface dataset:
robobopy-videostream 1.1.0
Robobo video streaming library
Requires Python: >=3.6

# robobo-python-video-stream

This library is required to use the video streaming from the Smartphone's camera in the Robobo.py library. It only runs in Android operating system.

## Installation

Download this repository to your computer and save it in the *robobo.by* folder. Then open a terminal window and type the two following commands:

```
pip install robobopy_videostream
```


## Example

The following script shows an example of the basic usage of this library:

``` python
from robobo_videostream.RoboboVideo import RoboboVideo
import cv2

#The IP must be that shown in the Robobo app
videoStream = RoboboVideo("X.X.X.X")
rob = Robobo("X.X.X.X")

def main():
    print("Starting test app")
    #Connect to the robot and start the video stream
    rob.connect()
    rob.startStream()

    videoStream.connect()

    print("Showing images")

    while True:
        cv2_image = videoStream.getImage()
        cv2.namedWindow('imagen', cv2.WINDOW_NORMAL)
        cv2.imshow('imagen', cv2_image)
        cv2.waitKey(1)

main()
```
martensite-utils 0.0.2
A utility library for Stonecrest Data Solution's Martensite ONNX Inference Server
Requires Python: >=3.10

# Martensite Utils

Welcome to Martensite Utils! This Python package is developed by Stonecrest 
Data Solutions and is designed to be used in conjunction with our Martensite
Docker Container. It is a simple package that is designed to handle the
transmission of Numpy Arrays over TCP by serializing the Arrays into a Protobuf
Message. Since a lot of this is complex and usually outside the normal realm of
AI/ML Engineers, we developed Martensite Utils to simplify this process.

Though Martensite Utils was designed to be used with Martensite, we can see the
potential benefit of using it in other projects that need to send Numpy Arrays
over TCP and would encourage this type of usage.

## Usage

There are a handful of translations that are included in Martensite Utils:

* Numpy Array -> Protobuf Message (`numpy_to_proto()`)
* Numpy Array -> Serialized Protobuf Message (`numpy_to_raw_proto()`)
* Protobuf Message -> Numpy Array (`proto_to_numpy()`)
* Serialized Protobuf Message -> Numpy Array (`raw_proto_to_numpy()`)

The typical process that is used for sending a Numpy Array to an endpoint is:

1. Create Numpy Array
2. Translate Numpy Array to Protobuf Message
3. Serialize Protobuf Message
4. Attach serialized Protobuf Message to request data
5. Send request

And to receive a Numpy Array:

1. Receive Request
2. Deserialize request data as Protobuf Message
3. Translate Protobuf Message into Numpy Array

**Note**: For both sending and receiving, steps 2&3 can be replaced by their
corresponding "raw" calls.

### Example

This example code creates a random Numpy Array, translates it to a serialized
Protobuf Message, sends it to the inference endpoint of a locally hosted
Martensite server, then parses the received data into a Numpy Array.

```python
import numpy as np
import requests
from martensite_utils import numpy_to_raw_proto
from martensite_utils import raw_proto_to_numpy

input_array = np.random.random((10, 10))
input_data = numpy_to_raw_proto(input_array)

response = requests.post(
    url="http://127.0.0.1:8000/inference",
    data=input_data
)

received_data = raw_proto_to_numpy(response.content)
print(f"Result: {received_data}")
```

There is also a helper function at `martensite_utils.post_numpy_array()` that
takes care of the translation and transmission all at once. View its docstring
to learn how to use it.
openeo-fastapi 2025.5.1
FastApi implementation conforming to the OpenEO Api specification.
Requires Python: <3.12,>=3.10

# OpenEO FastAPI
![PyPI - Status](https://img.shields.io/pypi/status/openeo-fastapi)
![PyPI](https://img.shields.io/pypi/v/openeo-fastapi)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openeo-fastapi)


A FastAPI implementation of the OpenEO Api specification.

## Install

Install using pip
```
pip install openeo-fastapi
```

### Use

The openeo fastapi repo has been set up to work with alembic. When you use this package to to prepare your api, you will need to create an alembic directory. In this directory, you can optionally add a models.py file and extend and of the models from openeo_fastapi.client.models.

The env.py file in the alembic directory, needs to be edited in the following way.
```
from openeo_fastapi.settings import BASE

target_metadata = BASE.metadata
```

You can now create auto revisions for a psql database using the alembic python commands.

```
alembic_cfg = Config("alembic.ini")

command.revision(alembic_cfg, f"openeo-fastapi-{__version__}", autogenerate=True)
command.upgrade(alembic_cfg, "head")

engine = get_engine()
```

Check how it is configured for the tests to see more.

## Contribute

Included is a vscode dev container which is intended to be used as the development environment for this package. A virtual environment needs to be set up inside the dev container, this is managed by poetry.

#### Setup

1. In VSCode `Ctrl + shift + p` and select "Dev Containers: Rebuild Container" to open the development environment for the first time.

2. Once the development environment is ready, run the following commands.
    ```
    # From /openeo-fastapi

    poetry config virtualenvs.path "<I tend to set this to the repo. I.e, ~/openeo-fastapi/.venv>"

    poetry lock

    poetry install --all-extras

    poetry run pre-commit install
    ```

    If you want to add a new dependency. Add it to the pyproject.toml and rerun the two commands again.

    Git is available in the container, so you can commit and push directy to your development branch.

3. You are now ready to write code and run tests!

    Either
    ```
    poetry run python -m pytest
    ```

    Or, run them directly from the testing section of vscode.
pldag-solver-sdk 0.2.2
Python SDK package for Solver API
Requires Python: <4.0,>=3.10

# How to use
```python
from solver import Solver, SolverType
from pldag import PLDAG

# Setup solver api
solver = Solver(url="http://localhost:9000")

# Setup a pldag model
model = PLDAG()
primitives = ["x", "y", "z"]
root = model.set_and(model.set_primitives(primitives))
solutions = solver.solve(model, [{}], {root: 0j}, SolverType.DEFAULT)
```