semvec/pypi-packages huggingface dataset:
flowmyna 0.1.1
Official Python SDK for FlowMyna - Process Mining Event Tracking
Requires Python: >=3.8
Keywords: flowmyna, process-mining, event-tracking, sdk, analytics

# FlowMyna Python SDK

Official Python SDK for [FlowMyna](https://flowmyna.com) - Process Mining Event Tracking.

## Installation

```bash
pip install flowmyna
```

Or with your preferred package manager:

```bash
uv add flowmyna
poetry add flowmyna
pipenv install flowmyna
```

For async support with HTTP/2:

```bash
pip install flowmyna[async]
```

## Quick Start

```python
from flowmyna import FlowMyna

# Initialize the client
client = FlowMyna(api_key="fm_live_your_key_here")

# Record an event
client.record_event(
    event="Order Placed",
    objects=[
        {"type": "Order", "id": "ORD-123"},
        {"type": "Customer", "id": "CUST-456"}
    ],
    properties={"total": 149.99}
)

# Upsert an object
client.upsert_object(
    type="Customer",
    id="CUST-456",
    properties={
        "name": "Jane Doe",
        "email": "jane@example.com"
    }
)
```

## Features

- **Simple API** - Intuitive methods for recording events and managing objects
- **Batch Operations** - Efficiently send up to 100 events/objects per request
- **Automatic Retries** - Built-in retry logic with exponential backoff
- **Type Hints** - Full type annotations for IDE support
- **Async Support** - Optional async client for high-concurrency applications

## Configuration

```python
import os
from flowmyna import FlowMyna

# Using environment variable (recommended)
client = FlowMyna(api_key=os.environ["FLOWMYNA_API_KEY"])

# With custom configuration
client = FlowMyna(
    api_key="fm_live_xxx",
    timeout=60,          # 60 second timeout
    max_retries=5,       # Retry up to 5 times
)
```

## Async Usage

```python
import asyncio
from flowmyna import AsyncFlowMyna

async def main():
    async with AsyncFlowMyna(api_key="fm_live_xxx") as client:
        await client.record_event(
            event="Order Placed",
            objects=[{"type": "Order", "id": "ORD-123"}]
        )

asyncio.run(main())
```

## Error Handling

```python
from flowmyna import FlowMyna
from flowmyna.exceptions import (
    FlowMynaError,
    AuthenticationError,
    ValidationError,
    RateLimitError,
    ServerError
)

client = FlowMyna(api_key="fm_live_xxx")

try:
    client.record_event(
        event="Order Placed",
        objects=[{"type": "Order", "id": "ORD-123"}]
    )
except AuthenticationError:
    print("Invalid API key")
except ValidationError as e:
    print(f"Invalid request: {e}")
except RateLimitError as e:
    print(f"Rate limited, retry after: {e.retry_after}")
except ServerError:
    print("Server error, please retry")
except FlowMynaError as e:
    print(f"Unexpected error: {e}")
```

## Documentation

Full documentation is available at [flowmyna.com/api/sdks/python](https://flowmyna.com/api/sdks/python)

## License

MIT License - see [LICENSE](LICENSE) for details.
pathwaysutils 0.1.4
Package of Pathways-on-Cloud utilities.
Requires Python: >=3.10

# Package of Pathways-on-Cloud utilities

Pathways is a novel compute orchestration method that enables single controller runtime ML workloads.
This approach unlocks a range of new capabilities for training resiliency, multihost inference and interactive development on cluster of arbitrary scale.
Pathways simplifies large-scale machine learning computations by enabling a single JAX client to orchestrate workloads across multiple large TPU slices, potentially spanning hundreds or thousands of TPU chips. Pathways is used internally at Google to train large models like Gemini. Pathways on Cloud brings the same benefits to Google Cloud customers.

To make it as easy as possible for you to leverage Pathways on Cloud, we've bundled the necessary cloud-specific integrations into a single Python package and a set of container images.
This package handles the underlying adaptations required for the cloud environment, allowing you to focus on your core workflows with minimal setup.

# Further Reading
[Pathways Research Paper](https://arxiv.org/abs/2203.12533)

[More resources coming Soon]


# How to get access to Pathways on Cloud

Pathways on Cloud is currently in Preview.
Please contact your Google Cloud account representative to request access to Pathways.
datasette-plugin-router 0.0.1a2
WIP router for Datasette plugins
Requires Python: >=3.10

# datasette-plugin-router

[![PyPI](https://img.shields.io/pypi/v/datasette-plugin-router.svg)](https://pypi.org/project/datasette-plugin-router/)
[![Changelog](https://img.shields.io/github/v/release/datasette/datasette-plugin-router?include_prereleases&label=changelog)](https://github.com/datasette/datasette-plugin-router/releases)
[![Tests](https://github.com/datasette/datasette-plugin-router/actions/workflows/test.yml/badge.svg)](https://github.com/datasette/datasette-plugin-router/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/datasette/datasette-plugin-router/blob/main/LICENSE)

WIP router for Datasette plugins

Datasette plugins that have a lot of [custom API endpoints](https://docs.datasette.io/en/stable/plugin_hooks.html#register-routes-datasette) can get tiresome to write by hand.  `datasette-plugin-router` aims to be a small Python library that adds a FastAPI-like API for defining custom Datasette plugin endpoints.

- Define routes with familiar GET/POST decorators
- Define Pydantic-backed input/output schemas on JSON endpoints
- `register_routes()` compatability
- export to OpenAPI schema for codegen'ing clients


Sample usage:

```python
from datasette import Response, hookimpl
from datasette_plugin_router import Router, Body
from pydantic import BaseModel

router = Router()

class Input(BaseModel):
    id: int
    name: str

class Output(BaseModel):
    id_negative: int
    name_upper: str

@router.POST(r"/-/demo1$", output=Output)
async def demo1(params: Body[Input]) -> Output:
    output = Output(
        id_negative=-1 * params.id,
        name_upper=params.name.upper(),
    )
    return Response.json(output.model_dump())


@router.GET(r"/-/hello/(?P<name>.*)$")
async def hello(name: str):
    return Response.html(f"<h1>Hello, {name}!</h1>")


@hookimpl
def register_routes():
    return router.routes()

```
secguard 2.0.0
Security Automation Tool for threat detection and response
Requires Python: >=3.7
Keywords: security automation threat detection log analysis

# SecGuard - Security Automation Suite

SecGuard is a powerful security automation tool for log analysis, threat detection, and incident response.

## Features
- Log analysis and parsing
- Real-time threat detection
- Automated reporting
- Quick response actions

## Installation
```bash
pip install secguard