semvec/pypi-packages huggingface dataset:
pyCRT 2.2.2
Tools for measuring Capillary Refill Time using Python.
Requires Python: >=3.9

# pyCRT

Tools for measuring the Polarized Capillary Refill Time (alternatively known
as Reflective CRT) using Python.

Documentation and a basic tutorial are available on [Read the
Docs](https://pyCRT.readthedocs.io/en/latest/index.html).
pygent-ai 0.1.0
The real agent framework
Requires Python: >=3.11

# Pygent

A Python framework for building LLM-powered agents with modular state management, composable operators, and LLM tool-calling integration (including MCP).

## Features

- **Modular architecture** — Agents, context, tools, memory, and plans as composable modules
- **State management** — Consistent save/load and serialization via `PygentOperator`
- **LLM-native** — Messages and tools align with OpenAI-style APIs
- **MCP support** — Use Model Context Protocol (SSE and stdio) tools via `ToolManager`
- **Toolkits** — Built-in toolkits such as `RestrictedTerminal` for safe shell access

## Requirements

- Python 3.11+

## Installation

From the project root:

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

Or with [uv](https://github.com/astral-sh/uv):

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

## Quick Start

```python
from pygent.agent import BaseAgent
from pygent.context import BaseContext
from pygent.llm import AsyncOpenAIClient
from pygent.message import UserMessage
from pygent.module.tool import ToolManager
from pygent.toolkits import RestrictedTerminal

class MyAgent(BaseAgent):
    def __init__(self):
        super().__init__()
        self.llm = AsyncOpenAIClient(
            base_url="https://api.openai.com/v1",
            api_key="YOUR_API_KEY",
            model_name="gpt-4",
        )
        self.tool_manager = ToolManager()
        terminal = RestrictedTerminal(root_dir=".")
        self.tool_manager.add_module("terminal", terminal)
        self.tool_manager.register_tools(terminal.get_tools())

    async def run(self, user_input: str):
        context = BaseContext(system_prompt="You are a helpful assistant.")
        context.add_message(UserMessage(content=user_input))
        # ... tool loop and LLM calls (see examples/react_agent)
        return context
```

See [examples/react_agent/react_agent.py](examples/react_agent/react_agent.py) for a full ReAct-style agent with tool calling.

## Project Layout

- **pygent/** — Core package: agents, context, LLM client, messages, modules (tool, plan, memory, etc.), toolkits
- **examples/** — Example agents (e.g. ReAct agent)
- **MCPs/** — Example MCP servers (e.g. LocalMemoryMCP)
- **docs/** — [Architecture](docs/ARCHITECTURE.md) and [API](docs/API.md) documentation
- **tests/** — Pytest tests

## Documentation

- [Architecture](docs/ARCHITECTURE.md) — Design, layers, and components
- [API](docs/API.md) — API reference

## License

Apache-2.0. See [LICENSE](LICENSE) for details.
ra-framalytics 1.1.1
Python tools for the Functional Resonance Analysis Method (FRAM) - Fork for RA-FRAM
Requires Python: >=3.10
Keywords: FRAM, risk-assessment, systems-analysis, functional-resonance, safety-analysis

# Framalytics 

Framalytics is a Python package to work with the Functional Resonance Analysis Method (FRAM).

Our goal is to bring FRAM to Python, enabling the interaction of FRAM models with data science
and machine learning tools. Framalytics can load FRAM models from `.xfmv` files created through
the [FRAM Model Visualizer](https://functionalresonance.com/the%20fram%20model%20visualiser/).
Components of the FRAM models can be extracted, such as list of functions, or which functions
are connected together via which aspect.

Models can be visualized directly inside a Jupyter notebook environment, reproducing the visual
style of the FMV. 

Real data can also be integrated with the FRAM model visualizations.


# Documentation

Framalytics documentation is hosted on 
[https://framalytics.readthedocs.io](https://framalytics.readthedocs.io).

## Tests

Install test dependencies and run the test suite:

```bash
python -m venv .venv
# On macOS/Linux
source .venv/bin/activate
# On Windows
# .venv\Scripts\activate

pip install -r test-requirements.txt
pytest
```
usdm4-m11 0.9.0
A package for processing M11 protocol documents and converting them to USDM format
Requires Python: >=3.12

# USDM4 M11 Protocol Package

A Python package for processing M11 protocol documents and converting them to USDM format.

## Installation

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

Or install the dependencies directly from the requirements.txt file:

```bash
pip install -r requirements.txt
```

This package uses a src-based layout, with the package code located in the `src/usdm4_m11` directory.

## Usage

```python
from usdm4_m11 import M11Protocol

# Initialize the protocol processor
protocol = M11Protocol(filepath="path/to/m11_protocol.docx", system_name="YourSystem", system_version="1.0.0")

# Process the protocol
await protocol.process()

# Convert to USDM format
usdm_data = protocol.to_usdm()
```

# Build

Build as a normal package

- Run `pytest`, ensure coverage and all tests pass
- Run `ruff format`
- Run `ruff check`, ensure no errors
- Build with `python3 -m build --sdist --wheel`
- Upload to pypi.org using `twine upload dist/*`
notebook-mcp 1.5.5
MCP server that provides notebook-aware context and analysis for .ipynb files
Requires Python: >=3.11

# Notebook MCP

![Notebook MCP](docs/notebook-mcp-pproduct-img.png)

Notebook MCP is a Model Context Protocol (MCP) server that provides deep semantic understanding of Jupyter notebooks for AI assistants and automation workflows.

---

## 🧠 Why Notebook MCP?

Jupyter notebooks are difficult for AI assistants to reason about because they are:

* Stateful
* Non-linear
* Execution-order dependent
* Mixed with outputs and markdown

Notebook MCP solves this by building execution graphs and runtime awareness.

---

## ✨ Features

* Static notebook dependency analysis
* Execution state detection (stale / unexecuted cells)
* Rerun planning engine
* Focused notebook context generation
* Notebook to deterministic Python conversion
* Jupyter kernel runtime execution and inspection

---

## 📦 Installation

```
pip install notebook-mcp
```

---

## 🚀 Running Server

```
notebook-mcp-python
```

---

## 🔧 Environment Variables (Optional)

For Jupyter runtime integration:

```
JUPYTER_BASE_URL=http://localhost:8888
JUPYTER_TOKEN=<your_token>
```

---

## 🧪 Example Use Cases

* AI notebook debugging
* Automated notebook refactoring
* Execution dependency tracking
* Runtime variable inspection

---

## 🧩 Integration

Notebook MCP is designed to integrate with:

* AI coding assistants
* MCP clients
* Notebook automation workflows

---

## 📚 Source Code

GitHub:
[https://github.com/akram-side-projects/notebook-mcp](https://github.com/akram-side-projects/notebook-mcp)

---

## 🤝 Contributions

PRs and feedback welcome.