wandelbots-nova 2.7.2__tar.gz → 2.7.3__tar.gz

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandelbots-nova
-Version: 2.7.2
+Version: 2.7.3
 Summary: Official Python SDK for the Wandelbots Nova
 Author: Wandelbots GmbH
 Author-email: Christoph Biering <christoph.biering@wandelbots.com>, Mahsum Demir <mahsum.demir@wandelbots.com>, Dirk Sonnemann <dirk.sonnemann@wandelbots.com>, Andreas Langenhagen <andreas.langenhagen@wandelbots.com>, Stefan Wagner <stefan.wagner@wandelbots.com>, André Kühnert <andre.kuhnert@wandelbots.com>

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/novax/novax.py

@@ -9,7 +9,7 @@ from nova.core.logging import logger
 from nova.program.function import Program
 from nova.program.store import Program as StoreProgram
 from nova.program.store import ProgramStore
-from novax.program_manager import ProgramDetails, ProgramManager, ProgramSource
+from novax.program_manager import ProgramDetails, ProgramManager
 
 # Read BASE_PATH environment variable and extract app name
 _BASE_PATH = config("BASE_PATH", default="/default/novax")
@@ -34,14 +34,6 @@ class Novax:
         """Get the program manager instance"""
         return self._program_manager
 
-    def register_program_source(self, program_source: ProgramSource) -> None:
-        """Register a program source"""
-        self._program_manager.register_program_source(program_source)
-
-    def deregister_program_source(self, program_source: ProgramSource) -> None:
-        """Deregister a program source"""
-        self._program_manager.deregister_program_source(program_source)
-
     def register_program(self, program: Program) -> str:
         """
         Register a function or wandelscript file as a program.

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/novax/program_manager.py

@@ -1,37 +1,12 @@
 import datetime as dt
 import inspect
-from pathlib import Path
-from typing import Any, AsyncIterator, Optional, Protocol
+from typing import Any, Optional
 
-from loguru import logger
 from pydantic import BaseModel
 
-import nova
-from nova import Nova
 from nova.cell.robot_cell import RobotCell
 from nova.program.function import Program, ProgramPreconditions
 from nova.program.runner import ExecutionContext, ProgramRun, ProgramRunner
-from wandelscript.ffi_loader import load_foreign_functions
-
-try:
-    import wandelscript
-
-    WANDELSCRIPT_AVAILABLE = True
-except ImportError:
-    WANDELSCRIPT_AVAILABLE = False
-
-
-class ProgramSource(Protocol):
-    """Protocol for program sources that can be registered with ProgramManager"""
-
-    def get_programs(self, program_manager: "ProgramManager") -> AsyncIterator[Program]:
-        """
-        Discover and yield all programs from this source.
-
-        Yields:
-            Program: A Program object (decorated with @nova.program)
-        """
-        ...
 
 
 class NovaxProgramRunner(ProgramRunner):
@@ -84,7 +59,6 @@ class ProgramManager:
         self._programs: dict[str, ProgramDetails] = {}
         self._program_functions: dict[str, Program] = {}
         self._runner: NovaxProgramRunner | None = None
-        self._program_sources: list[ProgramSource] = []
         self._robot_cell_override: RobotCell | None = robot_cell_override
 
     def has_program(self, program_id: str) -> bool:
@@ -98,25 +72,6 @@ class ProgramManager:
     def running_program(self) -> Optional[str]:
         return self._runner.program_id if self.is_any_program_running and self._runner else None
 
-    def register_program_source(self, program_source: ProgramSource) -> None:
-        """
-        Register a program source with the program manager.
-
-        Args:
-            program_source: The program source to register
-        """
-        self._program_sources.append(program_source)
-
-    def deregister_program_source(self, program_source: ProgramSource) -> None:
-        """
-        Deregister a program source from the program manager.
-
-        Args:
-            program_source: The program source to deregister
-        """
-        if program_source in self._program_sources:
-            self._program_sources.remove(program_source)
-
     def register_program(self, program: Program) -> str:
         """
         Register a function as a program.
@@ -161,9 +116,6 @@ class ProgramManager:
 
     async def get_programs(self) -> dict[str, ProgramDetails]:
         """Get all registered programs"""
-        for program_source in self._program_sources:
-            async for program in program_source.get_programs(self):
-                self.register_program(program)
         return self._programs.copy()
 
     async def get_program(self, program_id: str) -> Optional[ProgramDetails]:
@@ -171,11 +123,7 @@ class ProgramManager:
         return self._programs.get(program_id)
 
     async def start_program(
-        self,
-        program_id: str,
-        parameters: dict[str, Any] | None = None,
-        sync: bool = False,
-        simulate: bool = False,
+        self, program_id: str, parameters: dict[str, Any] | None = None, sync: bool = False
     ) -> ProgramRun:
         """Start a registered program with given parameters"""
         if self.is_any_program_running:
