errorsense 0.2.0__tar.gz → 0.2.1__tar.gz

{errorsense-0.2.0 → errorsense-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errorsense
-Version: 0.2.0
+Version: 0.2.1
 Summary: Error classification engine. Rules for the obvious, AI for the ambiguous.
 Project-URL: Homepage, https://github.com/OpenGPU-Network/errorsense
 Project-URL: Documentation, https://github.com/OpenGPU-Network/errorsense#readme
@@ -114,13 +114,13 @@ Phases run in order. First match wins. Rulesets are instant and free. LLM is the
 
 ## Rulesets
 
-Each ruleset does one thing — `match=` for field matching or `patterns=` for regex:
+Each ruleset does one thing — `match=` for exact field matching or `patterns=` for regex:
 
 ```python
 Ruleset(field="status_code", match={400: "client", 502: "server"})         # exact match
 Ruleset(field="status_code", match={"4xx": "client", 503: "server"})       # range match
-Ruleset(field="headers.content-type", match={"text/html": "server"})       # header match
 Ruleset(field="body.error.type", match={"validation_error": "client"})     # JSON dot-path
+Ruleset(field="headers.content-type", patterns=[("server", [r"^text/html"])])  # regex
 Ruleset(field="body", patterns=[("server", [r"OOM"]), ("client", [r"invalid"])])  # regex
 ```
 
@@ -136,7 +136,7 @@ class VendorBugRuleset(Ruleset):
 
 ## Skills
 
-Skills are LLM instructions stored as `.md` files. Each skill teaches the LLM how to classify errors in a specific domain.
+Skills are LLM instructions stored as `.md` files. Each skill teaches the LLM how to classify errors in a specific domain. Each skill triggers a separate LLM call — highest confidence result wins.
 
 ```python
 # Loads from errorsense/skills/http_classifier.md (built-in)
@@ -146,6 +146,17 @@ Skill("http_classifier")
 Skill("my_classifier", path="./skills/my_classifier.md")
 ```
 
+**Multiple skills in one phase:** Use this when you want multiple domain-specific opinions on the same error.
+
+```python
+Phase("llm", skills=[
+    Skill("http_classifier"),    # knows HTTP error patterns
+    Skill("db_classifier"),      # knows database error patterns
+], llm=LLMConfig(...))
+```
+
+In sync (`classify`), skills run sequentially. In async (`async_classify`), skills run concurrently.
+
 ## All Phases Mode
 
 ```python

{errorsense-0.2.0 → errorsense-0.2.1}/README.md

@@ -93,13 +93,13 @@ Phases run in order. First match wins. Rulesets are instant and free. LLM is the
 
 ## Rulesets
 
-Each ruleset does one thing — `match=` for field matching or `patterns=` for regex:
+Each ruleset does one thing — `match=` for exact field matching or `patterns=` for regex:
 
 ```python
 Ruleset(field="status_code", match={400: "client", 502: "server"})         # exact match
 Ruleset(field="status_code", match={"4xx": "client", 503: "server"})       # range match
-Ruleset(field="headers.content-type", match={"text/html": "server"})       # header match
 Ruleset(field="body.error.type", match={"validation_error": "client"})     # JSON dot-path
+Ruleset(field="headers.content-type", patterns=[("server", [r"^text/html"])])  # regex
 Ruleset(field="body", patterns=[("server", [r"OOM"]), ("client", [r"invalid"])])  # regex
 ```
 
@@ -115,7 +115,7 @@ class VendorBugRuleset(Ruleset):
 
 ## Skills
 
-Skills are LLM instructions stored as `.md` files. Each skill teaches the LLM how to classify errors in a specific domain.
+Skills are LLM instructions stored as `.md` files. Each skill teaches the LLM how to classify errors in a specific domain. Each skill triggers a separate LLM call — highest confidence result wins.
 
 ```python
 # Loads from errorsense/skills/http_classifier.md (built-in)
@@ -125,6 +125,17 @@ Skill("http_classifier")
 Skill("my_classifier", path="./skills/my_classifier.md")
 ```
 
+**Multiple skills in one phase:** Use this when you want multiple domain-specific opinions on the same error.
+
+```python
+Phase("llm", skills=[
+    Skill("http_classifier"),    # knows HTTP error patterns
+    Skill("db_classifier"),      # knows database error patterns
+], llm=LLMConfig(...))
+```
+
+In sync (`classify`), skills run sequentially. In async (`async_classify`), skills run concurrently.
+
 ## All Phases Mode
 
 ```python

{errorsense-0.2.0 → errorsense-0.2.1}/design/ERRORSENSE.md

@@ -40,13 +40,15 @@ from errorsense import Ruleset
 
 Ruleset(field="status_code", match={400: "client", 502: "server"})
 Ruleset(field="status_code", match={"4xx": "client", 503: "server"})
-Ruleset(field="headers.content-type", match={"text/html": "server"})
 Ruleset(field="body.error.type", match={"validation_error": "client"})
+Ruleset(field="headers.content-type", patterns=[("server", [r"^text/html"])])
 Ruleset(field="body", patterns=[("server", [r"OOM"]), ("client", [r"invalid"])])
 ```
 
 **Field resolution:** Plain field → `signal[field]`. `headers.*` → header lookup. `body.*` → JSON parse + dot-path. `body` (no dots) → raw string.
 
+**Match behavior:** `match=` does exact equality (`==`). For int fields, range keys like `"4xx"` match the hundred-range. For substring/prefix matching, use `patterns=` with regex.
+
 **Confidence:** Match = 1.0. Pattern = 0.9. Custom subclass sets its own.
 
 **Custom logic:** Subclass and override `classify()`:
@@ -167,7 +169,7 @@ sense = ErrorSense(
         count_labels=["server"],
         history_size=10,
         reviewer_llm=LLMConfig(),          # enables LLM review at threshold
-        reviewer_skill=Skill("custom"),     # optional, defaults to built-in reclassification.md
+        reviewer_skill=Skill("custom"),     # optional, defaults to built-in reviewer.md
     ),
 )
 
@@ -305,7 +307,7 @@ errorsense/
 │   └── http_gateway.py     # http(), http_no_llm()
 └── skills/
     ├── http_classifier.md  # HTTP error classification instructions
-    └── reclassification.md # Trailing review instructions
+    └── reviewer.md         # Trailing review instructions
 ```
 
 ## Dependencies

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/__init__.py

@@ -24,4 +24,4 @@ __all__ = [
     "TrailingConfig",
 ]
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/engine.py

@@ -44,7 +44,7 @@ class ErrorSense:
         on_classify: Callable[[Signal, SenseResult], Any] | None = None,
         on_error: Callable[[str, Exception], Any] | None = None,
     ) -> None:
