Auto-commit: Save local changes

Author: twardoch

src/pedalboard_pluginary/__init__.py

@@ -9,4 +9,4 @@
 finally:
     del version, PackageNotFoundError
 
-from .core import PedalboardPluginary
+from .core import PedalboardPluginary

src/pedalboard_pluginary/__main__.py

@@ -1,61 +1,43 @@
 #!/usr/bin/env python3
-from __future__ import annotations
-
-from typing import Dict, List, Optional
-
 import fire
-import yaml
-
-from .data import (
-    PLUGINS_CACHE_FILENAME_BASE,
-    get_cache_path,
-    load_json_file,
-    save_json_file,
-)
-from .types import SerializedPlugin
+from benedict import benedict as bdict
+
+from .core import PedalboardPluginary
 from .scanner import PedalboardScanner
 
 
-def scan_plugins_cli(extra_folders: Optional[str] = None, verbose: int = 0) -> None:
-    """Scans all plugins, optionally including extra folders (comma-separated string)."""
-    folders_list: List[str] = extra_folders.split(",") if extra_folders else []
-    scanner = PedalboardScanner(specific_paths=folders_list)
-    scanner.full_scan()  # This updates scanner.plugins
-    if scanner.plugins:  # Only save if we found plugins
-        cache_file = get_cache_path(PLUGINS_CACHE_FILENAME_BASE)
-        save_json_file(scanner.plugins, cache_file)
+def scan_plugins(extra_folders=None):
+    if extra_folders:
+        extra_folders = extra_folders.split(",")
+    PedalboardScanner().rescan(extra_folders=None)
 
 
-def update_plugins_cli(extra_folders: Optional[str] = None, verbose: int = 0) -> None:
-    """Updates the plugin cache, optionally including extra folders (comma-separated string)."""
-    scan_plugins_cli(extra_folders, verbose)
+def update_plugins(extra_folders=None):
+    if extra_folders:
+        extra_folders = extra_folders.split(",")
+    PedalboardScanner().update(extra_folders=None)
 
 
-def list_json_cli() -> Dict[str, SerializedPlugin]:
-    """Lists all plugins in JSON format."""
-    cache_file = get_cache_path(PLUGINS_CACHE_FILENAME_BASE)
-    if not cache_file.exists():
-        return {}
-    data = load_json_file(cache_file)
-    return data if isinstance(data, dict) else {}
+def list_json():
+    return bdict(PedalboardPluginary().plugins).to_json()
 
 
-def list_yaml_cli() -> str:
-    """Lists all plugins in YAML format."""
-    plugins = list_json_cli()
-    return yaml.dump(plugins, sort_keys=False, indent=2)
+def list_yaml():
+    return bdict(PedalboardPluginary().plugins).to_yaml()
 
 
-def main() -> None:
-    """Main entry point for the CLI."""
-    fire.Fire({
-        "scan": scan_plugins_cli,
-        "list": list_json_cli,
-        "json": list_json_cli,
-        "yaml": list_yaml_cli,
-        "update": update_plugins_cli,
-    })
+def cli():
+    fire.core.Display = lambda lines, out: print(*lines, file=out)
+    fire.Fire(
+        {
+            "scan": scan_plugins,
+            "update": update_plugins,
+            "list": list_json,
+            "json": list_json,
+            "yaml": list_yaml,
+        }
+    )
 
 
 if __name__ == "__main__":
-    main()
+    cli()

src/pedalboard_pluginary/core.py

@@ -1,39 +1,19 @@
 import json
-from pathlib import Path
-from typing import Dict
 
-from .data import get_cache_path
-from .models import PluginInfo
+from .data import get_cache_path, load_json_file
 from .scanner import PedalboardScanner
-from .serialization import PluginSerializer
 
 
 class PedalboardPluginary:
-    """Main class for the Pedalboard Pluginary application."""
-    
-    plugins_path: Path
-    plugins: Dict[str, PluginInfo]
-
-    def __init__(self) -> None:
-        """Initialize the Pedalboard Pluginary instance."""
+    def __init__(self):
         self.plugins_path = get_cache_path("plugins")
-        self.plugins = {}
         self.load_data()
 
-    def load_data(self) -> None:
-        """Load plugin data from cache or perform a scan if cache doesn't exist."""
+    def load_data(self):
         if not self.plugins_path.exists():
             scanner = PedalboardScanner()
-            scanner.full_scan()
-
-        # Load plugins using the serializer
-        self.plugins = PluginSerializer.load_plugins(self.plugins_path)
+            scanner.scan()
+        self.plugins = load_json_file(self.plugins_path)
 
-    def list_plugins(self) -> str:
-        """Returns a JSON string representation of the plugins."""
-        # Convert PluginInfo objects to dictionaries for JSON serialization
-        plugins_dict = {}
-        for plugin_id, plugin in self.plugins.items():
-            plugins_dict[plugin_id] = PluginSerializer.plugin_to_dict(plugin)
-        
-        return json.dumps(plugins_dict, indent=4)
+    def list_plugins(self):
+        return json.dumps(self.plugins, indent=4)

