semvec/pypi-packages huggingface dataset:
sg7569-cs9223-assgn1 0.1.0
Code for software supply chain security assignment 1
Requires Python: >=3.12

# SG7569 — CS9223 Assignment 1

A small toolkit and reference implementation for verifying Rekor transparency log entries
using Merkle proofs and offline verification. This repository contains the code used for
assignment 1 of the CS9223 course (software supply chain security).

## Project contents

- `assignment1/` — Primary assignment code and scripts.
	- `main.py` — Command-line Rekor transparency log verifier (inclusion, checkpoint, consistency).
	- `merkle_proof.py`, `util.py` — Helper modules for hashing, proof verification and signature checks.
	- `artifact.bundle` — Example artifact bundle used by some of the verification helpers.

## Requirements & Dependencies

- Python: supported Python versions are >= 3.12 (see `pyproject.toml`).
- Runtime dependencies (declared in `pyproject.toml`):
	- `cryptography>=46.0.1`
	- `requests>=2.32.5`

Development tools (optional) are listed under the `dev` dependency group in
`pyproject.toml` and include `bandit`, `mypy`, `pylint`, and `ruff`.

## Installation

1. Install uv (package manager): 
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

1. Setup and activate a virtual environment (recommended):

```bash
# Create virtual environment and install dependencies
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
uv sync
```

## Usage

The main entrypoint for the assignment tools is `assignment1/main.py`. Typical commands:

- Fetch and print the latest Rekor checkpoint:

```bash
python assignment1/main.py --checkpoint
```

- Verify inclusion of an artifact using a Rekor log index and a local artifact file:

```bash
python assignment1/main.py --inclusion 12345 --artifact path/to/artifact.file
```

- Verify consistency between a previous checkpoint and the latest Rekor checkpoint:

```bash
python assignment1/main.py --consistency --tree-id <TREE_ID> --tree-size <SIZE> --root-hash <ROOT>
```

Use `-d` / `--debug` with any command to enable verbose output for troubleshooting.

## Notes and assumptions

- The code uses the public Rekor instance endpoints that are referenced in
	`assignment1/main.py`. Network access is required to fetch entries and proofs.
- The repository expects Python 3.12+ (see `pyproject.toml`); if you use a different
	Python version, some features or type checks may behave differently.
- This README provides quick usage. For implementation details, consult the source
	files in `assignment1/` (notably `main.py`, `merkle_proof.py`, and `util.py`).

## License

This project is provided under the license found in the repository `LICENSE` file.

## Contact / Questions

If you need clarifications about the assignment or the code, open an issue in the
repository or contact the maintainer listed in the repository metadata.
orion-fhe 1.0.2
A Fully Homomorphic Encryption Framework for Deep Learning
Requires Python: <3.13,>=3.9

# Orion

## Installation
We tested our implementation on `Ubuntu 22.04.5 LTS`. First, install the required dependencies:

```
sudo apt update && sudo apt install -y \
    build-essential git wget curl ca-certificates \
    python3 python3-pip python3-venv \
    unzip pkg-config libgmp-dev libssl-dev
```

Install Go (for Lattigo backend):

```
cd /tmp
wget https://go.dev/dl/go1.22.3.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.3.linux-amd64.tar.gz
echo 'export PATH=/usr/local/go/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
go version # go version go1.22.3 linux/amd64
```

### Install Orion

```
git clone https://github.com/baahl-nyu/orion.git
cd orion/
pip install -e .
```

### Run the examples!

```
cd examples/
python3 run_lola.py
```
llama-index-llms-ovhcloud 0.1.0
llama-index llms ovhcloud integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: OVHcloud AI Endpoints

This integration allows you to use OVHcloud AI Endpoints with LlamaIndex. OVHcloud AI Endpoints provides OpenAI-compatible API endpoints for various models.

OVHcloud is a global player and the leading European cloud provider operating over 450,000 servers within 40 data centers across 4 continents to reach 1.6 million customers in over 140 countries. Our product AI Endpoints offers access to various models with sovereignty, data privacy and GDPR compliance.

## Installation

Install the required packages:

```bash
pip install llama-index llama-index-llms-ovhcloud
```

## API Key

OVHcloud AI Endpoints can be used in two ways:

1. **Free tier (with rate limits)**: You can use the API without an API key or with an empty string API key. This provides free access with rate limits.

2. **With API key**: For higher rate limits and production use, generate an API key from the OVHcloud manager:
   - Go to https://ovh.com/manager
   - Navigate to Public Cloud section
   - Go to AI & Machine Learning → AI Endpoints
   - Create an API key

