tilemap-editor 2.0.6__tar.gz → 2.0.7__tar.gz

{tilemap_editor-2.0.6/src/tilemap_editor.egg-info → tilemap_editor-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 2.0.6
+Version: 2.0.7
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -12,6 +12,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pygame-ce>=2.5
+Requires-Dist: numpy>=1.0
+Requires-Dist: Pillow>=10.0
 Dynamic: license-file
 
 # tilemap-editor

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "2.0.6"
+version = "2.0.7"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -12,6 +12,8 @@ license = { text = "Proprietary" }
 authors = [{ name = "tilemap editor contributors" }]
 dependencies = [
   "pygame-ce>=2.5",
+  "numpy>=1.0",
+  "Pillow>=10.0",
 ]
 classifiers = [
   "Programming Language :: Python :: 3",

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/editor.py

@@ -70,12 +70,77 @@ def setup_error_logging():
 logger = setup_error_logging()
 
 
+def _load_project_config() -> tuple[Path, Path, dict]:
+    """Load and validate settings.json from current working directory.
+
+    Returns:
+        Tuple of (base_path, data_root, config)
+
+    Raises:
+        RuntimeError: If settings.json is invalid or missing
+    """
+    settings_file = Path.cwd() / "settings.json"
+
+    if not settings_file.exists():
+        raise RuntimeError(
+            "settings.json not found. Run 'tilemap-editor init' first."
+        )
+
+    try:
+        with open(settings_file, "r", encoding="utf-8") as f:
+            config = json.load(f)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"Invalid settings.json: {e}")
+
+    # Validate required fields
+    required_fields = ["base_path", "data_path", "error_handler"]
+    for field in required_fields:
+        if field not in config:
+            raise RuntimeError(f"Invalid settings.json: missing '{field}'")
+
+    base_path = Path(config["base_path"]).expanduser()
+
+    if not base_path.is_absolute():
+        raise RuntimeError("base_path must be absolute")
+
+    base_path = base_path.resolve()
+
+    venv_path = Path(sys.prefix).resolve()
+    if venv_path in base_path.parents:
+        raise RuntimeError("base_path cannot be inside virtual environment")
+
+    # Validate data_path is relative, not absolute
+    data_path = config["data_path"]
+    if Path(data_path).is_absolute():
+        raise RuntimeError("data_path must be relative, not absolute")
+
+    data_root = base_path / data_path
+
+    if not data_root.exists():
+        raise RuntimeError(f"Data directory not found: {data_root}. Run 'tilemap-editor init' to create project structure.")
+
+    # Initialize error_handler with proper paths
+    log_root = data_root / "logs"
+
+    # Create logs directory only, don't create data root
+    log_root.mkdir(parents=True, exist_ok=True)
+
+    from utils.error_handler import init_error_handler
+    init_error_handler(log_root=log_root, config=config["error_handler"])
+
+    return base_path, data_root, config
+
+
 # Backwards-compatible alias for existing editor.py call sites
 _launch_standalone_module = launch_standalone
 
 
 class Editor:
     def __init__(self, size: Optional[Tuple[int, int]] = None, fps=60):
+        self.base_path, self.data_root, self.config = _load_project_config()
+        logger.info(f"Project base_path: {self.base_path}")
+        logger.info(f"Data root: {self.data_root}")
+
         pygame.init()
         pygame.display.set_caption("Pure Pygame Editor")
 
@@ -189,13 +254,12 @@ class Editor:
 
         if initial_dir:
             try:
-                rel_path = initial_dir.relative_to(BASE_PATH)
+                rel_path = initial_dir.relative_to(self.base_path)
                 args.extend(["--initial-dir", str(rel_path)])
             except ValueError:
-                # Not relative to BASE_PATH, use absolute
                 args.extend(["--initial-dir", str(initial_dir)])
         else:
-            args.extend(["--initial-dir", "data"])
+            args.extend(["--initial-dir", str(self.base_path / "data")])
 
         # Add allowed extensions
         if allowed_exts:
@@ -214,7 +278,7 @@ class Editor:
             self.file_manager_process = launch_standalone(
                 "standalone_filemanager",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
 
@@ -328,7 +392,7 @@ class Editor:
         if self.tilemap.active_project_path:
             default_name = self.tilemap.active_project_path.name
         self.open_file_manager(
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".json"],
             mode="save",
             default_name=default_name,
@@ -350,7 +414,7 @@ class Editor:
     def perform_load(self):
         self.open_file_manager(
             on_select=self.on_map_file_selected,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".json"],
         )
 
@@ -596,7 +660,7 @@ class Editor:
 
         self.open_file_manager(
             on_select=self._launch_animation_editor_with_image,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".png", ".jpg", ".jpeg"],
             mode="open",
         )
