revengai 2.74.0__py3-none-any.whl

revengai/models/get_ai_decompilation_task.py

@@ -0,0 +1,159 @@
+# 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, Optional
+from revengai.models.function_mapping_full import FunctionMappingFull
+from revengai.models.inverse_function_map_item import InverseFunctionMapItem
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetAiDecompilationTask(BaseModel):
+    """
+    GetAiDecompilationTask
+    """ # noqa: E501
+    status: StrictStr
+    decompilation: Optional[StrictStr]
+    raw_decompilation: Optional[StrictStr]
+    function_mapping: Optional[Dict[str, InverseFunctionMapItem]]
+    function_mapping_full: Optional[FunctionMappingFull]
+    summary: Optional[StrictStr] = None
+    ai_summary: Optional[StrictStr] = None
+    raw_ai_summary: Optional[StrictStr] = None
+    predicted_function_name: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["status", "decompilation", "raw_decompilation", "function_mapping", "function_mapping_full", "summary", "ai_summary", "raw_ai_summary", "predicted_function_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 GetAiDecompilationTask 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 value in function_mapping (dict)
+        _field_dict = {}
+        if self.function_mapping:
+            for _key_function_mapping in self.function_mapping:
+                if self.function_mapping[_key_function_mapping]:
+                    _field_dict[_key_function_mapping] = self.function_mapping[_key_function_mapping].to_dict()
+            _dict['function_mapping'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of function_mapping_full
+        if self.function_mapping_full:
+            _dict['function_mapping_full'] = self.function_mapping_full.to_dict()
+        # set to None if decompilation (nullable) is None
+        # and model_fields_set contains the field
+        if self.decompilation is None and "decompilation" in self.model_fields_set:
+            _dict['decompilation'] = None
+
+        # set to None if raw_decompilation (nullable) is None
+        # and model_fields_set contains the field
+        if self.raw_decompilation is None and "raw_decompilation" in self.model_fields_set:
+            _dict['raw_decompilation'] = None
+
+        # set to None if function_mapping (nullable) is None
+        # and model_fields_set contains the field
+        if self.function_mapping is None and "function_mapping" in self.model_fields_set:
+            _dict['function_mapping'] = None
+
+        # set to None if function_mapping_full (nullable) is None
+        # and model_fields_set contains the field
+        if self.function_mapping_full is None and "function_mapping_full" in self.model_fields_set:
+            _dict['function_mapping_full'] = None
+
+        # set to None if summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.summary is None and "summary" in self.model_fields_set:
+            _dict['summary'] = None
+
+        # set to None if ai_summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.ai_summary is None and "ai_summary" in self.model_fields_set:
+            _dict['ai_summary'] = None
+
+        # set to None if raw_ai_summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.raw_ai_summary is None and "raw_ai_summary" in self.model_fields_set:
+            _dict['raw_ai_summary'] = None
+
+        # set to None if predicted_function_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.predicted_function_name is None and "predicted_function_name" in self.model_fields_set:
+            _dict['predicted_function_name'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetAiDecompilationTask 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"),
+            "decompilation": obj.get("decompilation"),
+            "raw_decompilation": obj.get("raw_decompilation"),
+            "function_mapping": dict(
+                (_k, InverseFunctionMapItem.from_dict(_v))
+                for _k, _v in obj["function_mapping"].items()
+            )
+            if obj.get("function_mapping") is not None
+            else None,
+            "function_mapping_full": FunctionMappingFull.from_dict(obj["function_mapping_full"]) if obj.get("function_mapping_full") is not None else None,
+            "summary": obj.get("summary"),
+            "ai_summary": obj.get("ai_summary"),
+            "raw_ai_summary": obj.get("raw_ai_summary"),
+            "predicted_function_name": obj.get("predicted_function_name")
+        })
+        return _obj
+
+

revengai/models/get_me_response.py

@@ -0,0 +1,108 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetMeResponse(BaseModel):
+    """
+    GetMeResponse
+    """ # noqa: E501
+    username: StrictStr
+    user_id: StrictInt
+    first_name: StrictStr
+    last_name: StrictStr
+    email: StrictStr
+    creation: datetime
+    tutorial_seen: StrictBool
+    role: StrictStr
+    __properties: ClassVar[List[str]] = ["username", "user_id", "first_name", "last_name", "email", "creation", "tutorial_seen", "role"]
+
+    @field_validator('role')
+    def role_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['USER', 'ADMIN', 'SUPERADMIN', 'SYSTEM']):
+            raise ValueError("must be one of enum values ('USER', 'ADMIN', 'SUPERADMIN', 'SYSTEM')")
+        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 GetMeResponse 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 GetMeResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "username": obj.get("username"),
+            "user_id": obj.get("user_id"),
+            "first_name": obj.get("first_name"),
+            "last_name": obj.get("last_name"),
+            "email": obj.get("email"),
+            "creation": obj.get("creation"),
+            "tutorial_seen": obj.get("tutorial_seen"),
+            "role": obj.get("role")
+        })
+        return _obj
+
+

revengai/models/get_public_user_response.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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetPublicUserResponse(BaseModel):
+    """
+    GetPublicUserResponse
+    """ # noqa: E501
+    username: StrictStr
+    user_id: StrictInt
+    __properties: ClassVar[List[str]] = ["username", "user_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 GetPublicUserResponse 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 GetPublicUserResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "username": obj.get("username"),
+            "user_id": obj.get("user_id")
+        })
+        return _obj
+
+

revengai/models/global_variable.py

@@ -0,0 +1,101 @@
+# 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 GlobalVariable(BaseModel):
+    """
+    GlobalVariable
+    """ # noqa: E501
+    last_change: Optional[StrictStr] = None
+    addr: StrictInt = Field(description="Memory address of the global variable")
+    name: StrictStr = Field(description="Name of the global variable")
+    type: StrictStr = Field(description="Data type of the global variable")
+    size: StrictInt = Field(description="Size of the global variable in bytes")
+    artifact_type: Optional[StrictStr] = Field(default=None, description="Type of artifact that the global variable is associated with")
+    __properties: ClassVar[List[str]] = ["last_change", "addr", "name", "type", "size", "artifact_type"]
+
+    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 GlobalVariable 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 GlobalVariable 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"),
+            "addr": obj.get("addr"),
+            "name": obj.get("name"),
+            "type": obj.get("type"),
+            "size": obj.get("size"),
+            "artifact_type": obj.get("artifact_type")
+        })
+        return _obj
+
+

revengai/models/icon_model.py

@@ -0,0 +1,91 @@
+# 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, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IconModel(BaseModel):
+    """
+    IconModel
+    """ # noqa: E501
+    content: Optional[StrictStr]
+    __properties: ClassVar[List[str]] = ["content"]
+
+    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 IconModel 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 content (nullable) is None
+        # and model_fields_set contains the field
+        if self.content is None and "content" in self.model_fields_set:
+            _dict['content'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IconModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "content": obj.get("content")
+        })
+        return _obj
+
+

revengai/models/import_model.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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ImportModel(BaseModel):
+    """
+    ImportModel
+    """ # noqa: E501
+    number_of_imports: StrictInt
+    imports: List[Dict[str, Dict[str, StrictInt]]]
+    __properties: ClassVar[List[str]] = ["number_of_imports", "imports"]
+
+    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 ImportModel 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 ImportModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "number_of_imports": obj.get("number_of_imports"),
+            "imports": obj.get("imports")
+        })
+        return _obj
+
+