revengai 1.1.1__py3-none-any.whl

revengai/models/analysis_create_response.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalysisCreateResponse(BaseModel):
+    """
+    AnalysisCreateResponse
+    """ # noqa: E501
+    analysis_id: StrictInt = Field(description="ID of created analysis")
+    binary_id: StrictInt = Field(description="ID of created binary")
+    __properties: ClassVar[List[str]] = ["analysis_id", "binary_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 AnalysisCreateResponse 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 AnalysisCreateResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analysis_id": obj.get("analysis_id"),
+            "binary_id": obj.get("binary_id")
+        })
+        return _obj
+
+

revengai/models/analysis_detail_response.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.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 revengai.models.analysis_access_info import AnalysisAccessInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalysisDetailResponse(BaseModel):
+    """
+    AnalysisDetailResponse
+    """ # noqa: E501
+    access: AnalysisAccessInfo
+    analysis_id: StrictInt
+    analysis_scope: StrictStr
+    architecture: StrictStr
+    binary_dynamic: StrictBool
+    binary_format: StrictStr
+    binary_name: StrictStr
+    binary_size: StrictInt
+    binary_type: StrictStr
+    creation: StrictStr
+    debug: StrictBool
+    model_name: StrictStr
+    sbom: Optional[Dict[str, Any]] = None
+    sha_256_hash: StrictStr
+    __properties: ClassVar[List[str]] = ["access", "analysis_id", "analysis_scope", "architecture", "binary_dynamic", "binary_format", "binary_name", "binary_size", "binary_type", "creation", "debug", "model_name", "sbom", "sha_256_hash"]
+
+    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 AnalysisDetailResponse 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 access
+        if self.access:
+            _dict['access'] = self.access.to_dict()
+        # set to None if sbom (nullable) is None
+        # and model_fields_set contains the field
+        if self.sbom is None and "sbom" in self.model_fields_set:
+            _dict['sbom'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AnalysisDetailResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "access": AnalysisAccessInfo.from_dict(obj["access"]) if obj.get("access") is not None else None,
+            "analysis_id": obj.get("analysis_id"),
+            "analysis_scope": obj.get("analysis_scope"),
+            "architecture": obj.get("architecture"),
+            "binary_dynamic": obj.get("binary_dynamic"),
+            "binary_format": obj.get("binary_format"),
+            "binary_name": obj.get("binary_name"),
+            "binary_size": obj.get("binary_size"),
+            "binary_type": obj.get("binary_type"),
+            "creation": obj.get("creation"),
+            "debug": obj.get("debug"),
+            "model_name": obj.get("model_name"),
+            "sbom": obj.get("sbom"),
+            "sha_256_hash": obj.get("sha_256_hash")
+        })
+        return _obj
+
+

revengai/models/analysis_form.py

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.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 revengai.models.app_api_rest_v1_analyse_schema_model_name import AppApiRestV1AnalyseSchemaModelName
+from revengai.models.app_api_rest_v1_analyse_schema_symbols import AppApiRestV1AnalyseSchemaSymbols
+from revengai.models.file_options import FileOptions
+from revengai.models.isa_options import IsaOptions
+from revengai.models.platform_options import PlatformOptions
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalysisForm(BaseModel):
+    """
+    Form Model for receiving the analysis request
+    """ # noqa: E501
+    model_name: AppApiRestV1AnalyseSchemaModelName
+    platform_options: Optional[PlatformOptions] = None
+    isa_options: Optional[IsaOptions] = None
+    file_options: Optional[FileOptions] = None
+    dynamic_execution: Optional[StrictBool] = False
+    tags: Optional[List[StrictStr]] = None
+    binary_scope: Optional[StrictStr] = 'PRIVATE'
+    symbols: Optional[AppApiRestV1AnalyseSchemaSymbols] = None
+    file_name: Optional[StrictStr] = 'empty'
+    command_line_args: Optional[StrictStr] = ''
+    priority: Optional[StrictInt] = 0
+    sha_256_hash: Optional[StrictStr] = ''
+    debug_hash: Optional[StrictStr] = None
+    size_in_bytes: StrictInt
+    skip_scraping: Optional[StrictBool] = False
+    skip_cves: Optional[StrictBool] = False
+    skip_sbom: Optional[StrictBool] = False
+    skip_capabilities: Optional[StrictBool] = False
+    ignore_cache: Optional[StrictBool] = False
+    advanced_analysis: Optional[StrictBool] = False
+    __properties: ClassVar[List[str]] = ["model_name", "platform_options", "isa_options", "file_options", "dynamic_execution", "tags", "binary_scope", "symbols", "file_name", "command_line_args", "priority", "sha_256_hash", "debug_hash", "size_in_bytes", "skip_scraping", "skip_cves", "skip_sbom", "skip_capabilities", "ignore_cache", "advanced_analysis"]
+
+    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 AnalysisForm 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 symbols
+        if self.symbols:
+            _dict['symbols'] = self.symbols.to_dict()
+        # set to None if debug_hash (nullable) is None
+        # and model_fields_set contains the field
+        if self.debug_hash is None and "debug_hash" in self.model_fields_set:
+            _dict['debug_hash'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AnalysisForm 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"),
+            "platform_options": obj.get("platform_options"),
+            "isa_options": obj.get("isa_options"),
+            "file_options": obj.get("file_options"),
+            "dynamic_execution": obj.get("dynamic_execution") if obj.get("dynamic_execution") is not None else False,
+            "tags": obj.get("tags"),
+            "binary_scope": obj.get("binary_scope") if obj.get("binary_scope") is not None else 'PRIVATE',
+            "symbols": AppApiRestV1AnalyseSchemaSymbols.from_dict(obj["symbols"]) if obj.get("symbols") is not None else None,
+            "file_name": obj.get("file_name") if obj.get("file_name") is not None else 'empty',
+            "command_line_args": obj.get("command_line_args") if obj.get("command_line_args") is not None else '',
+            "priority": obj.get("priority") if obj.get("priority") is not None else 0,
+            "sha_256_hash": obj.get("sha_256_hash") if obj.get("sha_256_hash") is not None else '',
+            "debug_hash": obj.get("debug_hash"),
+            "size_in_bytes": obj.get("size_in_bytes"),
+            "skip_scraping": obj.get("skip_scraping") if obj.get("skip_scraping") is not None else False,
+            "skip_cves": obj.get("skip_cves") if obj.get("skip_cves") is not None else False,
+            "skip_sbom": obj.get("skip_sbom") if obj.get("skip_sbom") is not None else False,
+            "skip_capabilities": obj.get("skip_capabilities") if obj.get("skip_capabilities") is not None else False,
+            "ignore_cache": obj.get("ignore_cache") if obj.get("ignore_cache") is not None else False,
+            "advanced_analysis": obj.get("advanced_analysis") if obj.get("advanced_analysis") is not None else False
+        })
+        return _obj
+
+

