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

hiddenlayer/sdk/rest/models/reporting_configuration.py

@@ -0,0 +1,113 @@
+# 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, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReportingConfiguration(BaseModel):
+    """
+    Information about a rule or notification that can be configured at runtime.
+    """ # noqa: E501
+    enabled: Optional[StrictBool] = Field(default=True, description="Specifies whether the report may be produced during the scan.")
+    level: Optional[StrictStr] = Field(default='warning', description="Specifies the failure level for the report.")
+    rank: Optional[Union[Annotated[float, Field(le=100, strict=True, ge=-1)], Annotated[int, Field(le=100, strict=True, ge=-1)]]] = Field(default=-1, description="Specifies the relative priority of the report. Used for analysis output only.")
+    parameters: Optional[PropertyBag] = None
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["enabled", "level", "rank", "parameters", "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 ReportingConfiguration 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 parameters
+        if self.parameters:
+            _dict['parameters'] = self.parameters.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 ReportingConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "enabled": obj.get("enabled") if obj.get("enabled") is not None else True,
+            "level": obj.get("level") if obj.get("level") is not None else 'warning',
+            "rank": obj.get("rank") if obj.get("rank") is not None else -1,
+            "parameters": PropertyBag.from_dict(obj["parameters"]) if obj.get("parameters") 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/reporting_descriptor.py

@@ -0,0 +1,162 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.multiformat_message_string import MultiformatMessageString
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.reporting_configuration import ReportingConfiguration
+from hiddenlayer.sdk.rest.models.reporting_descriptor_relationship import ReportingDescriptorRelationship
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReportingDescriptor(BaseModel):
+    """
+    Metadata that describes a specific report produced by the tool, as part of the analysis it provides or its runtime reporting.
+    """ # noqa: E501
+    id: StrictStr = Field(description="A stable, opaque identifier for the report.")
+    deprecated_ids: Optional[Annotated[List[StrictStr], Field(min_length=0)]] = Field(default=None, description="An array of stable, opaque identifiers by which this report was known in some previous version of the analysis tool.", alias="deprecatedIds")
+    guid: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="A unique identifier for the reporting descriptor in the form of a GUID.")
+    deprecated_guids: Optional[Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=0)]] = Field(default=None, description="An array of unique identifies in the form of a GUID by which this report was known in some previous version of the analysis tool.", alias="deprecatedGuids")
+    name: Optional[StrictStr] = Field(default=None, description="A report identifier that is understandable to an end user.")
+    deprecated_names: Optional[Annotated[List[StrictStr], Field(min_length=0)]] = Field(default=None, description="An array of readable identifiers by which this report was known in some previous version of the analysis tool.", alias="deprecatedNames")
+    short_description: Optional[MultiformatMessageString] = Field(default=None, alias="shortDescription")
+    full_description: Optional[MultiformatMessageString] = Field(default=None, alias="fullDescription")
+    message_strings: Optional[Dict[str, MultiformatMessageString]] = Field(default=None, description="A set of name/value pairs with arbitrary names. Each value is a multiformatMessageString object, which holds message strings in plain text and (optionally) Markdown format. The strings can include placeholders, which can be used to construct a message in combination with an arbitrary number of additional string arguments.", alias="messageStrings")
+    default_configuration: Optional[ReportingConfiguration] = Field(default=None, alias="defaultConfiguration")
+    help_uri: Optional[StrictStr] = Field(default=None, description="A URI where the primary documentation for the report can be found.", alias="helpUri")
+    help: Optional[MultiformatMessageString] = None
+    relationships: Optional[Annotated[List[ReportingDescriptorRelationship], Field(min_length=0)]] = Field(default=None, description="An array of objects that describe relationships between this reporting descriptor and others.")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["id", "deprecatedIds", "guid", "deprecatedGuids", "name", "deprecatedNames", "shortDescription", "fullDescription", "messageStrings", "defaultConfiguration", "helpUri", "help", "relationships", "properties"]
+
+    @field_validator('guid')
+    def guid_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/")
+        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 ReportingDescriptor 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 short_description
+        if self.short_description:
+            _dict['shortDescription'] = self.short_description.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of full_description
+        if self.full_description:
+            _dict['fullDescription'] = self.full_description.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in message_strings (dict)
+        _field_dict = {}
+        if self.message_strings:
+            for _key in self.message_strings:
+                if self.message_strings[_key]:
+                    _field_dict[_key] = self.message_strings[_key].to_dict()
+            _dict['messageStrings'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of default_configuration
+        if self.default_configuration:
+            _dict['defaultConfiguration'] = self.default_configuration.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of help
+        if self.help:
+            _dict['help'] = self.help.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in relationships (list)
+        _items = []
+        if self.relationships:
+            for _item in self.relationships:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['relationships'] = _items
+        # 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 ReportingDescriptor 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"),
+            "deprecatedIds": obj.get("deprecatedIds"),
+            "guid": obj.get("guid"),
+            "deprecatedGuids": obj.get("deprecatedGuids"),
+            "name": obj.get("name"),
+            "deprecatedNames": obj.get("deprecatedNames"),
+            "shortDescription": MultiformatMessageString.from_dict(obj["shortDescription"]) if obj.get("shortDescription") is not None else None,
+            "fullDescription": MultiformatMessageString.from_dict(obj["fullDescription"]) if obj.get("fullDescription") is not None else None,
+            "messageStrings": dict(
+                (_k, MultiformatMessageString.from_dict(_v))
+                for _k, _v in obj["messageStrings"].items()
+            )
+            if obj.get("messageStrings") is not None
+            else None,
+            "defaultConfiguration": ReportingConfiguration.from_dict(obj["defaultConfiguration"]) if obj.get("defaultConfiguration") is not None else None,
+            "helpUri": obj.get("helpUri"),
+            "help": MultiformatMessageString.from_dict(obj["help"]) if obj.get("help") is not None else None,
+            "relationships": [ReportingDescriptorRelationship.from_dict(_item) for _item in obj["relationships"]] if obj.get("relationships") 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/reporting_descriptor_reference.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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.tool_component_reference import ToolComponentReference
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReportingDescriptorReference(BaseModel):
+    """
+    Information about how to locate a relevant reporting descriptor.
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="The id of the descriptor.")
+    index: Optional[Annotated[int, Field(strict=True, ge=-1)]] = Field(default=-1, description="The index into an array of descriptors in toolComponent.ruleDescriptors, toolComponent.notificationDescriptors, or toolComponent.taxonomyDescriptors, depending on context.")
+    guid: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="A guid that uniquely identifies the descriptor.")
+    tool_component: Optional[ToolComponentReference] = Field(default=None, alias="toolComponent")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = []
+
+    @field_validator('guid')
+    def guid_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/")
+        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 ReportingDescriptorReference 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 ReportingDescriptorReference 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/reporting_descriptor_relationship.py

@@ -0,0 +1,115 @@
+# 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.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 ReportingDescriptorRelationship(BaseModel):
+    """
+    Information about the relation of one reporting descriptor to another.
+    """ # noqa: E501
+    target: Optional[ReportingDescriptorReference]
+    kinds: Optional[List[StrictStr]] = Field(default=None, description="A set of distinct strings that categorize the relationship. Well-known kinds include 'canPrecede', 'canFollow', 'willPrecede', 'willFollow', 'superset', 'subset', 'equal', 'disjoint', 'relevant', and 'incomparable'.")
+    description: Optional[Message] = None
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["target", "kinds", "description", "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 ReportingDescriptorRelationship 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 target
+        if self.target:
+            _dict['target'] = self.target.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of description
+        if self.description:
+            _dict['description'] = self.description.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 target (nullable) is None
+        # and model_fields_set contains the field
+        if self.target is None and "target" in self.model_fields_set:
+            _dict['target'] = None
+
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReportingDescriptorRelationship from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "target": ReportingDescriptorReference.from_dict(obj["target"]) if obj.get("target") is not None else None,
+            "kinds": obj.get("kinds"),
+            "description": Message.from_dict(obj["description"]) if obj.get("description") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+