hiddenlayer-sdk 2.0.9__py3-none-any.whl → 3.0.0__py3-none-any.whl

hiddenlayer/sdk/rest/models/configuration_override.py

@@ -1,108 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    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
-from typing import Any, ClassVar, Dict, List, Optional
-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_reference import ReportingDescriptorReference
-from typing import Optional, Set
-from typing_extensions import Self
-
-class ConfigurationOverride(BaseModel):
-    """
-    Information about how a specific rule or notification was reconfigured at runtime.
-    """ # noqa: E501
-    configuration: ReportingConfiguration
-    descriptor: Optional[ReportingDescriptorReference]
-    properties: Optional[PropertyBag] = None
-    __properties: ClassVar[List[str]] = ["configuration", "descriptor", "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 ConfigurationOverride 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 configuration
-        if self.configuration:
-            _dict['configuration'] = self.configuration.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 properties
-        if self.properties:
-            _dict['properties'] = self.properties.to_dict()
-        # 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
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ConfigurationOverride from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "configuration": ReportingConfiguration.from_dict(obj["configuration"]) if obj.get("configuration") is not None else None,
-            "descriptor": ReportingDescriptorReference.from_dict(obj["descriptor"]) if obj.get("descriptor") 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/conversion.py

@@ -1,114 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    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 typing_extensions import Annotated
-from hiddenlayer.sdk.rest.models.artifact_location import ArtifactLocation
-from hiddenlayer.sdk.rest.models.invocation import Invocation
-from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
-from hiddenlayer.sdk.rest.models.tool import Tool
-from typing import Optional, Set
-from typing_extensions import Self
-
-class Conversion(BaseModel):
-    """
-    Describes how a converter transformed the output of a static analysis tool from the analysis tool's native output format into the SARIF format.
-    """ # noqa: E501
-    tool: Tool
-    invocation: Optional[Invocation] = None
-    analysis_tool_log_files: Optional[Annotated[List[ArtifactLocation], Field(min_length=0)]] = Field(default=None, description="The locations of the analysis tool's per-run log files.", alias="analysisToolLogFiles")
-    properties: Optional[PropertyBag] = None
-    __properties: ClassVar[List[str]] = ["tool", "invocation", "analysisToolLogFiles", "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 Conversion 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 tool
-        if self.tool:
-            _dict['tool'] = self.tool.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of invocation
-        if self.invocation:
-            _dict['invocation'] = self.invocation.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in analysis_tool_log_files (list)
-        _items = []
-        if self.analysis_tool_log_files:
-            for _item in self.analysis_tool_log_files:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['analysisToolLogFiles'] = _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 Conversion from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "tool": Tool.from_dict(obj["tool"]) if obj.get("tool") is not None else None,
-            "invocation": Invocation.from_dict(obj["invocation"]) if obj.get("invocation") is not None else None,
-            "analysisToolLogFiles": [ArtifactLocation.from_dict(_item) for _item in obj["analysisToolLogFiles"]] if obj.get("analysisToolLogFiles") 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/create_sensor_request.py

@@ -1,95 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    The version of the OpenAPI document: 1
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from typing import Optional, Set
-from typing_extensions import Self
-
-class CreateSensorRequest(BaseModel):
-    """
-    CreateSensorRequest
-    """ # noqa: E501
-    plaintext_name: StrictStr
-    version: Optional[StrictInt] = None
-    active: Optional[StrictBool] = True
-    tags: Optional[Dict[str, Any]] = None
-    adhoc: Optional[StrictBool] = False
-    __properties: ClassVar[List[str]] = ["plaintext_name", "version", "active", "tags", "adhoc"]
-
-    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 CreateSensorRequest 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 CreateSensorRequest 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"),
-            "version": obj.get("version"),
-            "active": obj.get("active") if obj.get("active") is not None else True,
-            "tags": obj.get("tags"),
-            "adhoc": obj.get("adhoc") if obj.get("adhoc") is not None else False
-        })
-        return _obj
-
-

hiddenlayer/sdk/rest/models/edge.py

@@ -1,108 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    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 typing import Optional, Set
-from typing_extensions import Self
-
-class Edge(BaseModel):
-    """
-    Represents a directed edge in a graph.
-    """ # noqa: E501
-    id: StrictStr = Field(description="A string that uniquely identifies the edge within its graph.")
-    label: Optional[Message] = None
-    source_node_id: StrictStr = Field(description="Identifies the source node (the node at which the edge starts).", alias="sourceNodeId")
-    target_node_id: StrictStr = Field(description="Identifies the target node (the node at which the edge ends).", alias="targetNodeId")
-    properties: Optional[PropertyBag] = None
-    __properties: ClassVar[List[str]] = ["id", "label", "sourceNodeId", "targetNodeId", "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 Edge 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 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 Edge 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,
-            "sourceNodeId": obj.get("sourceNodeId"),
-            "targetNodeId": obj.get("targetNodeId"),
-            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
-        })
-        return _obj
-
-

hiddenlayer/sdk/rest/models/edge_traversal.py

@@ -1,122 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    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.message import Message
-from hiddenlayer.sdk.rest.models.multiformat_message_string import MultiformatMessageString
-from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
-from typing import Optional, Set
-from typing_extensions import Self
-
-class EdgeTraversal(BaseModel):
-    """
-    Represents the traversal of a single edge during a graph traversal.
-    """ # noqa: E501
-    edge_id: StrictStr = Field(description="Identifies the edge being traversed.", alias="edgeId")
-    message: Optional[Message] = None
-    final_state: Optional[Dict[str, MultiformatMessageString]] = Field(default=None, description="The values of relevant expressions after the edge has been traversed.", alias="finalState")
-    step_over_edge_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of edge traversals necessary to return from a nested graph.", alias="stepOverEdgeCount")
-    properties: Optional[PropertyBag] = None
-    __properties: ClassVar[List[str]] = ["edgeId", "message", "finalState", "stepOverEdgeCount", "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 EdgeTraversal 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 each value in final_state (dict)
-        _field_dict = {}
-        if self.final_state:
-            for _key in self.final_state:
-                if self.final_state[_key]:
-                    _field_dict[_key] = self.final_state[_key].to_dict()
-            _dict['finalState'] = _field_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 EdgeTraversal from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "edgeId": obj.get("edgeId"),
-            "message": Message.from_dict(obj["message"]) if obj.get("message") is not None else None,
-            "finalState": dict(
-                (_k, MultiformatMessageString.from_dict(_v))
-                for _k, _v in obj["finalState"].items()
-            )
-            if obj.get("finalState") is not None
-            else None,
-            "stepOverEdgeCount": obj.get("stepOverEdgeCount"),
-            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
-        })
-        return _obj
-
-

hiddenlayer/sdk/rest/models/errors_inner.py

@@ -1,91 +0,0 @@
-# coding: utf-8
-
-"""
-    HiddenLayer-API
-
-    HiddenLayer-API
-
-    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 ErrorsInner(BaseModel):
-    """
-    ErrorsInner
-    """ # noqa: E501
-    code: Optional[StrictStr] = None
-    detail: Optional[StrictStr] = None
-    pointer: Optional[List[StrictStr]] = Field(default=None, description="array of JSON Pointers")
-    __properties: ClassVar[List[str]] = ["code", "detail", "pointer"]
-
-    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 ErrorsInner 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 ErrorsInner from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "code": obj.get("code"),
-            "detail": obj.get("detail"),
-            "pointer": obj.get("pointer")
-        })
-        return _obj
-
-