revengai 2.74.0__py3-none-any.whl

revengai/models/app_api_rest_v2_functions_types_function.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AppApiRestV2FunctionsTypesFunction(BaseModel):
+    """
+    AppApiRestV2FunctionsTypesFunction
+    """ # noqa: E501
+    function_id: StrictInt = Field(description="Function id")
+    function_name: StrictStr = Field(description="Demangled name of the function")
+    function_mangled_name: StrictStr = Field(description="Mangled name of the function")
+    function_vaddr: StrictInt = Field(description="Function virtual address")
+    function_size: StrictInt = Field(description="Function size")
+    debug: StrictBool = Field(description="Whether the function is debug")
+    embedding_3d: Optional[List[Union[StrictFloat, StrictInt]]] = None
+    embedding_1d: Optional[List[Union[StrictFloat, StrictInt]]] = None
+    __properties: ClassVar[List[str]] = ["function_id", "function_name", "function_mangled_name", "function_vaddr", "function_size", "debug", "embedding_3d", "embedding_1d"]
+
+    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 AppApiRestV2FunctionsTypesFunction 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 embedding_3d (nullable) is None
+        # and model_fields_set contains the field
+        if self.embedding_3d is None and "embedding_3d" in self.model_fields_set:
+            _dict['embedding_3d'] = None
+
+        # set to None if embedding_1d (nullable) is None
+        # and model_fields_set contains the field
+        if self.embedding_1d is None and "embedding_1d" in self.model_fields_set:
+            _dict['embedding_1d'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AppApiRestV2FunctionsTypesFunction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "function_id": obj.get("function_id"),
+            "function_name": obj.get("function_name"),
+            "function_mangled_name": obj.get("function_mangled_name"),
+            "function_vaddr": obj.get("function_vaddr"),
+            "function_size": obj.get("function_size"),
+            "debug": obj.get("debug"),
+            "embedding_3d": obj.get("embedding_3d"),
+            "embedding_1d": obj.get("embedding_1d")
+        })
+        return _obj
+
+

revengai/models/app_services_dynamic_execution_schemas_dynamic_execution_status.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AppServicesDynamicExecutionSchemasDynamicExecutionStatus(BaseModel):
+    """
+    AppServicesDynamicExecutionSchemasDynamicExecutionStatus
+    """ # noqa: E501
+    status: StrictStr
+    __properties: ClassVar[List[str]] = ["status"]
+
+    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 AppServicesDynamicExecutionSchemasDynamicExecutionStatus 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 AppServicesDynamicExecutionSchemasDynamicExecutionStatus from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "status": obj.get("status")
+        })
+        return _obj
+
+

revengai/models/argument.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Argument(BaseModel):
+    """
+    Argument
+    """ # noqa: E501
+    last_change: Optional[StrictStr] = None
+    offset: StrictInt = Field(description="Offset of the argument in the function signature")
+    name: StrictStr = Field(description="Name of the argument")
+    type: StrictStr = Field(description="Data type of the argument")
+    size: StrictInt = Field(description="Size of the argument in bytes")
+    __properties: ClassVar[List[str]] = ["last_change", "offset", "name", "type", "size"]
+
+    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 Argument 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 last_change (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_change is None and "last_change" in self.model_fields_set:
+            _dict['last_change'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Argument from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "last_change": obj.get("last_change"),
+            "offset": obj.get("offset"),
+            "name": obj.get("name"),
+            "type": obj.get("type"),
+            "size": obj.get("size")
+        })
+        return _obj
+
+

revengai/models/auto_unstrip_request.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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
+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 AutoUnstripRequest(BaseModel):
+    """
+    AutoUnstripRequest
+    """ # noqa: E501
+    min_similarity: Optional[Union[Annotated[float, Field(le=100.0, strict=True, ge=0.0)], Annotated[int, Field(le=100, strict=True, ge=0)]]] = Field(default=90.0, description="Minimum similarity expected for a match as a percentage, default is 90")
+    apply: Optional[StrictBool] = Field(default=False, description="Whether to apply the matched function names to the target binary, default is False")
+    confidence_threshold: Optional[Union[Annotated[float, Field(le=100.0, strict=True, ge=0.0)], Annotated[int, Field(le=100, strict=True, ge=0)]]] = Field(default=90.0, description="Confidence threshold for applying function names as a percentage, default is 90")
+    min_group_size: Optional[Annotated[int, Field(le=20, strict=True, ge=1)]] = Field(default=10, description="Minimum number of matching functions required to consider for a match, default is 10")
+    status_only: Optional[StrictBool] = Field(default=False, description="If set to true, only returns the status of the auto-unstrip operation without the actual results")
+    no_cache: Optional[StrictBool] = Field(default=False, description="If set to true, forces the system to bypass any cached results and perform a fresh computation")
+    use_canonical_names: Optional[StrictBool] = Field(default=False, description="Whether to use canonical function names during matching for auto-unstrip, default is False")
+    __properties: ClassVar[List[str]] = ["min_similarity", "apply", "confidence_threshold", "min_group_size", "status_only", "no_cache", "use_canonical_names"]
+
+    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 AutoUnstripRequest 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 AutoUnstripRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "min_similarity": obj.get("min_similarity") if obj.get("min_similarity") is not None else 90.0,
+            "apply": obj.get("apply") if obj.get("apply") is not None else False,
+            "confidence_threshold": obj.get("confidence_threshold") if obj.get("confidence_threshold") is not None else 90.0,
+            "min_group_size": obj.get("min_group_size") if obj.get("min_group_size") is not None else 10,
+            "status_only": obj.get("status_only") if obj.get("status_only") is not None else False,
+            "no_cache": obj.get("no_cache") if obj.get("no_cache") is not None else False,
+            "use_canonical_names": obj.get("use_canonical_names") if obj.get("use_canonical_names") is not None else False
+        })
+        return _obj
+
+