-        self.labels = set(labels)
+        self.labels = tuple(labels)
         self.default = default
         self._on_classify = on_classify
         self._on_error = on_error
@@ -63,7 +63,7 @@ class ErrorSense:
         self._validate_labels()
         self._validate_llm_api_keys()
         for phase in self._pipeline:
-            phase.set_labels(list(labels))
+            phase.set_labels(self.labels)
 
         # Trailing state
         self._trailing = trailing
@@ -99,7 +99,10 @@ class ErrorSense:
         return None
 
     def close(self) -> None:
-        """Close all LLM phase clients (sync)."""
+        """Close all LLM phase clients (sync).
+
+        Not thread-safe with in-flight classify/trail calls.
+        """
         for phase in self._pipeline:
             phase.close_sync()
         if self._reviewer_client:
@@ -310,7 +313,7 @@ class ErrorSense:
         signal, skill = self._build_review_context(key)
         try:
             return self._reviewer_client.classify_sync(
-                signal, skill, list(self.labels), include_reason=True,
+                signal, skill, self.labels, include_reason=True,
             )
         except Exception as e:
             logger.warning("LLM review failed: %s", e)
@@ -322,7 +325,7 @@ class ErrorSense:
         signal, skill = self._build_review_context(key)
         try:
             return await self._reviewer_client.classify_async(
-                signal, skill, list(self.labels), include_reason=True,
+                signal, skill, self.labels, include_reason=True,
             )
         except Exception as e:
             logger.warning("LLM review failed: %s", e)
