robloxmemoryapi 0.2.1__tar.gz → 0.2.2.1__tar.gz

{robloxmemoryapi-0.2.1/src/robloxmemoryapi.egg-info → robloxmemoryapi-0.2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.1
+Version: 0.2.2.1
 Summary: Python Library that abstracts reading and writing data from the Roblox DataModel
 Author-email: upio <notpoiu@users.noreply.github.com>, mstudio45 <mstudio45@users.noreply.github.com>, ActualMasterOogway <ActualMasterOogway@users.noreply.github.com>
 License: Copyright 2025 upio, mstudio45, master oogway

{robloxmemoryapi-0.2.1 → robloxmemoryapi-0.2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.2.1"
+version = "0.2.2.1"
 description = "Python Library that abstracts reading and writing data from the Roblox DataModel"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.9"

{robloxmemoryapi-0.2.1 → robloxmemoryapi-0.2.2.1}/src/robloxmemoryapi/__init__.py

@@ -80,10 +80,23 @@ class RobloxGameClient:
 
         self.memory_module = EvasiveProcess(self.pid, desired_access)
         self.failed = False
+        self._fflags = None
 
     def close(self):
         self.memory_module.close()
 
+    @property
+    def FFlags(self):
+        if platform.system() != "Windows":
+            raise RuntimeError("This module is only compatible with Windows.")
+        elif self.failed:
+            raise RuntimeError("There was an error while getting access to memory. Please try again later.")
+
+        if self._fflags is None:
+            from .utils.rbx.fflags import FFlagManager
+            self._fflags = FFlagManager(self.memory_module)
+        return self._fflags
+
     @property
     def DataModel(self):
         if platform.system() != "Windows":
@@ -92,4 +105,4 @@ class RobloxGameClient:
             raise RuntimeError("There was an error while getting access to memory. Please try again later.")
 
         from .utils.rbx.instance import DataModel
-        return DataModel(self.memory_module)
+        return DataModel(self.memory_module)

robloxmemoryapi-0.2.2.1/src/robloxmemoryapi/utils/offsets.py

@@ -0,0 +1,37 @@
+import requests
+
+BASE_URL = "https://imtheo.lol/Offsets"
+
+# Offsets
+OffsetsRequest = requests.get(f"{BASE_URL}/Offsets.json")
+
+# Legacy Offsets
+OldOffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
+try:
+    OldOffsets = OldOffsetsRequest.json()
+except:
+    OldOffsets = {}
+
+try:
+    Offsets = OffsetsRequest.json()["Offsets"]
+except:
+    Offsets = {}
+
+# Handle non-existant offsets
+try:
+    Offsets["Camera"]["ViewportSize"] = int(OldOffsets["ViewportSize"], 16)
+except:
+    Offsets["Camera"]["ViewportSize"] = 0x6AD28F
+
+# FFlag offsets (lazily loaded)
+_fflag_data = None
+_fflag_offsets = None
+
+def get_fflag_offsets() -> dict:
+    global _fflag_data, _fflag_offsets
+    if _fflag_data is None:
+        resp = requests.get(f"{BASE_URL}/FFlags.json")
+        resp.raise_for_status()
+        _fflag_data = resp.json()
+        _fflag_offsets = _fflag_data["FFlagOffsets"]["FFlags"]
+    return _fflag_offsets

robloxmemoryapi-0.2.2.1/src/robloxmemoryapi/utils/rbx/fflags.py

@@ -0,0 +1,197 @@
+from ..offsets import get_fflag_offsets
+
+_MODULE_SIZE_LIMIT = 0x20000000
+
+# FLog level byte → display name.
+_FLOG_LEVELS = {
+    2: "Error",
+    3: "Warning",
+    4: "Info",
+    5: "Debug",
+    6: "Verbose",
+    255: "None",
+}
+
+_VALID_FLOG_LEVELS = set(_FLOG_LEVELS.keys())
+
+_FLOG_LEVELS_REV = {v: k for k, v in _FLOG_LEVELS.items()}
+
+def _decode_flog(raw_int: int) -> str:
+    level_byte = (raw_int >> 8) & 0xFF
+    param_byte = raw_int & 0xFF
+    level_name = _FLOG_LEVELS.get(level_byte, str(level_byte))
+    return f"{level_name},{param_byte}"
+
+
+def _encode_flog(value: str) -> int:
+    parts = value.split(",", 1)
+    level_name = parts[0].strip()
+    param = int(parts[1].strip()) if len(parts) > 1 else 0
+    level_byte = _FLOG_LEVELS_REV.get(level_name)
+    if level_byte is None:
+        level_byte = int(level_name)
+    return (level_byte << 8) | (param & 0xFF)
+
+
+class FFlag:
+    __slots__ = ("name", "type", "value", "offset")
+
+    def __init__(self, name: str, flag_type: str, value, offset: int):
+        self.name = name
+        self.type = flag_type   # "bool", "int", or "string"
+        self.value = value
+        self.offset = offset
+
+    def __repr__(self):
+        return f"FFlag(name={self.name!r}, type={self.type!r}, value={self.value!r})"
+
+class FFlagManager:
+    def __init__(self, memory_module):
+        self._mem = memory_module
+        self._base = memory_module.base
+        self._offsets = None
+
+    def _ensure_offsets(self):
+        if self._offsets is None:
+            self._offsets = get_fflag_offsets()
+
+    def _is_module_ptr(self, ptr: int) -> bool:
+        return self._base <= ptr < self._base + _MODULE_SIZE_LIMIT
+
+    def _reflect(self, name: str, offset: int):
+        addr = self._base + offset
+        raw = self._mem.read(addr, 32)
+        if len(raw) < 32:
+            return "unknown", None
+
+        ptr_at_8 = int.from_bytes(raw[8:16], "little")
+
+        if self._is_module_ptr(ptr_at_8):
+            try:
+                name_in_mem = self._mem.read_raw_string(ptr_at_8, 256)
+            except OSError:
+                name_in_mem = ""
+
+            val_at_10 = int.from_bytes(raw[16:20], "little")
+
+            if name_in_mem and val_at_10 == len(name_in_mem):
+                return "bool", bool(raw[0])
+            else:
+                raw_int = int.from_bytes(raw[0:4], "little")
+                level_byte = (raw_int >> 8) & 0xFF
+                if level_byte in _VALID_FLOG_LEVELS:
+                    return "flog", _decode_flog(raw_int)
+                else:
+                    return "int", int.from_bytes(raw[0:4], "little", signed=True)
+        else:
+            str_len = int.from_bytes(raw[16:24], "little")
+            str_cap = int.from_bytes(raw[24:32], "little")
+
+            if str_cap == 15 and 0 <= str_len <= 15:
+                return "string", self._mem.read_string(addr)
+
+            if (str_cap >= 16 and str_cap < 0x100000
+                    and 0 < str_len <= str_cap):
+                ptr_at_0 = int.from_bytes(raw[0:8], "little")
+                if ptr_at_0 > 0x10000:
+                    return "string", self._mem.read_string(addr)
+
+            return "int", int.from_bytes(raw[0:4], "little", signed=True)
+
+    @property
+    def offsets(self) -> dict:
+        self._ensure_offsets()
+        return dict(self._offsets)
+
+    def get(self, name: str) -> FFlag | None:
+        self._ensure_offsets()
+        offset = self._offsets.get(name)
+        if offset is None:
+            return None
+        flag_type, value = self._reflect(name, offset)
+        return FFlag(name, flag_type, value, offset)
+
+    def get_many(self, *names: str) -> dict[str, FFlag]:
+        self._ensure_offsets()
+        out = {}
+        for n in names:
+            flag = self.get(n)
+            if flag is not None:
+                out[n] = flag
+        return out
+
+    def get_all(self) -> dict[str, FFlag]:
+        self._ensure_offsets()
+        out = {}
+        for name, offset in self._offsets.items():
+            try:
+                flag_type, value = self._reflect(name, offset)
+                out[name] = FFlag(name, flag_type, value, offset)
+            except OSError:
+                pass
+        return out
+
+    def set(self, name: str, value) -> FFlag:
+        self._ensure_offsets()
+        offset = self._offsets.get(name)
+        if offset is None:
+            raise KeyError(name)
+
+        flag_type, _ = self._reflect(name, offset)
+        addr = self._base + offset
+
+        if flag_type == "bool":
+            if not isinstance(value, (bool, int)):
+                raise TypeError(f"Expected bool for flag '{name}', got {type(value).__name__}")
+            self._mem.write_bool(addr, bool(value))
+
+        elif flag_type == "int":
+            if not isinstance(value, int):
+                raise TypeError(f"Expected int for flag '{name}', got {type(value).__name__}")
+            self._mem.write_int(addr, value)
+
+        elif flag_type == "string":
+            if not isinstance(value, str):
+                raise TypeError(f"Expected str for flag '{name}', got {type(value).__name__}")
+
+            self._mem.write_string(addr, str(value))
+
+        elif flag_type == "flog":
+            if not isinstance(value, (str, int)):
+                raise TypeError(f"Expected str or int for flag '{name}', got {type(value).__name__}")
+
+            self._mem.write_int(addr, _encode_flog(str(value)) if isinstance(value, str) else value)
+        else:
+            raise RuntimeError(f"Cannot write to flag with unknown type '{flag_type}'")
+
+        new_type, new_value = self._reflect(name, offset)
+        return FFlag(name, new_type, new_value, offset)
+
+    def __getitem__(self, name: str) -> FFlag:
+        flag = self.get(name)
+        if flag is None:
+            raise KeyError(name)
+        return flag
+    
+    def __getattr__(self, name) -> FFlag:
+        flag = self.get(name)
+        if flag is None:
+            raise AttributeError(f"FFlag '{name}' not found")
+        return flag
+
+    def __setitem__(self, name: str, value):
+        self.set(name, value)
+    
+    def __setattr__(self, name: str, value):
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            self.set(name, value)
+
+    def __contains__(self, name: str) -> bool:
+        self._ensure_offsets()
+        return name in self._offsets
+
+    def __repr__(self):
+        self._ensure_offsets()
+        return f"FFlagManager({len(self._offsets)} flags)"

{robloxmemoryapi-0.2.1 → robloxmemoryapi-0.2.2.1/src/robloxmemoryapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robloxmemoryapi
-Version: 0.2.1
+Version: 0.2.2.1
 Summary: Python Library that abstracts reading and writing data from the Roblox DataModel
 Author-email: upio <notpoiu@users.noreply.github.com>, mstudio45 <mstudio45@users.noreply.github.com>, ActualMasterOogway <ActualMasterOogway@users.noreply.github.com>
 License: Copyright 2025 upio, mstudio45, master oogway

{robloxmemoryapi-0.2.1 → robloxmemoryapi-0.2.2.1}/src/robloxmemoryapi.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/robloxmemoryapi/utils/luau/__init__.py
 src/robloxmemoryapi/utils/luau/parser.py
 src/robloxmemoryapi/utils/rbx/__init__.py
 src/robloxmemoryapi/utils/rbx/datastructures.py
+src/robloxmemoryapi/utils/rbx/fflags.py
 src/robloxmemoryapi/utils/rbx/instance.py
 src/robloxmemoryapi/utils/rbx/bytecode/decryptor.py
 src/robloxmemoryapi/utils/rbx/bytecode/encryptor.py

robloxmemoryapi-0.2.1/src/robloxmemoryapi/utils/offsets.py

@@ -1,22 +0,0 @@
-import requests
-
-# Offsets
-OffsetsRequest = requests.get("https://imtheo.lol/Offsets/Offsets.json")
-
-# Legacy Offsets
-OldOffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
-try:
-    OldOffsets = OldOffsetsRequest.json()
-except:
-    OldOffsets = {}
-
-try:
-    Offsets = OffsetsRequest.json()["Offsets"]
-except:
-    Offsets = {}
-
-# Handle non-existant offsets
-try:
-    Offsets["Camera"]["ViewportSize"] = int(OldOffsets["ViewportSize"], 16)
-except:
-    Offsets["Camera"]["ViewportSize"] = 0x6AD28F