semvec/pypi-packages huggingface dataset:
ragraph 1.23.2
Ratio graph handling in Python.
Requires Python: >=3.11
Keywords: analysis, graph, network, visualization

# RaGraph

RaGraph is a package to create, manipulate, and analyze graphs consisting of nodes and edges. Nodes
usually represent (hierarchies of) objects and edges the dependencies or relationships between them.

These graphs, or networks if you will, lend themselves well to applied analyses like clustering and
sequencing, as well as analyses involving the calculation of various insightful metrics.

## User documentation

For all user-facing documentation, please head over to our beautiful documentation over at
[https://ragraph.ratio-case.nl](https://ragraph.ratio-case.nl)!

## Development installation

This project is packaged using [uv](https://docs.astral.sh/uv/) as the environment manager and build
frontend. Packaging information as well as dependencies are stored in
[pyproject.toml](./pyproject.toml).

For ease of use, this project uses the [just](https://github.com/casey/just) command runner to
simplify common tasks. Installing the project and its development dependencies can be done by
running `just install` in the cloned repository directory or manually by running `uv sync`.

Please consult the [justfile](./justfile) for the underlying commands or run `just` to display a
list of all available commands.

### Tests

Tests can be run using `just test` and subsequent arguments will be passed to pytest.

### Linting

Linting the project can be done using `just lint`, automatic fixes can be applied using `just fix`.
Linting config is included in [pyproject.toml](./pyproject.toml) for both Black and Ruff.

## Contributions and license

To get contributing, feel free to fork, pick up an issue or file your own and get going for your
first merge! We'll be more than happy to help.

For contribution instructions, head over to the [open-source GitLab
repository](https://gitlab.com/ratio-case-os/python/ragraph)!

All code snippets in the tutorial and how-to guide sections of the package documentation are free to
use.

If you find any documentation worthwhile citing, please do so with a proper reference to our
documentation!

RaGraph is licensed following a dual licensing model. In short, we want to provide anyone that
wishes to use our published software under the GNU GPLv3 to do so freely and without any further
limitation. The GNU GPLv3 is a strong copyleft license that promotes the distribution of free,
open-source software. In that spirit, it requires dependent pieces of software to follow the same
route. This might be too restrictive for some. To accommodate users with specific requirements
regarding licenses, we offer a proprietary license. The terms can be discussed by reaching out to
Ratio.
vivabem 0.0.6
Base shared class for loading data from smartwatches collected for the VivaBem project.


# Table of Contents

-   [Sensors](#org0df8c8f)
    -   [IMU](#orgf19c183)
        -   [Accelerometer](#org14e2ca2)
        -   [Gyroscope](#org58dfd33)
        -   [Magnetometer](#orga1c2318)
    -   [Heart Rate Monitor](#org1435a9a)
-   [@TODO](#orga187bdb)



<a id="org0df8c8f"></a>

# Sensors


<a id="orgf19c183"></a>

## IMU


<a id="org14e2ca2"></a>

### Accelerometer


<a id="org58dfd33"></a>

### Gyroscope


<a id="orga1c2318"></a>

### Magnetometer


<a id="org1435a9a"></a>

## Heart Rate Monitor


<a id="orga187bdb"></a>

# @TODO

adjust source parameter in Imu class for vb\_touch
adjust source parameter in Imu class for vb\_ef
vdlpy 2.1.0
Python interface to virtual data lakes
Requires Python: >=3.6

# Python Virtual data Lake Interface

This is a Python interface to virtual data lakes. Virtual data lakes are open source data platforms 
based on simple triple stores that enable users to integrate data from different sources. 
This package enables a Python client to access the interface
described at https://lacibus.gitlab.io/vdl/org/lacibus/storeapi/StoreApi.html
over the Web.
langchain-aidr 0.1.0
LangChain integrations for CrowdStrike AIDR
Requires Python: >=3.13

# langchain-aidr

CrowdStrike AIDR's tools for LangChain provide AI security features to protect
your applications and data. Using these tools you can:

- Defend against prompt injection attacks.
- Prevent the exposure of sensitive information, including:
  - Personally Identifiable Information (PII)
  - Protected Health Information (PHI)
  - Financial data
  - Secrets
  - Intellectual property
  - Profanity
- Remove malicious content from inputs and outputs, such as IP addresses,
  domains, and URLs.
- Monitor user inputs and model responses to support threat analysis, auditing,
  and compliance efforts.

## Installation

```
pip install -U langchain-aidr
```

## Tools

One can run CrowdStrike AIDR tools using agents or invoke them as a `Runnable`
within chains.

### AI Guard

```python
import os

from langchain_aidr import CrowdStrikeAIGuard
from pydantic import SecretStr

aidr_token = SecretStr(os.getenv("CS_AIDR_TOKEN"))
aidr_base_url_template = SecretStr(os.getenv("CS_AIDR_BASE_URL_TEMPLATE"))
aidr_ai_guard_tool = CrowdStrikeAIGuard(token=aidr_token, base_url_template=aidr_base_url_template)
```

#### Agent

```python
from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool

@tool
def search_tool(data):
    """Call to perform search"""

    return """
    47.84.32.175
    37.44.238.68
    47.84.73.221
    47.236.252.254
    34.201.186.27
    52.89.173.88
    """

tools = [search_tool, aidr_ai_guard_tool]

query = """
Hi, I am Bond, James Bond. I monitor IPs found in MI6 network traffic.
Please find me the most recent ones, you copy?
"""

system_message="Always use AI Guard before your final response to keep it safe for the user."

langgraph_agent_executor = create_react_agent(model, tools, prompt=system_message)

state = langgraph_agent_executor.invoke({"messages": [("human", query)]})
```

#### Chain

```python
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([("human", "{input}")])

query = """
Hi, I am Bond, James Bond. I am looking for a job. Please write me a super short resume.

I am skilled in international espionage, covert operations, and seduction.

Include a contact header:
Email: j.bond@mi6.co.uk
Phone: +44 20 0700 7007
Address: Universal Exports, 85 Albert Embankment, London, United Kingdom
"""

chain = (
  prompt
  | aidr_ai_guard_tool
  | model
  | StrOutputParser()
)
```

#### Standalone

```python
aidr_ai_guard_tool.run("Spam me at example@example.com")
aidr_ai_guard_tool.invoke("Take my SSN: 234-56-7890")
```
morse-audio 0.1.0
Python library for Morse code conversion and audio generation
Requires Python: >=3.8

# Morse Audio

Python library for converting text to Morse code, generating audio Morse signals, 
and decoding Morse from microphone recordings.

## Installation

```bash
pip install morse_audio
```

## Usage

```bash
from morse_audio import Morse

m = Morse()
msg = m.text_to_morse("Hello World")
m.morse_to_audio(msg)  # plays Morse audio
```
uuid-mcp 0.1.0
A simple MCP server that provides a tool to generate UUIDs
Requires Python: >=3.8
Keywords: mcp, uuid, model-context-protocol, cursor

# UUID MCP Tool

A simple Model Context Protocol (MCP) server that provides a tool to generate UUIDs.

## Installation

### Install from PyPI (Recommended)

```bash
pip install uuid-mcp
```

### Install from source

1. Clone or download this repository
2. Install the package:
```bash
pip install .
```

Or install in development mode:
```bash
pip install -e .
```

### Install from local directory

If you have the package locally:
```bash
pip install /path/to/uuid-mcp
```

## Usage

After installation, you can run the MCP server using the `uuid-mcp` command:

```bash
uuid-mcp
```

The server will communicate via stdio and expose a `generate_uuid` tool that generates a random UUID (version 4) when called.

## Tool

- **generate_uuid**: Generates a random UUID (version 4). Takes no parameters and returns a UUID string.

## Adding to Cursor

To use this MCP tool in Cursor, add it to your Cursor MCP configuration:

1. Open Cursor Settings (Cmd/Ctrl + ,)
2. Navigate to "Features" → "Model Context Protocol" or search for "MCP"
3. Click "Edit Config" or open the MCP configuration file (typically located at `~/.cursor/mcp.json` or in Cursor's settings)

4. Add the following configuration:

```json
{
  "mcpServers": {
    "uuid-generator": {
      "command": "uuid-mcp"
    }
  }
}
```

If `uuid-mcp` is not in your PATH, you can use the full path to the executable. After pip installation, you can find it with:

```bash
which uuid-mcp
```

Or use Python's `-m` flag:

```json
{
  "mcpServers": {
    "uuid-generator": {
      "command": "python",
      "args": ["-m", "uuid_mcp.server"]
    }
  }
}
```

5. Restart Cursor for the changes to take effect.

Once configured, you can use the `generate_uuid` tool in Cursor's AI chat interface.

## Publishing

For package maintainers: See [PUBLISHING.md](PUBLISHING.md) for instructions on how to publish this package to PyPI.