pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/cli/install_man.py

@@ -1,36 +1,107 @@
+import argparse
 import os
-import sys
 import shutil
-from importlib.resources import files
+import subprocess
+import sys
+from pathlib import Path
+from importlib import resources
+
+
+def get_man_dir() -> Path | None:
+    """Locate the pygeai/man/man1 directory within the installed package."""
+    try:
+        # Use importlib.resources to find the man/man1 directory in pygeai package
+        with resources.path("pygeai.man", "man1") as man_path:
+            man_dir = Path(man_path)
+            if man_dir.is_dir():
+                return man_dir
+        return None
+    except (ImportError, FileNotFoundError):
+        return None
 
-def install_man_pages():
-    man_dir = "/usr/local/share/man/man1" if sys.platform == "darwin" else "/usr/share/man/man1"
 
-    if not os.access(man_dir, os.W_OK):
-        sys.stderr.write(f"Error: You need superuser (sudo) privileges to install man pages to {man_dir}.\n")
-        sys.stderr.write("Please rerun the script with sudo.\n")
+def validate_man_file(file_path: Path) -> bool:
+    """Validate if a file is a likely man page (ends with .1 or .1.gz)."""
+    return file_path.suffix in ('.1', '.gz') and (file_path.name.endswith('.1') or file_path.name.endswith('.1.gz'))
+
+
+def install_man_pages(system_wide: bool) -> int:
+    """Install man pages from pygeai/man/man1 to local or system-wide man directory."""
+    # Locate source directory
+    source_path = get_man_dir()
+    if not source_path:
+        print("Error: Could not locate 'pygeai/man/man1' directory in the installed pygeai package.")
         return 1
 
-    # Files are expected to be in pygeai/man/man1/
-    base = files("pygeai.man.man1")
-    man_files = ["geai.1", "geai-proxy.1"]
+    # Determine destination directory
+    if system_wide:
+        dest_path = Path("/usr/local/share/man/man1")
+    else:
+        dest_path = Path.home() / "share" / "man" / "man1"
+
+    # Ensure destination directory exists
+    try:
+        dest_path.mkdir(parents=True, exist_ok=True)
+    except PermissionError:
+        print(f"Error: Permission denied creating '{dest_path}'. Try running with sudo for system-wide installation.")
+        return 1
 
-    for fname in man_files:
+    # Collect man page files
+    man_files = [f for f in source_path.iterdir() if validate_man_file(f)]
+    if not man_files:
+        print(f"Warning: No valid man page files found in '{source_path}'.")
+        return 0
+
+    # Copy man page files
+    for man_file in man_files:
+        dest_file = dest_path / man_file.name
         try:
-            resource = base / fname
-            if not resource.is_file():
-                sys.stderr.write(f"Warning: {fname} does not exist in package.\n")
-                continue
+            shutil.copy2(man_file, dest_file)
+            print(f"Installed: {dest_file}")
+            # Set permissions (644)
+            dest_file.chmod(0o644)
+        except PermissionError:
+            print(f"Error: Permission denied copying '{man_file}' to '{dest_file}'. Try running with sudo.")
+            return 1
+        except OSError as e:
+            print(f"Error: Failed to copy '{man_file}' to '{dest_file}': {e}")
+            return 1
 
-            dest_path = os.path.join(man_dir, fname)
-            sys.stdout.write(f"Installing {fname} to {dest_path}...\n")
-            with resource.open("rb") as src_file, open(dest_path, "wb") as dst_file:
-                shutil.copyfileobj(src_file, dst_file)
+    # Update man database for system-wide installation
+    if system_wide:
+        try:
+            subprocess.run(["mandb"], check=True, capture_output=True, text=True)
+            print("Updated man page database.")
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: Failed to update man database: {e.stderr}")
+        except FileNotFoundError:
+            print("Warning: 'mandb' command not found. Man pages installed but database not updated.")
 
-        except Exception as e:
-            sys.stderr.write(f"Error installing {fname}: {e}\n")
+    # For local installation, remind user to update MANPATH
+    if not system_wide:
+        manpath_cmd = f'export MANPATH={Path.home() / "share" / "man"}:$MANPATH'
+        print(f"Local installation complete. Add to ~/.bashrc to update MANPATH:")
+        print(f"    {manpath_cmd}")
 
     return 0
 
+
+def main():
+    parser = argparse.ArgumentParser(description="Install man pages from pygeai/man/man1.")
+    parser.add_argument(
+        "--system",
+        action="store_true",
+        help="Install man pages system-wide to /usr/local/share/man/man1 (requires sudo).",
+    )
+    args = parser.parse_args()
+
+    # Check if running as root for system-wide installation
+    if args.system and os.geteuid() != 0:
+        print("Error: System-wide installation requires root privileges. Run with sudo.")
+        sys.exit(1)
+
+    sys.exit(install_man_pages(args.system))
+
+
 if __name__ == "__main__":
-    sys.exit(install_man_pages())
+    main()

pygeai/cli/parsers.py

