semvec/pypi-packages huggingface dataset:
envmaster 1.0.0
Type-safe environment variable management
Requires Python: >=3.8
Keywords: config, configuration, env, environment, settings

# envmaster 🔐

Type-safe environment variable management for Python.

## Installation

```bash
pip install envmaster
```

## Usage

```python
from envmaster import env

# String (required)
DATABASE_URL = env.str("DATABASE_URL", required=True)

# Boolean with default
DEBUG = env.bool("DEBUG", default=False)

# Integer with default
MAX_CONNECTIONS = env.int("MAX_CONNECTIONS", default=10)

# Float
TIMEOUT = env.float("TIMEOUT", default=30.0)

# List (comma-separated)
ALLOWED_HOSTS = env.list("ALLOWED_HOSTS", default=["localhost"])

# JSON
CONFIG = env.json("CONFIG", default={})
```

## Methods

| Method | Return Type | Description |
|--------|-------------|-------------|
| `env.str()` | str | String value |
| `env.int()` | int | Integer value |
| `env.float()` | float | Float value |
| `env.bool()` | bool | Boolean value |
| `env.list()` | list | List of strings |
| `env.json()` | any | Parsed JSON |

## Boolean Values

Truthy: `true`, `1`, `yes`, `on`  
Falsy: `false`, `0`, `no`, `off`

## Error Handling

```python
from envmaster import env, EnvError

try:
    secret = env.str("SECRET_KEY", required=True)
except EnvError as e:
    print(f"Configuration error: {e}")
```

## License

MIT
context-engineering-mcp 0.1.1
MCP server for Context Engineering templates and protocols
Requires Python: >=3.10

# Sutra

mcp-name: io.github.4rgon4ut/sutra

**The MCP Context Engineering Engine**

Sutra is a Model Context Protocol (MCP) server that transforms how LLMs handle reasoning, memory, and orchestration. It provides a "Standard Library" of cognitive tools (Thinking Models), memory structures (Cells), and multi-agent patterns (Organs).

## Installation

### Using `uv` (Recommended)
```bash
uv tool install context-engineering-mcp
```

### Using `pip`
```bash
pip install context-engineering-mcp
```

## Configuration

Select your agent below and copy-paste the config.

<details>
<summary>Claude Desktop</summary>

Add to `claude_desktop_config.json`:
```json
{
  "mcpServers": {
    "sutra": {
      "command": "uv",
      "args": ["tool", "run", "context-engineering-mcp"]
    }
  }
}
```
</details>

<details>
<summary>Claude Code</summary>

Run this in your terminal:
```bash
claude mcp add sutra uv tool run context-engineering-mcp
```
</details>

<details>
<summary>Aider</summary>

Run aider with the mcp flag:
```bash
aider --mcp "uv tool run context-engineering-mcp"
```
Or add to `.aider.conf.yml`:
```yaml
mcp: ["uv tool run context-engineering-mcp"]
```
</details>

<details>
<summary>Gemini CLI</summary>

Add to `~/.gemini/settings.json`:
```json
{
  "mcpServers": {
    "sutra": {
      "command": "uv",
      "args": ["tool", "run", "context-engineering-mcp"]
    }
  }
}
```
</details>

<details>
<summary>Cursor / Windsurf</summary>

In MCP settings, add a new server:
- **Name**: Sutra
- **Type**: command
- **Command**: `uv tool run context-engineering-mcp`
</details>

<details>
<summary>Codex</summary>

Add to your config (TOML):
```toml
[mcp_servers.sutra]
command = "uv"
args = ["tool", "run", "context-engineering-mcp"]
```
</details>

## Core Features (v0.1.0)

### 1. The Gateway (Router)
Sutra automatically analyzes your request to decide the best strategy:
- **YOLO Mode**: For immediate tasks ("Fix this bug"), it routes to specific cognitive tools.
- **Constructor Mode**: For system design ("Build a bot"), it routes to the Architect.

### 2. The Architect
Generates blueprints for custom agents, combining:
- **Thinking Models**: `understand_question`, `verify_logic`, `backtracking`, `symbolic_abstract`.
- **Memory Cells**: `key_value` (State), `windowed` (Short-term), `episodic` (Long-term).
- **Organs**: `debate_council` (Multi-perspective), `research_synthesis` (Deep Dive).

### 3. The Librarian
A manual discovery tool (`get_technique_guide`) that lets you or the agent browse the full catalog of Context Engineering techniques.

## Development

**Requirements**: Python 3.10+, `uv` (optional but recommended).

1. Clone the repo:
   ```bash
   git clone https://github.com/4rgon4ut/sutra.git
   cd sutra
   ```
2. Install dependencies:
   ```bash
   uv sync --all-extras
   # OR
   pip install -e ".[dev]"
   ```
3. Run tests:
   ```bash
   pytest
   ```

## License
MIT
cuda-python 12.9.5
CUDA Python: Performance meets Productivity

.. SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
.. SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE

**************************************************************
cuda-python: Metapackage collection of CUDA Python subpackages
**************************************************************

CUDA Python is the home for accessing NVIDIA's CUDA platform from Python. It consists of multiple components:

* `cuda.core <https://nvidia.github.io/cuda-python/cuda-core/latest>`_: Pythonic access to CUDA Runtime and other core functionalities
* `cuda.bindings <https://nvidia.github.io/cuda-python/cuda-bindings/latest>`_: Low-level Python bindings to CUDA C APIs
* `cuda.cooperative <https://nvidia.github.io/cccl/cuda_cooperative/>`_: A Python package providing CCCL's reusable block-wide and warp-wide *device* primitives for use within Numba CUDA kernels
* `cuda.parallel <https://nvidia.github.io/cccl/cuda_parallel/>`_: A Python package for easy access to CCCL's highly efficient and customizable parallel algorithms, like `sort`, `scan`, `reduce`, `transform`, etc, that are callable on the *host*
* `numba.cuda <https://nvidia.github.io/numba-cuda/>`_: Numba's target for CUDA GPU programming by directly compiling a restricted subset of Python code into CUDA kernels and device functions following the CUDA execution model.

For access to NVIDIA CPU & GPU Math Libraries, please refer to `nvmath-python <https://docs.nvidia.com/cuda/nvmath-python/latest>`_.

CUDA Python is currently undergoing an overhaul to improve existing and bring up new components. All of the previously available functionalities from the `cuda-python` package will continue to be available, please refer to the `cuda.bindings <https://nvidia.github.io/cuda-python/cuda-bindings/latest>`_ documentation for installation guide and further detail.

cuda-python as a metapackage
============================

`cuda-python` is now a metapackage that contains a collection of subpackages. Each subpackage is versioned independently, allowing installation of each component as needed.

Subpackage: cuda.core
---------------------

The `cuda.core` package offers idiomatic, pythonic access to CUDA Runtime and other functionalities.

The goals are to

1. Provide **idiomatic ("pythonic")** access to CUDA Driver, Runtime, and JIT compiler toolchain
2. Focus on **developer productivity** by ensuring end-to-end CUDA development can be performed quickly and entirely in Python
3. **Avoid homegrown** Python abstractions for CUDA for new Python GPU libraries starting from scratch
4. **Ease** developer **burden of maintaining** and catching up with latest CUDA features
5. **Flatten the learning curve** for current and future generations of CUDA developers

Subpackage: cuda.bindings
-------------------------

The `cuda.bindings` package is a standard set of low-level interfaces, providing full coverage of and access to the CUDA host APIs from Python.

The list of available interfaces are:

* CUDA Driver
* CUDA Runtime
* NVRTC
* nvJitLink
* NVVM