decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/utils/slack/__init__.py

@@ -0,0 +1 @@
+"""Slack helpers package."""

dt_arena/utils/slack/helpers.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+import json
+import http.client
+import time
+import urllib.parse as urlparse
+from pathlib import Path
+from typing import List, Dict, Any, Tuple, Optional
+import yaml
+
+
+def _get_registry() -> dict:
+    root = Path(__file__).resolve().parents[3]
+    registry_file = root / "dt_arena" / "envs" / "registry.yaml"
+    if registry_file.exists():
+        try:
+            return yaml.safe_load(registry_file.read_text()) or {}
+        except Exception:
+            return {}
+    return {}
+
+
+def _get_slack_host_port() -> Tuple[str, int]:
+    import os
+    # First check for environment variable (set by task_runner for dynamic ports)
+    env_port = os.environ.get("SLACK_API_PORT")
+    if env_port:
+        return "127.0.0.1", int(env_port)
+    
+    # Fall back to registry
+    reg = _get_registry()
+    slack_base = ((reg.get("services") or {}).get("slack") or {}).get(
+        "api_base_url", "http://127.0.0.1:8034"
+    )
+    parsed = urlparse.urlparse(slack_base)
+    host = parsed.hostname or "127.0.0.1"
+    port = parsed.port or (443 if (parsed.scheme or "http") == "https" else 80)
+    return host, port
+
+
+def login(email: str, password: str) -> str:
+    host, port = _get_slack_host_port()
+    form = urlparse.urlencode({"username": email, "password": password})
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+    conn = http.client.HTTPConnection(host, port, timeout=5)
+    conn.request("POST", "/api/v1/auth/login", body=form, headers=headers)
+    resp = conn.getresponse()
+    data = resp.read()
+    conn.close()
+    if resp.status == 200:
+        try:
+            return json.loads(data.decode()).get("access_token") or ""
+        except Exception:
+            return ""
+    return ""
+
+
+def channel_feed(token: str, channel: str, workspace_id: str = "W01", limit: int = 50) -> List[Dict[str, Any]]:
+    host, port = _get_slack_host_port()
+    headers = {"Authorization": f"Bearer {token}"}
+
+    def _fetch_for_workspace(wid: str) -> Optional[List[Dict[str, Any]]]:
+        params = urlparse.urlencode({"channel": channel, "workspace_id": wid, "limit": limit})
+        conn = http.client.HTTPConnection(host, port, timeout=5)
+        conn.request("GET", f"/api/v1/channels.history?{params}", headers=headers)
+        resp = conn.getresponse()
+        raw = resp.read()
+        conn.close()
+        if resp.status != 200:
+            return None
+        try:
+            data = json.loads(raw.decode())
+            return data if isinstance(data, list) else []
+        except Exception:
+            return []
+
+    primary: Optional[List[Dict[str, Any]]] = None
+    # Slack history can lag right after posting; retry briefly to avoid false negatives.
+    for _ in range(3):
+        primary = _fetch_for_workspace(workspace_id)
+        if primary:
+            return primary
+        if primary is None:
+            break
+        time.sleep(0.4)
+    if primary in ([], None):
+        # Empty/non-200 results can happen when task workspace id differs from default.
+        # Retry against discovered workspaces before giving up.
+        conn = http.client.HTTPConnection(host, port, timeout=5)
+        conn.request("GET", "/api/v1/workspaces", headers=headers)
+        resp = conn.getresponse()
+        raw = resp.read()
+        conn.close()
+        if resp.status == 200:
+            try:
+                workspaces = json.loads(raw.decode())
+                if isinstance(workspaces, list):
+                    for ws in workspaces:
+                        if not isinstance(ws, dict):
+                            continue
+                        alt_id = str(ws.get("id") or ws.get("workspace_id") or "").strip()
+                        if not alt_id or alt_id == workspace_id:
+                            continue
+                        alt = _fetch_for_workspace(alt_id)
+                        if alt:
+                            return alt
+            except Exception:
+                pass
+    return []
+
+
+def dm_feed(token: str, workspace_id: str = "W01", limit: int = 50):
+    host, port = _get_slack_host_port()
+    params = urlparse.urlencode({"workspace_id": workspace_id, "limit": limit})
+    headers = {"Authorization": f"Bearer {token}"}
+    conn = http.client.HTTPConnection(host, port, timeout=5)
+    conn.request("GET", f"/api/v1/dm_feed?{params}", headers=headers)
+    resp = conn.getresponse()
+    raw = resp.read()
+    conn.close()
+    if resp.status != 200:
+        return []
+    try:
+        return json.loads(raw.decode())
+    except Exception:
+        return []
+
+
+def get_channel_messages(
+    channel: str,
+    token: str,
+    workspace_id: str = "W01",
+    limit: int = 50
+) -> List[Dict[str, Any]]:
+    """Get messages from a Slack channel.
+
+    Args:
+        channel: Channel name (without #).
+        token: Slack access token.
+        workspace_id: Workspace ID (default "W01").
+        limit: Maximum number of messages to retrieve.
+
+    Returns:
+        List of message objects with 'text', 'user', 'ts' fields.
+    """
+    if not token:
+        return []
+
+    host, port = _get_slack_host_port()
+
+    params = urlparse.urlencode({
+        "channel": channel,
+        "workspace_id": workspace_id,
+        "limit": limit,
+    })
+    headers = {"Authorization": f"Bearer {token}"}
+
+    headers = {"Authorization": f"Bearer {token}"}
+    conn = http.client.HTTPConnection(host, port, timeout=10)
+    conn.request("GET", f"/api/v1/channels.history?{params}", headers=headers)
+    resp = conn.getresponse()
+    raw = resp.read()
+    conn.close()
+
+    if resp.status != 200:
+        return []
+
+    try:
+        data = json.loads(raw.decode())
+        # Handle different response formats
+        if isinstance(data, list):
+            return data
+        elif isinstance(data, dict):
+            return data.get("messages", data.get("data", []))
+        return []
+    except Exception:
+        return []

