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

hiddenlayer/sdk/rest/models/thread_flow.py

@@ -0,0 +1,144 @@
+# 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.message import Message
+from hiddenlayer.sdk.rest.models.multiformat_message_string import MultiformatMessageString
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.thread_flow_location import ThreadFlowLocation
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ThreadFlow(BaseModel):
+    """
+    Describes a sequence of code locations that specify a path through a single thread of execution such as an operating system or fiber.
+    """ # noqa: E501
+    id: Optional[StrictStr] = Field(default=None, description="An string that uniquely identifies the threadFlow within the codeFlow in which it occurs.")
+    message: Optional[Message] = None
+    initial_state: Optional[Dict[str, MultiformatMessageString]] = Field(default=None, description="Values of relevant expressions at the start of the thread flow that may change during thread flow execution.", alias="initialState")
+    immutable_state: Optional[Dict[str, MultiformatMessageString]] = Field(default=None, description="Values of relevant expressions at the start of the thread flow that remain constant.", alias="immutableState")
+    locations: Annotated[List[ThreadFlowLocation], Field(min_length=1)] = Field(description="A temporally ordered array of 'threadFlowLocation' objects, each of which describes a location visited by the tool while producing the result.")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["id", "message", "initialState", "immutableState", "locations", "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 ThreadFlow 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 initial_state (dict)
+        _field_dict = {}
+        if self.initial_state:
+            for _key in self.initial_state:
+                if self.initial_state[_key]:
+                    _field_dict[_key] = self.initial_state[_key].to_dict()
+            _dict['initialState'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in immutable_state (dict)
+        _field_dict = {}
+        if self.immutable_state:
+            for _key in self.immutable_state:
+                if self.immutable_state[_key]:
+                    _field_dict[_key] = self.immutable_state[_key].to_dict()
+            _dict['immutableState'] = _field_dict
+        # 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 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 ThreadFlow 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"),
+            "message": Message.from_dict(obj["message"]) if obj.get("message") is not None else None,
+            "initialState": dict(
+                (_k, MultiformatMessageString.from_dict(_v))
+                for _k, _v in obj["initialState"].items()
+            )
+            if obj.get("initialState") is not None
+            else None,
+            "immutableState": dict(
+                (_k, MultiformatMessageString.from_dict(_v))
+                for _k, _v in obj["immutableState"].items()
+            )
+            if obj.get("immutableState") is not None
+            else None,
+            "locations": [ThreadFlowLocation.from_dict(_item) for _item in obj["locations"]] if obj.get("locations") 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/thread_flow_location.py

@@ -0,0 +1,166 @@
+# 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, StrictStr, field_validator
+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.multiformat_message_string import MultiformatMessageString
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.reporting_descriptor_reference import ReportingDescriptorReference
+from hiddenlayer.sdk.rest.models.stack import Stack
+from hiddenlayer.sdk.rest.models.web_request import WebRequest
+from hiddenlayer.sdk.rest.models.web_response import WebResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ThreadFlowLocation(BaseModel):
+    """
+    A location visited by an analysis tool while simulating or monitoring the execution of a program.
+    """ # noqa: E501
+    index: Optional[Annotated[int, Field(strict=True, ge=-1)]] = Field(default=-1, description="The index within the run threadFlowLocations array.")
+    location: Optional[Location] = None
+    stack: Optional[Stack] = None
+    kinds: Optional[Annotated[List[StrictStr], Field(min_length=0)]] = Field(default=None, description="A set of distinct strings that categorize the thread flow location. Well-known kinds include 'acquire', 'release', 'enter', 'exit', 'call', 'return', 'branch', 'implicit', 'false', 'true', 'caution', 'danger', 'unknown', 'unreachable', 'taint', 'function', 'handler', 'lock', 'memory', 'resource', 'scope' and 'value'.")
+    taxa: Optional[Annotated[List[Optional[ReportingDescriptorReference]], Field(min_length=0)]] = Field(default=None, description="An array of references to rule or taxonomy reporting descriptors that are applicable to the thread flow location.")
+    module: Optional[StrictStr] = Field(default=None, description="The name of the module that contains the code that is executing.")
+    state: Optional[Dict[str, MultiformatMessageString]] = Field(default=None, description="A dictionary, each of whose keys specifies a variable or expression, the associated value of which represents the variable or expression value. For an annotation of kind 'continuation', for example, this dictionary might hold the current assumed values of a set of global variables.")
+    nesting_level: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="An integer representing a containment hierarchy within the thread flow.", alias="nestingLevel")
+    execution_order: Optional[Annotated[int, Field(strict=True, ge=-1)]] = Field(default=-1, description="An integer representing the temporal order in which execution reached this location.", alias="executionOrder")
+    execution_time_utc: Optional[datetime] = Field(default=None, description="The Coordinated Universal Time (UTC) date and time at which this location was executed.", alias="executionTimeUtc")
+    importance: Optional[StrictStr] = Field(default='important', description="Specifies the importance of this location in understanding the code flow in which it occurs. The order from most to least important is \"essential\", \"important\", \"unimportant\". Default: \"important\".")
+    web_request: Optional[WebRequest] = Field(default=None, alias="webRequest")
+    web_response: Optional[WebResponse] = Field(default=None, alias="webResponse")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["index", "location", "stack", "kinds", "taxa", "module", "state", "nestingLevel", "executionOrder", "executionTimeUtc", "importance", "webRequest", "webResponse", "properties"]
+
+    @field_validator('importance')
+    def importance_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['important', 'essential', 'unimportant']):
+            raise ValueError("must be one of enum values ('important', 'essential', 'unimportant')")
+        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 ThreadFlowLocation 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 location
+        if self.location:
+            _dict['location'] = self.location.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of stack
+        if self.stack:
+            _dict['stack'] = self.stack.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in taxa (list)
+        _items = []
+        if self.taxa:
+            for _item in self.taxa:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['taxa'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in state (dict)
+        _field_dict = {}
+        if self.state:
+            for _key in self.state:
+                if self.state[_key]:
+                    _field_dict[_key] = self.state[_key].to_dict()
+            _dict['state'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of web_request
+        if self.web_request:
+            _dict['webRequest'] = self.web_request.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of web_response
+        if self.web_response:
+            _dict['webResponse'] = self.web_response.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 ThreadFlowLocation from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "index": obj.get("index") if obj.get("index") is not None else -1,
+            "location": Location.from_dict(obj["location"]) if obj.get("location") is not None else None,
+            "stack": Stack.from_dict(obj["stack"]) if obj.get("stack") is not None else None,
+            "kinds": obj.get("kinds"),
+            "taxa": [ReportingDescriptorReference.from_dict(_item) for _item in obj["taxa"]] if obj.get("taxa") is not None else None,
+            "module": obj.get("module"),
+            "state": dict(
+                (_k, MultiformatMessageString.from_dict(_v))
+                for _k, _v in obj["state"].items()
+            )
+            if obj.get("state") is not None
+            else None,
+            "nestingLevel": obj.get("nestingLevel"),
+            "executionOrder": obj.get("executionOrder") if obj.get("executionOrder") is not None else -1,
+            "executionTimeUtc": obj.get("executionTimeUtc"),
+            "importance": obj.get("importance") if obj.get("importance") is not None else 'important',
+            "webRequest": WebRequest.from_dict(obj["webRequest"]) if obj.get("webRequest") is not None else None,
+            "webResponse": WebResponse.from_dict(obj["webResponse"]) if obj.get("webResponse") 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/tool.py

@@ -0,0 +1,107 @@
+# 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 typing_extensions import Annotated
+from hiddenlayer.sdk.rest.models.property_bag import PropertyBag
+from hiddenlayer.sdk.rest.models.tool_component import ToolComponent
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Tool(BaseModel):
+    """
+    The analysis tool that was run.
+    """ # noqa: E501
+    driver: ToolComponent
+    extensions: Optional[Annotated[List[ToolComponent], Field(min_length=0)]] = Field(default=None, description="Tool extensions that contributed to or reconfigured the analysis tool that was run.")
+    properties: Optional[PropertyBag] = None
+    __properties: ClassVar[List[str]] = ["driver", "extensions", "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 Tool 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 driver
+        if self.driver:
+            _dict['driver'] = self.driver.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in extensions (list)
+        _items = []
+        if self.extensions:
+            for _item in self.extensions:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['extensions'] = _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 Tool from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "driver": ToolComponent.from_dict(obj["driver"]) if obj.get("driver") is not None else None,
+            "extensions": [ToolComponent.from_dict(_item) for _item in obj["extensions"]] if obj.get("extensions") is not None else None,
+            "properties": PropertyBag.from_dict(obj["properties"]) if obj.get("properties") is not None else None
+        })
+        return _obj
+
+