revengai/models/analysis_functions.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.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
+from revengai.models.app_api_rest_v2_functions_types_function import AppApiRestV2FunctionsTypesFunction
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalysisFunctions(BaseModel):
+    """
+    AnalysisFunctions
+    """ # noqa: E501
+    functions: List[AppApiRestV2FunctionsTypesFunction] = Field(description="The functions associated with the analysis")
+    __properties: ClassVar[List[str]] = ["functions"]
+
+    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 AnalysisFunctions 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 functions (list)
+        _items = []
+        if self.functions:
+            for _item_functions in self.functions:
+                if _item_functions:
+                    _items.append(_item_functions.to_dict())
+            _dict['functions'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AnalysisFunctions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "functions": [AppApiRestV2FunctionsTypesFunction.from_dict(_item) for _item in obj["functions"]] if obj.get("functions") is not None else None
+        })
+        return _obj
+
+

revengai/models/analysis_record.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.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, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from revengai.models.app_api_rest_v2_analyses_enums_dynamic_execution_status import AppApiRestV2AnalysesEnumsDynamicExecutionStatus
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AnalysisRecord(BaseModel):
+    """
+    AnalysisRecord
+    """ # noqa: E501
+    analysis_id: StrictInt = Field(description="ID to identify analysis")
+    analysis_scope: StrictStr = Field(description="Scope of the analysis")
+    binary_id: StrictInt = Field(description="ID to identify the binary analyse")
+    model_id: StrictInt = Field(description="ID to identify the model used for analysis")
+    status: StrictStr = Field(description="The current status of analysis")
+    creation: datetime = Field(description="The current status of analysis")
+    is_owner: StrictBool = Field(description="Whether the current user is the owner of a binary")
+    binary_name: StrictStr = Field(description="The name of the file uploaded")
+    sha_256_hash: StrictStr = Field(description="The hash of the binary")
+    binary_size: StrictInt = Field(description="The size of the binary")
+    username: StrictStr = Field(description="The username of the analysis owner")
+    dynamic_execution_status: Optional[AppApiRestV2AnalysesEnumsDynamicExecutionStatus] = None
+    dynamic_execution_task_id: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["analysis_id", "analysis_scope", "binary_id", "model_id", "status", "creation", "is_owner", "binary_name", "sha_256_hash", "binary_size", "username", "dynamic_execution_status", "dynamic_execution_task_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 AnalysisRecord 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,
+        )
+        # set to None if dynamic_execution_status (nullable) is None
+        # and model_fields_set contains the field
+        if self.dynamic_execution_status is None and "dynamic_execution_status" in self.model_fields_set:
+            _dict['dynamic_execution_status'] = None
+
+        # set to None if dynamic_execution_task_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.dynamic_execution_task_id is None and "dynamic_execution_task_id" in self.model_fields_set:
+            _dict['dynamic_execution_task_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AnalysisRecord from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "analysis_id": obj.get("analysis_id"),
+            "analysis_scope": obj.get("analysis_scope"),
+            "binary_id": obj.get("binary_id"),
+            "model_id": obj.get("model_id"),
+            "status": obj.get("status"),
+            "creation": obj.get("creation"),
+            "is_owner": obj.get("is_owner"),
+            "binary_name": obj.get("binary_name"),
+            "sha_256_hash": obj.get("sha_256_hash"),
+            "binary_size": obj.get("binary_size"),
+            "username": obj.get("username"),
+            "dynamic_execution_status": obj.get("dynamic_execution_status"),
+            "dynamic_execution_task_id": obj.get("dynamic_execution_task_id")
+        })
+        return _obj
+
+

revengai/models/analysis_scope.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    The version of the OpenAPI document: 0.0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class AnalysisScope(str, Enum):
+    """
+    AnalysisScope
+    """
+
+    """
+    allowed enum values
+    """
+    PRIVATE = 'PRIVATE'
+    PUBLIC = 'PUBLIC'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AnalysisScope from a JSON string"""
+        return cls(json.loads(json_str))
+
+