@@ -1,3 +1,6 @@
+from typing import List, Tuple, Optional
+
+from pygeai import logger
 from pygeai.cli.commands.base import base_options
 from pygeai.cli.commands import Command, Option
 from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException
@@ -5,7 +8,17 @@ from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequireme
 
 class CommandParser:
 
-    def __init__(self, available_commands, available_options):
+    def __init__(
+        self, 
+        available_commands: Optional[List[Command]], 
+        available_options: Optional[List[Option]]
+    ) -> None:
+        """
+        Initialize a CommandParser with available commands and options.
+
+        :param available_commands: Optional[List[Command]] - List of valid commands, or None.
+        :param available_options: Optional[List[Option]] - List of valid options, or None.
+        """
         self.available_commands = available_commands
         self.available_options = available_options
 
@@ -13,23 +26,34 @@ class CommandParser:
         """
         Analyzes the first argument and checks if it's a valid command.
 
-        :param first_argument: The first argument to be analyzed.
-        :return: The command to be run.
+        :param arg: str - The argument to be analyzed.
+        :return: Command - The identified command object.
+        :raises UnknownArgumentError: If the argument is not a valid command.
         """
+        logger.debug(f"Searching for command matching: {arg}")
         command = self._get_associated_command(arg)
         if not command:
-            raise UnknownArgumentError(f"'{arg}' is not a valid command. Run with help or h to check usage.")
-
+            logger.debug(f"No command found for: {arg}")
+            raise UnknownArgumentError(
+                f"'{arg}' is not a valid command.",
+                arg=arg,
+                available_commands=self.available_commands
+            )
+        
+        logger.debug(f"Command found: {command.name} (identifiers: {command.identifiers})")
         return command
 
-    def extract_option_list(self, arguments: list) -> list[(Option, str)]:
+    def extract_option_list(self, arguments: List[str]) -> List[Tuple[Option, str]]:
         """
-        Parses a list of arguments and returns the commands being invoked.
+        Parses a list of arguments and returns the options being invoked.
 
-        :param arguments: list - The list of arguments received by the CLI utility.
-        :return: list - A list of flags and their associated arguments.
+        :param arguments: List[str] - The list of arguments received by the CLI utility.
+        :return: List[Tuple[Option, str]] - A list of tuples containing Option objects and their values.
+        :raises UnknownArgumentError: If an unknown option is provided.
+        :raises MissingRequirementException: If a required option argument is missing.
         """
-        flag_list = []
+        logger.debug(f"Extracting options from arguments: {arguments}")
+        flag_list: List[Tuple[Option, str]] = []
 
         complementary_arg = False
         for i, arg in enumerate(arguments):
@@ -39,33 +63,59 @@ class CommandParser:
 
             flag = self._get_associated_option(arg)
             if not flag:
-                raise UnknownArgumentError(f"'{arg}' is not a valid option. Run with help or h to check usage.")
+                logger.debug(f"Unknown option: {arg}")
+                raise UnknownArgumentError(
+                    f"'{arg}' is not a valid option.",
+                    arg=arg,
+                    available_options=self.available_options
+                )
+            
+            logger.debug(f"Option found: {flag.name} (identifiers: {flag.identifiers})")
 
             if flag.requires_args:
                 complementary_arg = True
                 try:
-                    flag_list.append((flag, arguments[i + 1]))
-                except IndexError as e:
+                    value = arguments[i + 1]
+                    logger.debug(f"Option {flag.name} has value: {value}")
+                    flag_list.append((flag, value))
+                except IndexError:
+                    logger.debug(f"Missing required argument for option: {flag.name}")
                     raise MissingRequirementException(f"'{flag.name}' requires an argument.")
             else:
-                flag_list.append([flag, []])
+                logger.debug(f"Option {flag.name} is a flag (no value required)")
+                flag_list.append((flag, ""))
 
+        logger.debug(f"Total options parsed: {len(flag_list)}")
         return flag_list
 
-    def _get_associated_command(self, arg: str) -> Command:
-        associated_command = None
+    def _get_associated_command(self, arg: str) -> Optional[Command]:
+        """
+        Finds the command associated with the given argument.
+
+        :param arg: str - The argument to search for.
+        :return: Optional[Command] - The associated command if found, None otherwise.
+        """
+        if not self.available_commands:
+            return None
+            
         for command in self.available_commands:
             if arg in command.identifiers:
-                associated_command = command
-                break
+                return command
+        
+        return None
 
-        return associated_command
+    def _get_associated_option(self, arg: str) -> Optional[Option]:
+        """
+        Finds the option associated with the given argument.
 
-    def _get_associated_option(self, arg: str) -> Option:
-        associated_option = None
+        :param arg: str - The argument to search for.
+        :return: Optional[Option] - The associated option if found, None otherwise.
+        """
+        if not self.available_options:
+            return None
+            
         for option in self.available_options:
             if arg in option.identifiers:
-                associated_option = option
-                break
-
-        return associated_option
+                return option
+        
+        return None