dt_arena/utils/snowflake/__init__.py

@@ -0,0 +1 @@
+"""Snowflake helpers package."""

dt_arena/utils/snowflake/helpers.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+import csv
+import io
+import json
+import http.client
+import os
+import subprocess
+import urllib.parse as urlparse
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+import yaml
+
+
+def _get_registry() -> dict:
+    root = Path(__file__).resolve().parents[3]
+    registry_file = root / "dt_arena" / "envs" / "registry.yaml"
+    if registry_file.exists():
+        try:
+            return yaml.safe_load(registry_file.read_text()) or {}
+        except Exception:
+            return {}
+    return {}
+
+
+def _get_snowflake_host_port() -> Tuple[str, int]:
+    env_port = os.environ.get("SNOWFLAKE_PG_PORT")
+    if env_port:
+        return "127.0.0.1", int(env_port)
+
+    reg = _get_registry()
+    base = ((reg.get("services") or {}).get("snowflake") or {}).get(
+        "api_base_url", "http://127.0.0.1:8051"
+    )
+    parsed = urlparse.urlparse(base)
+    host = parsed.hostname or "127.0.0.1"
+    port = parsed.port or (443 if (parsed.scheme or "http") == "https" else 80)
+    return host, port
+
+
+def login(email: str, password: str) -> str:
+    host, port = _get_snowflake_host_port()
+    form = urlparse.urlencode({"username": email, "password": password})
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+    conn = http.client.HTTPConnection(host, port, timeout=5)
+    conn.request("POST", "/api/v1/auth/login", body=form, headers=headers)
+    resp = conn.getresponse()
+    data = resp.read()
+    conn.close()
+    if resp.status == 200:
+        try:
+            return json.loads(data.decode()).get("access_token") or ""
+        except Exception:
+            return ""
+    return ""
+
+
+def _compose_file() -> Path:
+    return Path(__file__).resolve().parents[3] / "dt_arena" / "envs" / "snowflake" / "docker-compose.yml"
+
+
+def _parse_rows(csv_text: str) -> List[Dict[str, Any]]:
+    try:
+        reader = csv.DictReader(io.StringIO(csv_text))
+        out: List[Dict[str, Any]] = []
+        for row in reader:
+            if not isinstance(row, dict):
+                continue
+            out.append({str(k): v for k, v in row.items()})
+        return out
+    except Exception:
+        return []
+
+
+def _find_container_by_published_port(port: int, name_hint: str = "") -> str:
+    proc = subprocess.run(
+        ["docker", "ps", "--format", "{{.ID}}\t{{.Ports}}\t{{.Names}}"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        return ""
+    needle = f":{int(port)}->"
+    hint = (name_hint or "").lower()
+    for line in (proc.stdout or "").splitlines():
+        parts = line.split("\t")
+        if len(parts) < 3:
+            continue
+        cid, ports, name = parts[0].strip(), parts[1], parts[2]
+        if needle not in ports:
+            continue
+        if hint and hint not in name.lower():
+            continue
+        return cid
+    return ""
+
+
+def run_query(query: str, token: str = "", limit: int = 200) -> List[Dict[str, Any]]:
+    """Execute SQL against local Snowflake sandbox Postgres and return rows.
+
+    Judges in this repository expect a list of dictionaries and only rely on
+    basic text/number fields. We intentionally keep this helper lightweight and
+    resilient across task-specific schemas.
+    """
+    _ = token  # Token is accepted for API compatibility with judge calls.
+
+    sql = (query or "").strip().rstrip(";")
+    if not sql:
+        return []
+
+    # Keep judge queries bounded to avoid accidentally huge outputs.
+    bounded_sql = f"SELECT * FROM ({sql}) AS _q LIMIT {max(1, min(5000, limit))};"
+
+    host, port = _get_snowflake_host_port()
+    if host in ("127.0.0.1", "localhost"):
+        cid = _find_container_by_published_port(int(port), name_hint="snowflake")
+        if cid:
+            proc = subprocess.run(
+                [
+                    "docker",
+                    "exec",
+                    "-i",
+                    cid,
+                    "psql",
+                    "-U",
+                    "snow",
+                    "-d",
+                    "snowdb",
+                    "--csv",
+                    "-c",
+                    bounded_sql,
+                ],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            if proc.returncode == 0 and (proc.stdout or "").strip():
+                return _parse_rows(proc.stdout)
+
+    compose = _compose_file()
+    if not compose.exists():
+        return []
+    project_name = os.getenv("SNOWFLAKE_PROJECT_NAME", "").strip()
+    cmd = ["docker", "compose"]
+    if project_name:
+        cmd += ["-p", project_name]
+    cmd += [
+        "-f",
+        str(compose),
+        "exec",
+        "-T",
+        "snowflake-pg",
+        "psql",
+        "-U",
+        "snow",
+        "-d",
+        "snowdb",
+        "--csv",
+        "-c",
+        bounded_sql,
+    ]
+
+    proc = subprocess.run(cmd, check=False, capture_output=True, text=True)
+    if proc.returncode != 0 or not (proc.stdout or "").strip():
+        return []
+    return _parse_rows(proc.stdout)

dt_arena/utils/telecom/__init__.py

@@ -0,0 +1 @@
+"""Telecom domain utilities and helpers."""