@@ -609,11 +673,11 @@ class Editor:
                 tw, th = self.tilemap.tile_size
                 tile_size = f"{tw}x{th}"
 
-            args = [str(path), "--tile-size", tile_size]
+            args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
             process = launch_standalone(
                 "plugins.sprite_animation.standalone",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -645,17 +709,18 @@ class Editor:
                 tw, th = self.tilemap.tile_size
                 tile_size = f"{tw}x{th}"
 
-            args = [str(path), "--tile-size", tile_size]
+            args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
             
             # Check if collision data file exists and load it
-            collision_path = path.with_suffix('.collision.json')
+            collision_dir = self.data_root / self.config.get("collision_paths", {}).get("tileset", "collision")
+            collision_path = collision_dir / f"{path.stem}.collision.json"
             if collision_path.exists():
                 args.extend(["--load", str(collision_path)])
 
             process = launch_standalone(
                 "plugins.tileset_collision.standalone",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -673,7 +738,7 @@ class Editor:
         """
         self.open_file_manager(
             on_select=self._launch_character_collision_editor_with_image,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".png", ".jpg", ".jpeg"],
             mode="open",
         )
@@ -684,17 +749,18 @@ class Editor:
             # Use filename (without extension) as default character name
             character_name = path.stem
 
-            args = [str(path), "--name", character_name]
+            args = [str(path), "--name", character_name, "--data-root", str(self.data_root)]
             
             # Check if collision data file exists and load it
-            collision_path = path.with_suffix('.collision.json')
+            collision_dir = self.data_root / self.config.get("collision_paths", {}).get("character", "character_collision")
+            collision_path = collision_dir / f"{character_name}.collision.json"
             if collision_path.exists():
                 args.extend(["--load", str(collision_path)])
 
             process = launch_standalone(
                 "plugins.character_collision.standalone",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -721,11 +787,12 @@ class Editor:
 
             window_size = f"{console_width}x{console_height}"
 
-            args = ["--window-size", window_size]
+            log_file = self.data_root / "logs" / "errors.log"
+            args = ["--window-size", window_size, "--log-file", str(log_file)]
             process = launch_standalone(
                 "standalone_error_console",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -1023,10 +1090,6 @@ if __name__ == "__main__":
     sys.excepthook = handle_exception
 
     try:
-        log_path = setup_console_log(BASE_PATH)
-        if log_path:
-            print(f"Logging to {log_path}")
-
         with error_context("editor_main"):
             editor = Editor(size=(1500, 900))
             editor.run()

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/character_collision/editor.py

@@ -43,6 +43,7 @@ class CharacterCollisionEditor:
         self.rect = rect
         self.sprite_surface = sprite_surface
         self.character_name = character_name
+        self._data_root: Path = None
         self.visible = True
 
         # UI layout
@@ -142,6 +143,12 @@ class CharacterCollisionEditor:
         self.character_name = data.name
         self.shape_editor.load_shape_data(data.shape.to_dict())
 
+    def _get_collision_dir(self) -> Path:
+        """Get collision data directory (data_root/character_collision)"""
+        if self._data_root is None:
+            raise RuntimeError("data_root is required. Initialize via from_path() with data_root parameter.")
+        return self._data_root / "character_collision"
+
     def save_to_file(self, path: Path) -> None:
         """Save collision data to file"""
         try:
@@ -274,11 +281,14 @@ class CharacterCollisionEditor:
         sprite_path: Path,
         window_size: Tuple[int, int] = (1000, 800),
         character_name: str = "Character",
+        data_root: Path = None,
     ) -> "CharacterCollisionEditor":
         """Create editor from sprite image path (for standalone use)"""
         surface = pygame.image.load(sprite_path).convert_alpha()
         rect = Rect(0, 0, window_size[0], window_size[1])
-        return cls(rect, surface, character_name)
+        editor = cls(rect, surface, character_name)
+        editor._data_root = data_root
+        return editor
 
     def run(self) -> None:
         """Run standalone editor (for standalone use)"""
@@ -300,14 +310,17 @@ class CharacterCollisionEditor:
                         pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
                     ):
                         # Ctrl+S / Cmd+S to save
-                        save_path = Path("character_collision.json")
+                        collision_dir = self._get_collision_dir()
+                        collision_dir.mkdir(parents=True, exist_ok=True)
+                        save_path = collision_dir / "character_collision.json"
                         self.save_to_file(save_path)
                         print(f"Saved collision data to {save_path}")
                     elif event.key == pygame.K_l and (
                         pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
                     ):
                         # Ctrl+L / Cmd+L to load
-                        load_path = Path("character_collision.json")
+                        collision_dir = self._get_collision_dir()
+                        load_path = collision_dir / "character_collision.json"
                         if load_path.exists():
                             self.load_from_file(load_path)
                             print(f"Loaded collision data from {load_path}")

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/character_collision/standalone.py

@@ -72,9 +72,17 @@ def main(argv: list[str] | None = None) -> None:
             default="1000x800",
             help="Window size as WxH (default: 1000x800)",
         )
+        parser.add_argument(
+            "--data-root",
+            type=Path,
+            required=True,
+            help="Path to project data root directory (REQUIRED)",
+        )
 
         args = parser.parse_args(argv)
 
+        data_root = args.data_root
+
         if not args.image.exists():
             error_handler.capture(
                 Exception(f"File not found: {args.image}"),
@@ -94,6 +102,7 @@ def main(argv: list[str] | None = None) -> None:
                 args.image,
                 window_size=window_size,
                 character_name=args.name,
+                data_root=data_root,
             )
 
             if args.load and args.load.exists():

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/sprite_animation/editor.py

@@ -268,6 +268,7 @@ class SpriteAnimationEditor:
         image_path: Path,
         tile_size: Tuple[int, int] = (32, 32),
         window_size: Tuple[int, int] = (1100, 720),
+        data_root: Path = None,
     ) -> SpriteAnimationEditor:
         """Load a spritesheet from disk and create a standalone editor."""
         pygame.init()
@@ -276,6 +277,7 @@ class SpriteAnimationEditor:
         ed = cls.from_surface(surf, tile_size, window_size)
         ed.library.spritesheet_path = str(image_path)
         ed._sheet_name = image_path.name
+        ed._data_root = data_root
         return ed
 
     # ------------------------------------------------------------------
@@ -1823,8 +1825,7 @@ class SpriteAnimationEditor:
             initial_dir = Path(self.library.spritesheet_path).parent
             default_name = Path(self.library.spritesheet_path).stem + ".anim.json"
         else:
-            # Use data folder
-            initial_dir = BASE_PATH / "data"
+            initial_dir = self._data_root / "animations"
             default_name = "animations.anim.json"
 
         # Create file manager for save
@@ -1889,7 +1890,7 @@ class SpriteAnimationEditor:
         if self.library.spritesheet_path:
             initial_dir = Path(self.library.spritesheet_path).parent
         else:
-            initial_dir = BASE_PATH / "data"
+            initial_dir = self._data_root / "animations"
 
         # Create file manager for load
         screen = pygame.display.get_surface()
@@ -1960,7 +1961,7 @@ class SpriteAnimationEditor:
         if self.library.spritesheet_path:
             initial_dir = Path(self.library.spritesheet_path).parent
         else:
-            initial_dir = BASE_PATH / "data"
+            initial_dir = self._data_root / "animations"
 
         # Create file manager for loading spritesheet
         screen = cast(Surface, pygame.display.get_surface())

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/sprite_animation/standalone.py

@@ -73,9 +73,18 @@ def main(argv: list[str] | None = None) -> None:
             default="1100x720",
             help="Window size as WxH (default: 1100x720)",
         )
+        parser.add_argument(
+            "--data-root",
+            type=Path,
+            default=None,
+            help="Path to project data root directory",
+        )
 
         args = parser.parse_args(argv)
 
+        # Resolve data_root - use provided path or default to cwd/data
+        data_root = args.data_root if args.data_root else Path.cwd() / "data"
+
         if not args.image.exists():
             error_handler.capture(
                 Exception(f"File not found: {args.image}"),
@@ -93,6 +102,7 @@ def main(argv: list[str] | None = None) -> None:
                 args.image,
                 tile_size=tile_size,
                 window_size=window_size,
+                data_root=data_root,
             )
 
             if args.load and args.load.exists():

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/tileset_collision/editor.py

@@ -21,7 +21,6 @@ from pathlib import Path
 
 import pygame
 from pygame import Rect, Surface
-import thorpy as tp
 
 from .models import CollisionPolygon, TileCollisionData, TilesetCollisionLibrary
 from .collision_painter import CollisionPainter
@@ -115,57 +114,87 @@ class TilesetCollisionEditor:
         self._font = font_manager.get_font(FONTS.name, FONTS.size_md, FontWeight.REGULAR)
         self._font_sm = font_manager.get_font(FONTS.name, FONTS.size_sm, FontWeight.REGULAR)
 
-        # ThorPy toolbar elements
-        self._setup_thorpy_toolbar()
+        # Toolbar buttons
+        self._setup_toolbar_buttons()
 
         # Load collision data for first tile
         self._load_tile_collision_for_selection()
 
-    def _setup_thorpy_toolbar(self) -> None:
-        """Setup ThorPy toolbar elements"""
-        save_btn = tp.Button("Save")
-        save_btn.set_size((80, 28))
-        save_btn.callback = self._thorpy_save
-
-        load_btn = tp.Button("Load")
-        load_btn.set_size((80, 28))
-        load_btn.callback = self._thorpy_load
-
-        clear_btn = tp.Button("Clear")
-        clear_btn.set_size((80, 28))
-        clear_btn.callback = self._thorpy_clear_current
-
-        self._thorpy_buttons = [save_btn, load_btn, clear_btn]
-        self._thorpy_toolbar = tp.Group(self._thorpy_buttons, "h")
-        self._thorpy_updater = self._thorpy_toolbar.get_updater()
-
-    def _thorpy_save(self) -> None:
-        """Save collision via thorpy button"""
-        save_path = Path("collision_data.json")
+    def _setup_toolbar_buttons(self) -> None:
+        """Setup simple pygame toolbar buttons"""
+        self._toolbar_buttons: List[Dict[str, Any]] = []
+
+        buttons_config = [
+            {"label": "Save", "action": self._save_collision},
+            {"label": "Load", "action": self._load_collision},
+            {"label": "Clear", "action": self._clear_current},
+        ]
+
+        for i, config in enumerate(buttons_config):
+            self._toolbar_buttons.append({
+                "label": config["label"],
+                "action": config["action"],
+                "rect": Rect(0, 0, 80, 28),
+                "hovered": False,
+            })
+
+    def _save_collision(self) -> None:
+        """Save collision via toolbar button"""
+        collision_dir = self._get_collision_dir()
+        collision_dir.mkdir(parents=True, exist_ok=True)
+        save_path = collision_dir / "collision_data.json"
         self.save_to_file(save_path)
         print(f"Saved collision data to {save_path}")
 
-    def _thorpy_load(self) -> None:
-        """Load collision via thorpy button"""
-        load_path = Path("collision_data.json")
+    def _load_collision(self) -> None:
+        """Load collision via toolbar button"""
+        collision_dir = self._get_collision_dir()
+        load_path = collision_dir / "collision_data.json"
         if load_path.exists():
             self.load_from_file(load_path)
             print(f"Loaded collision data from {load_path}")
 
-    def _thorpy_clear_current(self) -> None:
-        """Clear collision for selected tiles via thorpy button"""
+    def _get_collision_dir(self) -> Path:
+        """Get collision directory path"""
+        if self._data_root is None:
+            raise RuntimeError("data_root is required. Initialize via from_path() with data_root parameter.")
+        return self._data_root / "collision"
+
+    def _clear_current(self) -> None:
+        """Clear collision for selected tiles via toolbar button"""
         self.clear_current_selection()
 
-    def _position_thorpy_toolbar(self) -> None:
-        """Position ThorPy toolbar buttons in the toolbar area"""
-        if not hasattr(self, '_thorpy_toolbar'):
+    def _position_toolbar_buttons(self) -> None:
+        """Position toolbar buttons in the toolbar area"""
+        if not hasattr(self, '_toolbar_buttons'):
             return
 
-        # Position toolbar on the right side of the toolbar rect
-        toolbar_x = self.toolbar_rect.right - self._thorpy_toolbar.rect.width - 10
-        toolbar_y = self.toolbar_rect.y + (self.toolbar_rect.height - self._thorpy_toolbar.rect.height) // 2
+        start_x = self.toolbar_rect.right - (len(self._toolbar_buttons) * 90) - 10
+        toolbar_y = self.toolbar_rect.y + (self.toolbar_rect.height - 28) // 2
+
+        for button in self._toolbar_buttons:
+            button["rect"].x = start_x
+            button["rect"].y = toolbar_y
+            start_x += 90
 
-        self._thorpy_toolbar.move(toolbar_x, toolbar_y)
+    def _handle_toolbar_button_clicks(self, events: List[pygame.event.Event]) -> None:
+        """Handle toolbar button click events"""
+        mouse_pos = pygame.mouse.get_pos()
+
+        for button in self._toolbar_buttons:
+            was_hovered = button["hovered"]
+            button["hovered"] = button["rect"].collidepoint(mouse_pos)
+
+            for event in events:
+                if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                    if button["rect"].collidepoint(mouse_pos):
+                        button["action"]()
+
+    def _draw_toolbar_buttons(self, surface: Surface) -> None:
+        """Draw toolbar buttons"""
+        for button in self._toolbar_buttons:
+            label_surf = self._font.render(button["label"], True, COLORS.text)
+            draw_button(surface, button["rect"], label_surf, hover=button["hovered"])
 
     def _update_layout(self) -> None:
         """Update layout rects based on current sizes"""
@@ -570,6 +599,10 @@ class TilesetCollisionEditor:
         )
         screen.blit(count_text, (self.toolbar_rect.right - count_text.get_width() - 10, self.toolbar_rect.y + 12))
 
+        # Draw toolbar buttons
+        if hasattr(self, '_toolbar_buttons'):
+            self._draw_toolbar_buttons(screen)
+
     def _draw_painted_tiles_list(self, screen: Surface) -> None:
         """Draw the list of tiles with collision"""
         draw_panel(screen, self.painted_tiles_rect, COLORS.panel, COLORS.border)
@@ -706,11 +739,14 @@ class TilesetCollisionEditor:
         tileset_path: Path,
         tile_size: Tuple[int, int] = (32, 32),
         window_size: Tuple[int, int] = (1200, 800),
+        data_root: Path = None,
     ) -> "TilesetCollisionEditor":
         """Create editor from tileset image path (for standalone use)"""
         surface = pygame.image.load(tileset_path).convert_alpha()
         rect = Rect(0, 0, window_size[0], window_size[1])
-        return cls(rect, surface, tile_size)
+        editor = cls(rect, surface, tile_size)
+        editor._data_root = data_root
+        return editor
 
     def run(self) -> None:
         """Run standalone editor (for standalone use)"""
@@ -719,7 +755,7 @@ class TilesetCollisionEditor:
             raise RuntimeError("pygame display not initialized")
 
         # Position thorpy toolbar
-        self._position_thorpy_toolbar()
+        self._position_toolbar_buttons()
 
         clock = pygame.time.Clock()
         running = True
@@ -750,10 +786,8 @@ class TilesetCollisionEditor:
 
                 self.handle_event(event)
 
-            # Update ThorPy elements
-            if hasattr(self, '_thorpy_updater'):
-                mouse_rel = pygame.mouse.get_rel()
-                self._thorpy_updater.update(events=events, mouse_rel=mouse_rel)
+            # Handle toolbar button clicks
+            self._handle_toolbar_button_clicks(events)
 
             screen.fill((20, 20, 20))
             self.draw(screen)

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/plugins/tileset_collision/standalone.py

@@ -25,7 +25,6 @@ if sys.platform == "darwin":
     os.environ.setdefault("SDL_VIDEO_MAC_SCREEN_SCALE", "1")
 
 import pygame
-import thorpy as tp
 
 from .editor import TilesetCollisionEditor
 from utils import error_handler, error_context
@@ -78,9 +77,17 @@ def main(argv: list[str] | None = None) -> None:
             default="1200x800",
             help="Window size as WxH (default: 1200x800)",
         )
+        parser.add_argument(
+            "--data-root",
+            type=Path,
+            required=True,
+            help="Path to project data root directory (REQUIRED)",
+        )
 
         args = parser.parse_args(argv)
 
+        data_root = args.data_root
+
         if not args.image.exists():
             error_handler.capture(
                 Exception(f"File not found: {args.image}"),
@@ -97,13 +104,11 @@ def main(argv: list[str] | None = None) -> None:
             screen = pygame.display.set_mode(window_size, pygame.RESIZABLE)
             pygame.display.set_caption(f"Tileset Collision Editor — {args.image.name}")
 
-            tp.set_default_font("arial", 16)
-            tp.init(screen, tp.theme_game2)
-
             editor = TilesetCollisionEditor.from_path(
                 args.image,
                 tile_size=tile_size,
                 window_size=window_size,
+                data_root=data_root,
             )
 
             if args.load and args.load.exists():

{tilemap_editor-2.0.6 → tilemap_editor-2.0.7}/src/standalone_automap.py

@@ -109,6 +109,9 @@ class StandaloneAutomap:
                 pygame.draw.rect(screen, color, rect)
 
 if __name__ == "__main__":
-    target = Path(sys.argv[1]) if len(sys.argv) > 1 else BASE_PATH / "data" / "automap"
+    if len(sys.argv) < 2:
+        print("Usage: standalone_automap.py <target_path>", file=sys.stderr)
+        sys.exit(1)
+    target = Path(sys.argv[1])
     app = StandaloneAutomap(target)
     app.run()