cisco-ai-skill-scanner 1.0.0__py3-none-any.whl

skillanalyzer/utils/di_container.py

@@ -0,0 +1,154 @@
+# Copyright 2026 Cisco Systems, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Dependency Injection Container for Skill Analyzer.
+
+This module provides a simple dependency injection container to improve
+testability and decouple configuration from implementation.
+"""
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from ..config.config import Config
+
+T = TypeVar("T")
+
+
+class DIContainer:
+    """Simple dependency injection container."""
+
+    def __init__(self):
+        """Initialize the container."""
+        self._services: dict[type, Any] = {}
+        self._singletons: dict[type, Any] = {}
+
+    def register(self, service_type: type[T], instance: T, singleton: bool = True) -> None:
+        """Register a service instance.
+
+        Args:
+            service_type: The type/interface to register.
+            instance: The instance to register.
+            singleton: Whether to treat as singleton (default: True).
+        """
+        if singleton:
+            self._singletons[service_type] = instance
+        else:
+            self._services[service_type] = instance
+
+    def register_factory(self, service_type: type[T], factory: Callable[[], T], singleton: bool = True) -> None:
+        """Register a factory function for creating instances.
+
+        Args:
+            service_type: The type/interface to register.
+            factory: Factory function that creates instances.
+            singleton: Whether to treat as singleton (default: True).
+        """
+        if singleton:
+            self._singletons[service_type] = factory()
+        else:
+            self._services[service_type] = factory
+
+    def get(self, service_type: type[T]) -> T | None:
+        """Get a service instance.
+
+        Args:
+            service_type: The type to retrieve.
+
+        Returns:
+            The service instance or None if not found.
+        """
+        if service_type in self._singletons:
+            return self._singletons[service_type]
+
+        if service_type in self._services:
+            service = self._services[service_type]
+            if callable(service):
+                return service()
+            return service
+
+        return None
+
+    def get_or_create(self, service_type: type[T], factory: Callable[[], T] | None = None) -> T:
+        """Get a service instance or create with factory if not found.
+
+        Args:
+            service_type: The type to retrieve.
+            factory: Optional factory function if service not registered.
+
+        Returns:
+            The service instance.
+
+        Raises:
+            ValueError: If service not found and no factory provided.
+        """
+        instance = self.get(service_type)
+        if instance is not None:
+            return instance
+
+        if factory is not None:
+            instance = factory()
+            self.register(service_type, instance)
+            return instance
+
+        raise ValueError(f"Service {service_type} not registered and no factory provided")
+
+    def clear(self) -> None:
+        """Clear all registered services."""
+        self._services.clear()
+        self._singletons.clear()
+
+
+# Global container instance
+_container = DIContainer()
+
+
+def get_container() -> DIContainer:
+    """Get the global DI container instance.
+
+    Returns:
+        The global container instance.
+    """
+    return _container
+
+
+def configure_default_services(config: Config | None = None) -> None:
+    """Configure default services in the container.
+
+    Args:
+        config: Optional config instance to register.
+    """
+    container = get_container()
+
+    if config:
+        container.register(Config, config)
+
+
+def inject_config() -> Config:
+    """Inject Config dependency.
+
+    Returns:
+        Config instance from container.
+
+    Raises:
+        ValueError: If Config not registered in container.
+    """
+    container = get_container()
+    config = container.get(Config)
+    if config is None:
+        raise ValueError("Config not registered in DI container. Call configure_default_services() first.")
+    return config

skillanalyzer/utils/file_utils.py

@@ -0,0 +1,86 @@
+# Copyright 2026 Cisco Systems, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+File utility functions.
+"""
+
+from pathlib import Path
+
+
+def read_file_safe(file_path: Path, max_size_mb: int = 10) -> str | None:
+    """
+    Safely read a file with size limit.
+
+    Args:
+        file_path: Path to file
+        max_size_mb: Maximum file size in MB
+
+    Returns:
+        File content or None if unreadable
+    """
+    try:
+        size_bytes = file_path.stat().st_size
+        max_bytes = max_size_mb * 1024 * 1024
+
+        if size_bytes > max_bytes:
+            return None
+
+        with open(file_path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def get_file_type(file_path: Path) -> str:
+    """
+    Determine file type from extension.
+
+    Args:
+        file_path: Path to file
+
+    Returns:
+        File type string
+    """
+    suffix = file_path.suffix.lower()
+
+    type_mapping = {
+        ".py": "python",
+        ".sh": "bash",
+        ".bash": "bash",
+        ".md": "markdown",
+        ".markdown": "markdown",
+        ".exe": "binary",
+        ".so": "binary",
+        ".dylib": "binary",
+        ".dll": "binary",
+        ".bin": "binary",
+    }
+
+    return type_mapping.get(suffix, "other")
+
+
+def is_binary_file(file_path: Path) -> bool:
+    """
+    Check if file is binary.
+
+    Args:
+        file_path: Path to file
+
+    Returns:
+        True if binary
+    """
+    return get_file_type(file_path) == "binary"

skillanalyzer/utils/logging_config.py

@@ -0,0 +1,96 @@
+# Copyright 2026 Cisco Systems, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Centralized logging configuration for Skill Analyzer.
+
+This module provides consistent logging setup across all components.
+"""
+
+import logging
+import sys
+
+
+def setup_logger(name: str, level: str | None = None, format_string: str | None = None) -> logging.Logger:
+    """
+    Set up a logger with consistent configuration.
+
+    Args:
+        name: Logger name (typically __name__)
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        format_string: Custom format string, uses default if None
+
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name)
+
+    if logger.handlers:
+        return logger
+
+    skillanalyzer_root = logging.getLogger("skillanalyzer")
+    if skillanalyzer_root.level == logging.DEBUG and name.startswith("skillanalyzer"):
+        logger.setLevel(logging.DEBUG)
+    elif level:
+        logger.setLevel(getattr(logging, level.upper()))
+    else:
+        logger.setLevel(logging.INFO)
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logger.level)
+
+    default_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    formatter = logging.Formatter(format_string or default_format)
+    handler.setFormatter(formatter)
+
+    logger.addHandler(handler)
+    logger.propagate = False
+
+    return logger
+
+
+def get_logger(name: str, level: str | None = None) -> logging.Logger:
+    """
+    Get a logger with standard configuration.
+
+    Args:
+        name: Logger name (typically __name__)
+        level: Optional logging level override
+
+    Returns:
+        Configured logger instance
+    """
+    return setup_logger(name, level)
+
+
+def set_verbose_logging(verbose: bool = False) -> None:
+    """
+    Enable or disable verbose logging for all skillanalyzer loggers.
+
+    Args:
+        verbose: If True, set all existing skillanalyzer loggers to DEBUG level
+    """
+    target_level = logging.DEBUG if verbose else logging.INFO
+
+    root_logger = logging.getLogger("skillanalyzer")
+    root_logger.setLevel(target_level)
+
+    for name in list(logging.Logger.manager.loggerDict.keys()):
+        if name.startswith("skillanalyzer"):
+            logger = logging.getLogger(name)
+            logger.setLevel(target_level)
+            for handler in logger.handlers:
+                handler.setLevel(target_level)

skillanalyzer/utils/logging_utils.py

@@ -0,0 +1,71 @@
+# Copyright 2026 Cisco Systems, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Logging utility functions.
+"""
+
+import logging
+import sys
+
+
+def setup_logger(name: str, level: int = logging.INFO, log_file: str | None = None) -> logging.Logger:
+    """
+    Set up a logger with console and optional file output.
+
+    Args:
+        name: Logger name
+        level: Logging level
+        log_file: Optional file path for logs
+
+    Returns:
+        Configured logger
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Remove existing handlers
+    logger.handlers = []
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(level)
+
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    # File handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(level)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get or create a logger.
+
+    Args:
+        name: Logger name
+
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(name)