semvec/pypi-packages huggingface dataset:
aioserve 0.1.0
A simple ASGI based web framework for exposing HTTP and MCP tools
License: MIT
Requires Python: >=3.13

# Aioserve

A lightweight, modern, and async web framework for Python. Built on ASGI, it provides a simple yet powerful way to build web services and APIs.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python Versions](https://img.shields.io/pypi/pyversions/aioserve.svg)](https://pypi.org/project/aioserve/)

## Features

- **Async to the Core**: Built on top of ASGI (Asynchronous Server Gateway Interface).
- **Simple Routing**: Expressive decorator-based routing (`@app.get`, `@app.post`).
- **Middleware Support**: easily extend functionality with middleware.
- **JSON Support**: Built-in JSON request parsing and response generation.
- **Lightweight**: Minimal dependencies, fast execution.

## Installation

```bash
pip install aioserve
```

## Quick Start

Create a file named `main.py`:

```python
from aioserve.server.app import App, app
from aioserve.server.http import JSONResponse

# Define a route
@app.get("/")
async def home(request):
    return JSONResponse({"message": "Hello, Aioserve!"})

# Run with uvicorn
# uvicorn main:app
```

## Usage

### Routing

```python
@app.get("/items")
async def get_items(request):
    return ["item1", "item2"]

@app.post("/items")
async def create_item(request):
    data = await request.json()
    return JSONResponse(data, status_code=201)
```

### Middleware

You can add middleware to wrap your application. Middleware allows you to intercept requests and responses.

```python
class LoggingMiddleware:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        print(f"Request: {scope['method']} {scope['path']}")
        await self.app(scope, receive, send)

app.add_middleware(LoggingMiddleware)
```

## Development

To contribute or run tests locally:

1.  Clone the repository.
2.  Install dependencies with Poetry:
    ```bash
    poetry install
    ```
3.  Run tests:
    ```bash
    poetry run pytest
    ```

## License

This project is licensed under the MIT License.
edgepulse 0.1.2
EdgePulse Python SDK for edge functions monitoring and observability
License: MIT
Requires Python: >=3.9
Keywords: monitoring, observability, telemetry, performance, tracking

# EdgePulse Python SDK

[![PyPI version](https://badge.fury.io/py/edgepulse.svg)](https://badge.fury.io/py/edgepulse)
[![Python Support](https://img.shields.io/pypi/pyversions/edgepulse.svg)](https://pypi.org/project/edgepulse/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The EdgePulse Python SDK provides monitoring and observability capabilities for Python applications. It allows you to track function executions, capture timing data, handle errors, and send telemetry to EdgePulse services.

## Installation

Install the EdgePulse SDK using pip:

```bash
pip install edgepulse
```

## Quick Start

1. **Set up your environment**:
   ```bash
   export EDGEPULSE_PROJECT_KEY="your-api-key-here"
   export EDGEPULSE_API_URL="https://api.edgepulse.com/api/Invocation"  # Optional
   ```

2. **Use the decorator to monitor functions**:
   ```python
   from Edgepulse import with_edgepulse

   @with_edgepulse
   def my_function(x, y):
       """Your function logic here."""
       return x + y

   # The function will now be monitored automatically
   result = my_function(1, 2)
   ```

## Features

- **Zero-configuration monitoring**: Simple decorator-based approach
- **Automatic timing**: Captures function execution duration
- **Error tracking**: Records exceptions with full stack traces  
- **Flexible telemetry**: Sends data to configurable EdgePulse endpoints
- **Type safety**: Full type hints for better development experience
- **No external dependencies**: Uses only Python standard library

## Configuration

The SDK uses environment variables for configuration:

- `EDGEPULSE_PROJECT_KEY` (required): Your EdgePulse API key
- `EDGEPULSE_API_URL` (optional): EdgePulse API endpoint (defaults to localhost for development)

## Advanced Usage

### Manual invocation tracking

```python
from Edgepulse import EdgePulseInvocation, store_invocation

# Create a custom invocation
invocation = EdgePulseInvocation.create(
    function_name="my_function",
    invoked_at="2026-01-02T10:30:00Z",
    status_code=200,
    duration_ms=150
)

# Store it
store_invocation(invocation)
```

### Custom HTTP client

```python
from Edgepulse import WebClient, store_invocation

# Use a custom client with different timeout
client = WebClient("https://api.edgepulse.com/api/Invocation", timeout=30)
store_invocation(invocation, client=client)
```

## Development

### Setting up development environment

```bash
git clone https://github.com/edgepulse/sdk-python.git
cd sdk-python
pip install -e ".[dev]"
```

## Requirements

- Python 3.9+

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

- Documentation: Does not exists yet
- Issues: [https://github.com/jeremytrips/edgepulse.py/issues](https://github.com/edgepulse/sdk-python/issues)
- Email: jeremy.trips@gmail.com

## Contributing

We welcome contributions!
accqsure 0.3.1
AccQsure client SDK and command line utilities
License: MIT
Requires Python: >=3.10

<div align="center">
  <a href="https://www.accqsure.ai/"><img src="https://app.accqsure.ai/logo.png"></a><br>
</div>

# AccQsure Python SDK and Command Line Tools

Provides programmatic access to [AccQsure platform](https://app.accqsure.ai).

## Installation

Python 3.10 or above is required.

```
pip install accqsure
```