robloxmemoryapi 0.3.1__tar.gz → 0.3.2__tar.gz

{robloxmemoryapi-0.3.1 → robloxmemoryapi-0.3.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: robloxmemoryapi
-Version: 0.3.1
+Version: 0.3.2
 Summary: Python Library that abstracts reading and writing data from the Roblox DataModel
-Keywords: roblox,memory,windows
+Keywords: roblox,memory,windows,macOS
 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
          
@@ -15,6 +15,7 @@ License: Copyright 2025 upio, mstudio45, master oogway
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries

{robloxmemoryapi-0.3.1 → robloxmemoryapi-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "robloxmemoryapi"
-version = "0.3.1"
+version = "0.3.2"
 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"
@@ -14,11 +14,12 @@ authors = [
   { name = "mstudio45", email = "mstudio45@users.noreply.github.com" },
   { name = "ActualMasterOogway", email = "ActualMasterOogway@users.noreply.github.com" },
 ]
-keywords = ["roblox", "memory", "windows"]
+keywords = ["roblox", "memory", "windows", "macOS"]
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: MIT License",
   "Operating System :: Microsoft :: Windows",
+  "Operating System :: MacOS",
   "Development Status :: 3 - Alpha",
   "Intended Audience :: Developers",
   "Topic :: Software Development :: Libraries",

robloxmemoryapi-0.3.2/src/robloxmemoryapi/__init__.py

@@ -0,0 +1,231 @@
+import platform
+import math
+import os
+import subprocess
+import sys
+import tempfile
+
+from ._version import __version__
+
+__all__ = [
+    "RobloxRandom",
+    "RobloxGameClient",
+    "codesign_roblox_macos",
+    "codesign_python_macos",
+    "__version__",
+]
+
+
+def codesign_roblox_macos(
+    app_path: str | os.PathLike[str] | None = None,
+    *,
+    silicon_app_path: str | os.PathLike[str] = "/Applications/Roblox.app",
+    intel_app_path: str | os.PathLike[str] = "/Applications/RobloxPlayer.app",
+    use_sudo: bool = True,
+) -> str:
+    """Ad-hoc sign a macOS Roblox app bundle for local memory access workflows."""
+    if platform.system() != "Darwin":
+        raise RuntimeError("codesign_roblox_macos is only available on macOS.")
+
+    if app_path is None:
+        app_path = silicon_app_path if platform.machine().lower() == "arm64" else intel_app_path
+
+    app_path = os.fspath(app_path)
+    if not os.path.exists(app_path):
+        raise FileNotFoundError(app_path)
+
+    sudo_prefix = ["sudo"] if use_sudo and os.geteuid() != 0 else []
+    subprocess.run(
+        sudo_prefix + ["codesign", "--remove-signature", app_path],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        check=False,
+    )
+    subprocess.run(
+        sudo_prefix + ["codesign", "--force", "--deep", "--sign", "-", app_path],
+        check=True,
+    )
+
+    return app_path
+
+
+def codesign_python_macos(
+    executable_path: str | os.PathLike[str] | None = None,
+    *,
+    use_sudo: bool = True,
+) -> str:
+    """Ad-hoc sign the Python executable/launcher with the macOS debugger entitlement."""
+    if platform.system() != "Darwin":
+        raise RuntimeError("codesign_python_macos is only available on macOS.")
+
+    if executable_path is None:
+        executable_path = sys.executable
+
+    executable_path = os.path.realpath(os.fspath(executable_path))
+    if not os.path.exists(executable_path):
+        raise FileNotFoundError(executable_path)
+
+    entitlements = """<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+ "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.cs.debugger</key>
+  <true/>
+  <key>com.apple.security.get-task-allow</key>
+  <true/>
+  <key>SecTaskAccess</key>
+  <array><string>allowed</string></array>
+</dict>
+</plist>
+"""
+
+    sudo_prefix = ["sudo"] if use_sudo and os.geteuid() != 0 else []
+    with tempfile.NamedTemporaryFile("w", suffix=".plist", delete=False) as entitlement_file:
+        entitlement_file.write(entitlements)
+        entitlement_path = entitlement_file.name
+
+    try:
+        subprocess.run(
+            sudo_prefix + ["codesign", "--remove-signature", executable_path],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        subprocess.run(
+            sudo_prefix
+            + [
+                "codesign",
+                "--force",
+                "--sign",
+                "-",
+                "--entitlements",
+                entitlement_path,
+                executable_path,
+            ],
+            check=True,
+        )
+    finally:
+        try:
+            os.unlink(entitlement_path)
+        except OSError:
+            pass
+
+    return executable_path
+
+
+class RobloxRandom:
+    MULT = 6364136223846793005
+    INC = 105
+    MASK64 = (1 << 64) - 1
+
+    def __init__(self, seed):
+        s = math.floor(seed)
+
+        self._state = 0
+        self._inc = RobloxRandom.INC
+        self._next_internal()         # warm-up #1
+        self._state = (self._state + s) & RobloxRandom.MASK64
+        self._next_internal()         # warm-up #2
+
+    def _next_internal(self):
+        old = self._state
+        self._state = (old * RobloxRandom.MULT + self._inc) & RobloxRandom.MASK64
+        x = ((old >> 18) ^ old) >> 27
+        r = old >> 59
+        return ((x >> r) | (x << ((32 - r) & 31))) & 0xFFFFFFFF
+
+    def _next_fraction64(self):
+        lo = self._next_internal()
+        hi = self._next_internal()
+        bits = (hi << 32) | lo
+        return bits / 2**64
+
+    def NextNumber(self, minimum=0.0, maximum=1.0):
+        frac = self._next_fraction64()
+        return minimum + frac * (maximum - minimum)
+
+    def NextInteger(self, a, b=None):
+        if b is None:
+            u = a
+            r = self._next_internal()
+            return ((u * r) >> 32) + 1
+        else:
+            lo, hi = (a, b) if a <= b else (b, a)
+            u = hi - lo + 1
+            r = self._next_internal()
+            return ((u * r) >> 32) + lo
+
+class RobloxGameClient:
+    def __init__(
+        self,
+        pid: int = None,
+        process_name: str = "RobloxPlayerBeta.exe",
+        allow_write: bool = False,
+    ):
+        system = platform.system()
+        if system not in {"Windows", "Darwin"}:
+            self.failed = True
+            return
+
+        if system == "Darwin" and os.geteuid() != 0:
+            raise PermissionError(
+                "macOS memory access requires running the Python process with sudo/root. "
+                "Run this script with sudo and try again."
+            )
+
+        from .utils.memory import (
+            EvasiveProcess,
+            PROCESS_QUERY_INFORMATION,
+            PROCESS_VM_READ,
+            PROCESS_VM_WRITE,
+            PROCESS_VM_OPERATION,
+            get_pid_by_name,
+        )
+
+        if system == "Darwin" and process_name == "RobloxPlayerBeta.exe":
+            process_name = "RobloxPlayer"
+
+        if pid is None:
+            self.pid = get_pid_by_name(process_name)
+        else:
+            self.pid = pid
+
+        if self.pid is None or self.pid == 0:
+            raise ValueError("Failed to get PID.")
+
+        if system == "Darwin":
+            os.environ["ROBLOXMEMORYAPI_ROBLOX_PID"] = str(self.pid)
+
+        desired_access = PROCESS_VM_READ | PROCESS_QUERY_INFORMATION
+        if allow_write:
+            desired_access |= PROCESS_VM_WRITE | PROCESS_VM_OPERATION
+
+        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() not in {"Windows", "Darwin"}:
+            raise RuntimeError("This module is only compatible with Windows and macOS.")
+        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() not in {"Windows", "Darwin"}:
+            raise RuntimeError("This module is only compatible with Windows and macOS.")
+        elif self.failed:
+            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)

{robloxmemoryapi-0.3.1 → robloxmemoryapi-0.3.2}/src/robloxmemoryapi/_native/memory.cpp

@@ -2,9 +2,11 @@
 #include <pybind11/stl.h>
 
 #include <algorithm>
+#include <cctype>
 #include <cstdint>
 #include <cstring>
 #include <iomanip>
+#include <optional>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -26,6 +28,7 @@ namespace py = pybind11;
 #include <mach-o/loader.h>
 #include <libproc.h>
 #include <sys/proc_info.h>
+#include <unistd.h>
 #endif
 
 namespace {
@@ -39,6 +42,17 @@ constexpr std::uint32_t MEM_RESERVE_VALUE = 0x2000;
 constexpr std::uint32_t PAGE_READWRITE_VALUE = 0x04;
 constexpr std::uint32_t PAGE_EXECUTE_READWRITE_VALUE = 0x40;
 
+#if defined(__APPLE__)
+constexpr std::string_view MACOS_CODESIGN_HINT =
+    "\n\nTry ad-hoc codesigning Roblox and the Python executable/launcher, "
+    "from a sudo/root shell run the following commands:\n"
+    "from robloxmemoryapi import codesign_roblox_macos, codesign_python_macos\n\n"
+    "# run with sudo\n"
+    "codesign_python_macos()\n"
+    "codesign_roblox_macos()\n\n"
+    "Then restart roblox and run the script again.";
+#endif
+
 std::string hex_status(long status) {
     std::ostringstream oss;
     oss << "0x" << std::uppercase << std::hex << static_cast<unsigned long>(status);
@@ -276,13 +290,22 @@ public:
             raise_python(PyExc_ConnectionError, "Failed to get module base address.");
         }
 #elif defined(__APPLE__)
+        if (geteuid() != 0) {
+            raise_python(
+                PyExc_PermissionError,
+                "macOS memory access requires running the Python process with sudo/root. "
+                "Run this script with sudo and try again."
+            );
+        }
+
         mach_port_t task = MACH_PORT_NULL;
         kern_return_t result = task_for_pid(mach_task_self(), pid, &task);
         if (result != KERN_SUCCESS) {
             raise_python(
                 PyExc_OSError,
                 "task_for_pid failed: " + std::string(mach_error_string(result)) +
-                    ". macOS memory reads require permission to acquire the target task port."
+                    ". macOS memory reads require permission to acquire the target task port." +
+                    std::string(MACOS_CODESIGN_HINT)
             );
         }
 
@@ -535,6 +558,104 @@ public:
         return py::reinterpret_steal<py::str>(decoded).cast<std::string>();
     }
 
+#if defined(__APPLE__)
+    static bool is_plausible_string(const std::string &value) {
+        if (value.empty()) {
+            return false;
+        }
+
+        return std::all_of(value.begin(), value.end(), [](const unsigned char c) {
+            return c == '\t' || c == '\n' || c == '\r' || std::isprint(c);
+        });
+    }
+
+    std::optional<std::string> read_libcpp_string(std::uintptr_t address) {
+        const std::string bytes = read_bytes(address, 24);
+        if (bytes.size() != 24) {
+            return std::nullopt;
+        }
+
+        auto read_qword = [&](const std::size_t offset) {
+            std::uintptr_t value = 0;
+            std::memcpy(&value, bytes.data() + offset, sizeof(value));
+            return value;
+        };
+
+        auto read_inline = [&](const std::size_t data_offset, const std::size_t size)
+            -> std::optional<std::string> {
+            if (size == 0 || data_offset + size > bytes.size()) {
+                return std::nullopt;
+            }
+
+            std::string value(bytes.data() + data_offset, size);
+            if (!is_plausible_string(value)) {
+                return std::nullopt;
+            }
+
+            return value;
+        };
+
+        // libc++ short layout used by current Roblox macOS builds stores raw size in byte 0.
+        if (static_cast<unsigned char>(bytes[0]) <= 23) {
+            if (const auto value = read_inline(1, static_cast<unsigned char>(bytes[0]))) {
+                return value;
+            }
+        }
+
+        // Some libc++ layouts shift the short size left by one.
+        if ((static_cast<unsigned char>(bytes[0]) & 1U) == 0 &&
+            (static_cast<unsigned char>(bytes[0]) >> 1) <= 23) {
+            if (const auto value = read_inline(1, static_cast<unsigned char>(bytes[0]) >> 1)) {
+                return value;
+            }
+        }
+
+        // Alternate libc++ layout: short data begins at byte 0 and size is stored in byte 23.
+        if (static_cast<unsigned char>(bytes[23]) <= 23) {
+            if (const auto value = read_inline(0, static_cast<unsigned char>(bytes[23]))) {
+                return value;
+            }
+        }
+
+        if ((static_cast<unsigned char>(bytes[23]) & 1U) == 0 &&
+            (static_cast<unsigned char>(bytes[23]) >> 1) <= 23) {
+            if (const auto value = read_inline(0, static_cast<unsigned char>(bytes[23]) >> 1)) {
+                return value;
+            }
+        }
+
+        auto read_external = [&](std::uintptr_t data_ptr, std::uintptr_t size)
+            -> std::optional<std::string> {
+            if (data_ptr < 0x10000 || size == 0 || size > 4096) {
+                return std::nullopt;
+            }
+
+            std::string value = read_raw_string(data_ptr, static_cast<std::size_t>(size + 1));
+            if (value.size() != size || !is_plausible_string(value)) {
+                return std::nullopt;
+            }
+
+            return value;
+        };
+
+        // libc++ default long layout: cap, size, data.
+        if (static_cast<unsigned char>(bytes[0]) & 1U) {
+            if (const auto value = read_external(read_qword(16), read_qword(8))) {
+                return value;
+            }
+        }
+
+        // libc++ alternate long layout: data, size, cap.
+        if (static_cast<unsigned char>(bytes[23]) & 0x80U) {
+            if (const auto value = read_external(read_qword(0), read_qword(8))) {
+                return value;
+            }
+        }
+
+        return std::nullopt;
+    }
+#endif
+
     void write_raw_string(std::uintptr_t address, const std::string &value, bool null_terminate = true) {
         std::string bytes = value;
         if (null_terminate) {
@@ -586,6 +707,13 @@ public:
 
     std::string read_string(std::uintptr_t address, std::uintptr_t offset = 0) {
         address += offset;
+
+#if defined(__APPLE__)
+        if (const auto value = read_libcpp_string(address)) {
+            return *value;
+        }
+#endif
+
         const int string_length = read_int(address + 0x10);
 
         if (string_length <= 0 || string_length > 1024 * 1024) {
@@ -682,7 +810,11 @@ private:
         }
 
         if (result != KERN_SUCCESS) {
-            raise_python(PyExc_OSError, "mach_vm_read_overwrite failed: " + std::string(mach_error_string(result)));
+            raise_python(
+                PyExc_OSError,
+                "mach_vm_read_overwrite failed: " + std::string(mach_error_string(result)) +
+                    std::string(MACOS_CODESIGN_HINT)
+            );
         }
 
         buffer.resize(static_cast<std::size_t>(bytes_read));

robloxmemoryapi-0.3.2/src/robloxmemoryapi/_version.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from importlib import metadata
+from pathlib import Path
+import re
+
+_DISTRIBUTION_NAME = "robloxmemoryapi"
+
+
+def _read_source_version() -> str | None:
+    for parent in Path(__file__).resolve().parents:
+        pyproject_path = parent / "pyproject.toml"
+        if not pyproject_path.is_file():
+            continue
+
+        in_project_section = False
+        for line in pyproject_path.read_text(encoding="utf-8").splitlines():
+            stripped = line.strip()
+            if stripped == "[project]":
+                in_project_section = True
+                continue
+            if in_project_section and stripped.startswith("["):
+                break
+            if in_project_section:
+                match = re.match(r'version\s*=\s*["\']([^"\']+)["\']', stripped)
+                if match:
+                    return match.group(1)
+
+    return None
+
+
+def _read_installed_version() -> str | None:
+    try:
+        return metadata.version(_DISTRIBUTION_NAME)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _resolve_version() -> str:
+    return _read_source_version() or _read_installed_version() or "0+unknown"
+
+
+__version__ = _resolve_version()
+USER_AGENT = f"RobloxMemoryAPI/{__version__}"

robloxmemoryapi-0.3.2/src/robloxmemoryapi/utils/macos.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import ctypes
+import os
+import platform
+import subprocess
+
+
+def normalize_architecture(architecture: str | None) -> str | None:
+    if not architecture:
+        return None
+
+    normalized = architecture.strip().lower()
+    if normalized in {"arm", "arm64", "aarch64", "apple silicon", "silicon"}:
+        return "arm64"
+    if normalized in {"intel", "x64", "x86_64", "amd64"}:
+        return "x64"
+    return None
+
+
+def process_path(pid: int) -> str | None:
+    if platform.system() != "Darwin" or pid <= 0:
+        return None
+
+    try:
+        libc = ctypes.CDLL(None)
+        proc_pidpath = libc.proc_pidpath
+        proc_pidpath.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_uint32]
+        proc_pidpath.restype = ctypes.c_int
+
+        buffer = ctypes.create_string_buffer(4096)
+        result = proc_pidpath(pid, buffer, ctypes.sizeof(buffer))
+        if result > 0:
+            return os.fsdecode(buffer.value)
+    except Exception:
+        pass
+
+    try:
+        output = subprocess.check_output(
+            ["ps", "-p", str(pid), "-o", "comm="],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip()
+        return output or None
+    except Exception:
+        return None
+
+
+def binary_architecture(path: str | os.PathLike[str] | None) -> str | None:
+    if not path:
+        return None
+
+    path = os.fspath(path)
+    if not os.path.exists(path):
+        return None
+
+    try:
+        output = subprocess.check_output(
+            ["lipo", "-archs", path],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip().lower()
+        architectures = set(output.split())
+        if architectures == {"arm64"}:
+            return "arm64"
+        if architectures <= {"x86_64", "i386"} and "x86_64" in architectures:
+            return "x64"
+    except Exception:
+        pass
+
+    try:
+        output = subprocess.check_output(
+            ["file", "-b", path],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).lower()
+        if "arm64" in output and "x86_64" not in output:
+            return "arm64"
+        if "x86_64" in output and "arm64" not in output:
+            return "x64"
+    except Exception:
+        pass
+
+    return None
+
+
+def running_roblox_binary_path() -> str | None:
+    try:
+        output = subprocess.check_output(
+            [
+                "pgrep",
+                "-f",
+                "/Applications/.*Roblox.*\\.app/Contents/MacOS/RobloxPlayer",
+            ],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except Exception:
+        return None
+
+    for line in output.splitlines():
+        try:
+            pid = int(line.strip())
+        except ValueError:
+            continue
+
+        path = process_path(pid)
+        if path:
+            return path
+
+    return None
+
+
+def installed_roblox_architecture() -> str | None:
+    candidates = [
+        "/Applications/Roblox.app/Contents/MacOS/RobloxPlayer",
+        "/Applications/RobloxPlayer.app/Contents/MacOS/RobloxPlayer",
+    ]
+
+    detected = []
+    for path in candidates:
+        architecture = binary_architecture(path)
+        if architecture:
+            detected.append(architecture)
+
+    if len(set(detected)) == 1:
+        return detected[0]
+    return None
+
+
+def roblox_architecture() -> str:
+    env_architecture = normalize_architecture(os.environ.get("ROBLOXMEMORYAPI_ROBLOX_ARCH"))
+    if env_architecture:
+        return env_architecture
+
+    try:
+        pid = int(os.environ.get("ROBLOXMEMORYAPI_ROBLOX_PID", "0"))
+    except ValueError:
+        pid = 0
+
+    architecture = binary_architecture(process_path(pid))
+    if architecture:
+        return architecture
+
+    architecture = binary_architecture(running_roblox_binary_path())
+    if architecture:
+        return architecture
+
+    architecture = installed_roblox_architecture()
+    if architecture:
+        return architecture
+
+    return "arm64" if platform.machine().lower() in {"arm64", "aarch64"} else "x64"

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

@@ -0,0 +1,43 @@
+import requests
+import platform
+
+from .._version import USER_AGENT
+from .macos import roblox_architecture
+
+IMTHEO_BASE_URL = "https://offsets.imtheo.lol"
+MAC_ARM_OFFSETS_URL = "https://offsets.upio.dev/rbxl-macarm-latest.json"
+MAC_INTEL_OFFSETS_URL = "https://offsets.upio.dev/rbxl-macintel-latest.json"
+REQUEST_HEADERS = {"User-Agent": USER_AGENT}
+
+_macos_roblox_architecture = roblox_architecture
+
+
+def _offsets_url() -> str:
+    if platform.system() != "Darwin":
+        return f"{IMTHEO_BASE_URL}/Offsets.json"
+
+    if roblox_architecture() == "arm64":
+        return MAC_ARM_OFFSETS_URL
+
+    return MAC_INTEL_OFFSETS_URL
+
+# Offsets
+OffsetsRequest = requests.get(_offsets_url(), headers=REQUEST_HEADERS)
+
+try:
+    Offsets = OffsetsRequest.json()["Offsets"]
+except Exception:
+    Offsets = {}
+
+# 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"{IMTHEO_BASE_URL}/FFlags.json", headers=REQUEST_HEADERS)
+        resp.raise_for_status()
+        _fflag_data = resp.json()
+        _fflag_offsets = _fflag_data["FFlagOffsets"]["FFlags"]
+    return _fflag_offsets

{robloxmemoryapi-0.3.1 → robloxmemoryapi-0.3.2}/src/robloxmemoryapi/utils/rbx/instance.py

@@ -70,7 +70,7 @@ _ENABLED_OFFSETS_BY_CLASS = {
     "BloomEffect": bloom_effect_offsets,
     "DepthOfFieldEffect": depth_of_field_effect_offsets,
     "SunRaysEffect": sun_rays_effect_offsets,
-    "ScreenGui": {"Enabled": gui_offsets["ScreenGui_Enabled"]},
+    "ScreenGui": {"Enabled": gui_offsets.get("ScreenGui_Enabled")},
     "ProximityPrompt": proximityprompt_offsets,
     "Tool": tool_offsets,
     "SpawnLocation": spawnlocation_offsets,
@@ -295,6 +295,12 @@ class RBXInstance:
                     f"{property_name} is only available on {self._format_class_list(offsets_by_class)} instances."
                 )
             return None
+        if offsets.get(property_name) is None:
+            if write:
+                raise AttributeError(
+                    f"{property_name} offset is not available for {self.ClassName} instances."
+                )
+            return None
         return offsets
 
     def _read_class_float(self, property_name, offsets_by_class):
@@ -4632,8 +4638,13 @@ class DataModel(ServiceBase):
 
         with self._refresh_lock:
             try:
-                fake_datamodel_ptr = self.memory_module.get_address(Offsets["FakeDataModel"]["Pointer"], pointer=True)
-                datamodel_address_ptr = self.memory_module.get_pointer(fake_datamodel_ptr, Offsets["FakeDataModel"]["RealDataModel"])
+                visual_engine = VisualEngine(self.memory_module)
+                fake_datamodel_ptr = visual_engine.FakeDataModel if not visual_engine.failed else 0
+                datamodel_address_ptr = (
+                    self.memory_module.get_pointer(fake_datamodel_ptr, Offsets["FakeDataModel"]["RealDataModel"])
+                    if fake_datamodel_ptr != 0
+                    else 0
+                )
 
                 if datamodel_address_ptr == 0:
                     if self.instance is not None:

robloxmemoryapi-0.3.1/src/robloxmemoryapi/__init__.py

@@ -1,112 +0,0 @@
-import platform
-import math
-
-__all__ = ["RobloxRandom", "RobloxGameClient", "__version__"]
-__version__ = "0.0.2"
-
-class RobloxRandom:
-    MULT = 6364136223846793005
-    INC = 105
-    MASK64 = (1 << 64) - 1
-
-    def __init__(self, seed):
-        s = math.floor(seed)
-
-        self._state = 0
-        self._inc = RobloxRandom.INC
-        self._next_internal()         # warm-up #1
-        self._state = (self._state + s) & RobloxRandom.MASK64
-        self._next_internal()         # warm-up #2
-
-    def _next_internal(self):
-        old = self._state
-        self._state = (old * RobloxRandom.MULT + self._inc) & RobloxRandom.MASK64
-        x = ((old >> 18) ^ old) >> 27
-        r = old >> 59
-        return ((x >> r) | (x << ((32 - r) & 31))) & 0xFFFFFFFF
-
-    def _next_fraction64(self):
-        lo = self._next_internal()
-        hi = self._next_internal()
-        bits = (hi << 32) | lo
-        return bits / 2**64
-
-    def NextNumber(self, minimum=0.0, maximum=1.0):
-        frac = self._next_fraction64()
-        return minimum + frac * (maximum - minimum)
-
-    def NextInteger(self, a, b=None):
-        if b is None:
-            u = a
-            r = self._next_internal()
-            return ((u * r) >> 32) + 1
-        else:
-            lo, hi = (a, b) if a <= b else (b, a)
-            u = hi - lo + 1
-            r = self._next_internal()
-            return ((u * r) >> 32) + lo
-
-class RobloxGameClient:
-    def __init__(
-        self,
-        pid: int = None,
-        process_name: str = "RobloxPlayerBeta.exe",
-        allow_write: bool = False,
-    ):
-        system = platform.system()
-        if system not in {"Windows", "Darwin"}:
-            self.failed = True
-            return
-
-        from .utils.memory import (
-            EvasiveProcess,
-            PROCESS_QUERY_INFORMATION,
-            PROCESS_VM_READ,
-            PROCESS_VM_WRITE,
-            PROCESS_VM_OPERATION,
-            get_pid_by_name,
-        )
-
-        if system == "Darwin" and process_name == "RobloxPlayerBeta.exe":
-            process_name = "RobloxPlayer"
-
-        if pid is None:
-            self.pid = get_pid_by_name(process_name)
-        else:
-            self.pid = pid
-
-        if self.pid is None or self.pid == 0:
-            raise ValueError("Failed to get PID.")
-
-        desired_access = PROCESS_VM_READ | PROCESS_QUERY_INFORMATION
-        if allow_write:
-            desired_access |= PROCESS_VM_WRITE | PROCESS_VM_OPERATION
-
-        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() not in {"Windows", "Darwin"}:
-            raise RuntimeError("This module is only compatible with Windows and macOS.")
-        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() not in {"Windows", "Darwin"}:
-            raise RuntimeError("This module is only compatible with Windows and macOS.")
-        elif self.failed:
-            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)

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

@@ -1,24 +0,0 @@
-import requests
-
-BASE_URL = "https://offsets.imtheo.lol"
-
-# Offsets
-OffsetsRequest = requests.get(f"{BASE_URL}/Offsets.json")
-
-try:
-    Offsets = OffsetsRequest.json()["Offsets"]
-except:
-    Offsets = {}
-
-# 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