codrone-edu 2.6__tar.gz → 2.9__tar.gz

{codrone_edu-2.6 → codrone_edu-2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codrone_edu
-Version: 2.6
+Version: 2.9
 Summary: Python CoDrone EDU library
 Home-page: 
 Author: 

{codrone_edu-2.6 → codrone_edu-2.9}/codrone_edu/drone.py

@@ -182,6 +182,8 @@ class Drone:
         self._cpuId = []
         self._battery = 0
         self._system = ModeSystem.Error
+        self._state_update_count = 0
+        self._last_state_update_time = 0.0
 
         self.timeStartProgram = time.time()  # Program Start Time Recording
 
@@ -1142,6 +1144,10 @@ class Drone:
         self.state_data[6] = drone_type.battery
         self.state_data[7] = drone_type.modeMovement
         self.state_data[8] = drone_type.controlSpeed
+        if sys.platform == 'emscripten':
+            self._battery = drone_type.battery
+            self._state_update_count += 1
+            self._last_state_update_time = time.time()
 
     def get_state_data(self, delay=0.01):
         if sys.platform != 'emscripten' and not self._swarm:
@@ -1162,10 +1168,14 @@ class Drone:
         return self.state_data
     
     async def _get_state_data_emscripten(self, delay=0.01):
+        prev_count = self._state_update_count
         await self.sendRequest(DeviceType.Drone, DataType.State)
         await asyncio.sleep(delay)
         self._system = self.state_data[1]
-        self._battery = self.state_data[6]
+        if self._state_update_count == prev_count:
+            # No response this call — only zero battery if data is genuinely stale
+            if time.time() - self._last_state_update_time > 2.0:
+                self._battery = 0
         self.state_data[1] = ModeSystem.Error
         self.state_data[6] = 0
         return self.state_data
@@ -1192,9 +1202,7 @@ class Drone:
 
     async def _get_battery_emscripten(self):
         await self.get_state_data(delay=0.02)
-        battery = self._battery
-        self._battery = 0
-        return battery
+        return self._battery
 
     def get_system_state(self):
         if sys.platform != 'emscripten' and not self._swarm:
@@ -3022,7 +3030,7 @@ class Drone:
         :param power: int from -100-100
         :return: None
         """
-        self._control.roll = int(power)
+        self._control.roll = max(-100, min(100, int(power)))
 
     def set_pitch(self, power):
         """
@@ -3031,7 +3039,7 @@ class Drone:
         :param power: int from 100-100
         :return: None
         """
-        self._control.pitch = int(power)
+        self._control.pitch = max(-100, min(100, int(power)))
 
     def set_yaw(self, power):
         """
@@ -3040,7 +3048,7 @@ class Drone:
         :param power: int from -100-100
         :return: None
         """
-        self._control.yaw = int(power)
+        self._control.yaw = max(-100, min(100, int(power)))
 
     def set_throttle(self, power):
         """
@@ -3049,7 +3057,7 @@ class Drone:
         :param power: int from -100-100
         :return: None
         """
-        self._control.throttle = int(power)
+        self._control.throttle = max(-100, min(100, int(power)))
 
     def move(self, duration=None):
         """

{codrone_edu-2.6 → codrone_edu-2.9}/codrone_edu/system.py

@@ -77,7 +77,10 @@ class ModelNumber(Enum):
     
     Drone_12_Controller_P1  = 0x000C2001  # Drone_12_Controller_P1 (CDE JROTC ed.)
     Drone_12_Drone_P1       = 0x000C1002  # Drone_12_Drone_P1 (CDE JROTC ed.)
+    Drone_8_Drone_P3        = 0x00081003  # Drone_8_Drone_P3 CoDrone EDU (IMU)
 
+    Drone_12_Controller_P10 = 0x000C200A  # CDEP Controller
+    Drone_12_Drone_P10      = 0x000C100A  # CDEP Drone
 
 
 class DeviceType(Enum):

codrone_edu-2.9/codrone_edu/tools/module_loader.py

@@ -0,0 +1,110 @@
+"""
+Custom import system for user modules in Pyodide environment.
+Handles import hook installation, path management, and module transformation
+"""
+
+import importlib
+import importlib.abc
+import importlib.machinery
+import os
+import sys
+
+
+class TransformingLoader(importlib.abc.Loader):
+    """Loader that transforms user modules using transform_imported_module before execution."""
+
+    def __init__(self, fullname, path):
+        self.fullname = fullname
+        self.path = path
+
+    def get_filename(self, fullname):
+        return self.path
+
+    def exec_module(self, module):
+        from codrone_edu.tools.transformer import transform_imported_module
+
+        # Read the source file
+        with open(self.path, 'r') as f:
+            source = f.read()
+
+        # Transform the code for imported modules (no wrapper, no drone init)
+        try:
+            transformed_ast, transformed_code = transform_imported_module(source)
+            # Execute the transformed code in the module's namespace
+            code_obj = compile(transformed_ast, self.path, 'exec')
+            exec(code_obj, module.__dict__)
+        except Exception as e:
+            # If transformation fails, execute original code
+            try:
+                import js
+                js.console.log(f"Warning: Could not transform module {self.fullname}: {str(e)}")
+                import traceback
+                js.console.log(traceback.format_exc())
+            except:
+                # js module not available (not in Pyodide), just print
+                print(f"Warning: Could not transform module {self.fullname}: {str(e)}")
+
+            exec(compile(source, self.path, 'exec'), module.__dict__)
+
+
+class TransformingFinder(importlib.abc.MetaPathFinder):
+    """MetaPathFinder that intercepts imports from user directories."""
+
+    def find_spec(self, fullname, path, target=None):
+        # Only transform modules from user directories
+        search_paths = path if path is not None else sys.path
+
+        # Early exit: if no user paths to search, skip entirely
+        has_user_path = any(
+            entry.startswith(('/mnt/pfr', '/mnt/blockly'))
+            for entry in search_paths
+        )
+        if not has_user_path:
+            return None
+
+        for entry in search_paths:
+            if entry.startswith(('/mnt/pfr', '/mnt/blockly')):
+                # Try to find the module file using full dotted path
+                parts = fullname.split('.')
+
+                # For submodule imports (e.g., package.module_1), when path is provided
+                # and points to the package directory, only use the last part of the name
+                if path is not None and len(parts) > 1:
+                    # This is a submodule import from within a package
+                    # path already points to package dir, so only use the submodule name
+                    module_file = os.path.join(entry, parts[-1]) + '.py'
+                else:
+                    # Top-level import from sys.path
+                    # Convert dotted name to file path (e.g., utils.helpers -> utils/helpers.py)
+                    module_file = os.path.join(entry, *parts) + '.py'
+
+                if os.path.exists(module_file):
+                    loader = TransformingLoader(fullname, module_file)
+                    spec = importlib.machinery.ModuleSpec(fullname, loader, origin=module_file)
+                    spec.has_location = True
+                    return spec
+
+                # Check if it's a package (directory with __init__.py)
+                # Only check when importing from sys.path (not when path is a package subdir)
+                if path is None:
+                    package_init = os.path.join(entry, *parts, '__init__.py')
+                    if os.path.exists(package_init):
+                        loader = TransformingLoader(fullname, package_init)
+                        spec = importlib.machinery.ModuleSpec(fullname, loader, origin=package_init)
+                        spec.has_location = True
+                        spec.submodule_search_locations = [os.path.join(entry, *parts)]
+                        return spec
+
+        return None
+
+
+
+
+def install_import_hook():
+    """Install the import hook at the beginning of sys.meta_path."""
+    # Check if already installed
+    for finder in sys.meta_path:
+        if isinstance(finder, TransformingFinder):
+            return  # Already installed
+
+    sys.meta_path.insert(0, TransformingFinder())

codrone_edu-2.9/codrone_edu/tools/scrubber.py

@@ -0,0 +1,111 @@
+import os
+import sys
+import importlib
+
+def clear_user_module_cache():
+    """
+    Clear all user modules from sys.modules cache.
+
+    This removes cached modules from /mnt/pfr and /mnt/blockly to ensure
+    fresh imports on each code execution. This is important because module
+    cache can cause stale code to be used if a file is modified between runs.
+
+    Also handles namespace packages (no __init__.py) which have __file__ = None
+    but __path__ pointing to user directories.
+    """
+    user_prefixes = ('/mnt/pfr', '/mnt/blockly')
+
+    modules_to_remove = []
+    for mod_name, mod in sys.modules.items():
+        # Check 1: Module has __file__ starting with user prefix
+        if hasattr(mod, '__file__') and mod.__file__:
+            if mod.__file__.startswith(user_prefixes):
+                modules_to_remove.append(mod_name)
+                continue
+
+        # Check 2: Namespace package with __path__ in user directories
+        # Namespace packages have __file__ = None but __path__ set
+        if hasattr(mod, '__path__'):
+            mod_path = getattr(mod, '__path__', None)
+            if mod_path:
+                # __path__ can be a list or _NamespacePath object
+                path_list = list(mod_path) if hasattr(mod_path, '__iter__') else []
+                for p in path_list:
+                    if isinstance(p, str) and p.startswith(user_prefixes):
+                        modules_to_remove.append(mod_name)
+                        break
+
+    for mod in modules_to_remove:
+        del sys.modules[mod]
+
+    # Also invalidate import caches to handle renamed/moved modules
+    importlib.invalidate_caches()
+
+def rebuild_python_path():
+    """
+    Clear user script paths from sys.path.
+
+    This removes /mnt/pfr and /mnt/blockly from sys.path to prevent
+    stale module imports from user code directories.
+    """
+    sys.path = [
+        p for p in sys.path
+        if not p.startswith(('/mnt/pfr', '/mnt/blockly'))
+    ]
+
+def cleanup_wildcard_imports_and_path(script_dir, exec_globals):
+    """
+    Clean up wildcard imports from the global namespace.
+
+    This function is called after user code execution to remove all names that were
+    imported via wildcard imports (e.g., from module import *), while preserving
+    the original initialization imports.
+
+    Args:
+        script_dir: The script's directory to remove from sys.path
+        exec_globals: The globals dictionary from the main execution context
+
+    Requires the following to be in exec_globals:
+    - _wildcard_cleanup_modules: List of module names to clean up (added by transformer)
+    - _globals_before_user_code: Set of global names before user code execution
+
+    This prevents namespace pollution between different code executions while maintaining
+    the necessary imports from PyodideManager initialization.
+    """
+
+    if script_dir and script_dir in sys.path and script_dir != '/mnt/pfr' and script_dir != '/mnt/blockly':
+        sys.path.remove(script_dir)
+
+    if '_wildcard_cleanup_modules' not in exec_globals:
+        return
+
+    # Check if we have the snapshot of globals before user code
+    if '_globals_before_user_code' in exec_globals:
+        globals_before = exec_globals['_globals_before_user_code']
+
+        for module_name in exec_globals['_wildcard_cleanup_modules']:
+            try:
+                # Import the module so we can access it for cleanup
+                module = importlib.import_module(module_name)
+
+                # Get all public names from the module
+                imported_names = [name for name in dir(module) if not name.startswith('_')]
+
+                # Delete each imported name from globals, but preserve initialization imports
+                for name in imported_names:
+                    # Only delete if it was added by user code (not present before)
+                    if name in exec_globals and name not in globals_before:
+                        del exec_globals[name]
+            except Exception:
+                print("Error during cleanup of module:", module_name)
+                pass
+
+        # Clean up the tracking variable
+        del exec_globals['_wildcard_cleanup_modules']
+    else:
+        # If we don't have the snapshot, just delete the tracking variable
+        del exec_globals['_wildcard_cleanup_modules']
+
+    # Clean up our snapshot variable
+    if '_globals_before_user_code' in exec_globals:
+        del exec_globals['_globals_before_user_code']