dreadnode 1.0.0__tar.gz

dreadnode-1.0.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.3
+Name: dreadnode
+Version: 1.0.0
+Summary: Dreadnode SDK
+Author: Nick Landers
+Author-email: monoxgas@gmail.com
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: training
+Requires-Dist: coolname (>=2.2.0,<3.0.0)
+Requires-Dist: fast-depends (>=2.4.12,<3.0.0)
+Requires-Dist: fsspec[s3] (>=2023.1.0,<=2025.3.0)
+Requires-Dist: httpx (>=0.28.0,<0.29.0)
+Requires-Dist: logfire (>=3.5.3,<4.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: python-ulid (>=3.0.0,<4.0.0)
+Requires-Dist: transformers (>=4.41.0,<5.0.0) ; extra == "training"
+Project-URL: Repository, https://github.com/dreadnode/sdk
+Description-Content-Type: text/markdown
+
+<p align="center">
+    <img
+    src="https://d1lppblt9t2x15.cloudfront.net/logos/5714928f3cdc09503751580cffbe8d02.png"
+    alt="Logo"
+    align="center"
+    width="144px"
+    height="144px"
+    />
+</p>
+
+<h3 align="center">
+Dreadnode Strikes SDK
+</h3>
+
+<h4 align="center">
+    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/dreadnode">
+    <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/dreadnode">
+    <img alt="GitHub License" src="https://img.shields.io/github/license/dreadnode/sdk">
+    <img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/tests.yaml">
+    <img alt="Pre-Commit" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/pre-commit.yaml">
+    <img alt="Renovate" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/renovate.yaml">
+</h4>
+
+</br>
+
+Strikes is a platform for building, experimenting with, and evaluating AI security agent code.
+
+- **Experiment + Tasking + Observability** in a single place that's lightweight and scales.
+- **Track your data** with parameters, inputs, and outputs all connected to your tasks.
+- **Log your artifacts** — data, models, files, and folders — to track data of your Dreadnode runs, enabling easy reuse and reproducibility.
+- **Measure everything** with metrics throughout your code and anywhere you need them.
+- **Scale your code** from a single run to thousands.
+
+```python
+import dreadnode as dn
+import rigging as rg
+
+from .tools import reversing_tools
+
+dn.configure()
+
+@dataclass
+class Finding:
+    name: str
+    severity: str
+    description: str
+    exploit_code: str
+
+@dn.scorer(name="Score Finding")
+async def score_finding(finding: Finding) -> float:
+    if finding.severity == "critical":
+        return 1.0
+    elif finding.severity == "high":
+        return 0.8
+    else:
+        return 0.2
+
+@dn.task(scorers=[score_finding])
+@rg.prompt(tools=[reversing_tools])
+async def analyze_binary(binary: str) -> list[Finding]:
+    """
+    Analyze the binary for vulnerabilities.
+    """
+    ...
+
+with dn.run(tags=["reverse-engineering"]):
+    binary = "c2/downloads/service.exe"
+
+    dn.log_params(
+        model="gpt-4",
+        temperature=0.5,
+        binary=binary
+    )
+
+    findings = await analyze_binary(binary)
+
+    dn.log_metric("findings", len(findings))
+```
+
+## Installation
+
+We publish every version to PyPi:
+```bash
+pip install -U dreadnode
+```
+
+If you want to build from source:
+```bash
+poetry install
+```
+
+See our **[installation guide](https://docs.dreadnode.io/strikes/install)** for more options.
+
+## Getting Started
+
+Read through our **[introduction guide](https://docs.dreadnode.io/strikes/intro)** in the docs.
+
+## Examples
+
+Check out **[dreadnode/example-agents](https://github.com/dreadnode/example-agents)** to find your favorite use case. 

dreadnode-1.0.0/README.md

@@ -0,0 +1,100 @@
+<p align="center">
+    <img
+    src="https://d1lppblt9t2x15.cloudfront.net/logos/5714928f3cdc09503751580cffbe8d02.png"
+    alt="Logo"
+    align="center"
+    width="144px"
+    height="144px"
+    />
+</p>
+
+<h3 align="center">
+Dreadnode Strikes SDK
+</h3>
+
+<h4 align="center">
+    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/dreadnode">
+    <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/dreadnode">
+    <img alt="GitHub License" src="https://img.shields.io/github/license/dreadnode/sdk">
+    <img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/tests.yaml">
+    <img alt="Pre-Commit" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/pre-commit.yaml">
+    <img alt="Renovate" src="https://img.shields.io/github/actions/workflow/status/dreadnode/sdk/renovate.yaml">
+</h4>
+
+</br>
+
+Strikes is a platform for building, experimenting with, and evaluating AI security agent code.
+
+- **Experiment + Tasking + Observability** in a single place that's lightweight and scales.
+- **Track your data** with parameters, inputs, and outputs all connected to your tasks.
+- **Log your artifacts** — data, models, files, and folders — to track data of your Dreadnode runs, enabling easy reuse and reproducibility.
+- **Measure everything** with metrics throughout your code and anywhere you need them.
+- **Scale your code** from a single run to thousands.
+
+```python
+import dreadnode as dn
+import rigging as rg
+
+from .tools import reversing_tools
+
+dn.configure()
+
+@dataclass
+class Finding:
+    name: str
+    severity: str
+    description: str
+    exploit_code: str
+
+@dn.scorer(name="Score Finding")
+async def score_finding(finding: Finding) -> float:
+    if finding.severity == "critical":
+        return 1.0
+    elif finding.severity == "high":
+        return 0.8
+    else:
+        return 0.2
+
+@dn.task(scorers=[score_finding])
+@rg.prompt(tools=[reversing_tools])
+async def analyze_binary(binary: str) -> list[Finding]:
+    """
+    Analyze the binary for vulnerabilities.
+    """
+    ...
+
+with dn.run(tags=["reverse-engineering"]):
+    binary = "c2/downloads/service.exe"
+
+    dn.log_params(
+        model="gpt-4",
+        temperature=0.5,
+        binary=binary
+    )
+
+    findings = await analyze_binary(binary)
+
+    dn.log_metric("findings", len(findings))
+```
+
+## Installation
+
+We publish every version to PyPi:
+```bash
+pip install -U dreadnode
+```
+
+If you want to build from source:
+```bash
+poetry install
+```
+
+See our **[installation guide](https://docs.dreadnode.io/strikes/install)** for more options.
+
+## Getting Started
+
+Read through our **[introduction guide](https://docs.dreadnode.io/strikes/intro)** in the docs.
+
+## Examples
+
+Check out **[dreadnode/example-agents](https://github.com/dreadnode/example-agents)** to find your favorite use case. 

dreadnode-1.0.0/dreadnode/__init__.py

@@ -0,0 +1,51 @@
+from dreadnode.main import DEFAULT_INSTANCE, Dreadnode
+from dreadnode.metric import Metric, MetricDict, Scorer
+from dreadnode.object import Object
+from dreadnode.task import Task
+from dreadnode.tracing.span import RunSpan, Span, TaskSpan
+from dreadnode.version import VERSION
+
+configure = DEFAULT_INSTANCE.configure
+shutdown = DEFAULT_INSTANCE.shutdown
+
+api = DEFAULT_INSTANCE.api
+span = DEFAULT_INSTANCE.span
+task = DEFAULT_INSTANCE.task
+task_span = DEFAULT_INSTANCE.task_span
+run = DEFAULT_INSTANCE.run
+scorer = DEFAULT_INSTANCE.scorer
+task_span = DEFAULT_INSTANCE.task_span
+push_update = DEFAULT_INSTANCE.push_update
+
+log_metric = DEFAULT_INSTANCE.log_metric
+log_param = DEFAULT_INSTANCE.log_param
+log_params = DEFAULT_INSTANCE.log_params
+log_input = DEFAULT_INSTANCE.log_input
+log_inputs = DEFAULT_INSTANCE.log_inputs
+log_output = DEFAULT_INSTANCE.log_output
+link_objects = DEFAULT_INSTANCE.link_objects
+log_artifact = DEFAULT_INSTANCE.log_artifact
+
+__version__ = VERSION
+
+__all__ = [
+    "Dreadnode",
+    "Metric",
+    "MetricDict",
+    "Object",
+    "Run",
+    "RunSpan",
+    "Score",
+    "Scorer",
+    "Span",
+    "Task",
+    "TaskSpan",
+    "__version__",
+    "configure",
+    "log_metric",
+    "log_param",
+    "run",
+    "shutdown",
+    "span",
+    "task",
+]

dreadnode-1.0.0/dreadnode/api/client.py

@@ -0,0 +1,244 @@
+import io
+import json
+import typing as t
+
+import httpx
+import pandas as pd
+from pydantic import BaseModel
+from ulid import ULID
+
+from dreadnode.util import logger
+from dreadnode.version import VERSION
+
+from .models import (
+    MetricAggregationType,
+    Project,
+    Run,
+    StatusFilter,
+    Task,
+    TimeAggregationType,
+    TimeAxisType,
+    TraceSpan,
+    UserDataCredentials,
+)
+
+ModelT = t.TypeVar("ModelT", bound=BaseModel)
+
+
+class ApiClient:
+    """Client for the Dreadnode API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        *,
+        debug: bool = False,
+    ):
+        self._base_url = base_url.rstrip("/")
+        if not self._base_url.endswith("/api"):
+            self._base_url += "/api"
+
+        self._client = httpx.Client(
+            headers={
+                "User-Agent": f"dreadnode-sdk/{VERSION}",
+                "Accept": "application/json",
+                "X-API-Key": api_key,
+            },
+            base_url=self._base_url,
+            timeout=30,
+        )
+
+        if debug:
+            self._client.event_hooks["request"].append(self._log_request)
+            self._client.event_hooks["response"].append(self._log_response)
+
+    def _log_request(self, request: httpx.Request) -> None:
+        """Log every request to the console if debug is enabled."""
+
+        logger.debug("-------------------------------------------")
+        logger.debug("%s %s", request.method, request.url)
+        logger.debug("Headers: %s", request.headers)
+        logger.debug("Content: %s", request.content)
+        logger.debug("-------------------------------------------")
+
+    def _log_response(self, response: httpx.Response) -> None:
+        """Log every response to the console if debug is enabled."""
+
+        logger.debug("-------------------------------------------")
+        logger.debug("Response: %s", response.status_code)
+        logger.debug("Headers: %s", response.headers)
+        logger.debug("Content: %s", response.read())
+        logger.debug("--------------------------------------------")
+
+    def _get_error_message(self, response: httpx.Response) -> str:
+        """Get the error message from the response."""
+
+        try:
+            obj = response.json()
+            return f"{response.status_code}: {obj.get('detail', json.dumps(obj))}"
+        except Exception:  # noqa: BLE001
+            return str(response.content)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, t.Any] | None = None,
+        json_data: dict[str, t.Any] | None = None,
+    ) -> httpx.Response:
+        """Make a raw request to the API."""
+
+        return self._client.request(method, path, json=json_data, params=params)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, t.Any] | None = None,
+        json_data: dict[str, t.Any] | None = None,
+    ) -> httpx.Response:
+        """Make a request to the API. Raise an exception for non-200 status codes."""
+
+        response = self._request(method, path, params, json_data)
+        if response.status_code == 401:  # noqa: PLR2004
+            raise RuntimeError("Authentication failed, please check your API token.")
+
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(self._get_error_message(response)) from e
+
+        return response
+
+    def list_projects(self) -> list[Project]:
+        response = self.request("GET", "/strikes/projects")
+        return [Project(**project) for project in response.json()]
+
+    def get_project(self, project: str) -> Project:
+        response = self.request("GET", f"/strikes/projects/{project!s}")
+        return Project(**response.json())
+
+    def list_runs(self, project: str) -> list[Run]:
+        response = self.request("GET", f"/strikes/projects/{project!s}/runs")
+        return [Run(**run) for run in response.json()]
+
+    def get_run(self, run: str | ULID) -> Run:
+        response = self.request("GET", f"/strikes/projects/runs/{run!s}")
+        return Run(**response.json())
+
+    def get_run_tasks(self, run: str | ULID) -> list[Task]:
+        response = self.request("GET", f"/strikes/projects/runs/{run!s}/tasks")
+        return [Task(**task) for task in response.json()]
+
+    def get_run_trace(self, run: str | ULID) -> list[Task | TraceSpan]:
+        response = self.request("GET", f"/strikes/projects/runs/{run!s}/spans")
+        spans: list[Task | TraceSpan] = []
+        for item in response.json():
+            if "parent_task_span_id" in item:
+                spans.append(Task(**item))
+            else:
+                spans.append(TraceSpan(**item))
+        return spans
+
+    # Data exports
+
+    def export_runs(
+        self,
+        project: str,
+        *,
+        filter: str | None = None,
+        # format: ExportFormat = "parquet",
+        status: StatusFilter = "completed",
+        aggregations: list[MetricAggregationType] | None = None,
+    ) -> pd.DataFrame:
+        response = self.request(
+            "GET",
+            f"/strikes/projects/{project!s}/export",
+            params={
+                "format": "parquet",
+                "status": status,
+                **({"filter": filter} if filter else {}),
+                **({"aggregations": aggregations} if aggregations else {}),
+            },
+        )
+        return pd.read_parquet(io.BytesIO(response.content))
+
+    def export_metrics(
+        self,
+        project: str,
+        *,
+        filter: str | None = None,
+        # format: ExportFormat = "parquet",
+        status: StatusFilter = "completed",
+        metrics: list[str] | None = None,
+        aggregations: list[MetricAggregationType] | None = None,
+    ) -> pd.DataFrame:
+        response = self.request(
+            "GET",
+            f"/strikes/projects/{project!s}/export/metrics",
+            params={
+                "format": "parquet",
+                "status": status,
+                "filter": filter,
+                **({"metrics": metrics} if metrics else {}),
+                **({"aggregations": aggregations} if aggregations else {}),
+            },
+        )
+        return pd.read_parquet(io.BytesIO(response.content))
+
+    def export_parameters(
+        self,
+        project: str,
+        *,
+        filter: str | None = None,
+        # format: ExportFormat = "parquet",
+        status: StatusFilter = "completed",
+        parameters: list[str] | None = None,
+        metrics: list[str] | None = None,
+        aggregations: list[MetricAggregationType] | None = None,
+    ) -> pd.DataFrame:
+        response = self.request(
+            "GET",
+            f"/strikes/projects/{project!s}/export/parameters",
+            params={
+                "format": "parquet",
+                "status": status,
+                "filter": filter,
+                **({"parameters": parameters} if parameters else {}),
+                **({"metrics": metrics} if metrics else {}),
+                **({"aggregations": aggregations} if aggregations else {}),
+            },
+        )
+        return pd.read_parquet(io.BytesIO(response.content))
+
+    def export_timeseries(
+        self,
+        project: str,
+        *,
+        filter: str | None = None,
+        # format: ExportFormat = "parquet",
+        status: StatusFilter = "completed",
+        metrics: list[str] | None = None,
+        time_axis: TimeAxisType = "relative",
+        aggregations: list[TimeAggregationType] | None = None,
+    ) -> pd.DataFrame:
+        response = self.request(
+            "GET",
+            f"/strikes/projects/{project!s}/export/timeseries",
+            params={
+                "format": "parquet",
+                "status": status,
+                "filter": filter,
+                "time_axis": time_axis,
+                **({"metrics": metrics} if metrics else {}),
+                **({"aggregation": aggregations} if aggregations else {}),
+            },
+        )
+        return pd.read_parquet(io.BytesIO(response.content))
+
+    # User data access
+
+    def get_user_data_credentials(self) -> UserDataCredentials:
+        response = self.request("GET", "/user-data/credentials")
+        return UserDataCredentials(**response.json())