@@ -330,7 +333,7 @@ class ErrorSense:
 
     def _get_reviewer_skill(self) -> Skill:
         if self._reviewer_skill is None:
-            self._reviewer_skill = Skill("reclassification")
+            self._reviewer_skill = Skill("reviewer")
         return self._reviewer_skill
 
     def _build_review_context(self, key: str) -> tuple[Signal, Skill]:
@@ -400,7 +403,7 @@ class ErrorSense:
             seen.add(phase.name)
 
     def _validate_labels(self) -> None:
-        all_labels = self.labels | {self.default}
+        all_labels = set(self.labels) | {self.default}
         for phase in self._pipeline:
             for ruleset in phase.rulesets:
                 bad = ruleset.referenced_labels() - all_labels

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/llm.py

@@ -10,6 +10,11 @@ import threading
 from dataclasses import dataclass
 from typing import Any
 
+try:
+    import httpx
+except ImportError:
+    httpx = None  # type: ignore[assignment]
+
 from errorsense.models import SenseResult
 from errorsense.signal import Signal
 from errorsense.skill import Skill
@@ -20,7 +25,7 @@ __all__ = ["LLMConfig", "LLMClient"]
 
 DEFAULT_BASE_URL = "https://relay.opengpu.network/v2/openai/v1"
 DEFAULT_MODEL = "Qwen/Qwen3.5-397B-A17B-FP8"