## Usage

### Basic Usage

To use OVHcloud AI Endpoints with LlamaIndex, first initialize the LLM:

```python
from llama_index.llms.ovhcloud import OVHcloud

# Using with API key
llm = OVHcloud(
    model="gpt-oss-120b",
    api_key="YOUR_API_KEY",  # Or empty string for free tier with rate limits)
)
```

You can find available models in the [OVHcloud AI Endpoints catalog](https://www.ovhcloud.com/en/public-cloud/ai-endpoints/catalog/).

### Basic Completion

Generate a simple completion:

```python
response = llm.complete("The capital of France is")
print(response.text)
```

### Chat Messages

Use chat-style interactions:

```python
from llama_index.core.llms import ChatMessage

messages = [
    ChatMessage(role="system", content="You are a helpful assistant"),
    ChatMessage(role="user", content="What is the capital of France?"),
]
response = llm.chat(messages)
print(response)
```

### Streaming

Stream completions in real-time:

```python
# Streaming completion
response = llm.stream_complete("The capital of France is")
for r in response:
    print(r.delta, end="")

# Streaming chat
messages = [
    ChatMessage(role="system", content="You are a helpful assistant"),
    ChatMessage(role="user", content="What is the capital of France?"),
]
response = llm.stream_chat(messages)
for r in response:
    print(r.delta, end="")
```

### Get Available Models

You can dynamically fetch available models:

```python
llm = OVHcloud(model="gpt-oss-120b")
available = llm.available_models  # List[Model] - fetched dynamically
model_ids = [model.id for model in available]
print(f"Available models: {model_ids}")
```

## Additional Resources

For more information about OVHcloud AI Endpoints, visit:

- [OVHcloud AI Endpoints Catalog](https://www.ovhcloud.com/en/public-cloud/ai-endpoints/catalog/)
- [OVHcloud Manager](https://ovh.com/manager)
- [OVHcloud Help Centre](https://help.ovhcloud.com/csm/world-home?id=csm_index)
pysio-hermes-moticon 0.0.2
A Moticon OpenGo pressure insoles support module for HERMES
Requires Python: >=3.7
Keywords: embedded ai, wearables, sensors, pressure insoles, moticon, streaming, realtime processing, physiology

# HERMES - Moticon OpenGO Insoles

Support package to interface the [Moticon OpenGo](https://moticon.com/opengo/sensor-insoles) commercial pressure insole sensors in [HERMES](https://github.com/maximyudayev/hermes). The interface connects to the UDP output stream of the [OpenGo desktop software](https://moticon.com/opengo/software) endpoint, which receives streaming data from the [OpenGo mobile app](https://moticon.com/opengo/app) endpoint connected over BLE to the insoles.

> [!NOTE]
> This package relies on the complementary software provided along with the insoles kit. Moticon also offers the [Insole SDK](https://moticon.com/solutions-integrations) via a paid license, which enables direct communication to the insoles over BLE instead of through the 2 OEM software endpoints. The option is not covered by this package for costs reasons.

> [!WARNING]
> (October, 2025): [unresolved] Previously working version interfacing `03.05.00_11804` of OpenGo desktop app and `03.10.00 (80)`/`03.13.01 (99)` mobile app is experiencing unexpected prolong dropout in streamed data.

## Installation
Node available under the same HERMES namespace of `hermes.moticon` as `MoticonProducer`. Follow [these instructions](https://moticon.com/opengo/docs#tutorials) to prepare the insoles and configure live streaming, setup the stream out of the mobile app, configure UDP output streaming from the desktop app to the `localhost`.

### From PyPI
```bash
pip install pysio-hermes-moticon
```

### From source
```bash
git clone https://github.com/maximyudayev/hermes-moticon.git
pip install -e hermes-moticon
```

## Usage
Using the device follows the standard [configuration file specification](https://maximyudayev.github.io/hermes/) process of HERMES nodes.

### Desktop app
Turn on OpenGo software on the desktop, take note of IP address. Select all desired modalities to stream out of the app over UDP to the localhost.

### Mobile app
Zero the insoles, calibrate the weight of the person, connect to the desktop endpoint over IP.

> [!TIP]
> Use USB tethering between smartphone and desktop for lower latency and a robust connection.

Start capturing the data in the mobile app. The desktop app should begin to visualize streaming data and retransmit it on the localhost at the specified port number. Default port `8888` will automatically receive data in HERMES.

## Citation
When using any parts of this repository outside of its intended use, please cite the parent project [HERMES](https://github.com/maximyudayev/hermes).