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

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

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

{codrone_edu-2.8 → 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:

{codrone_edu-2.8 → 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.8 → codrone_edu-2.9}/codrone_edu/tools/transformer.py

@@ -369,6 +369,141 @@ class AsyncTransformer(ast.NodeTransformer):
                 return self.copy_location(new_node, node)
         return node
 
+class ModuleAsyncTransformer(ast.NodeTransformer):
+    """
+    Transforms imported user modules to async without wrapping in a _wrapper function.
+    Unlike AsyncTransformer, this does not restructure the module body — it only converts
+    functions to async and adds await to drone/custom calls in-place.
+    Used by transform_imported_module() for user modules loaded via the custom import hook.
+    """
+    def __init__(self, custom_functions, drone_instance_name, function_aliases=None):
+        self.custom_functions = custom_functions
+        self.drone_instance_name = drone_instance_name
+        self.function_aliases = function_aliases if function_aliases else {}
+        self.time_alias = None  # Track what 'time' is imported as
+        self.custom_modules = set()  # Track modules from custom imports
+
+    def copy_location(self, new_node, old_node):
+        ast.copy_location(new_node, old_node)
+        if hasattr(old_node, 'end_lineno'):
+            new_node.end_lineno = old_node.end_lineno
+        if hasattr(old_node, 'end_col_offset'):
+            new_node.end_col_offset = old_node.end_col_offset
+        return new_node
+
+    def visit_Import(self, node):
+        """Track time module imports and custom module imports"""
+        for alias in node.names:
+            if alias.name == 'time':
+                self.time_alias = alias.asname if alias.asname else 'time'
+            else:
+                # Track custom module imports (not library modules)
+                module_name = alias.name.split('.')[0]  # Get root module name
+                if module_name not in LIBRARY_MODULES:
+                    local_name = alias.asname if alias.asname else alias.name
+                    self.custom_modules.add(local_name)
+        return self.generic_visit(node)
+
+    def visit_ImportFrom(self, node):
+        """Track ImportFrom statements for both time and custom modules"""
+        if node.module == 'time':
+            self.time_alias = 'time'
+        elif node.module:
+            # Track custom module imports
+            module_name = node.module.split('.')[0]  # Get root module name
+            if module_name not in LIBRARY_MODULES:
+                # For "from module import x", track imported names
+                for alias in node.names:
+                    local_name = alias.asname if alias.asname else alias.name
+                    if local_name != '*':  # Skip import *
+                        self.custom_modules.add(local_name)
+        return self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        new_node = ast.AsyncFunctionDef(
+            name=node.name,
+            args=node.args,
+            body=node.body,
+            decorator_list=node.decorator_list,
+            returns=node.returns
+        )
+        new_node = self.copy_location(new_node, node)
+        self.generic_visit(new_node)
+        return new_node
+
+    def visit_Call(self, node):
+        # First, visit all arguments and keywords to ensure nested calls are transformed
+        node = self.generic_visit(node)
+
+        if isinstance(node.func, ast.Attribute):
+            # Handle attribute calls (e.g., drone.takeoff(), helper.do_something(), np.array())
+            if isinstance(node.func.value, ast.Name):
+                module_name = node.func.value.id
+                method_name = node.func.attr
+
+                # Check if this is a drone method call (by method name, not variable name)
+                # This allows imported modules to use drone instances with any parameter name
+                if method_name in awaitable_drone_methods:
+                    if method_name in ['pair', 'open', 'connect', 'disconnect', 'close']:
+                        # Replace with dummy_function()
+                        new_node = ast.Call(
+                            func=ast.Attribute(value=node.func.value, attr='dummy_function', ctx=ast.Load()),
+                            args=[], keywords=[]
+                        )
+                        return self.copy_location(new_node, node)
+                    elif method_name not in non_await_drone_functions:
+                        new_node = ast.Await(value=node)
+                        return self.copy_location(new_node, node)
+                elif module_name == self.drone_instance_name:
+                    # Fallback: check if variable is named 'drone' (for any unlisted methods)
+                    if node.func.attr in ['pair', 'open', 'connect', 'disconnect', 'close']:
+                        # Replace with dummy_function()
+                        new_node = ast.Call(
+                            func=ast.Attribute(value=ast.Name(id=self.drone_instance_name, ctx=ast.Load()), attr='dummy_function', ctx=ast.Load()),
+                            args=[], keywords=[]
+                        )
+                        return self.copy_location(new_node, node)
+                    elif node.func.attr not in non_await_drone_functions:
+                        new_node = ast.Await(value=node)
+                        return self.copy_location(new_node, node)
+                elif module_name in self.custom_modules:
+                    # Calls on custom imported modules (e.g., helper.do_something())
+                    new_node = ast.Await(value=node)
+                    return self.copy_location(new_node, node)
+                # Skip library module calls (e.g., np.array(), asyncio.sleep())
+        elif isinstance(node.func, ast.Name):
+            # Direct function calls (e.g., my_function(), some_utility_function())
+            func_name = node.func.id
+
+            # Check if it's a Python built-in function (don't await built-ins)
+            # EXCEPT for input() which is overridden with an async version in Pyodide
+            import builtins
+            if hasattr(builtins, func_name) and func_name != 'input':
+                builtin_obj = getattr(builtins, func_name)
+                # Check if it's callable (a function/class) and not async
+                # Exclude async built-ins like aiter, anext
+                if callable(builtin_obj) and func_name not in {'aiter', 'anext'}:
+                    return node
+
+            # Look up the original function name if this is an alias
+            original_name = self.function_aliases.get(func_name, func_name)
+
+            # Await if it's NOT a known library function
+            # This handles:
+            # - Custom functions defined in the file
+            # - Functions imported from custom modules
+            # - Functions from 'import *' (which we can't track)
+            # - input() calls (overridden with async version in Pyodide)
+            if (func_name in self.custom_functions or
+                original_name in self.custom_functions or
+                func_name in self.custom_modules or
+                func_name == 'input' or
+                func_name not in LIBRARY_MODULES):  # Await unknown functions (could be from import *)
+                new_node = ast.Await(value=node)
+                return self.copy_location(new_node, node)
+        return node
+
+
 class SleepTransformer(ast.NodeTransformer):
     def __init__(self, time_alias=None):
         self.time_alias = time_alias if time_alias else 'time'
@@ -531,136 +666,6 @@ def transform_imported_module(code):
     analyzer = CodeAnalyzer()
     analyzer.visit(tree)
 
-    # Create a modified AsyncTransformer that doesn't wrap in _wrapper
-    class ModuleAsyncTransformer(ast.NodeTransformer):
-        def __init__(self, custom_functions, drone_instance_name, function_aliases=None):
-            self.custom_functions = custom_functions
-            self.drone_instance_name = drone_instance_name
-            self.function_aliases = function_aliases if function_aliases else {}
-            self.time_alias = None  # Track what 'time' is imported as
-            self.custom_modules = set()  # Track modules from custom imports
-
-        def copy_location(self, new_node, old_node):
-            ast.copy_location(new_node, old_node)
-            if hasattr(old_node, 'end_lineno'):
-                new_node.end_lineno = old_node.end_lineno
-            if hasattr(old_node, 'end_col_offset'):
-                new_node.end_col_offset = old_node.end_col_offset
-            return new_node
-
-        def visit_Import(self, node):
-            """Track time module imports and custom module imports"""
-            for alias in node.names:
-                if alias.name == 'time':
-                    self.time_alias = alias.asname if alias.asname else 'time'
-                else:
-                    # Track custom module imports (not library modules)
-                    module_name = alias.name.split('.')[0]  # Get root module name
-                    if module_name not in LIBRARY_MODULES:
-                        local_name = alias.asname if alias.asname else alias.name
-                        self.custom_modules.add(local_name)
-            return self.generic_visit(node)
-
-        def visit_ImportFrom(self, node):
-            """Track ImportFrom statements for both time and custom modules"""
-            if node.module == 'time':
-                self.time_alias = 'time'
-            elif node.module:
-                # Track custom module imports
-                module_name = node.module.split('.')[0]  # Get root module name
-                if module_name not in LIBRARY_MODULES:
-                    # For "from module import x", track imported names
-                    for alias in node.names:
-                        local_name = alias.asname if alias.asname else alias.name
-                        if local_name != '*':  # Skip import *
-                            self.custom_modules.add(local_name)
-            return self.generic_visit(node)
-
-        # Don't wrap module - just transform functions
-        def visit_FunctionDef(self, node):
-            new_node = ast.AsyncFunctionDef(
-                name=node.name,
-                args=node.args,
-                body=node.body,
-                decorator_list=node.decorator_list,
-                returns=node.returns
-            )
-            new_node = self.copy_location(new_node, node)
-            self.generic_visit(new_node)
-            return new_node
-
-        def visit_Call(self, node):
-            # First, visit all arguments and keywords to ensure nested calls are transformed
-            node = self.generic_visit(node)
-
-            if isinstance(node.func, ast.Attribute):
-                # Handle attribute calls (e.g., drone.takeoff(), helper.do_something(), np.array())
-                if isinstance(node.func.value, ast.Name):
-                    module_name = node.func.value.id
-                    method_name = node.func.attr
-
-                    # Check if this is a drone method call (by method name, not variable name)
-                    # This allows imported modules to use drone instances with any parameter name
-                    if method_name in awaitable_drone_methods:
-                        if method_name in ['pair', 'open', 'connect', 'disconnect', 'close']:
-                            # Replace with dummy_function()
-                            new_node = ast.Call(
-                                func=ast.Attribute(value=node.func.value, attr='dummy_function', ctx=ast.Load()),
-                                args=[], keywords=[]
-                            )
-                            return self.copy_location(new_node, node)
-                        elif method_name not in non_await_drone_functions:
-                            new_node = ast.Await(value=node)
-                            return self.copy_location(new_node, node)
-                    elif module_name == self.drone_instance_name:
-                        # Fallback: check if variable is named 'drone' (for any unlisted methods)
-                        if node.func.attr in ['pair', 'open', 'connect', 'disconnect', 'close']:
-                            # Replace with dummy_function()
-                            new_node = ast.Call(
-                                func=ast.Attribute(value=ast.Name(id=self.drone_instance_name, ctx=ast.Load()), attr='dummy_function', ctx=ast.Load()),
-                                args=[], keywords=[]
-                            )
-                            return self.copy_location(new_node, node)
-                        elif node.func.attr not in non_await_drone_functions:
-                            new_node = ast.Await(value=node)
-                            return self.copy_location(new_node, node)
-                    elif module_name in self.custom_modules:
-                        # Calls on custom imported modules (e.g., helper.do_something())
-                        new_node = ast.Await(value=node)
-                        return self.copy_location(new_node, node)
-                    # Skip library module calls (e.g., np.array(), asyncio.sleep())
-            elif isinstance(node.func, ast.Name):
-                # Direct function calls (e.g., my_function(), some_utility_function())
-                func_name = node.func.id
-
-                # Check if it's a Python built-in function (don't await built-ins)
-                # EXCEPT for input() which is overridden with an async version in Pyodide
-                import builtins
-                if hasattr(builtins, func_name) and func_name != 'input':
-                    builtin_obj = getattr(builtins, func_name)
-                    # Check if it's callable (a function/class) and not async
-                    # Exclude async built-ins like aiter, anext
-                    if callable(builtin_obj) and func_name not in {'aiter', 'anext'}:
-                        return node
-
-                # Look up the original function name if this is an alias
-                original_name = self.function_aliases.get(func_name, func_name)
-
-                # Await if it's NOT a known library function
-                # This handles:
-                # - Custom functions defined in the file
-                # - Functions imported from custom modules
-                # - Functions from 'import *' (which we can't track)
-                # - input() calls (overridden with async version in Pyodide)
-                if (func_name in self.custom_functions or
-                    original_name in self.custom_functions or
-                    func_name in self.custom_modules or
-                    func_name == 'input' or
-                    func_name not in LIBRARY_MODULES):  # Await unknown functions (could be from import *)
-                    new_node = ast.Await(value=node)
-                    return self.copy_location(new_node, node)
-            return node
-
     # Transform the AST (without module wrapper)
     module_transformer = ModuleAsyncTransformer(
         analyzer.custom_functions,

{codrone_edu-2.8 → codrone_edu-2.9}/codrone_edu.egg-info/PKG-INFO

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

{codrone_edu-2.8 → codrone_edu-2.9}/setup.py

@@ -22,7 +22,7 @@ Python package for controlling CoDrone EDU.
 
 setup(
     name='codrone_edu',
-    version='2.8',
+    version='2.9',
     description='Python CoDrone EDU library',
     url='',
     author='',