revengai 2.74.0__py3-none-any.whl

revengai/models/function_matching_request.py

@@ -0,0 +1,114 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from revengai.models.function_matching_filters import FunctionMatchingFilters
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionMatchingRequest(BaseModel):
+    """
+    FunctionMatchingRequest
+    """ # noqa: E501
+    model_id: StrictInt = Field(description="ID of the model used for function matching, used to determine the embedding model")
+    function_ids: List[StrictInt] = Field(description="ID's of functions to find matches for, must be at least one function ID")
+    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")
+    filters: Optional[FunctionMatchingFilters] = None
+    results_per_function: Optional[Annotated[int, Field(le=50, strict=True, ge=1)]] = Field(default=1, description="Maximum number of matches to return per function, default is 1, max is 50")
+    page: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=1, description="Page number for paginated results, default is 1 (first page)")
+    page_size: Optional[Annotated[int, Field(le=1000, strict=True, ge=0)]] = Field(default=0, description="Number of functions to return per page, default is 0 (all functions), max is 1000")
+    status_only: Optional[StrictBool] = Field(default=False, description="If set to true, only returns the status of the matching 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 function matching for confidence results, default is False")
+    __properties: ClassVar[List[str]] = ["model_id", "function_ids", "min_similarity", "filters", "results_per_function", "page", "page_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 FunctionMatchingRequest 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 filters
+        if self.filters:
+            _dict['filters'] = self.filters.to_dict()
+        # set to None if filters (nullable) is None
+        # and model_fields_set contains the field
+        if self.filters is None and "filters" in self.model_fields_set:
+            _dict['filters'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionMatchingRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "model_id": obj.get("model_id"),
+            "function_ids": obj.get("function_ids"),
+            "min_similarity": obj.get("min_similarity") if obj.get("min_similarity") is not None else 90.0,
+            "filters": FunctionMatchingFilters.from_dict(obj["filters"]) if obj.get("filters") is not None else None,
+            "results_per_function": obj.get("results_per_function") if obj.get("results_per_function") is not None else 1,
+            "page": obj.get("page") if obj.get("page") is not None else 1,
+            "page_size": obj.get("page_size") if obj.get("page_size") is not None else 0,
+            "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/function_matching_response.py

@@ -0,0 +1,157 @@
+# 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 revengai.models.function_match import FunctionMatch
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionMatchingResponse(BaseModel):
+    """
+    FunctionMatchingResponse
+    """ # noqa: E501
+    progress: Optional[StrictInt] = Field(default=0, description="Progress of the matching operation, represented as a percentage")
+    status: Optional[StrictStr] = None
+    total_time: Optional[StrictInt] = None
+    error_message: Optional[StrictStr] = None
+    current_page: Optional[StrictInt] = None
+    total_pages: Optional[StrictInt] = None
+    matches: Optional[List[FunctionMatch]] = None
+    num_matches: Optional[StrictInt] = None
+    num_debug_matches: Optional[StrictInt] = None
+    updated_at: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["progress", "status", "total_time", "error_message", "current_page", "total_pages", "matches", "num_matches", "num_debug_matches", "updated_at"]
+
+    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 FunctionMatchingResponse 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 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
+
+        # set to None if current_page (nullable) is None
+        # and model_fields_set contains the field
+        if self.current_page is None and "current_page" in self.model_fields_set:
+            _dict['current_page'] = None
+
+        # set to None if total_pages (nullable) is None
+        # and model_fields_set contains the field
+        if self.total_pages is None and "total_pages" in self.model_fields_set:
+            _dict['total_pages'] = 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 num_matches (nullable) is None
+        # and model_fields_set contains the field
+        if self.num_matches is None and "num_matches" in self.model_fields_set:
+            _dict['num_matches'] = None
+
+        # set to None if num_debug_matches (nullable) is None
+        # and model_fields_set contains the field
+        if self.num_debug_matches is None and "num_debug_matches" in self.model_fields_set:
+            _dict['num_debug_matches'] = None
+
+        # set to None if updated_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.updated_at is None and "updated_at" in self.model_fields_set:
+            _dict['updated_at'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionMatchingResponse 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"),
+            "error_message": obj.get("error_message"),
+            "current_page": obj.get("current_page"),
+            "total_pages": obj.get("total_pages"),
+            "matches": [FunctionMatch.from_dict(_item) for _item in obj["matches"]] if obj.get("matches") is not None else None,
+            "num_matches": obj.get("num_matches"),
+            "num_debug_matches": obj.get("num_debug_matches"),
+            "updated_at": obj.get("updated_at")
+        })
+        return _obj
+
+

revengai/models/function_name_history.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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from revengai.models.function_source_type import FunctionSourceType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionNameHistory(BaseModel):
+    """
+    FunctionNameHistory
+    """ # noqa: E501
+    history_id: StrictInt = Field(description="The ID of the history record")
+    change_made_by: StrictStr = Field(description="The user who made the change")
+    function_name: StrictStr = Field(description="The name of the function")
+    mangled_name: StrictStr = Field(description="The mangled name of the function")
+    is_debug: StrictBool = Field(description="Whether the function is debugged")
+    source_type: FunctionSourceType = Field(description="The source type of the function")
+    created_at: StrictStr = Field(description="The timestamp when the function name was created")
+    __properties: ClassVar[List[str]] = ["history_id", "change_made_by", "function_name", "mangled_name", "is_debug", "source_type", "created_at"]
+
+    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 FunctionNameHistory 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 FunctionNameHistory from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "history_id": obj.get("history_id"),
+            "change_made_by": obj.get("change_made_by"),
+            "function_name": obj.get("function_name"),
+            "mangled_name": obj.get("mangled_name"),
+            "is_debug": obj.get("is_debug"),
+            "source_type": obj.get("source_type"),
+            "created_at": obj.get("created_at")
+        })
+        return _obj
+
+

