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

hiddenlayer/sdk/rest/models/paged_response_with_total.py

@@ -0,0 +1,94 @@
+# 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, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PagedResponseWithTotal(BaseModel):
+    """
+    PagedResponseWithTotal
+    """ # noqa: E501
+    items: Optional[List[StrictStr]] = Field(default=None, description="List of items. If no matching items are found, then `[]` will be returned.")
+    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 PagedResponseWithTotal 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 PagedResponseWithTotal from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "items": obj.get("items"),
+            "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/physical_location.py

@@ -0,0 +1,94 @@
+# 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
+from hiddenlayer.sdk.rest.models.address import Address
+from hiddenlayer.sdk.rest.models.artifact_location import ArtifactLocation
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.region import Region
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PhysicalLocation(BaseModel):
+    """
+    A physical location relevant to a result. Specifies a reference to a programming artifact together with a range of bytes or characters within that artifact.
+    """ # noqa: E501
+    address: Optional[Address] = None
+    artifact_location: Optional[ArtifactLocation] = Field(default=None, alias="artifactLocation")
+    region: Optional[Region] = None
+    context_region: Optional[Region] = Field(default=None, alias="contextRegion")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = []
+
+    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 PhysicalLocation 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 PhysicalLocation from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/property_bag.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PropertyBag(BaseModel):
+    """
+    Key/value pairs that provide additional information about the object.
+    """ # noqa: E501
+    tags: Optional[Annotated[List[StrictStr], Field(min_length=0)]] = Field(default=None, description="A set of distinct strings that provide additional information.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["tags"]
+
+    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 PropertyBag 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PropertyBag from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "tags": obj.get("tags")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

hiddenlayer/sdk/rest/models/rectangle.py

@@ -0,0 +1,110 @@
+# 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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+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 Rectangle(BaseModel):
+    """
+    An area within an image.
+    """ # noqa: E501
+    top: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The Y coordinate of the top edge of the rectangle, measured in the image's natural units.")
+    left: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The X coordinate of the left edge of the rectangle, measured in the image's natural units.")
+    bottom: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The Y coordinate of the bottom edge of the rectangle, measured in the image's natural units.")
+    right: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The X coordinate of the right edge of the rectangle, measured in the image's natural units.")
+    message: Optional[Message] = None
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["top", "left", "bottom", "right", "message", "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 Rectangle 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 message
+        if self.message:
+            _dict['message'] = self.message.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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Rectangle from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "top": obj.get("top"),
+            "left": obj.get("left"),
+            "bottom": obj.get("bottom"),
+            "right": obj.get("right"),
+            "message": Message.from_dict(obj["message"]) if obj.get("message") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/region.py

@@ -0,0 +1,127 @@
+# 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.artifact_content import ArtifactContent
+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 Region(BaseModel):
+    """
+    A region within an artifact where a result was detected.
+    """ # noqa: E501
+    start_line: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=None, description="The line number of the first character in the region.", alias="startLine")
+    start_column: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=None, description="The column number of the first character in the region.", alias="startColumn")
+    end_line: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=None, description="The line number of the last character in the region.", alias="endLine")
+    end_column: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=None, description="The column number of the character following the end of the region.", alias="endColumn")
+    char_offset: Optional[Annotated[int, Field(strict=True, ge=-1)]] = Field(default=-1, description="The zero-based offset from the beginning of the artifact of the first character in the region.", alias="charOffset")
+    char_length: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The length of the region in characters.", alias="charLength")
+    byte_offset: Optional[Annotated[int, Field(strict=True, ge=-1)]] = Field(default=-1, description="The zero-based offset from the beginning of the artifact of the first byte in the region.", alias="byteOffset")
+    byte_length: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The length of the region in bytes.", alias="byteLength")
+    snippet: Optional[ArtifactContent] = None
+    message: Optional[Message] = None
+    source_language: Optional[StrictStr] = Field(default=None, description="Specifies the source language, if any, of the portion of the artifact specified by the region object.", alias="sourceLanguage")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["startLine", "startColumn", "endLine", "endColumn", "charOffset", "charLength", "byteOffset", "byteLength", "snippet", "message", "sourceLanguage", "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 Region 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 snippet
+        if self.snippet:
+            _dict['snippet'] = self.snippet.to_dict()
+        # 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 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Region from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "startLine": obj.get("startLine"),
+            "startColumn": obj.get("startColumn"),
+            "endLine": obj.get("endLine"),
+            "endColumn": obj.get("endColumn"),
+            "charOffset": obj.get("charOffset") if obj.get("charOffset") is not None else -1,
+            "charLength": obj.get("charLength"),
+            "byteOffset": obj.get("byteOffset") if obj.get("byteOffset") is not None else -1,
+            "byteLength": obj.get("byteLength"),
+            "snippet": ArtifactContent.from_dict(obj["snippet"]) if obj.get("snippet") is not None else None,
+            "message": Message.from_dict(obj["message"]) if obj.get("message") is not None else None,
+            "sourceLanguage": obj.get("sourceLanguage"),
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+

hiddenlayer/sdk/rest/models/replacement.py

@@ -0,0 +1,103 @@
+# 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
+from hiddenlayer.sdk.rest.models.artifact_content import ArtifactContent
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.region import Region
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Replacement(BaseModel):
+    """
+    The replacement of a single region of an artifact.
+    """ # noqa: E501
+    deleted_region: Region = Field(alias="deletedRegion")
+    inserted_content: Optional[ArtifactContent] = Field(default=None, alias="insertedContent")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["deletedRegion", "insertedContent", "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 Replacement 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 deleted_region
+        if self.deleted_region:
+            _dict['deletedRegion'] = self.deleted_region.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of inserted_content
+        if self.inserted_content:
+            _dict['insertedContent'] = self.inserted_content.to_dict()
+        # 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 Replacement from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "deletedRegion": Region.from_dict(obj["deletedRegion"]) if obj.get("deletedRegion") is not None else None,
+            "insertedContent": ArtifactContent.from_dict(obj["insertedContent"]) if obj.get("insertedContent") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+