hiddenlayer-sdk 1.2.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

hiddenlayer/sdk/rest/models/scan_results_v3.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan V2
+
+    HiddenLayer ModelScan API for scanning of models
+
+    The version of the OpenAPI document: 1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from hiddenlayer.sdk.rest.models.file_result_v3 import FileResultV3
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScanResultsV3(BaseModel):
+    """
+    ScanResultsV3
+    """ # noqa: E501
+    scan_id: Optional[StrictStr] = None
+    start_time: Optional[StrictInt] = None
+    end_time: Optional[StrictInt] = None
+    status: Optional[StrictStr] = None
+    version: Optional[StrictStr] = None
+    inventory: Optional[Dict[str, Any]] = None
+    file_results: List[FileResultV3]
+    __properties: ClassVar[List[str]] = ["scan_id", "start_time", "end_time", "status", "version", "inventory", "file_results"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['done', 'running', 'failed', 'pending', 'canceled']):
+            raise ValueError("must be one of enum values ('done', 'running', 'failed', 'pending', 'canceled')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ScanResultsV3 from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of inventory
+        if self.inventory:
+            _dict['inventory'] = self.inventory.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in file_results (list)
+        _items = []
+        if self.file_results:
+            for _item in self.file_results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['file_results'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ScanResultsV3 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "scan_id": obj.get("scan_id"),
+            "start_time": obj.get("start_time"),
+            "end_time": obj.get("end_time"),
+            "status": obj.get("status"),
+            "version": obj.get("version"),
+            "inventory": InventoryV3.from_dict(obj["inventory"]) if obj.get("inventory") is not None else None,
+            "file_results": [FileResultV3.from_dict(_item) for _item in obj["file_results"]] if obj.get("file_results") is not None else None
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/{model.py → sensor.py}

@@ -23,9 +23,9 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Model(BaseModel):
+class Sensor(BaseModel):
     """
-    Model
+    Sensor
     """ # noqa: E501
     sensor_id: StrictStr
     created_at: datetime
@@ -54,7 +54,7 @@ class Model(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Model from a JSON string"""
+        """Create an instance of Sensor from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -79,7 +79,7 @@ class Model(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Model from a dict"""
+        """Create an instance of Sensor from a dict"""
         if obj is None:
             return None
 

hiddenlayer/sdk/rest/models/{model_query_response.py → sensor_query_response.py}

@@ -19,18 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List
-from hiddenlayer.sdk.rest.models.model import Model
+from hiddenlayer.sdk.rest.models.sensor import Sensor
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ModelQueryResponse(BaseModel):
+class SensorQueryResponse(BaseModel):
     """
-    ModelQueryResponse
+    SensorQueryResponse
     """ # noqa: E501
     total_count: StrictInt
     page_size: StrictInt
     page_number: StrictInt
-    results: List[Model]
+    results: List[Sensor]
     __properties: ClassVar[List[str]] = ["total_count", "page_size", "page_number", "results"]
 
     model_config = ConfigDict(
@@ -51,7 +51,7 @@ class ModelQueryResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ModelQueryResponse from a JSON string"""
+        """Create an instance of SensorQueryResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -83,7 +83,7 @@ class ModelQueryResponse(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ModelQueryResponse from a dict"""
+        """Create an instance of SensorQueryResponse from a dict"""
         if obj is None:
             return None
 
@@ -94,7 +94,7 @@ class ModelQueryResponse(BaseModel):
             "total_count": obj.get("total_count"),
             "page_size": obj.get("page_size"),
             "page_number": obj.get("page_number"),
-            "results": [Model.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None
+            "results": [Sensor.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None
         })
         return _obj
 

hiddenlayer/sdk/services/aidr_predictive.py

@@ -4,22 +4,29 @@ from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 
+from hiddenlayer.sdk.exceptions import SensorDoesNotExistError
 from hiddenlayer.sdk.rest.api import AidrPredictiveApi
+from hiddenlayer.sdk.rest.api.sensor_api import SensorApi
 from hiddenlayer.sdk.rest.api_client import ApiClient
 from hiddenlayer.sdk.rest.models import (
     SubmissionResponse,
     SubmissionV2,
 )
+from hiddenlayer.sdk.rest.models.create_sensor_request import CreateSensorRequest
+from hiddenlayer.sdk.rest.models.sensor import Sensor
+from hiddenlayer.sdk.rest.models.sensor_sor_query_filter import SensorSORQueryFilter
+from hiddenlayer.sdk.rest.models.sensor_sor_query_request import SensorSORQueryRequest
 
 
 class AIDRPredictive:
     def __init__(self, api_client: ApiClient) -> None:
+        self._sensor_api = SensorApi(api_client=api_client)
         self._aidr_predictive = AidrPredictiveApi(api_client=api_client)
 
     def submit_vectors(
         self,
         *,
-        model_id: str,
+        sensor_id: str,
         requester_id: str,
         input_vectors: Union[List[float], np.ndarray],
         output: Union[List[float], np.ndarray],
@@ -31,7 +38,7 @@ class AIDRPredictive:
         """
         Submit feature vectors and model outputs via the HiddenLayer API.
 
-        :param model_id: Model id.
+        :param sensor_id: Sensor id.
         :param requester_id: Custom identifier for the inbound request. This should be a value that can be used to identify individual users interacting with the model.
         :param input_vectors: Feature vectors for your model.
         :param output: Output vectors directly from your model.
@@ -60,7 +67,7 @@ class AIDRPredictive:
             SubmissionV2(
                 metadata=metadata if metadata else {},
                 tags=tags if tags else [],
-                sensor_id=model_id,
+                sensor_id=sensor_id,
                 requester_id=requester_id,
                 input_layer=input_layer,
                 input_layer_dtype=str(input_vectors.dtype),
@@ -74,3 +81,50 @@ class AIDRPredictive:
                 else str(datetime.now().isoformat()),
             )
         )
+
+    def create_sensor(self, *, sensor_name: str) -> Sensor:
+        """
+        Creates a sensor in the HiddenLayer Platform.
+
+        :params sensor_name: Name of the sensor
+
+        :returns: HiddenLayer Sensor
+        """
+        return self._sensor_api.create_sensor(
+            CreateSensorRequest(plaintext_name=sensor_name)
+        )
+
+    def get_sensor(self, *, sensor_name: str) -> Sensor:
+        """
+        Gets a HiddenLayer sensor object.
+
+        :params sensor_name: Name of the sensor
+
+        :returns: HiddenLayer Sensor
+        """
+
+        return self._get_sensor_by_name(sensor_name=sensor_name)
+
+    def _get_sensor_by_name(self, *, sensor_name: str) -> Sensor:
+        """
+        Gets a model sensor by name.
+
+        :param sensor_name: Name of the model.
+
+        :returns: HiddenLayer Model object
+        """
+
+        sensors = self._sensor_api.query_sensor(
+            sensor_sor_query_request=SensorSORQueryRequest(
+                filter=SensorSORQueryFilter(plaintext_name=sensor_name)
+            )
+        )
+
+        if not sensors.results or len(sensors.results) == 0:
+            msg = f"ModSensorel {sensor_name} does not exist"
+
+            raise SensorDoesNotExistError(msg)
+
+        sensors.results.sort(key=lambda x: x.version, reverse=True)
+
+        return sensors.results[0]

hiddenlayer/sdk/services/model_scan.py

@@ -1,26 +1,18 @@
-import json
 import os
 import random
 import tempfile
 import time
-import warnings
 import zipfile
-from datetime import datetime
 from pathlib import Path
 from typing import List, Optional, Union
-from uuid import uuid4
-
-from pydantic_core import ValidationError
 
 from hiddenlayer.sdk.constants import ScanStatus
-from hiddenlayer.sdk.models import EmptyScanResults, Sarif, ScanResults
-from hiddenlayer.sdk.rest.api import ModelScanApi, ModelSupplyChainApi, SensorApi
+from hiddenlayer.sdk.models import EmptyScanResults, ScanResults
+from hiddenlayer.sdk.rest.api import ModelSupplyChainApi
 from hiddenlayer.sdk.rest.api_client import ApiClient
-from hiddenlayer.sdk.rest.models import MultipartUploadPart
-from hiddenlayer.sdk.rest.models.model import Model
-from hiddenlayer.sdk.rest.models.sarif210 import Sarif210
-from hiddenlayer.sdk.services.model import ModelAPI
-from hiddenlayer.sdk.utils import filter_path_objects, is_saas
+from hiddenlayer.sdk.rest.exceptions import NotFoundException
+from hiddenlayer.sdk.rest.models import MultiFileUploadRequestV3
+from hiddenlayer.sdk.utils import filter_path_objects
 
 EXCLUDE_FILE_TYPES = [
     "*.txt",
@@ -37,22 +29,14 @@ EXCLUDE_FILE_TYPES = [
 class ModelScanAPI:
     def __init__(self, api_client: ApiClient) -> None:
         self._api_client = api_client
-
         self._model_supply_chain_api = ModelSupplyChainApi(api_client=api_client)
-        self._model_api = ModelAPI(api_client=api_client)
-        self._sensor_api = SensorApi(
-            api_client=api_client
-        )  # lower level api of ModelAPI
-
-        self._model_scan_api = ModelScanApi(api_client=api_client)
 
     def scan_file(
         self,
         *,
         model_name: str,
         model_path: Union[str, os.PathLike],
-        model_version: Optional[int] = None,
-        chunk_size: int = 16,
+        model_version: str = "1",
         wait_for_results: bool = True,
     ) -> ScanResults:
         """
@@ -69,52 +53,22 @@ class ModelScanAPI:
 
         file_path = Path(model_path)
 
-        filesize = file_path.stat().st_size
-        sensor = self._model_api.create_or_get(
-            model_name=model_name, model_version=model_version
+        request = MultiFileUploadRequestV3(
+            model_name=model_name,
+            model_version=model_version,
+            requesting_entity="hiddenlayer-python-sdk",
         )
-        upload = self._sensor_api.begin_multipart_upload(sensor.sensor_id, filesize)
-
-        with open(file_path, "rb") as f:
-            for i in range(0, len(upload.parts), chunk_size):
-                group: List[MultipartUploadPart] = upload.parts[i : i + chunk_size]
-                for part in group:
-                    read_amount = part.end_offset - part.start_offset
-                    f.seek(int(part.start_offset))
-                    part_data = f.read(int(read_amount))
-
-                    # The SaaS multipart upload returns a upload url for each part
-                    # So there is no specified route
-                    self._api_client.call_api(
-                        "PUT",
-                        part.upload_url,
-                        body=part_data,
-                        header_params={"Content-Type": "application/octet-binary"},
-                    )
-
-        self._sensor_api.complete_multipart_upload(sensor.sensor_id, upload.upload_id)
-
-        self._model_scan_api.scan_model(sensor.sensor_id)
-
-        scan_results = self.get_scan_results(
-            model_name=model_name, model_version=model_version
+        response = self._model_supply_chain_api.begin_multi_file_upload(
+            multi_file_upload_request_v3=request
         )
+        scan_id = response.scan_id
+        if scan_id is None:
+            raise Exception("scan_id must have a value")
 
-        base_delay = 0.1  # seconds
-        retries = 0
-        if wait_for_results:
-            print(f"{file_path.name} scan status: {scan_results.status}")
-            while scan_results.status not in [ScanStatus.DONE, ScanStatus.FAILED]:
-                retries += 1
-                delay = base_delay * 2**retries + random.uniform(
-                    0, 1
-                )  # exponential back off retry
-                time.sleep(delay)
-                scan_results = self.get_scan_results(
-                    model_name=model_name, model_version=model_version
-                )
-                print(f"{file_path.name} scan status: {scan_results.status}")
+        self._scan_file(scan_id=scan_id, file_path=file_path)
 
+        self._model_supply_chain_api.complete_multi_file_upload(scan_id=scan_id)
+        scan_results = self._wait_for_scan_results(scan_id=scan_id)
         scan_results.file_name = file_path.name
         scan_results.file_path = str(file_path)
 
@@ -126,9 +80,8 @@ class ModelScanAPI:
         model_name: str,
         bucket: str,
         key: str,
-        model_version: Optional[int] = None,
+        model_version: str = "1",
         s3_client: Optional[object] = None,
-        chunk_size: int = 4,
         wait_for_results: bool = True,
     ) -> ScanResults:
         """
@@ -173,7 +126,6 @@ class ModelScanAPI:
             model_path=f"/tmp/{file_name}",
             model_name=model_name,
             model_version=model_version,
-            chunk_size=chunk_size,
             wait_for_results=wait_for_results,
         )
 
@@ -184,10 +136,9 @@ class ModelScanAPI:
         account_url: str,
         container: str,
         blob: str,
-        model_version: Optional[int] = None,
+        model_version: str = "1",
         blob_service_client: Optional[object] = None,
         credential: Optional[object] = None,
-        chunk_size: int = 4,
         wait_for_results: bool = True,
     ) -> ScanResults:
         """
@@ -253,7 +204,6 @@ class ModelScanAPI:
             model_path=f"/tmp/{file_name}",
             model_name=model_name,
             model_version=model_version,
-            chunk_size=chunk_size,
             wait_for_results=wait_for_results,
         )
 
@@ -270,8 +220,6 @@ class ModelScanAPI:
         ignore_file_patterns: Optional[List[str]] = None,
         force_download: bool = False,
         hf_token: Optional[Union[str, bool]] = None,
-        # HL parameters
-        chunk_size: int = 4,
         wait_for_results: bool = True,
     ) -> ScanResults:
         """
@@ -317,21 +265,19 @@ class ModelScanAPI:
             token=hf_token,
         )
 
+        if revision is None:
+            revision = "1"
+
         return self.scan_folder(
             model_name=model_name or repo_id,
+            model_version=revision,
             path=local_dir,
             allow_file_patterns=allow_file_patterns,
             ignore_file_patterns=ignore_file_patterns,
-            chunk_size=chunk_size,
             wait_for_results=wait_for_results,
         )
 
-    def get_scan_results(
-        self,
-        *,
-        model_name: str,
-        model_version: Optional[int] = None,
-    ) -> ScanResults:
+    def get_scan_results(self, *, scan_id: str) -> ScanResults:
         """
         Get results from a model scan.
 
@@ -341,48 +287,17 @@ class ModelScanAPI:
         :returns: Scan results.
         """
 
-        response = self._sensor_api.sensor_sor_api_v3_model_cards_query_get(
-            model_name_eq=model_name, limit=1
-        )
-        model_id = response.results[0].model_id
-
-        scans = self._model_supply_chain_api.model_scan_api_v3_scan_query(
-            model_ids=[model_id], latest_per_model_version_only=True
-        )
-        if scans.total == 0:
-            return EmptyScanResults()
-
-        if scans.items is None:
-            return EmptyScanResults()
-
-        scan = scans.items[0]
-        if model_version:
-            scan = next(
-                (
-                    s
-                    for s in scans.items
-                    if s.inventory.model_version == str(model_version)
-                ),
-                None,
-            )
-        if not scan:
+        try:
+            scan_report = self._model_supply_chain_api.get_scan_results(scan_id)
+        except NotFoundException:
             return EmptyScanResults()
 
-        scan_report = (
-            self._model_supply_chain_api.model_scan_api_v3_scan_model_version_id_get(
-                scan.scan_id
-            )
-        )
-
-        return ScanResults.from_scanreportv3(
-            scan_report_v3=scan_report, model_id=model_id
-        )
+        return ScanResults.from_scanreportv3(scan_report_v3=scan_report)
 
     def get_sarif_results(
         self,
         *,
-        model_name: str,
-        model_version: Optional[int] = None,
+        scan_id: str,
     ) -> Optional[str]:
         """
         Get sarif results from a model scan.
@@ -392,34 +307,31 @@ class ModelScanAPI:
 
         :returns: Scan results.
         """
-        scan = self.get_scan_results(model_name=model_name, model_version=model_version)
-        if scan.scan_id == "":
-            return None
 
         # Unfortunately, the generated code for the API doesn't directly support modifying the Accept header
         # in order to enable us to get the Sarif results
         # Here we will reach in to the request serialization process. The 2nd element in the tuple is the headers
         # where we will modify the Accept header to application/sarif+json
-        request = self._model_supply_chain_api._model_scan_api_v3_scan_model_version_id_get_serialize(
-            scan.scan_id, None, None, None, None, 0
+        request = self._model_supply_chain_api._get_scan_results_serialize(
+            scan_id, None, None, None, None, 0
         )
         request[2]["Accept"] = "application/sarif+json"
         response = self._api_client.call_api(*request)
         response.read()
 
-        return self._api_client.response_deserialize(
-            response_data=response, response_types_map={"200": str}
-        ).data  # type: ignore
+        if response.data is None:
+            return None
+
+        return response.data.decode()
 
     def scan_folder(
         self,
         *,
         model_name: str,
         path: Union[str, os.PathLike],
-        model_version: Optional[int] = None,
+        model_version: str = "1",
         allow_file_patterns: Optional[List[str]] = None,
         ignore_file_patterns: Optional[List[str]] = None,
-        chunk_size: int = 4,
         wait_for_results: bool = True,
     ) -> ScanResults:
         """
@@ -437,7 +349,18 @@ class ModelScanAPI:
         """
 
         model_path = Path(path)
-        filename = tempfile.NamedTemporaryFile().name + ".zip"
+
+        request = MultiFileUploadRequestV3(
+            model_name=model_name,
+            model_version=model_version,
+            requesting_entity="hiddenlayer-python-sdk",
+        )
+        response = self._model_supply_chain_api.begin_multi_file_upload(
+            multi_file_upload_request_v3=request
+        )
+        scan_id = response.scan_id
+        if scan_id is None:
+            raise Exception("scan_id must have a value")
 
         ignore_file_patterns = (
             EXCLUDE_FILE_TYPES + ignore_file_patterns
@@ -451,14 +374,54 @@ class ModelScanAPI:
             ignore_patterns=ignore_file_patterns,
         )
 
-        with zipfile.ZipFile(filename, "a") as zipf:
-            for file in files:
-                zipf.write(file, os.path.relpath(file, model_path))
+        for file in files:
+            self._scan_file(scan_id=scan_id, file_path=Path(file))
 
-        return self.scan_file(
-            model_name=model_name,
-            model_version=model_version,
-            model_path=filename,
-            chunk_size=chunk_size,
-            wait_for_results=wait_for_results,
+        self._model_supply_chain_api.complete_multi_file_upload(scan_id=scan_id)
+        scan_results = self._wait_for_scan_results(scan_id=scan_id)
+
+        return scan_results
+
+    def _scan_file(self, *, scan_id: str, file_path: Path):
+        filesize = file_path.stat().st_size
+        upload = self._model_supply_chain_api.begin_multipart_file_upload(
+            scan_id=str(scan_id), file_name=str(file_path), file_content_length=filesize
         )
+
+        with open(file_path, "rb") as f:
+            for part in upload.parts:
+                if part.start_offset is None:
+                    raise Exception("part must have a start_offset")
+                if part.stop_offset is not None:
+                    read_amount = part.stop_offset - part.start_offset
+                else:
+                    read_amount = None
+                f.seek(part.start_offset)
+                part_data = f.read(read_amount)
+                self._api_client.call_api(
+                    "PUT",
+                    part.upload_url,
+                    body=part_data,
+                    header_params={"Content-Type": "application/octet-binary"},
+                )
+
+            self._model_supply_chain_api.complete_multipart_file_upload(
+                scan_id=scan_id, file_id=upload.upload_id
+            )
+
+    def _wait_for_scan_results(self, *, scan_id: str):
+        scan_results = self.get_scan_results(scan_id=scan_id)
+
+        base_delay = 0.1  # seconds
+        retries = 0
+        print(f"scan status: {scan_results.status}")
+        while scan_results.status not in [ScanStatus.DONE, ScanStatus.FAILED]:
+            retries += 1
+            delay = base_delay * 2**retries + random.uniform(
+                0, 1
+            )  # exponential back off retry
+            time.sleep(delay)
+            scan_results = self.get_scan_results(scan_id=scan_id)
+            print(f"scan status: {scan_results.status}")
+
+        return scan_results

hiddenlayer/sdk/version.py

@@ -1 +1 @@
-VERSION = "1.2.1"
+VERSION = "2.0.1"