semvec/pypi-packages huggingface dataset:
skosprovider-atramhasis 1.1.0
Skosprovider implementation of Atramhasis Vocabularies
Requires Python: <3.13.11,>=3.10
Keywords: rdf, skos, skosprovider, thesauri, vocabularies

skosprovider_atramhasis
=======================

A `Skosprovider <http://skosprovider.readthedocs.org>`_ that can talk to an
`Atramhasis <http://atramhasis.readthedocs.org>`_ instance.

.. image:: https://travis-ci.org/OnroerendErfgoed/skosprovider_atramhasis.png?branch=master
        :target: https://travis-ci.org/OnroerendErfgoed/skosprovider_atramhasis
.. image:: https://coveralls.io/repos/OnroerendErfgoed/skosprovider_atramhasis/badge.png?branch=master
        :target: https://coveralls.io/r/OnroerendErfgoed/skosprovider_atramhasis

.. image:: https://readthedocs.org/projects/skosprovider-atramhasis/badge/?version=latest
        :target: https://readthedocs.org/projects/skosprovider-atramhasis/?badge=latest
.. image:: https://badge.fury.io/py/skosprovider_atramhasis.png
        :target: http://badge.fury.io/py/skosprovider_atramhasis
plott-sdk-langgraph 0.0.1a1
Plott Analytics SDK for LangGraph - Automatic analytics tracking for LangGraph
Requires Python: >=3.9
Keywords: agents, ai, analytics, langchain, langgraph, llm, plott

# Plott SDK for LangGraph

Automatic analytics tracking for LangGraph applications. Just wrap your graph and analytics are collected transparently.

## Installation

```bash
pip install plott-sdk-langgraph
```

## Quick Start

```python
from langgraph.graph import StateGraph
from langchain_core.messages import HumanMessage
from plott_langgraph import plott_tracked_graph

# Create and compile your graph
graph = workflow.compile(checkpointer=memory)

# Wrap with Plott - that's it!
tracked_graph = plott_tracked_graph(graph, {
    "api_key": "cpk_...",  # or set PLOTT_API_KEY env var
    "environment": "development",
})

# Use exactly like the original graph - analytics are automatic
async for event in tracked_graph.astream_events(
    {"messages": [HumanMessage(content="Hello!")]},
    config={"configurable": {"thread_id": "123", "run_id": "run-456"}},
):
    # Your normal event handling
    if event["event"] == "on_chat_model_stream":
        print(event["data"]["chunk"].content, end="", flush=True)
```

## What Gets Tracked

The SDK automatically tracks:

| Event | Description |
|-------|-------------|
| **Messages** | User input and assistant responses |
| **Tool Calls** | Tool executions with arguments and results |
| **State Snapshots** | State changes as the graph executes |
| **Run Lifecycle** | Start and end of each graph run |
| **Errors** | Any errors that occur during execution |

## Configuration

```python
tracked_graph = plott_tracked_graph(graph, {
    "api_key": "cpk_...",           # Required (or PLOTT_API_KEY env var)
    "environment": "production",     # production, staging, development, test
    "retry_attempts": 3,             # Number of retry attempts on failure
    "retry_delay": 1.0,              # Seconds between retries
    "debug": False,                  # Enable debug logging
})
```

## Environment Variables

- `PLOTT_API_KEY` - API key (if not provided in config)

## Tracked Methods

The following methods have analytics tracking:

- `astream_events()` - Full event streaming with detailed tracking
- `astream()` - State streaming with lifecycle tracking
- `invoke()` - Synchronous invocation with lifecycle tracking
- `ainvoke()` - Async invocation with lifecycle tracking

## License

Apache 2.0
plott-sdk-core 0.0.1a1
Plott Analytics SDK Core for Python - Event tracking and batching
Requires Python: >=3.9
Keywords: ai, analytics, events, llm, plott, tracking

# Plott SDK Core for Python

The core analytics client for Plott, providing event tracking with batching, retry logic, and async support.

## Installation

```bash
pip install plott-sdk-core
```

## Quick Start

```python
from plott_analytics import PlottAnalytics

# Initialize the client
client = PlottAnalytics({
    "api_key": "cpk_...",  # or set PLOTT_API_KEY env var
    "environment": "development",
})

# Track events
client.track_message_event(
    role="user",
    content="Hello, world!",
    run_id="run-123",
    session_id="session-456",
)

client.track_message_event(
    role="assistant",
    content="Hi there! How can I help you today?",
    run_id="run-123",
    session_id="session-456",
)

# Flush and shutdown when done
await client.flush()
await client.shutdown()
```

## Event Types

### Message Events
Track messages between users and AI assistants:

```python
client.track_message_event(
    role="user",  # or "assistant", "system"
    content="Message content",
    run_id="run-123",
    session_id="session-456",
    token_count=50,  # optional
    model="gpt-4",   # optional
)
```

