semvec/pypi-packages huggingface dataset:
novita-sandbox 1.2.0b1
Novita Agent Sandbox SDK - Python library for Novita Agent Sandbox
License: MIT
Requires Python: >=3.9
Keywords: Novita, sandbox, ai, agent, sdk, code-interpreter, desktop-automation

# Novita Agent Sandbox SDK for Python

A Python SDK for Novita Agent Sandbox environments that provides code execution, desktop automation, and cloud computing capabilities. Compatible with e2b.

[📖 Documentation](https://novita.ai/docs/guides/sandbox-overview) • [🔑 Get API Key](https://novita.ai/settings/key-management) 

## Features

- **Code Interpreter**: Execute Python, JavaScript, and other languages in isolated environments
- **Desktop Automation**: Control desktop applications and GUI interactions
- **Cloud Computing**: Scalable sandbox environments for various computing tasks
- **Data Visualization**: Built-in charting and visualization capabilities
- **File System Operations**: Complete file system management and monitoring


## Installation

```bash
pip install novita-sandbox
```

## Quick Start

### Authentication

Get your Novita API key from the [key management page](https://novita.ai/settings/key-management).

### Core Sandbox

The basic package provides a way to interact with the sandbox environment.

```python
from novita_sandbox.core import Sandbox
import os

# Using the official template `base` by default
sandbox = Sandbox.create(
    template="base",
    api_key=os.getenv("NOVITA_API_KEY", "")
)

# File operations
sandbox.files.write('/tmp/test.txt', 'Hello, World!')
content = sandbox.files.read('/tmp/test.txt')

# Command execution
result = sandbox.commands.run('ls -la /tmp')
print(result.stdout)

sandbox.kill()
```

### Code Interpreter

The Code Interpreter sandbox provides a Jupyter-like environment for executing code using the official `code-interpreter-v1` template.

```python
from novita_sandbox.code_interpreter import Sandbox
import os

sandbox = Sandbox.create(
    api_key=os.getenv("NOVITA_API_KEY", "")
)

# Execute Python code
result = sandbox.run_code('print("Hello, World!")')
print(result.logs)

sandbox.kill()
```

### Desktop Automation

The Desktop sandbox allows you to control desktop environments programmatically using the official `desktop` template.

```python
from novita_sandbox.desktop import Sandbox
import os

desktop = Sandbox.create(
    api_key=os.getenv("NOVITA_API_KEY", "")
)

# Take a screenshot
screenshot = desktop.screenshot()

# Automate mouse and keyboard
desktop.left_click(100, 200)
desktop.press('Return')
desktop.write('Hello, World!')

desktop.kill()
```

## Documentation

For comprehensive guides, API references, and examples, visit our [official documentation](https://novita.ai/docs/guides/sandbox-overview).

## Development

### Install

```bash
poetry install --with dev --extras "all" 
```

### Test

```bash
make test
make test-core
make test-code-interpreter
make test-desktop
```
tsunagi 0.1.1
SDK-first orchestration framework for AI pipelines and agents
License: MIT
Requires Python: >=3.11
Keywords: agents, ai, orchestration, pipelines

# Tsunagi

SDK-first orchestration framework for AI pipelines and agents. Tsunagi keeps SDK calls
as plain user code while adding composition, retry, timeout, and tracing.

## Installation

Install as a standard library (from PyPI or a local checkout):

```bash
pip install tsunagi
# or include optional extras, e.g. tracing
pip install "tsunagi[otel]"
```

Using [uv](https://docs.astral.sh/uv/) for dependency management:

```bash
uv add tsunagi
uv add "tsunagi[otel]"
```

For local development with extras:

```bash
pip install -e .[dev]
uv pip install -e .[dev]
```

## Quick Start

```python
from tsunagi import Pipeline, step


@step
async def add_one(x: int) -> int:
    return x + 1


@step
async def double(x: int) -> int:
    return x * 2


pipe = Pipeline("basic")
result = await pipe.run(add_one >> double, input=3)
print(result)  # 8
```

## Design Philosophy

- **SDK-first**: You call OpenAI/Anthropic/Qdrant directly. Tsunagi never wraps SDKs.
- **Opt-in extras**: Tracing, retry, and timeouts are explicit. No hidden behavior.
- **Zero runtime deps**: Core relies only on Python standard library.
- **Small pieces**: Decorators and adapters stay short and readable (<400 lines).

## API Highlights

- `@step`: Wrap async functions for pipeline use; direct calls stay untouched.
- `Pipeline`: Run steps sequentially or in parallel with tracing and context.
- `RetryConfig`: Per-step retry/backoff configuration.
- `Tracer`: Protocol for observability; includes `NullTracer` and `StdoutTracer`.
- `@tool` and `Agent`: Register async tools and drive LLM tool-use loops via adapters.

## Comparing with LangChain

- Tsunagi keeps SDK calls unwrapped; LangChain introduces wrappers and abstractions.
- No built-in chunking, parsing, or vector store layers — your code, your logic.
- Minimal surface area: a handful of decorators and classes instead of large class hierarchies.

## Examples

See `examples/` for pipelines, agents with tools, custom tracers, and RAG sketches. API-key
dependent examples are annotated accordingly.
iflow-mcp_gdcc-semantic-croissant 0.1.1
A MCP server exposing a croissant tools
License: MIT
Requires Python: >=3.10
Keywords: mcp, llm, automation, web, fetch


A simple MCP server that exposes a website fetching tool.

## Usage

Start the server using either stdio (default) or SSE transport:

```bash
# Using stdio transport (default)
uv run mcp-simple-tool

# Using SSE transport on custom port
uv run mcp-simple-tool --transport sse --port 8000
```

The server exposes a tool named "fetch" that accepts one required argument:

- `url`: The URL of the website to fetch

## Example

Using the MCP client, you can use the tool like this using the STDIO transport:

```python
import asyncio
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client


async def main():
    async with stdio_client(
        StdioServerParameters(command="uv", args=["run", "mcp-simple-tool"])
    ) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            print(tools)

            # Call the fetch tool
            result = await session.call_tool("fetch", {"url": "https://example.com"})
            print(result)


asyncio.run(main())

```