hiddenlayer-sdk 0.1.0__py3-none-any.whl

hiddenlayer/sdk/rest/models/scan_results_v2.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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
+from hiddenlayer.sdk.rest.models.file_info import FileInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScanResultsV2(BaseModel):
+    """
+    ScanResultsV2
+    """ # noqa: E501
+    scan_id: StrictStr
+    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"]
+
+    @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')")
+        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 ScanResultsV2 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 results
+        if self.results:
+            _dict['results'] = self.results.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ScanResultsV2 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"),
+            "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")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/sensor_sor_query_filter.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SensorSORQueryFilter(BaseModel):
+    """
+    SensorSORQueryFilter
+    """ # noqa: E501
+    plaintext_name: Optional[StrictStr] = None
+    active: Optional[StrictBool] = None
+    version: Optional[StrictInt] = None
+    created_at_start: Optional[datetime] = None
+    created_at_stop: Optional[datetime] = None
+    source: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["plaintext_name", "active", "version", "created_at_start", "created_at_stop", "source"]
+
+    @field_validator('source')
+    def source_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['adhoc']):
+            raise ValueError("must be one of enum values ('adhoc')")
+        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 SensorSORQueryFilter 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 SensorSORQueryFilter from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "plaintext_name": obj.get("plaintext_name"),
+            "active": obj.get("active"),
+            "version": obj.get("version"),
+            "created_at_start": obj.get("created_at_start"),
+            "created_at_stop": obj.get("created_at_stop"),
+            "source": obj.get("source")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/sensor_sor_query_request.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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.sensor_sor_query_filter import SensorSORQueryFilter
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SensorSORQueryRequest(BaseModel):
+    """
+    SensorSORQueryRequest
+    """ # noqa: E501
+    filter: Optional[SensorSORQueryFilter] = None
+    order_by: Optional[StrictStr] = 'created_at'
+    order_dir: Optional[StrictStr] = None
+    page_size: Optional[StrictInt] = 25
+    page_number: Optional[StrictInt] = 0
+    __properties: ClassVar[List[str]] = ["filter", "order_by", "order_dir", "page_size", "page_number"]
+
+    @field_validator('order_dir')
+    def order_dir_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['asc', 'desc', 'ASC', 'DESC']):
+            raise ValueError("must be one of enum values ('asc', 'desc', 'ASC', 'DESC')")
+        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 SensorSORQueryRequest 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 filter
+        if self.filter:
+            _dict['filter'] = self.filter.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SensorSORQueryRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "filter": SensorSORQueryFilter.from_dict(obj["filter"]) if obj.get("filter") is not None else None,
+            "order_by": obj.get("order_by") if obj.get("order_by") is not None else 'created_at',
+            "order_dir": obj.get("order_dir"),
+            "page_size": obj.get("page_size") if obj.get("page_size") is not None else 25,
+            "page_number": obj.get("page_number") if obj.get("page_number") is not None else 0
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/submission_response.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SubmissionResponse(BaseModel):
+    """
+    SubmissionResponse
+    """ # noqa: E501
+    tenant_id: StrictStr
+    sensor_id: StrictStr
+    requester_id: StrictStr
+    group_id: StrictStr
+    event_time: StrictStr
+    __properties: ClassVar[List[str]] = ["tenant_id", "sensor_id", "requester_id", "group_id", "event_time"]
+
+    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 SubmissionResponse 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 SubmissionResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "tenant_id": obj.get("tenant_id"),
+            "sensor_id": obj.get("sensor_id"),
+            "requester_id": obj.get("requester_id"),
+            "group_id": obj.get("group_id"),
+            "event_time": obj.get("event_time")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/submission_v2.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SubmissionV2(BaseModel):
+    """
+    SubmissionV2
+    """ # noqa: E501
+    metadata: Optional[Dict[str, Any]] = None
+    tags: Optional[List[StrictStr]] = None
+    sensor_id: StrictStr
+    requester_id: Optional[StrictStr] = 'UNKNOWN'
+    input_layer: StrictStr
+    input_layer_dtype: StrictStr
+    input_layer_shape: List[Union[StrictFloat, StrictInt]]
+    output_layer: StrictStr
+    output_layer_dtype: StrictStr
+    output_layer_shape: List[Union[StrictFloat, StrictInt]]
+    predictions: Optional[List[Union[StrictFloat, StrictInt]]] = None
+    event_time: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["metadata", "tags", "sensor_id", "requester_id", "input_layer", "input_layer_dtype", "input_layer_shape", "output_layer", "output_layer_dtype", "output_layer_shape", "predictions", "event_time"]
+
+    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 SubmissionV2 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 SubmissionV2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "metadata": obj.get("metadata"),
+            "tags": obj.get("tags"),
+            "sensor_id": obj.get("sensor_id"),
+            "requester_id": obj.get("requester_id") if obj.get("requester_id") is not None else 'UNKNOWN',
+            "input_layer": obj.get("input_layer"),
+            "input_layer_dtype": obj.get("input_layer_dtype"),
+            "input_layer_shape": obj.get("input_layer_shape"),
+            "output_layer": obj.get("output_layer"),
+            "output_layer_dtype": obj.get("output_layer_dtype"),
+            "output_layer_shape": obj.get("output_layer_shape"),
+            "predictions": obj.get("predictions"),
+            "event_time": obj.get("event_time")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/validation_error_model.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    HiddenLayer ModelScan
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from hiddenlayer.sdk.rest.models.validation_error_model_loc_inner import ValidationErrorModelLocInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ValidationErrorModel(BaseModel):
+    """
+    ValidationErrorModel
+    """ # noqa: E501
+    loc: List[ValidationErrorModelLocInner]
+    msg: StrictStr
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["loc", "msg", "type"]
+
+    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 ValidationErrorModel 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 loc (list)
+        _items = []
+        if self.loc:
+            for _item in self.loc:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['loc'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ValidationErrorModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "loc": [ValidationErrorModelLocInner.from_dict(_item) for _item in obj["loc"]] if obj.get("loc") is not None else None,
+            "msg": obj.get("msg"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+