### Run Events
Track the lifecycle of agent runs:

```python
client.track_run_event(value="start", run_id="run-123")
# ... agent execution ...
client.track_run_event(value="end", run_id="run-123")
```

### Tool Events
Track tool/function calls:

```python
client.track_tool_event(
    tool_call_id="call-123",
    tool_status="started",
    tool_name="search",
    args={"query": "latest news"},
)

client.track_tool_event(
    tool_call_id="call-123",
    tool_status="completed",
    result="Found 10 results...",
)
```

### State Snapshot Events
Track state changes:

```python
client.track_state_snapshot_event(
    snapshot={"messages": [...], "context": {...}},
    run_id="run-123",
)
```

### Error Events
Track errors:

```python
client.track_error_event(
    error={
        "name": "ValidationError",
        "message": "Invalid input",
        "code": "INVALID_INPUT",
    },
    run_id="run-123",
    severity="medium",
)
```

### LLM Call Events
Track LLM API calls with token usage:

```python
client.track_llm_call_event(
    model="gpt-4",
    input_tokens=100,
    output_tokens=50,
    latency_ms=1200,
    provider="openai",
    is_streaming=True,
)
```

## Configuration

```python
client = PlottAnalytics({
    "api_key": "cpk_...",           # Required
    "environment": "production",     # production, staging, development, test
    "retry_attempts": 3,             # Max retry attempts
    "retry_delay": 1.0,              # Initial retry delay (exponential backoff)
    "debug": False,                  # Enable debug logging
})
```

## License

MIT
flask-scheduler-manager 1.0.0
基于Flask SQLAlchemy和flask_apscheduler的动态定时任务管理系统
Requires Python: >=3.7

# Flask Scheduler Manager

基于Flask、SQLAlchemy和flask_apscheduler的动态定时任务管理系统。

## 功能特性

- ✅ 定时任务SQLAlchemy持久化管理
- ✅ 动态添加、删除、更新定时任务
- ✅ 任务启用/禁用控制
- ✅ 一键数据库迁移
- ✅ 支持Cron和Interval两种调度方式
- ✅ 完整的任务状态管理

## 安装

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

或者从PyPI安装（发布后）：

```bash
pip install flask-scheduler-manager
```

## 快速开始

### 1. 初始化Flask应用

```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_scheduler_manager import SchedulerManager

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///scheduler.db'
app.config['SCHEDULER_API_ENABLED'] = True

db = SQLAlchemy(app)
scheduler_manager = SchedulerManager(app, db)

# 初始化数据库
with app.app_context():
    db.create_all()
    scheduler_manager.init_db()

if __name__ == '__main__':
    app.run(debug=True)
```

### 2. 添加定时任务

```python
# 添加一个Cron任务
scheduler_manager.add_job(
    job_id='task_1',
    func='your_module:your_function',  # 函数路径
    trigger='cron',
    hour=10,
    minute=30,
    enabled=True
)

# 添加一个Interval任务
scheduler_manager.add_job(
    job_id='task_2',
    func='your_module:another_function',
    trigger='interval',
    minutes=5,
    enabled=True
)
```

### 3. 管理任务

```python
# 获取所有任务
jobs = scheduler_manager.get_all_jobs()

# 获取单个任务
job = scheduler_manager.get_job('task_1')

# 更新任务
scheduler_manager.update_job(
    job_id='task_1',
    hour=11,
    minute=0
)

# 启用/禁用任务
scheduler_manager.enable_job('task_1')
scheduler_manager.disable_job('task_1')

# 删除任务
scheduler_manager.remove_job('task_1')
```

## 数据库迁移

### 一键迁移（推荐用于开发）

```python
from flask_scheduler_manager.migrations import migrate_database

with app.app_context():
    migrate_database(app, db)
```

### 使用Flask-Migrate（推荐用于生产环境）

```bash
# 安装Flask-Migrate
pip install flask-migrate

# 初始化迁移
flask db init

# 创建迁移
flask db migrate -m "Initial migration"

# 应用迁移
flask db upgrade
```

## 完整示例

```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_scheduler_manager import SchedulerManager
from flask_scheduler_manager.migrations import migrate_database

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///scheduler.db'
app.config['SCHEDULER_API_ENABLED'] = True

db = SQLAlchemy(app)
scheduler_manager = SchedulerManager(app, db)

# 初始化数据库
with app.app_context():
    migrate_database(app, db)
    scheduler_manager.init_db()

# 定义任务函数
def my_task():
    print("执行定时任务")

# 添加任务
scheduler_manager.add_job(
    job_id='task_1',
    func='__main__:my_task',
    trigger='interval',
    seconds=10,
    enabled=True
)

if __name__ == '__main__':
    app.run()
```

## 文档

- [安装和使用指南](INSTALL.md)
- [API文档](docs/API.md)
- [示例应用](example/README.md)

## 许可证

MIT License