semvec/pypi-packages huggingface dataset:
islabtech-upw-sensor-v1-mock-api 0.1.6
Mock API simulating the Rest+Modbus/TCP API of the ISLabTech UPW sensor
Requires Python: >=3.7

# UPW Sensor API

API for the [ISLabTech UPW Sensor](https://gitlab.com/islabtech/upw-sensor)

## REST API
[The entire REST API is documented in OpenAPI/Swagger.](https://gitlab.com/islabtech/upw-sensor/api/-/blob/main/openapi.yml).

## Modbus/TCP
[The Modbus/TCP interface is documented in this PDF.](https://gitlab.com/islabtech/upw-sensor/api/-/raw/main/modbus-doc.pdf?inline=false)

## 🐍 Mock API

Run the mock API locally with Python:

```sh
pip3 install islabtech_upw_sensor_v1_mock_api
python3 -m islabtech_upw_sensor_v1_mock_api
```

Run it with the web app:

```sh
python3 -m islabtech_upw_sensor_v1_mock_api --web-app /path/to/web-app-git-repo
```

Access it with cURL:

```sh
curl -X GET http://localhost:5000/api/v1/measurements/latest
curl -X GET http://localhost:5000/api/v1/system/status
curl -X PATCH http://localhost:5000/api/v1/settings/network/wifi -H "Content-Type: application/json" \
    -d '{"ssid": "my wifi", "password": "my password"}'
```

<!-- ## :book: Documentation

### Guides

Each group of API endoints is documented in its own guide.

- [measure](/guides/measure.md)
- [temperature calibration](/guides/temperature%20calibration.md)
- [conductivity calibration](/guides/conductivity%20calibration.md)

- [system](/guides/system.md)
- [settings](/guides/settings.md) -->
nextcloud-mcp 0.1.0
A Model-Context-Protocol (MCP) for saving files to Nextcloud and getting public share links.
Requires Python: >=3.8

# Nextcloud MCP

This project provides a Model-Context-Protocol (MCP) for saving files to a Nextcloud instance and immediately receiving a publicly available share URL.

## Features

-   **Save & Share:** Upload files to a designated Nextcloud folder and automatically generate a public, read-only share link.
-   **File and Folder Management:** Create and delete files and folders.
-   **Configurable:** All Nextcloud connection details are configurable via environment variables.
-   **Robust:** Built with modern Python libraries (`httpx`, `pydantic`) and includes error handling.
-   **Asynchronous:** Uses `asyncio` for non-blocking I/O operations.

## Quickstart

### 1. Prerequisites

-   Python 3.8+
-   A Nextcloud account with WebDAV access enabled.

### 2. Installation

Clone the repository and install the required dependencies:

```bash
git clone https://github.com/your-username/nextcloud-mcp.git
cd nextcloud-mcp
pip install -e .
```

### 3. Configuration

This project uses environment variables for configuration. Create a `.env` file in the project root and add the following variables:

```
NEXTCLOUD_INSTANCE_URL="https://your-nextcloud-instance.com"
NEXTCLOUD_USERNAME="your_username"
NEXTCLOUD_PASSWORD="your_password"
# Optional: Specify a folder to save files in.
# If not set, files will be saved in the root directory.
NEXTCLOUD_USAGE_FOLDER="MyUploads"
```

You can get a secure app password from your Nextcloud account settings under **Security > Devices & sessions**.

### 4. Usage

The `save_and_share.py` script provides a simple example of how to use the library.

```bash
python nextcloud_mcp/save_and_share.py
```

The script will:
1.  Load the configuration from your `.env` file.
2.  Create a new text file with a timestamp.
3.  Upload the file to your Nextcloud instance.
4.  Print the public share URL to the console.

## How It Works

The core logic is in the `Ctx` class (`nextcloud_mcp/context.py`), which handles the two main steps:

1.  **File Upload:** Uses the WebDAV protocol (`PUT` request) to upload the file to the specified path.
2.  **Share Link Creation:** Uses the Nextcloud OCS (Open Collaboration Services) API to create a public share link for the uploaded file.

## Project Structure

```
.
├── nextcloud_mcp/
│   ├── __init__.py
│   ├── config.py       # Configuration loading and validation
│   ├── context.py      # Core Ctx class for Nextcloud interaction
│   ├── exceptions.py   # Custom exception classes
│   └── save_and_share.py # Example usage script
├── tests/              # Unit tests
├── .env.example        # Example environment file
├── pyproject.toml      # Project metadata and dependencies
└── README.md
```
odoo12-addon-sm-rest-capture-log 12.0.1.0.0
Temporary module to capture and log all REST API requests during Odoo 12 to 17 migration
Requires Python: >=3.5

This module intercepts all incoming REST API requests made through base_rest
    and stores them in a persistent model for later replay in Odoo 17.
    
    Features:
    - Captures all HTTP methods (GET, POST, PUT, DELETE, etc.)
    - Stores request details: URL, headers, body, timestamp, client IP
    - Records response data for complete audit trail
    - Non-intrusive design compatible with base_rest architecture
    
    WARNING: This is a temporary module for migration purposes only.
stigrock 1.2.0
Stigrock v1.2 - Progetto Python con contenuti web
Requires Python: >=3.8

# 🚀 Stigrock v1.2

---

## 🔥 Descrizione

Stigrock v1.2 è un progetto avanzato e professionale sviluppato per [descrizione del progetto].  
Segue le migliori pratiche di sviluppo e distribuzione.

---

## 🛠️ Installazione e Setup

Per installare e far partire il progetto, segui questi passaggi direttamente da terminale:

```bash
# Clona il repository
git clone https://github.com/dnfhacktm/stigrock-v1.2.git
cd stigrock-v1.2

# Crea e attiva un ambiente virtuale (Linux/macOS)
python3 -m venv venv
source venv/bin/activate

# Windows (PowerShell)
# python -m venv venv
# .\venv\Scripts\Activate.ps1

# Aggiorna pip
pip install --upgrade pip

# Installa le dipendenze
pip install -r requirements.txt
postmodal 0.2.1
Postprocessing of modal parameters from structural dynamics.
Requires Python: <3.14,>=3.10

# postmodal

[![Release](https://img.shields.io/github/v/release/runlevel0/postmodal)](https://img.shields.io/github/v/release/runlevel0/postmodal)
[![Build status](https://img.shields.io/github/actions/workflow/status/runlevel0/postmodal/main.yml?branch=main)](https://github.com/runlevel0/postmodal/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/runlevel0/postmodal/branch/main/graph/badge.svg)](https://codecov.io/gh/runlevel0/postmodal)
[![Commit activity](https://img.shields.io/github/commit-activity/m/runlevel0/postmodal)](https://img.shields.io/github/commit-activity/m/runlevel0/postmodal)
[![License](https://img.shields.io/github/license/runlevel0/postmodal)](https://img.shields.io/github/license/runlevel0/postmodal)

Postprocessing of modal parameters from structural dynamics.

- **Github repository**: <https://github.com/runlevel0/postmodal/>
- **Documentation** <https://runlevel0.github.io/postmodal/>

## Getting started with your project

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:runlevel0/postmodal.git
git push -u origin main
```

Finally, install the environment and the pre-commit hooks with

```bash
make install
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).

## Releasing a new version

- Create an API Token on [PyPI](https://pypi.org/).
- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/runlevel0/postmodal/settings/secrets/actions/new).
- Create a [new release](https://github.com/runlevel0/postmodal/releases/new) on Github.
- Create a new tag in the form `*.*.*`.
- For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
redpanda-connect 0.1.3
A library for writing Redpanda Connect plugins in Python
Requires Python: >=3.12

# Redpanda Connect Python Plugins

This library allows you to create python plugins for [Redpanda Connect](https://www.redpanda.com/connect).

In order to use create a processor plugin you can follow these steps:

```shell
uv init project

cd project

uv add redpanda_connect

cat <<EOF > main.py
import asyncio
import logging
import redpanda_connect


@redpanda_connect.processor
def yell(msg: redpanda_connect.Message) -> redpanda_connect.Message:
    msg.payload = msg.payload.upper()
    return msg

if __name__ == "__main__":
    asyncio.run(redpanda_connect.processor_main(yell))
EOF

cat <<EOF > plugin.yaml
name: foo
summary: Just the simplest example
command: ["uv", "run", "main.py"]
type: processor
fields: []
EOF

cat <<EOF > connect.yaml
pipeline:
  processors:
    - foo: {}
EOF

rpk connect run --rpc-plugins=plugin.yaml connect.yaml
```