hiddenlayer-sdk 3.0.0__tar.gz → 3.0.1__tar.gz

hiddenlayer_sdk-3.0.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "3.0.1"
+}

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 3.0.1 (2025-09-23)
+
+Full Changelog: [v3.0.0...v3.0.1](https://github.com/hiddenlayerai/hiddenlayer-sdk-python/compare/v3.0.0...v3.0.1)
+
+### Features
+
+* **api:** manual updates ([2be2f2c](https://github.com/hiddenlayerai/hiddenlayer-sdk-python/commit/2be2f2c124d8ac9b9d22c675c165be496c1793ba))
+
 ## 3.0.0 (2025-09-23)
 
 Full Changelog: [v0.1.0-alpha.33...v3.0.0](https://github.com/hiddenlayerai/hiddenlayer-sdk-python/compare/v0.1.0-alpha.33...v3.0.0)

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hiddenlayer-sdk
-Version: 3.0.0
+Version: 3.0.1
 Summary: The official Python library for the hiddenlayer API
 Project-URL: Homepage, https://github.com/hiddenlayerai/hiddenlayer-sdk-python
 Project-URL: Repository, https://github.com/hiddenlayerai/hiddenlayer-sdk-python
@@ -70,10 +70,21 @@ client = HiddenLayer(
     environment="prod-eu",
 )
 
-sensor = client.sensors.create(
-    plaintext_name="REPLACE_ME",
+response = client.interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
-print(sensor.model_id)
+print(response.analysis)
 ```
 
 While you can provide a `bearer_token` keyword argument,
@@ -96,10 +107,21 @@ client = AsyncHiddenLayer(
 
 
 async def main() -> None:
-    sensor = await client.sensors.create(
-        plaintext_name="REPLACE_ME",
+    response = await client.interactions.analyze(
+        metadata={
+            "model": "REPLACE_ME",
+            "requester_id": "REPLACE_ME",
+        },
+        input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "REPLACE_ME",
+                }
+            ]
+        },
     )
-    print(sensor.model_id)
+    print(response.analysis)
 
 
 asyncio.run(main())
@@ -130,10 +152,21 @@ async def main() -> None:
     async with AsyncHiddenLayer(
         http_client=DefaultAioHttpClient(),
     ) as client:
-        sensor = await client.sensors.create(
-            plaintext_name="REPLACE_ME",
+        response = await client.interactions.analyze(
+            metadata={
+                "model": "REPLACE_ME",
+                "requester_id": "REPLACE_ME",
+            },
+            input={
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "REPLACE_ME",
+                    }
+                ]
+            },
         )
-        print(sensor.model_id)
+        print(response.analysis)
 
 
 asyncio.run(main())
@@ -157,10 +190,14 @@ from hiddenlayer import HiddenLayer
 
 client = HiddenLayer()
 
-page = client.models.cards.list(
-    model_created={},
+response = client.interactions.analyze(
+    metadata={
+        "model": "gpt-5",
+        "requester_id": "user-1234",
+        "provider": "openai",
+    },
 )
-print(page.results)
+print(response.metadata)
 ```
 
 ## Handling errors
@@ -179,8 +216,19 @@ from hiddenlayer import HiddenLayer
 client = HiddenLayer()
 
 try:
-    client.sensors.create(
-        plaintext_name="REPLACE_ME",
+    client.interactions.analyze(
+        metadata={
+            "model": "REPLACE_ME",
+            "requester_id": "REPLACE_ME",
+        },
+        input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "REPLACE_ME",
+                }
+            ]
+        },
     )
 except hiddenlayer.APIConnectionError as e:
     print("The server could not be reached")
@@ -224,8 +272,19 @@ client = HiddenLayer(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).sensors.create(
-    plaintext_name="REPLACE_ME",
+client.with_options(max_retries=5).interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
 ```
 
@@ -249,8 +308,19 @@ client = HiddenLayer(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).sensors.create(
-    plaintext_name="REPLACE_ME",
+client.with_options(timeout=5.0).interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
 ```
 
@@ -292,13 +362,22 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from hiddenlayer import HiddenLayer
 
 client = HiddenLayer()
-response = client.sensors.with_raw_response.create(
-    plaintext_name="REPLACE_ME",
+response = client.interactions.with_raw_response.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [{
+            "role": "user",
+            "content": "REPLACE_ME",
+        }]
+    },
 )
 print(response.headers.get('X-My-Header'))
 
-sensor = response.parse()  # get the object that `sensors.create()` would have returned
-print(sensor.model_id)
+interaction = response.parse()  # get the object that `interactions.analyze()` would have returned
+print(interaction.analysis)
 ```
 
 These methods return an [`APIResponse`](https://github.com/hiddenlayerai/hiddenlayer-sdk-python/tree/main/src/hiddenlayer/_response.py) object.
@@ -312,8 +391,19 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.sensors.with_streaming_response.create(
-    plaintext_name="REPLACE_ME",
+with client.interactions.with_streaming_response.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 ) as response:
     print(response.headers.get("X-My-Header"))
 

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/README.md

@@ -32,10 +32,21 @@ client = HiddenLayer(
     environment="prod-eu",
 )
 
-sensor = client.sensors.create(
-    plaintext_name="REPLACE_ME",
+response = client.interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
-print(sensor.model_id)
+print(response.analysis)
 ```
 
 While you can provide a `bearer_token` keyword argument,
@@ -58,10 +69,21 @@ client = AsyncHiddenLayer(
 
 
 async def main() -> None:
-    sensor = await client.sensors.create(
-        plaintext_name="REPLACE_ME",
+    response = await client.interactions.analyze(
+        metadata={
+            "model": "REPLACE_ME",
+            "requester_id": "REPLACE_ME",
+        },
+        input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "REPLACE_ME",
+                }
+            ]
+        },
     )
-    print(sensor.model_id)
+    print(response.analysis)
 
 
 asyncio.run(main())
@@ -92,10 +114,21 @@ async def main() -> None:
     async with AsyncHiddenLayer(
         http_client=DefaultAioHttpClient(),
     ) as client:
-        sensor = await client.sensors.create(
-            plaintext_name="REPLACE_ME",
+        response = await client.interactions.analyze(
+            metadata={
+                "model": "REPLACE_ME",
+                "requester_id": "REPLACE_ME",
+            },
+            input={
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "REPLACE_ME",
+                    }
+                ]
+            },
         )
-        print(sensor.model_id)
+        print(response.analysis)
 
 
 asyncio.run(main())
@@ -119,10 +152,14 @@ from hiddenlayer import HiddenLayer
 
 client = HiddenLayer()
 
-page = client.models.cards.list(
-    model_created={},
+response = client.interactions.analyze(
+    metadata={
+        "model": "gpt-5",
+        "requester_id": "user-1234",
+        "provider": "openai",
+    },
 )
-print(page.results)
+print(response.metadata)
 ```
 
 ## Handling errors
@@ -141,8 +178,19 @@ from hiddenlayer import HiddenLayer
 client = HiddenLayer()
 
 try:
-    client.sensors.create(
-        plaintext_name="REPLACE_ME",
+    client.interactions.analyze(
+        metadata={
+            "model": "REPLACE_ME",
+            "requester_id": "REPLACE_ME",
+        },
+        input={
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "REPLACE_ME",
+                }
+            ]
+        },
     )
 except hiddenlayer.APIConnectionError as e:
     print("The server could not be reached")
@@ -186,8 +234,19 @@ client = HiddenLayer(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).sensors.create(
-    plaintext_name="REPLACE_ME",
+client.with_options(max_retries=5).interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
 ```
 
@@ -211,8 +270,19 @@ client = HiddenLayer(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).sensors.create(
-    plaintext_name="REPLACE_ME",
+client.with_options(timeout=5.0).interactions.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 )
 ```
 
@@ -254,13 +324,22 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from hiddenlayer import HiddenLayer
 
 client = HiddenLayer()
-response = client.sensors.with_raw_response.create(
-    plaintext_name="REPLACE_ME",
+response = client.interactions.with_raw_response.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [{
+            "role": "user",
+            "content": "REPLACE_ME",
+        }]
+    },
 )
 print(response.headers.get('X-My-Header'))
 
-sensor = response.parse()  # get the object that `sensors.create()` would have returned
-print(sensor.model_id)
+interaction = response.parse()  # get the object that `interactions.analyze()` would have returned
+print(interaction.analysis)
 ```
 
 These methods return an [`APIResponse`](https://github.com/hiddenlayerai/hiddenlayer-sdk-python/tree/main/src/hiddenlayer/_response.py) object.
@@ -274,8 +353,19 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.sensors.with_streaming_response.create(
-    plaintext_name="REPLACE_ME",
+with client.interactions.with_streaming_response.analyze(
+    metadata={
+        "model": "REPLACE_ME",
+        "requester_id": "REPLACE_ME",
+    },
+    input={
+        "messages": [
+            {
+                "role": "user",
+                "content": "REPLACE_ME",
+            }
+        ]
+    },
 ) as response:
     print(response.headers.get("X-My-Header"))
 

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hiddenlayer-sdk"
-version = "3.0.0"
+version = "3.0.1"
 description = "The official Python library for the hiddenlayer API"
 dynamic = ["readme"]
 license = {text = "Apache-2.0"}

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/src/hiddenlayer/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "hiddenlayer"
-__version__ = "3.0.0"  # x-release-please-version
+__version__ = "3.0.1"  # x-release-please-version

{hiddenlayer_sdk-3.0.0 → hiddenlayer_sdk-3.0.1}/tests/test_client.py

@@ -742,20 +742,30 @@ class TestHiddenLayer:
     @mock.patch("hiddenlayer._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
     def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: HiddenLayer) -> None:
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=httpx.TimeoutException("Test timeout error"))
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            client.sensors.with_streaming_response.create(plaintext_name="plaintext_name").__enter__()
+            client.interactions.with_streaming_response.analyze(
+                metadata={
+                    "model": "gpt-5",
+                    "requester_id": "user-1234",
+                }
+            ).__enter__()
 
         assert _get_open_connections(self.client) == 0
 
     @mock.patch("hiddenlayer._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
     def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: HiddenLayer) -> None:
-        respx_mock.post("/api/v2/sensors/create").mock(return_value=httpx.Response(500))
+        respx_mock.post("/detection/v1/interactions").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            client.sensors.with_streaming_response.create(plaintext_name="plaintext_name").__enter__()
+            client.interactions.with_streaming_response.analyze(
+                metadata={
+                    "model": "gpt-5",
+                    "requester_id": "user-1234",
+                }
+            ).__enter__()
         assert _get_open_connections(self.client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
@@ -782,9 +792,14 @@ class TestHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = client.sensors.with_raw_response.create(plaintext_name="plaintext_name")
+        response = client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            }
+        )
 
         assert response.retries_taken == failures_before_success
         assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
@@ -806,10 +821,14 @@ class TestHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = client.sensors.with_raw_response.create(
-            plaintext_name="plaintext_name", extra_headers={"x-stainless-retry-count": Omit()}
+        response = client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            },
+            extra_headers={"x-stainless-retry-count": Omit()},
         )
 
         assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0
@@ -831,10 +850,14 @@ class TestHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = client.sensors.with_raw_response.create(
-            plaintext_name="plaintext_name", extra_headers={"x-stainless-retry-count": "42"}
+        response = client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            },
+            extra_headers={"x-stainless-retry-count": "42"},
         )
 
         assert response.http_request.headers.get("x-stainless-retry-count") == "42"
