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

hiddenlayer/sdk/rest/models/model_inventory_info.py

@@ -0,0 +1,99 @@
+# 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, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelInventoryInfo(BaseModel):
+    """
+    information about model and version that this scan relates to
+    """ # noqa: E501
+    model_name: StrictStr = Field(description="name of the model")
+    model_version: StrictStr = Field(description="version of the model")
+    model_source: StrictStr = Field(description="source (provider) info")
+    requested_scan_location: StrictStr = Field(description="Location to be scanned")
+    requesting_entity: Optional[StrictStr] = Field(default=None, description="Entity that requested the scan")
+    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_name", "model_version", "model_source", "requested_scan_location", "requesting_entity", "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 ModelInventoryInfo 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 ModelInventoryInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "model_name": obj.get("model_name"),
+            "model_version": obj.get("model_version"),
+            "model_source": obj.get("model_source"),
+            "requested_scan_location": obj.get("requested_scan_location"),
+            "requesting_entity": obj.get("requesting_entity"),
+            "model_id": obj.get("model_id"),
+            "model_version_id": obj.get("model_version_id")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/model_query_response.py

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

hiddenlayer/sdk/rest/models/model_scan_api_v3_scan_model_version_id_patch200_response.py

@@ -0,0 +1,87 @@
+# 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 ModelScanApiV3ScanModelVersionIdPatch200Response(BaseModel):
+    """
+    ModelScanApiV3ScanModelVersionIdPatch200Response
+    """ # noqa: E501
+    message: StrictStr = Field(description="Request to resource is successful")
+    __properties: ClassVar[List[str]] = ["message"]
+
+    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 ModelScanApiV3ScanModelVersionIdPatch200Response 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 ModelScanApiV3ScanModelVersionIdPatch200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message")
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/model_scan_api_v3_scan_query200_response.py