revengai/models/auto_unstrip_response.py

@@ -0,0 +1,129 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from revengai.models.matched_function_suggestion import MatchedFunctionSuggestion
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AutoUnstripResponse(BaseModel):
+    """
+    AutoUnstripResponse
+    """ # noqa: E501
+    progress: Optional[StrictInt] = Field(default=0, description="Progress of the auto-unstrip operation, represented as a percentage")
+    status: Optional[StrictStr] = None
+    total_time: Optional[StrictInt] = None
+    matches: Optional[List[MatchedFunctionSuggestion]] = None
+    applied: Optional[StrictBool] = None
+    error_message: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["progress", "status", "total_time", "matches", "applied", "error_message"]
+
+    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 AutoUnstripResponse 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 matches (list)
+        _items = []
+        if self.matches:
+            for _item_matches in self.matches:
+                if _item_matches:
+                    _items.append(_item_matches.to_dict())
+            _dict['matches'] = _items
+        # set to None if status (nullable) is None
+        # and model_fields_set contains the field
+        if self.status is None and "status" in self.model_fields_set:
+            _dict['status'] = None
+
+        # set to None if total_time (nullable) is None
+        # and model_fields_set contains the field
+        if self.total_time is None and "total_time" in self.model_fields_set:
+            _dict['total_time'] = None
+
+        # set to None if matches (nullable) is None
+        # and model_fields_set contains the field
+        if self.matches is None and "matches" in self.model_fields_set:
+            _dict['matches'] = None
+
+        # set to None if applied (nullable) is None
+        # and model_fields_set contains the field
+        if self.applied is None and "applied" in self.model_fields_set:
+            _dict['applied'] = None
+
+        # set to None if error_message (nullable) is None
+        # and model_fields_set contains the field
+        if self.error_message is None and "error_message" in self.model_fields_set:
+            _dict['error_message'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AutoUnstripResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "progress": obj.get("progress") if obj.get("progress") is not None else 0,
+            "status": obj.get("status"),
+            "total_time": obj.get("total_time"),
+            "matches": [MatchedFunctionSuggestion.from_dict(_item) for _item in obj["matches"]] if obj.get("matches") is not None else None,
+            "applied": obj.get("applied"),
+            "error_message": obj.get("error_message")
+        })
+        return _obj
+
+

revengai/models/base_response.py

@@ -0,0 +1,124 @@
+# coding: utf-8
+
+"""
+    RevEng.AI API
+
+    RevEng.AI is Similarity Search Engine for executable binaries
+
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from revengai.models.error_model import ErrorModel
+from revengai.models.meta_model import MetaModel
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BaseResponse(BaseModel):
+    """
+    BaseResponse
+    """ # noqa: E501
+    status: Optional[StrictBool] = Field(default=True, description="Response status on whether the request succeeded")
+    data: Optional[Any] = Field(default=None, description="Response data")
+    message: Optional[StrictStr] = None
+    errors: Optional[List[ErrorModel]] = None
+    meta: Optional[MetaModel] = Field(default=None, description="Metadata")
+    __properties: ClassVar[List[str]] = ["status", "data", "message", "errors", "meta"]
+
+    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 BaseResponse 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
+        # override the default output from pydantic by calling `to_dict()` of meta
+        if self.meta:
+            _dict['meta'] = self.meta.to_dict()
+        # set to None if data (nullable) is None
+        # and model_fields_set contains the field
+        if self.data is None and "data" in self.model_fields_set:
+            _dict['data'] = None
+
+        # 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
+
+        # set to None if errors (nullable) is None
+        # and model_fields_set contains the field
+        if self.errors is None and "errors" in self.model_fields_set:
+            _dict['errors'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BaseResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "status": obj.get("status") if obj.get("status") is not None else True,
+            "data": AnyOf.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "message": obj.get("message"),
+            "errors": [ErrorModel.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None,
+            "meta": MetaModel.from_dict(obj["meta"]) if obj.get("meta") is not None else None
+        })
+        return _obj
+
+