@@ -1581,10 +1604,15 @@ class TestAsyncHiddenLayer:
     async def test_retrying_timeout_errors_doesnt_leak(
         self, respx_mock: MockRouter, async_client: AsyncHiddenLayer
     ) -> None:
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=httpx.TimeoutException("Test timeout error"))
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            await async_client.sensors.with_streaming_response.create(plaintext_name="plaintext_name").__aenter__()
+            await async_client.interactions.with_streaming_response.analyze(
+                metadata={
+                    "model": "gpt-5",
+                    "requester_id": "user-1234",
+                }
+            ).__aenter__()
 
         assert _get_open_connections(self.client) == 0
 
@@ -1593,10 +1621,15 @@ class TestAsyncHiddenLayer:
     async def test_retrying_status_errors_doesnt_leak(
         self, respx_mock: MockRouter, async_client: AsyncHiddenLayer
     ) -> None:
-        respx_mock.post("/api/v2/sensors/create").mock(return_value=httpx.Response(500))
+        respx_mock.post("/detection/v1/interactions").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            await async_client.sensors.with_streaming_response.create(plaintext_name="plaintext_name").__aenter__()
+            await async_client.interactions.with_streaming_response.analyze(
+                metadata={
+                    "model": "gpt-5",
+                    "requester_id": "user-1234",
+                }
+            ).__aenter__()
         assert _get_open_connections(self.client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
@@ -1624,9 +1657,14 @@ class TestAsyncHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = await client.sensors.with_raw_response.create(plaintext_name="plaintext_name")
+        response = await client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            }
+        )
 
         assert response.retries_taken == failures_before_success
         assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
@@ -1649,10 +1687,14 @@ class TestAsyncHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = await client.sensors.with_raw_response.create(
-            plaintext_name="plaintext_name", extra_headers={"x-stainless-retry-count": Omit()}
+        response = await client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            },
+            extra_headers={"x-stainless-retry-count": Omit()},
         )
 
         assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0
@@ -1675,10 +1717,14 @@ class TestAsyncHiddenLayer:
                 return httpx.Response(500)
             return httpx.Response(200)
 
-        respx_mock.post("/api/v2/sensors/create").mock(side_effect=retry_handler)
+        respx_mock.post("/detection/v1/interactions").mock(side_effect=retry_handler)
 
-        response = await client.sensors.with_raw_response.create(
-            plaintext_name="plaintext_name", extra_headers={"x-stainless-retry-count": "42"}
+        response = await client.interactions.with_raw_response.analyze(
+            metadata={
+                "model": "gpt-5",
+                "requester_id": "user-1234",
+            },
+            extra_headers={"x-stainless-retry-count": "42"},
         )
 
         assert response.http_request.headers.get("x-stainless-retry-count") == "42"

hiddenlayer_sdk-3.0.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "3.0.0"
-}