revengai/models/function_param_response.py

@@ -0,0 +1,94 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionParamResponse(BaseModel):
+    """
+    FunctionParamResponse
+    """ # noqa: E501
+    d_type: StrictStr
+    loc: StrictStr
+    addr: StrictStr
+    length: StrictInt
+    name: StrictStr
+    __properties: ClassVar[List[str]] = ["d_type", "loc", "addr", "length", "name"]
+
+    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 FunctionParamResponse 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 FunctionParamResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "d_type": obj.get("d_type"),
+            "loc": obj.get("loc"),
+            "addr": obj.get("addr"),
+            "length": obj.get("length"),
+            "name": obj.get("name")
+        })
+        return _obj
+
+

revengai/models/function_rename.py

@@ -0,0 +1,88 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionRename(BaseModel):
+    """
+    FunctionRename
+    """ # noqa: E501
+    new_name: StrictStr = Field(description="The new name for the function")
+    new_mangled_name: StrictStr = Field(description="The new mangled name for the function")
+    __properties: ClassVar[List[str]] = ["new_name", "new_mangled_name"]
+
+    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 FunctionRename 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 FunctionRename from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "new_name": obj.get("new_name"),
+            "new_mangled_name": obj.get("new_mangled_name")
+        })
+        return _obj
+
+

revengai/models/function_rename_map.py

@@ -0,0 +1,90 @@
+# 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
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionRenameMap(BaseModel):
+    """
+    FunctionRenameMap
+    """ # noqa: E501
+    function_id: StrictInt = Field(description="The ID of the function to rename")
+    new_name: StrictStr = Field(description="The new name for the function")
+    new_mangled_name: StrictStr = Field(description="The new mangled name for the function")
+    __properties: ClassVar[List[str]] = ["function_id", "new_name", "new_mangled_name"]
+
+    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 FunctionRenameMap 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 FunctionRenameMap 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"),
+            "new_name": obj.get("new_name"),
+            "new_mangled_name": obj.get("new_mangled_name")
+        })
+        return _obj
+
+