hiddenlayer-sdk 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

hiddenlayer/sdk/rest/models/scan_model_ids_v3.py

@@ -0,0 +1,89 @@
+# 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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScanModelIdsV3(BaseModel):
+    """
+    ScanModelIdsV3
+    """ # noqa: E501
+    model_id: StrictStr = Field(description="Unique identifier for the model")
+    model_version_id: StrictStr = Field(description="unique identifier for the model version")
+    __properties: ClassVar[List[str]] = ["model_id", "model_version_id"]
+
+    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 ScanModelIdsV3 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ScanModelIdsV3 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "model_id": obj.get("model_id"),
+            "model_version_id": obj.get("model_version_id")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/scan_model_request.py

@@ -1,7 +1,7 @@
 # coding: utf-8
 
 """
-    HiddenLayer ModelScan
+    HiddenLayer ModelScan V2
 
     HiddenLayer ModelScan API for scanning of models
 

hiddenlayer/sdk/rest/models/scan_report_v3.py

@@ -0,0 +1,139 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from hiddenlayer.sdk.rest.models.file_results_inner import FileResultsInner
+from hiddenlayer.sdk.rest.models.model_inventory_info import ModelInventoryInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScanReportV3(BaseModel):
+    """
+    ScanReportV3
+    """ # noqa: E501
+    file_count: StrictInt = Field(description="number of files scanned")
+    files_with_detections_count: StrictInt = Field(description="number of files with detections found")
+    detection_count: StrictInt = Field(description="number of detections found")
+    detection_categories: Optional[List[StrictStr]] = Field(default=None, description="list of detection categories found")
+    inventory: ModelInventoryInfo
+    version: StrictStr = Field(description="scanner version")
+    scan_id: StrictStr = Field(description="unique identifier for the scan")
+    start_time: datetime = Field(description="time the scan started")
+    end_time: Optional[datetime] = Field(default=None, description="time the scan ended")
+    status: StrictStr = Field(description="status of the scan")
+    severity: Optional[StrictStr] = Field(default=None, description="detection severity")
+    file_results: Optional[List[FileResultsInner]] = None
+    __properties: ClassVar[List[str]] = ["file_count", "files_with_detections_count", "detection_count", "detection_categories", "inventory", "version", "scan_id", "start_time", "end_time", "status", "severity", "file_results"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['pending', 'running', 'done', 'failed', 'canceled']):
+            raise ValueError("must be one of enum values ('pending', 'running', 'done', 'failed', 'canceled')")
+        return value
+
+    @field_validator('severity')
+    def severity_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['low', 'medium', 'high', 'critical', 'safe', 'unknown']):
+            raise ValueError("must be one of enum values ('low', 'medium', 'high', 'critical', 'safe', 'unknown')")
+        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 ScanReportV3 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 ScanReportV3 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "file_count": obj.get("file_count"),
+            "files_with_detections_count": obj.get("files_with_detections_count"),
+            "detection_count": obj.get("detection_count"),
+            "detection_categories": obj.get("detection_categories"),
+            "inventory": ModelInventoryInfo.from_dict(obj["inventory"]) if obj.get("inventory") is not None else None,
+            "version": obj.get("version"),
+            "scan_id": obj.get("scan_id"),
+            "start_time": obj.get("start_time"),
+            "end_time": obj.get("end_time"),
+            "status": obj.get("status"),
+            "severity": obj.get("severity"),
+            "file_results": [FileResultsInner.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/{file_info.py → scan_results.py}

@@ -1,7 +1,7 @@
 # coding: utf-8
 
 """
-    HiddenLayer ModelScan
+    HiddenLayer ModelScan V2
 
     HiddenLayer ModelScan API for scanning of models
 
@@ -22,18 +22,22 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class FileInfo(BaseModel):
+class ScanResults(BaseModel):
     """
-    FileInfo
+    ScanResults
     """ # noqa: E501
     md5: Optional[StrictStr] = None