-DEFAULT_PROMPT_TEMPLATE = (
+DEFAULT_PROMPT_FORMAT = (
     "{instructions}\n\n"
     "Classify the following error signal into exactly one of these labels: {labels}\n\n"
     "Signal data:\n{signal}\n\n"
@@ -57,9 +62,9 @@ class LLMConfig:
 def _build_prompt(signal: Signal, skill: Skill, labels: list[str], config: LLMConfig) -> str:
     signal_text = json.dumps(signal.to_dict(), default=str)
     if len(signal_text) > config.max_signal_size:
-        signal_text = signal_text[: config.max_signal_size] + "..."
+        signal_text = signal_text[: config.max_signal_size] + "...(truncated)"
 
-    template = skill.prompt_template or DEFAULT_PROMPT_TEMPLATE
+    template = skill.prompt_format or DEFAULT_PROMPT_FORMAT
     return template.format(
         instructions=skill.instructions,
         labels=", ".join(labels) if labels else "unknown",
@@ -76,6 +81,7 @@ def _build_request_body(skill: Skill, prompt: str, config: LLMConfig) -> dict:
 
 
 def _build_headers(config: LLMConfig) -> dict:
+    # Empty api_key sends "Bearer " — relay accepts this for guest tier.
     return {
         "Authorization": f"Bearer {config.api_key}",
         "Content-Type": "application/json",
@@ -121,12 +127,10 @@ class LLMClient:
     """HTTP client for LLM classification calls. Supports both sync and async."""
 
     def __init__(self, config: LLMConfig) -> None:
-        try:
-            import httpx  # noqa: F401
-        except ImportError:
+        if httpx is None:
             raise ImportError(
                 "LLM skills require httpx. Install with: pip install errorsense[llm]"
-            ) from None
+            )
 
         self._config = config
         self._sync_client: Any = None
@@ -135,16 +139,12 @@ class LLMClient:
         self._async_lock = asyncio.Lock()
 
     def _get_sync_client(self) -> Any:
-        import httpx
-
         with self._sync_lock:
             if self._sync_client is None:
                 self._sync_client = httpx.Client(timeout=self._config.timeout)
             return self._sync_client
 
     async def _get_async_client(self) -> Any:
-        import httpx
-
         async with self._async_lock:
             if self._async_client is None:
                 self._async_client = httpx.AsyncClient(timeout=self._config.timeout)
@@ -169,7 +169,7 @@ class LLMClient:
             )
             resp.raise_for_status()
             data = resp.json()
-        except (OSError, ValueError, KeyError, TypeError) as e:
+        except (httpx.HTTPError, ValueError) as e:
             logger.warning("LLM call failed for skill %r: %s", skill.name, e)
             return None
 
@@ -194,7 +194,7 @@ class LLMClient:
             )
             resp.raise_for_status()
             data = resp.json()
-        except (OSError, ValueError, KeyError, TypeError) as e:
+        except (httpx.HTTPError, ValueError) as e:
             logger.warning("LLM call failed for skill %r: %s", skill.name, e)
             return None
 

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/models.py

@@ -45,11 +45,15 @@ class TrailingConfig:
         count_labels: Only these labels count toward threshold.
         history_size: Max errors kept per key (ring buffer).
         reviewer_llm: LLM config for review. Set to enable review, None to disable.
-        reviewer_skill: Custom review skill. Defaults to built-in reclassification.
+        reviewer_skill: Custom review skill. Defaults to built-in reviewer.
     """
 
     threshold: int = 3
-    count_labels: list[str] | None = None
+    count_labels: list[str] | tuple[str, ...] | None = None
     history_size: int = 10
     reviewer_llm: LLMConfig | None = None
     reviewer_skill: Skill | None = None
+
+    def __post_init__(self) -> None:
+        if self.count_labels is not None:
+            object.__setattr__(self, "count_labels", tuple(self.count_labels))

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/phase.py

@@ -97,6 +97,11 @@ class Phase:
         return None
 
     def _run_skills_sync(self, signal: Signal, explain: bool) -> SenseResult | None:
+        """Run skills sequentially. Highest confidence wins.
+
+        Note: async variant runs skills concurrently via asyncio.gather,
+        so ordering may differ when skills tie on confidence.
+        """
         if not self._llm_client:
             return None
 

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/presets/http_gateway.py

@@ -18,9 +18,9 @@ def _ruleset_phases(extra_rulesets: list[Ruleset] | None = None) -> list[Phase]:
             Ruleset(field="status_code", match={
                 "4xx": "client", 502: "server", 503: "server", 504: "server",
             }),
-            Ruleset(field="headers.content-type", match={
-                "text/html": "server", "application/json": None,
-            }),
+            Ruleset(field="headers.content-type", patterns=[
+                ("server", [r"^text/html"]),
+            ]),
         ]),
         Phase("patterns", rulesets=[
             Ruleset(field="body", patterns=[

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/ruleset.py

@@ -86,10 +86,14 @@ class Ruleset:
 
     def referenced_labels(self) -> set[str]:
         """Return set of label strings this ruleset can produce. Used by engine validation."""
+        labels: set[str] = set()
         match = getattr(self, "_match", None)
-        if match is None:
-            return set()
-        return {v for v in match.values() if isinstance(v, str)}
+        if match is not None:
+            labels |= {v for v in match.values() if isinstance(v, str)}
+        compiled = getattr(self, "_compiled", None)
+        if compiled is not None:
+            labels |= {label for label, _ in compiled}
+        return labels
 
     def classify(self, signal: Signal) -> SenseResult | None:
         """Classify a signal. Override in subclass for custom logic."""
@@ -132,8 +136,6 @@ class Ruleset:
         return signal.get(field)
 
     def _match_value(self, value: Any) -> SenseResult | None:
-        field = self.field
-
         if value in self._exact_keys:
             label = self._exact_keys[value]
             if label is None:
@@ -146,13 +148,6 @@ class Ruleset:
                 label = self._range_keys[range_key]
                 return SenseResult(label=label, confidence=1.0)
 
-        if isinstance(value, str) and self._exact_keys:
-            for pattern, label in self._exact_keys.items():
-                if isinstance(pattern, str) and pattern in value:
-                    if label is None:
-                        return None
-                    return SenseResult(label=label, confidence=1.0)
-
         return None
 
     def _match_patterns(self, value: Any) -> SenseResult | None:

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/signal.py

@@ -6,7 +6,11 @@ from typing import Any
 
 
 def _deep_freeze(obj: Any) -> Any:
-    """Recursively freeze dicts into MappingProxyType and lists into tuples."""
+    """Recursively freeze dicts into MappingProxyType and lists into tuples.
+
+    Note: lists become tuples. Code receiving signal data should check
+    for Sequence, not list specifically.
+    """
     if isinstance(obj, dict):
         return MappingProxyType({k: _deep_freeze(v) for k, v in obj.items()})
     if isinstance(obj, list):

{errorsense-0.2.0 → errorsense-0.2.1}/errorsense/skill.py

@@ -15,7 +15,7 @@ class Skill:
     Instructions are loaded from a markdown file by default. Built-in skills
     live in errorsense/skills/. Custom skills can point to any file path.
 
-    For programmatic use (e.g. Tracker reclassification), inline instructions=
+    For programmatic use (e.g. trailing review), inline instructions=
     is also supported.
 
     Args:
@@ -23,7 +23,7 @@ class Skill:
               in the built-in skills directory.
         path: Explicit path to a .md file. Overrides built-in lookup.
         instructions: Inline instructions string. Overrides file loading.
-        prompt_template: Override the default LLM prompt template.
+        prompt_format: Override the default LLM prompt format.
         temperature: LLM temperature (default: 0.0 for determinism).
     """
 
@@ -32,14 +32,14 @@ class Skill:
         name: str,
         path: str | Path | None = None,
         instructions: str | None = None,
-        prompt_template: str | None = None,
+        prompt_format: str | None = None,
         temperature: float = 0.0,
     ) -> None:
         if not name:
             raise ValueError("Skill requires a non-empty 'name'")
 
         self.name = name