@@ -203,70 +151,3 @@ class ProgramManager:
 
         self._runner.stop(sync=True)
         self._runner = None
-
-
-# Example implementations of ProgramSource
-
-
-class WandelscriptProgramSource:
-    def __init__(self, scan_paths: list[Path], foreign_functions_paths: list[Path] | None = None):
-        """
-        Initialize the WandelscriptProgramSource with a list of paths to scan.
-
-        Args:
-            scan_paths: List of paths to scan for .ws files. Can be individual files or directories.
-            foreign_functions: Optional dictionary of foreign functions to attach to all programs.
-        """
-        self.scan_paths = scan_paths
-        self.foreign_functions = (
-            load_foreign_functions(foreign_functions_paths) if foreign_functions_paths else {}
-        )
-
-    async def get_programs(self, program_manager: "ProgramManager") -> AsyncIterator[Program]:
-        """Discover and yield programs from filesystem"""
-        for path in self.scan_paths:
-            if not path.exists():
-                logger.warning(f"Path does not exist: {path}")
-                continue
-
-            if path.is_file():
-                # Single file
-                if path.suffix == ".ws":
-                    yield self._create_wandelscript_program(path)
-            elif path.is_dir():
-                # Directory - scan for .ws files
-                for file_path in path.glob("*.ws"):
-                    yield self._create_wandelscript_program(file_path)
-
-    def _create_wandelscript_program(self, path: Path) -> Program:
-        """Create a nova.program wrapper for a wandelscript file"""
-        if not WANDELSCRIPT_AVAILABLE:
-            raise ImportError(
-                f"Cannot register wandelscript file {path}: wandelscript package is not installed. "
-                "Please install it with 'pip install wandelscript' or 'uv add wandelscript'"
-            )
-
-        # Create program ID from filename
-        program_id = path.stem
-        logger.info(f"Creating wandelscript program: {program_id}")
-
-        # Create a wrapper function
-        @nova.program(id=program_id)
-        async def wandelscript_wrapper():
-            async with Nova() as nova:
-                robot_cell = await nova.cell().get_robot_cell()
-                # Read the file content
-                with open(path) as f:
-                    program_content = f.read()
-
-                result = wandelscript.run(
-                    program_id=program_id,
-                    program=program_content,
-                    # TODO: Also pass args
-                    args={},
-                    foreign_functions=self.foreign_functions,
-                    robot_cell_override=robot_cell,
-                )
-                return result
-
-        return wandelscript_wrapper

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wandelbots-nova"
-version = "2.7.2"
+version = "2.7.3"
 description = "Official Python SDK for the Wandelbots Nova"
 authors = [
     { name = "Wandelbots GmbH" },

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/tests/novax/test_program_manager.py

@@ -229,26 +229,3 @@ async def test_get_program():
     # Test getting non-existent program
     non_existent = await manager.get_program("nonexistent")
     assert non_existent is None
-
-
-@pytest.mark.asyncio
-async def test_program_source_integration():
-    """Test integration with program sources"""
-    manager = ProgramManager(robot_cell_override=SimulatedRobotCell())
-
-    # Create a simple program source
-    class SimpleProgramSource:
-        async def get_programs(self, program_manager):
-            yield simple_program
-            yield parameterized_program
-
-    # Register the program source
-    source = SimpleProgramSource()
-    manager.register_program_source(source)
-
-    # Get programs (this should trigger source discovery)
-    programs = await manager.get_programs()
-
-    # Verify programs from source are registered
-    assert "simple_program_test" in programs
-    assert "parameterized_program" in programs

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/wandelscript/__init__.py

@@ -14,7 +14,7 @@ Vector3d(x=0.0, y=1.0, z=5.0)
 import wandelscript.antlrvisitor  # load Program.from_code # noqa: F401
 from wandelscript import builtins, motions
 from wandelscript.metamodel import Program, register_builtin_func
-from wandelscript.runner import ProgramRunner, run
+from wandelscript.runner import ProgramRunner, create_wandelscript_program, run
 from wandelscript.runtime import Store
 from wandelscript.version import version
 
@@ -34,4 +34,5 @@ __all__ = [
     "register_builtin_func",
     "motions",
     "builtins",
+    "create_wandelscript_program",
 ]

{wandelbots_nova-2.7.2 → wandelbots_nova-2.7.3}/wandelscript/runner.py

@@ -1,11 +1,17 @@
+from pathlib import Path
+
 from loguru import logger
 
+import nova
+from nova import Nova
 from nova.cell.robot_cell import RobotCell
+from nova.program import Program
 from nova.program import ProgramRunner as NovaProgramRunner
 from nova.program.runner import ExecutionContext as NovaExecutionContext
 from nova.program.runner import ProgramRun
 from wandelscript.datatypes import ElementType
 from wandelscript.ffi import ForeignFunction
+from wandelscript.ffi_loader import load_foreign_functions
 from wandelscript.metamodel import Program as WandelscriptProgram
 from wandelscript.runtime import ExecutionContext
 
@@ -97,3 +103,36 @@ def run(
     )
     runner.start(sync=True)
     return runner
+
+
+def create_wandelscript_program(
+    program_id: str,
+    code: str,
+    args: dict[str, ElementType] = {},
+    foreign_functions_paths: list[Path] | None = None,
+    default_robot: str | None = None,
+    default_tcp: str | None = None,
+) -> Program:
+    logger.info(f"Creating wandelscript program: {program_id}")
+    foreign_functions = (
+        load_foreign_functions(foreign_functions_paths) if foreign_functions_paths else {}
+    )
+
+    @nova.program(id=program_id)
+    async def wandelscript_wrapper():
+        async with Nova() as nova:
+            robot_cell = await nova.cell().get_robot_cell()
+
+            # TODO: Don't create another runner here, just execute the program
+            result = run(
+                program_id=program_id,
+                program=code,
+                args=args,
+                foreign_functions=foreign_functions,
+                robot_cell_override=robot_cell,
+                default_robot=default_robot,
+                default_tcp=default_tcp,
+            )
+            return result
+
+    return wandelscript_wrapper

wandelbots_nova-2.7.2/tests/novax/test_program_sources.py

@@ -1,103 +0,0 @@
-import asyncio
-from pathlib import Path
-from typing import AsyncIterator
-
-import pytest
-
-import nova
-from novax import Novax
-from novax.program_manager import ProgramManager, WandelscriptProgramSource
-
-
-@nova.program(id="simple_program")
-async def simple_program(number_of_steps: int = 30):
-    print("Hello World!")
-
-    for i in range(number_of_steps):
-        print(f"Step: {i}")
-        await asyncio.sleep(1)
-
-    print("Finished Hello World!")
-
-
-@pytest.fixture
-def wandelscript_source():
-    return WandelscriptProgramSource(
-        scan_paths=[Path("./examples/wandelscript_ffi.ws")],
-        foreign_functions_paths=[Path("./examples/wandelscript_ffi.py")],
-    )
-
-
-@pytest.fixture
-def novax_with_program_sources(wandelscript_source):
-    """Example using the new protocol-based approach"""
-    # Create a standard program manager
-    program_manager = ProgramManager()
-
-    # Register program sources instead of using inheritance
-    program_manager.register_program_source(wandelscript_source)
-
-    novax = Novax(program_manager_override=program_manager)
-    app = novax.create_app()
-    novax.include_programs_router(app)
-
-    # Register Python programs (existing functionality)
-    novax.register_program(simple_program)
-    return app
-
-
-def test_register_program_source(wandelscript_source):
-    """Test registering a program source with the program manager"""
-    program_manager = ProgramManager()
-    program_manager.register_program_source(wandelscript_source)
-
-    # Verify the source was registered
-    assert len(program_manager._program_sources) == 1
-    assert wandelscript_source in program_manager._program_sources
-
-
-def test_deregister_program_source(wandelscript_source):
-    """Test unregistering a program source"""
-    program_manager = ProgramManager()
-    program_manager.register_program_source(wandelscript_source)
-
-    # Verify registration
-    assert wandelscript_source in program_manager._program_sources
-
-    # Unregister
-    program_manager.deregister_program_source(wandelscript_source)
-
-    # Verify unregistration
-    assert wandelscript_source not in program_manager._program_sources
-
-
-@pytest.mark.asyncio
-async def test_discover_programs_from_source(wandelscript_source):
-    """Test that programs are discovered and registered from a source"""
-    program_manager = ProgramManager()
-    program_manager.register_program_source(wandelscript_source)
-
-    # Verify programs were registered
-    programs = await program_manager.get_programs()
-    assert "wandelscript_ffi" in programs
-
-
-@pytest.mark.asyncio
-async def test_multiple_program_sources(wandelscript_source):
-    """Test using multiple program sources"""
-    from novax.program_manager import Program, ProgramSource
-
-    class TestProgramSource(ProgramSource):
-        async def get_programs(self, program_manager: ProgramManager) -> AsyncIterator[Program]:
-            yield simple_program
-
-    program_manager = ProgramManager()
-
-    # Register both sources
-    program_manager.register_program_source(TestProgramSource())
-    program_manager.register_program_source(wandelscript_source)
-
-    # Verify programs from both sources were registered
-    programs = await program_manager.get_programs()
-    assert "simple_program" in programs
-    assert "wandelscript_ffi" in programs