+    rds_encoding: Optional[StrictStr] = None
+    rds_min_reader_version: Optional[StrictStr] = None
+    rds_version: Optional[StrictStr] = None
+    rds_writer_version: Optional[StrictStr] = None
     sha256: Optional[StrictStr] = None
     type: Optional[StrictStr] = None
     subtype: Optional[List[StrictStr]] = None
     tlsh: Optional[StrictStr] = None
     pickle_modules: Optional[List[StrictStr]] = None
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["md5", "sha256", "type", "subtype", "tlsh", "pickle_modules"]
+    __properties: ClassVar[List[str]] = ["md5", "rds_encoding", "rds_min_reader_version", "rds_version", "rds_writer_version", "sha256", "type", "subtype", "tlsh", "pickle_modules"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -53,7 +57,7 @@ class FileInfo(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of FileInfo from a JSON string"""
+        """Create an instance of ScanResults from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -85,7 +89,7 @@ class FileInfo(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of FileInfo from a dict"""
+        """Create an instance of ScanResults from a dict"""
         if obj is None:
             return None
 
@@ -94,6 +98,10 @@ class FileInfo(BaseModel):
 
         _obj = cls.model_validate({
             "md5": obj.get("md5"),
+            "rds_encoding": obj.get("rds_encoding"),
+            "rds_min_reader_version": obj.get("rds_min_reader_version"),
+            "rds_version": obj.get("rds_version"),
+            "rds_writer_version": obj.get("rds_writer_version"),
             "sha256": obj.get("sha256"),
             "type": obj.get("type"),
             "subtype": obj.get("subtype"),

hiddenlayer/sdk/rest/models/scan_results_v2.py

@@ -1,7 +1,7 @@
 # coding: utf-8
 
 """
-    HiddenLayer ModelScan
+    HiddenLayer ModelScan V2
 
     HiddenLayer ModelScan API for scanning of models
 
@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
-from hiddenlayer.sdk.rest.models.file_info import FileInfo
+from typing import Any, ClassVar, Dict, List, Optional
+from hiddenlayer.sdk.rest.models.detections import Detections
+from hiddenlayer.sdk.rest.models.scan_results import ScanResults
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -31,15 +32,26 @@ class ScanResultsV2(BaseModel):
     status: StrictStr
     start_time: StrictInt
     end_time: StrictInt
-    results: FileInfo
-    detections: List[Dict[str, Any]]
-    __properties: ClassVar[List[str]] = ["scan_id", "status", "start_time", "end_time", "results", "detections"]
+    results: Optional[ScanResults] = None
+    severity: Optional[StrictStr] = None
+    detections: List[Detections]
+    __properties: ClassVar[List[str]] = ["scan_id", "status", "start_time", "end_time", "results", "severity", "detections"]
 
     @field_validator('status')
     def status_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['done', 'accepted', 'failed', 'pending', 'created', 'retry']):
-            raise ValueError("must be one of enum values ('done', 'accepted', 'failed', 'pending', 'created', 'retry')")
+        if value not in set(['done', 'accepted', 'failed', 'pending', 'created', 'retry', 'unknown']):
+            raise ValueError("must be one of enum values ('done', 'accepted', 'failed', 'pending', 'created', 'retry', 'unknown')")
+        return value
+
+    @field_validator('severity')
+    def severity_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['UNKNOWN', 'SAFE', 'SUSPICIOUS', 'MALICIOUS']):
+            raise ValueError("must be one of enum values ('UNKNOWN', 'SAFE', 'SUSPICIOUS', 'MALICIOUS')")
         return value
 
     model_config = ConfigDict(
@@ -84,6 +96,13 @@ class ScanResultsV2(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of results
         if self.results:
             _dict['results'] = self.results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in detections (list)
+        _items = []
+        if self.detections:
+            for _item in self.detections:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['detections'] = _items
         return _dict
 
     @classmethod
@@ -100,8 +119,9 @@ class ScanResultsV2(BaseModel):
             "status": obj.get("status"),
             "start_time": obj.get("start_time"),
             "end_time": obj.get("end_time"),
-            "results": FileInfo.from_dict(obj["results"]) if obj.get("results") is not None else None,
-            "detections": obj.get("detections")
+            "results": ScanResults.from_dict(obj["results"]) if obj.get("results") is not None else None,
+            "severity": obj.get("severity"),
+            "detections": [Detections.from_dict(_item) for _item in obj["detections"]] if obj.get("detections") is not None else None
         })
         return _obj
 

hiddenlayer/sdk/rest/models/security_posture.py

@@ -0,0 +1,89 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SecurityPosture(BaseModel):
+    """
+    SecurityPosture
+    """ # noqa: E501
+    model_scan: Optional[StrictBool] = None
+    attack_monitoring: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["model_scan", "attack_monitoring"]
+
+    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 SecurityPosture 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SecurityPosture from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "model_scan": obj.get("model_scan"),
+            "attack_monitoring": obj.get("attack_monitoring")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/sensor_sor_model_card_query_response.py

@@ -0,0 +1,101 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from hiddenlayer.sdk.rest.models.sensor_sor_model_card_response import SensorSORModelCardResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SensorSORModelCardQueryResponse(BaseModel):
+    """
+    SensorSORModelCardQueryResponse
+    """ # noqa: E501
+    total_count: StrictInt
+    page_size: StrictInt
+    page_number: StrictInt
+    results: List[SensorSORModelCardResponse]
+    __properties: ClassVar[List[str]] = ["total_count", "page_size", "page_number", "results"]
+
+    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 SensorSORModelCardQueryResponse 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 each item in results (list)
+        _items = []
+        if self.results:
+            for _item in self.results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['results'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SensorSORModelCardQueryResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "total_count": obj.get("total_count"),
+            "page_size": obj.get("page_size"),
+            "page_number": obj.get("page_number"),
+            "results": [SensorSORModelCardResponse.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None
+        })
+        return _obj
+
+