-        self.prompt_template = prompt_template
+        self.prompt_format = prompt_format
         self.temperature = temperature
 
         if instructions:

{errorsense-0.2.0 → errorsense-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "errorsense"
-version = "0.2.0"
+version = "0.2.1"
 description = "Error classification engine. Rules for the obvious, AI for the ambiguous."
 readme = "README.md"
 license = "MIT"

errorsense-0.2.1/tests/test_llm.py

@@ -0,0 +1,126 @@
+"""Tests for LLM prompt building and response parsing."""
+
+import json
+
+from errorsense.llm import (
+    DEFAULT_PROMPT_FORMAT,
+    LLMConfig,
+    _build_prompt,
+    _parse_response,
+)
+from errorsense.signal import Signal
+from errorsense.skill import Skill
+
+
+class TestParseResponse:
+    def _make_response(self, content: str) -> dict:
+        return {"choices": [{"message": {"content": content}}]}
+
+    def test_valid_json(self):
+        data = self._make_response('{"label": "server", "confidence": 0.9, "reason": "OOM"}')
+        result = _parse_response(data, ["client", "server"], "test_skill", include_reason=True)
+        assert result is not None
+        assert result.label == "server"
+        assert result.confidence == 0.9
+        assert result.reason == "OOM"
+
+    def test_reason_excluded_when_not_requested(self):
+        data = self._make_response('{"label": "server", "confidence": 0.9, "reason": "OOM"}')
+        result = _parse_response(data, ["client", "server"], "test_skill", include_reason=False)
+        assert result is not None
+        assert result.reason is None
+
+    def test_unknown_label_returns_none(self):
+        data = self._make_response('{"label": "bogus", "confidence": 0.9}')
+        result = _parse_response(data, ["client", "server"], "test_skill")
+        assert result is None
+
+    def test_empty_label_returns_none(self):
+        data = self._make_response('{"confidence": 0.9}')
+        result = _parse_response(data, ["client", "server"], "test_skill")
+        assert result is None
+
+    def test_malformed_json_returns_none(self):
+        data = self._make_response("not json at all")
+        result = _parse_response(data, ["client", "server"], "test_skill")
+        assert result is None
+
+    def test_code_fence_stripped(self):
+        content = '```json\n{"label": "client", "confidence": 0.8}\n```'
+        data = self._make_response(content)
+        result = _parse_response(data, ["client", "server"], "test_skill")
+        assert result is not None
+        assert result.label == "client"
+
+    def test_confidence_clamped_high(self):
+        data = self._make_response('{"label": "server", "confidence": 5.0}')
+        result = _parse_response(data, ["server"], "test_skill")
+        assert result.confidence == 1.0
+
+    def test_confidence_clamped_low(self):
+        data = self._make_response('{"label": "server", "confidence": -1.0}')
+        result = _parse_response(data, ["server"], "test_skill")
+        assert result.confidence == 0.0
+
+    def test_default_confidence(self):
+        data = self._make_response('{"label": "server"}')
+        result = _parse_response(data, ["server"], "test_skill")
+        assert result.confidence == 0.7
+
+    def test_missing_choices_returns_none(self):
+        result = _parse_response({}, ["server"], "test_skill")
+        assert result is None
+
+    def test_empty_labels_accepts_anything(self):
+        data = self._make_response('{"label": "whatever", "confidence": 0.5}')
+        result = _parse_response(data, [], "test_skill")
+        assert result is not None
+        assert result.label == "whatever"
+
+    def test_skill_name_set(self):
+        data = self._make_response('{"label": "server", "confidence": 0.9}')
+        result = _parse_response(data, ["server"], "my_skill")
+        assert result.skill_name == "my_skill"
+
+
+class TestBuildPrompt:
+    def _make_skill(self, instructions: str = "Classify this error.", **kwargs) -> Skill:
+        return Skill("test", instructions=instructions, **kwargs)
+
+    def test_basic_format(self):
+        signal = Signal({"status_code": 500})
+        skill = self._make_skill()
+        config = LLMConfig()
+        prompt = _build_prompt(signal, skill, ["client", "server"], config)
+        assert "Classify this error." in prompt
+        assert "client, server" in prompt
+        assert "500" in prompt
+
+    def test_truncation(self):
+        signal = Signal({"body": "x" * 1000})
+        skill = self._make_skill()
+        config = LLMConfig(max_signal_size=50)
+        prompt = _build_prompt(signal, skill, ["a"], config)
+        assert "...(truncated)" in prompt
+
+    def test_no_truncation_when_small(self):
+        signal = Signal({"x": 1})
+        skill = self._make_skill()
+        config = LLMConfig(max_signal_size=500)
+        prompt = _build_prompt(signal, skill, ["a"], config)
+        assert "(truncated)" not in prompt
+
+    def test_custom_template(self):
+        skill = self._make_skill(prompt_format="Labels: {labels}\nSignal: {signal}\n{instructions}")
+        signal = Signal({"code": 1})
+        config = LLMConfig()
+        prompt = _build_prompt(signal, skill, ["a", "b"], config)
+        assert prompt.startswith("Labels: a, b")
+        assert "Classify this error." in prompt
+
+    def test_empty_labels(self):
+        signal = Signal({"x": 1})
+        skill = self._make_skill()
+        config = LLMConfig()
+        prompt = _build_prompt(signal, skill, [], config)
+        assert "unknown" in prompt

{errorsense-0.2.0 → errorsense-0.2.1}/tests/test_ruleset.py

@@ -57,14 +57,28 @@ class TestRangeMatch:
 
 
 class TestHeaderMatch:
-    def test_content_type_match(self):
+    def test_content_type_exact_match(self):
         rs = Ruleset(field="headers.content-type", match={"text/html": "infra"})
+        signal = Signal.from_http(status_code=500, body="<html>", headers={"content-type": "text/html"})
+        result = rs.classify(signal)
+        assert result.label == "infra"
+
+    def test_content_type_with_charset_no_match(self):
+        """Exact match: 'text/html' != 'text/html; charset=utf-8'. Use patterns for prefix matching."""
+        rs = Ruleset(field="headers.content-type", match={"text/html": "infra"})
+        signal = Signal.from_http(status_code=500, body="<html>", headers={"content-type": "text/html; charset=utf-8"})
+        result = rs.classify(signal)
+        assert result is None
+
+    def test_content_type_pattern_match(self):
+        """Use patterns= for prefix matching on content-type with charset."""
+        rs = Ruleset(field="headers.content-type", patterns=[("infra", [r"^text/html"])])
         signal = Signal.from_http(status_code=500, body="<html>", headers={"content-type": "text/html; charset=utf-8"})
         result = rs.classify(signal)
         assert result.label == "infra"
 
     def test_content_type_none_pass(self):
-        rs = Ruleset(field="headers.content-type", match={"application/json": None, "text/html": "infra"})
+        rs = Ruleset(field="headers.content-type", match={"application/json": None})
         signal = Signal.from_http(status_code=500, body="{}", headers={"content-type": "application/json"})
         result = rs.classify(signal)
         assert result is None