src/pedalboard_pluginary/data.py

@@ -1,106 +1,52 @@
 import json
 import os
-import platform
 import shutil
-from importlib import resources
 from pathlib import Path
-from typing import Any, Dict, List, Set, Union
 
-# JSON-serializable types
-JSONValue = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
-JSONDict = Dict[str, JSONValue]
+from pkg_resources import resource_filename
 
-from .utils import ensure_folder
+from .utils import *
 
-APP_NAME: str = "com.twardoch.pedalboard-pluginary"
-PLUGINS_CACHE_FILENAME_BASE: str = "plugins"  # To identify the plugins cache file
+APP_NAME = "com.twardoch.pedalboard-pluginary"
 
 
-def get_cache_path(cache_name: str, extension: str = "json") -> Path:
+def get_cache_path(cache_name):
     """Get the path to a cache file."""
-    os_name = platform.system()
-    if os_name == "Windows":
-        app_data_env = os.getenv("APPDATA")
-        if app_data_env is None:
-            app_data_dir = (
-                Path(os.path.expanduser("~")) / "AppData" / "Roaming" / APP_NAME
-            )
-        else:
-            app_data_dir = Path(app_data_env) / APP_NAME
-    elif os_name == "Darwin":  # macOS
-        app_data_dir = Path.home() / "Library" / "Application Support" / APP_NAME
-    else:  # Linux and other Unix-like systems
-        xdg_cache_home_env = os.getenv("XDG_CACHE_HOME")
-        if xdg_cache_home_env:
-            app_data_dir = Path(xdg_cache_home_env) / APP_NAME
-        else:
-            app_data_dir = Path.home() / ".cache" / APP_NAME
+    if os.name == "nt":
+        cache_folder = Path(os.getenv("APPDATA")) / APP_NAME
+    else:
+        cache_folder = Path.home() / "Library" / "Application Support" / APP_NAME
+    return cache_folder / f"{cache_name}.json"
 
-    app_data_dir.mkdir(parents=True, exist_ok=True)  # Ensure base app dir exists
-    return app_data_dir / f"{cache_name}.{extension}"
 
-
-def get_sqlite_cache_path(cache_name: str) -> Path:
-    """Get the path to a SQLite cache database."""
-    return get_cache_path(cache_name, "db")
-
-
-def load_json_file(file_path: Path) -> Any:
+def load_json_file(file_path):
     """Load JSON data from a file."""
-    if not file_path.exists():
-        return {}
-
-    with open(file_path, "r", encoding="utf-8") as file:
-        try:
-            raw_data = json.load(file)
-        except json.JSONDecodeError:
-            return {}  # Return empty dict if JSON is corrupted
+    if file_path.exists():
+        with open(file_path) as file:
+            return json.load(file)
+    return {}
 
-    return raw_data
 
-
-def save_json_file(data: Any, file_path: Path) -> None:
+def save_json_file(data, file_path):
     """Save JSON data to a file."""
-    ensure_folder(file_path.parent)
-    with open(file_path, "w", encoding="utf-8") as file:
+    ensure_folder(file_path)
+    with open(file_path, "w") as file:
         json.dump(data, file, indent=4)
 
 
-def load_ignores(ignores_path: Path) -> Set[str]:
-    """Load ignores data (list of strings) from the file."""
-    content = load_json_file(ignores_path)
-    if isinstance(content, list):  # Expects a list of strings
-        return set(item for item in content if isinstance(item, str))
-    return set()
+def load_ignores(ignores_path):
+    """Load ignores data from the file."""
+    return set(load_json_file(ignores_path))
 
 
-def save_ignores(ignores: Set[str], ignores_path: Path) -> None:
+def save_ignores(ignores, ignores_path):
     """Save ignores data to the file."""
     save_json_file(sorted(list(ignores)), ignores_path)
 
 
-def copy_default_ignores(destination_path: Path) -> None:
+def copy_default_ignores(destination_path):
     """Copy the default ignores file to the destination if it does not exist."""
-    try:
-        import importlib.resources
-
-        default_ignores_src_path = importlib.resources.files(
-            "pedalboard_pluginary.resources"
-        ).joinpath("default_ignores.json")
-
-        if not destination_path.exists():
-            ensure_folder(destination_path.parent)
-            with importlib.resources.as_file(
-                default_ignores_src_path
-            ) as src_file_on_fs:
-                if src_file_on_fs.exists():
-                    shutil.copy(src_file_on_fs, destination_path)
-                else:
-                    save_json_file([], destination_path)
-    except (ImportError, FileNotFoundError, TypeError) as e:
-        print(
-            f"Warning: Could not copy default ignores using importlib.resources: {e}. Creating empty ignores file."
-        )
-        if not destination_path.exists():
-            ensure_folder(destination_path.parent)
-            save_json_file([], destination_path)
+    default_ignores_path = resource_filename(__name__, "resources/default_ignores.json")
+    if not destination_path.exists():
+        ensure_folder(destination_path)
+        shutil.copy(default_ignores_path, destination_path)