@@ -0,0 +1,102 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.scan_report_v3 import ScanReportV3
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelScanApiV3ScanQuery200Response(BaseModel):
+    """
+    ModelScanApiV3ScanQuery200Response
+    """ # noqa: E501
+    items: Optional[List[ScanReportV3]] = None
+    total: Union[Annotated[float, Field(strict=True, ge=0)], Annotated[int, Field(strict=True, ge=0)]] = Field(description="Total number of items available based on the query criteria.")
+    limit: Annotated[int, Field(le=100, strict=True, ge=1)] = Field(description="Maximum number of items to return")
+    offset: Annotated[int, Field(strict=True, ge=0)] = Field(description="Begin returning the results from this offset")
+    __properties: ClassVar[List[str]] = ["items", "total", "limit", "offset"]
+
+    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 ModelScanApiV3ScanQuery200Response 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 items (list)
+        _items = []
+        if self.items:
+            for _item in self.items:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ModelScanApiV3ScanQuery200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "items": [ScanReportV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "total": obj.get("total"),
+            "limit": obj.get("limit") if obj.get("limit") is not None else 25,
+            "offset": obj.get("offset") if obj.get("offset") is not None else 0
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/multiformat_message_string.py

@@ -0,0 +1,95 @@
+# 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, Optional
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MultiformatMessageString(BaseModel):
+    """
+    A message string or message format string rendered in multiple formats.
+    """ # noqa: E501
+    text: StrictStr = Field(description="A plain text message string or format string.")
+    markdown: Optional[StrictStr] = Field(default=None, description="A Markdown message string or format string.")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["text", "markdown", "properties"]
+
+    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 MultiformatMessageString 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 properties
+        if self.properties:
+            _dict['properties'] = self.properties.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MultiformatMessageString from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "text": obj.get("text"),
+            "markdown": obj.get("markdown"),
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/multipart_upload_part.py

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

hiddenlayer/sdk/rest/models/node.py

@@ -0,0 +1,122 @@
+# 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, Optional
+from typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.location import Location
+from hiddenlayer.sdk.rest.models.message import Message
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Node(BaseModel):
+    """
+    Represents a node in a graph.
+    """ # noqa: E501
+    id: StrictStr = Field(description="A string that uniquely identifies the node within its graph.")
+    label: Optional[Message] = None
+    location: Optional[Location] = None
+    children: Optional[Annotated[List[Node], Field(min_length=0)]] = Field(default=None, description="Array of child nodes.")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["id", "label", "location", "children", "properties"]
+
+    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 Node 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 label
+        if self.label:
+            _dict['label'] = self.label.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of location
+        if self.location:
+            _dict['location'] = self.location.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in children (list)
+        _items = []
+        if self.children:
+            for _item in self.children:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['children'] = _items
+        # override the default output from pydantic by calling `to_dict()` of properties
+        if self.properties:
+            _dict['properties'] = self.properties.to_dict()
+        # set to None if label (nullable) is None
+        # and model_fields_set contains the field
+        if self.label is None and "label" in self.model_fields_set:
+            _dict['label'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Node from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "label": Message.from_dict(obj["label"]) if obj.get("label") is not None else None,
+            "location": Location.from_dict(obj["location"]) if obj.get("location") is not None else None,
+            "children": [Node.from_dict(_item) for _item in obj["children"]] if obj.get("children") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+Node.model_rebuild(raise_errors=False)
+

hiddenlayer/sdk/rest/models/notification.py

@@ -0,0 +1,157 @@
+# 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 typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.exception import Exception
+from hiddenlayer.sdk.rest.models.location import Location
+from hiddenlayer.sdk.rest.models.message import Message
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.reporting_descriptor_reference import ReportingDescriptorReference
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Notification(BaseModel):
+    """
+    Describes a condition relevant to the tool itself, as opposed to being relevant to a target being analyzed by the tool.
+    """ # noqa: E501
+    locations: Optional[Annotated[List[Location], Field(min_length=0)]] = Field(default=None, description="The locations relevant to this notification.")
+    message: Optional[Message]
+    level: Optional[StrictStr] = Field(default='warning', description="A value specifying the severity level of the notification.")
+    thread_id: Optional[StrictInt] = Field(default=None, description="The thread identifier of the code that generated the notification.", alias="threadId")
+    time_utc: Optional[datetime] = Field(default=None, description="The Coordinated Universal Time (UTC) date and time at which the analysis tool generated the notification.", alias="timeUtc")
+    exception: Optional[Exception] = None
+    descriptor: Optional[ReportingDescriptorReference] = None
+    associated_rule: Optional[ReportingDescriptorReference] = Field(default=None, alias="associatedRule")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["locations", "message", "level", "threadId", "timeUtc", "exception", "descriptor", "associatedRule", "properties"]
+
+    @field_validator('level')
+    def level_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['none', 'note', 'warning', 'error']):
+            raise ValueError("must be one of enum values ('none', 'note', 'warning', 'error')")
+        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 Notification 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 locations (list)
+        _items = []
+        if self.locations:
+            for _item in self.locations:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['locations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of message
+        if self.message:
+            _dict['message'] = self.message.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of exception
+        if self.exception:
+            _dict['exception'] = self.exception.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of descriptor
+        if self.descriptor:
+            _dict['descriptor'] = self.descriptor.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of associated_rule
+        if self.associated_rule:
+            _dict['associatedRule'] = self.associated_rule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of properties
+        if self.properties:
+            _dict['properties'] = self.properties.to_dict()
+        # set to None if message (nullable) is None
+        # and model_fields_set contains the field
+        if self.message is None and "message" in self.model_fields_set:
+            _dict['message'] = None
+
+        # set to None if descriptor (nullable) is None
+        # and model_fields_set contains the field
+        if self.descriptor is None and "descriptor" in self.model_fields_set:
+            _dict['descriptor'] = None
+
+        # set to None if associated_rule (nullable) is None
+        # and model_fields_set contains the field
+        if self.associated_rule is None and "associated_rule" in self.model_fields_set:
+            _dict['associatedRule'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Notification from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "locations": [Location.from_dict(_item) for _item in obj["locations"]] if obj.get("locations") is not None else None,
+            "message": Message.from_dict(obj["message"]) if obj.get("message") is not None else None,
+            "level": obj.get("level") if obj.get("level") is not None else 'warning',
+            "threadId": obj.get("threadId"),
+            "timeUtc": obj.get("timeUtc"),
+            "exception": Exception.from_dict(obj["exception"]) if obj.get("exception") is not None else None,
+            "descriptor": ReportingDescriptorReference.from_dict(obj["descriptor"]) if obj.get("descriptor") is not None else None,
+            "associatedRule": ReportingDescriptorReference.from_dict(obj["associatedRule"]) if obj.get("associatedRule") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+