semvec/pypi-packages huggingface dataset:
youtrack-sdk 1.0.202602201123
YouTrack SDK
Requires Python: >=3.12
Keywords: youtrack, sdk

# YouTrack REST API Client

A client library for accessing YouTrack REST API.

## Usage

```python
from datetime import date
from youtrack_sdk import Client
from youtrack_sdk.entities import (
    DateIssueCustomField,
    EnumBundleElement,
    Issue,
    Tag,
    Project,
    SingleEnumIssueCustomField,
    SingleUserIssueCustomField,
    StateBundleElement,
    StateIssueCustomField,
    User,
)

client = Client(base_url="https://dummy.myjetbrains.com/youtrack", token="dummy")
result = client.create_issue(
    issue=Issue(
        project=Project(id="0-0"),
        summary="Created from YouTrack SDK",
        description="Description **text**.",
        tags=[
            Tag(id="6-0"),
        ],
        custom_fields=[
            StateIssueCustomField(
                name="State",
                value=StateBundleElement(
                    name="In Progress",
                ),
            ),
            SingleUserIssueCustomField(
                name="Assignee",
                value=User(
                    ring_id="00000000-a31c-4174-bb27-abd3387df67a",
                ),
            ),
            SingleEnumIssueCustomField(
                name="Type",
                value=EnumBundleElement(
                    name="Bug",
                ),
            ),
            DateIssueCustomField(
                name="Due Date",
                value=date(2005, 12, 31),
            ),
        ],
    ),
)
```

## Note

- You should prefer to use internal entity IDs everywhere. Some methods accept readable issue IDs (e.g. HD-99) but it's not supported everywhere.
aceteam-aep 0.1.0
AEP-native execution layer for AI agents - spans, costs, budget enforcement
Requires Python: >=3.12
Keywords: aep, agents, ai, cost-tracking, llm

# aceteam-aep

AEP-native execution layer for AI agents. Replaces LangChain with direct provider SDKs while adding AEP protocol compliance (spans, costs, budget enforcement).

## Installation

```bash
pip install aceteam-aep
# Or with all providers:
pip install aceteam-aep[all]
```

## Quick Start

```python
from aceteam_aep import create_client, run_agent_loop, ChatMessage, tool

# Create a client
client = create_client("gpt-4o", api_key="sk-...")

# Define tools
@tool
def calculator(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))

# Run agent loop
result = await run_agent_loop(
    client,
    [ChatMessage(role="user", content="What is 2+2?")],
    tools=[calculator],
    system_prompt="You are a helpful assistant.",
)
```

## AEP Compliance

Every execution through `run_agent_loop` can produce AEP-compliant output:

```python
from aceteam_aep import SpanTracker, CostTracker, BudgetEnforcer

tracker = SpanTracker()
costs = CostTracker(entity="org:my-org")
budget = BudgetEnforcer(total="10.00")

result = await run_agent_loop(
    client, messages,
    span_tracker=tracker,
    cost_tracker=costs,
    budget=budget,
)

# Access AEP data
print(tracker.get_spans())      # Execution trace
print(costs.get_cost_tree())    # Hierarchical costs
print(budget.state.remaining()) # Budget remaining
```

## Streaming

```python
from aceteam_aep import run_agent_loop_stream

async for event in run_agent_loop_stream(client, messages, tools=tools):
    if event.type == "chunk":
        print(event.data["text"], end="")
    elif event.type == "tool_call_start":
        print(f"\nCalling {event.data['name']}...")
    elif event.type == "cost":
        print(f"\nCost: ${event.data['compute_cost']}")
```

## Providers

- **OpenAI** (GPT-4o, o1, o3, etc.)
- **Anthropic** (Claude Opus, Sonnet, Haiku)
- **Google** (Gemini 2.5, 3.0)
- **xAI** (Grok)
- **Ollama** (local models)
- **OpenAI-compatible** (SambaNova, TheAgentic, DeepSeek)
prs-ui 0.1.3
Reusable Reflex UI components for Polygenic Risk Score computation with PGS Catalog
Requires Python: >=3.13

# prs-ui

[![PyPI version](https://badge.fury.io/py/prs-ui.svg)](https://badge.fury.io/py/prs-ui)

Reusable [Reflex](https://reflex.dev/) UI components for **Polygenic Risk Score (PRS)** computation using the [PGS Catalog](https://www.pgscatalog.org/).

Built on top of [`just-prs`](https://pypi.org/project/just-prs/) for the computation engine and [`reflex-mui-datagrid`](https://pypi.org/project/reflex-mui-datagrid/) for data grid display.

## Installation

```bash
pip install prs-ui
```

## Quick Start

```python
import polars as pl
import reflex as rx
from reflex_mui_datagrid import LazyFrameGridMixin
from prs_ui import PRSComputeStateMixin, prs_section


class MyAppState(rx.State):
    genome_build: str = "GRCh38"
    cache_dir: str = ""
    status_message: str = ""


class PRSState(PRSComputeStateMixin, LazyFrameGridMixin, MyAppState):
    def load_genotypes(self, parquet_path: str) -> None:
        lf = pl.scan_parquet(parquet_path)
        self.set_prs_genotypes_lf(lf)  # preferred: provide a LazyFrame
        self.prs_genotypes_path = parquet_path


def prs_page() -> rx.Component:
    return prs_section(PRSState)
```

## Components

| Component | Description |
|-----------|-------------|
| `prs_section(state)` | Complete PRS section: build selector + score grid + compute button + progress + results |
| `prs_build_selector(state)` | Genome build dropdown (GRCh37/GRCh38) |
| `prs_scores_selector(state)` | MUI DataGrid for score selection with checkboxes and filtering |
| `prs_compute_button(state)` | Compute button with disclaimer callout |
| `prs_progress_section(state)` | Progress bar and status text during computation |
| `prs_results_table(state)` | Results table with quality badges, interpretation cards, and CSV download |

## State Mixin

`PRSComputeStateMixin` provides all PRS computation logic as a Reflex state mixin. Mix it into your concrete state class alongside `LazyFrameGridMixin` to get the full PRS workflow.

The preferred input method is a polars LazyFrame via `set_prs_genotypes_lf()` -- memory-efficient and avoids re-reading VCF files on each computation. A parquet path (`prs_genotypes_path`) is supported as a fallback.

## Documentation

See the [just-prs documentation](https://github.com/antonkulaga/just-prs) for the full Python API, CLI reference, and integration guide.