igntui 0.0.0__py3-none-any.whl

igntui/cli/parser.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-\
+
+
+import argparse
+from pathlib import Path
+from typing import Optional
+
+from .. import __description__, __version__, get_version_string
+
+
+def create_base_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="igntui",
+        description=__description__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"""
+igntui v{__version__} - Interactive GitIgnore Template User Interface
+
+Examples:
+  igntui                    # Launch interactive TUI
+  igntui list               # List available templates  
+  igntui generate python    # Generate .gitignore for Python
+  igntui tui                # Explicitly launch TUI mode
+  
+For more information, visit: https://github.com/toptal/gitignore.io
+        """,
+    )
+
+    parser.add_argument(
+        "--version", "-v", action="version", version=get_version_string()
+    )
+
+    parser.add_argument(
+        "--verbose", action="store_true", help="Enable verbose/debug output"
+    )
+
+    parser.add_argument(
+        "--log-level",
+        "-l",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Set specific logging level",
+    )
+
+    parser.add_argument(
+        "--config", "-c", type=Path, help="Path to custom configuration file"
+    )
+
+    parser.add_argument(
+        "--no-cache", action="store_true", help="Disable caching for this session"
+    )
+
+    return parser
+
+
+def create_command_parser(
+    base_parser: argparse.ArgumentParser,
+) -> argparse.ArgumentParser:
+    subparsers = base_parser.add_subparsers(
+        dest="command",
+        title="commands",
+        description="Available commands",
+        help="Command to execute",
+    )
+
+    tui_parser = subparsers.add_parser(
+        "tui",
+        help="Launch interactive TUI (default)",
+        description="Launch the interactive Terminal User Interface",
+    )
+    tui_parser.add_argument(
+        "--no-splash", action="store_true", help="Skip the splash screen"
+    )
+
+    list_parser = subparsers.add_parser(
+        "list",
+        help="List available templates",
+        description="List all available .gitignore templates",
+    )
+    list_parser.add_argument(
+        "--filter", "-f", metavar="PATTERN", help="Filter templates by pattern"
+    )
+    list_parser.add_argument(
+        "--count", "-c", action="store_true", help="Show count only"
+    )
+
+    generate_parser = subparsers.add_parser(
+        "generate",
+        help="Generate .gitignore content",
+        description="Generate .gitignore content for specified templates",
+    )
+    generate_parser.add_argument(
+        "templates", nargs="+", help="Template names to generate (space-separated)"
+    )
+    generate_parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        metavar="FILE",
+        help="Output file path (default: stdout)",
+    )
+    generate_parser.add_argument(
+        "--append",
+        "-a",
+        action="store_true",
+        help="Append to existing file instead of overwriting",
+    )
+    generate_parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Force overwrite without confirmation",
+    )
+
+    cache_parser = subparsers.add_parser(
+        "cache", help="Manage cache", description="Manage template and API cache"
+    )
+    cache_subparsers = cache_parser.add_subparsers(
+        dest="cache_action", title="cache actions", help="Cache action to perform"
+    )
+
+    cache_subparsers.add_parser("clear", help="Clear all cache")
+    cache_subparsers.add_parser("stats", help="Show cache statistics")
+    cache_subparsers.add_parser("info", help="Show cache information")
+
+    test_parser = subparsers.add_parser(
+        "test",
+        help="Test API connection",
+        description="Test connection to gitignore.io API",
+    )
+    test_parser.add_argument(
+        "--timeout",
+        type=int,
+        default=10,
+        help="Connection timeout in seconds (default: 10)",
+    )
+
+    return base_parser
+
+
+def get_command_instance(command_name: str, cli_instance):
+    from .commands import (
+        CacheCommand,
+        GenerateCommand,
+        ListCommand,
+        TestCommand,
+        TUICommand,
+    )
+
+    commands = {
+        "list": ListCommand,
+        "generate": GenerateCommand,
+        "tui": TUICommand,
+        "cache": CacheCommand,
+        "test": TestCommand,
+    }
+
+    command_class = commands.get(command_name)
+    if command_class:
+        return command_class(cli_instance)
+
+    return None

igntui/cli/setup.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import logging
+from logging.handlers import RotatingFileHandler
+from typing import Optional
+
+from ..core.config import config
+
+
+def setup_logging(verbose: bool = False, log_level: Optional[str] = None) -> None:
+    if log_level:
+        level = getattr(logging, log_level.upper(), logging.INFO)
+    elif verbose:
+        level = logging.DEBUG
+    else:
+        log_config = config.logging_config
+        level = getattr(logging, log_config["level"].upper(), logging.INFO)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    handlers = []
+
+    log_config = config.logging_config
+    if log_config["file_enabled"]:
+        try:
+            log_file = config.get_log_file()
+            log_file.parent.mkdir(parents=True, exist_ok=True)
+
+            file_handler = RotatingFileHandler(
+                log_file,
+                maxBytes=log_config["max_file_size"],
+                backupCount=log_config["backup_count"],
+                encoding="utf-8",
+            )
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(level)
+            handlers.append(file_handler)
+
+        except (OSError, PermissionError) as e:
+            print(f"Warning: Could not set up file logging: {e}")
+
+    if log_config["console_enabled"] or not handlers:
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        console_handler.setLevel(level)
+        handlers.append(console_handler)
+
+    logging.basicConfig(level=level, handlers=handlers, force=True)
+
+    logger = logging.getLogger(__name__)
+    logger.debug(f"Logging configured at {logging.getLevelName(level)} level")
+
+
+def check_curses_availability() -> bool:
+    try:
+        import curses
+
+        return True
+    except ImportError:
+        return False
+
+
+def print_curses_error() -> None:
+    print("Error: curses module not available.")
+    print("On Windows, install: pip install windows-curses")
+    print("On Linux/Mac, curses should be included with Python.")

igntui/core/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from .config import config, Config
+from .api import GitIgnoreAPI, APIResponse
+
+__all__ = ["config", "Config", "GitIgnoreAPI", "APIResponse"]

igntui/core/api/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from .client import GitIgnoreAPI
+from .response import APIResponse
+from .errors import APIError, NetworkError, RateLimitError, ServiceUnavailableError
+
+__all__ = [
+    "GitIgnoreAPI",
+    "APIResponse",
+    "APIError",
+    "NetworkError",
+    "RateLimitError",
+    "ServiceUnavailableError",
+]

igntui/core/api/client.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..cache import CacheManager, TemplateCache
+from ..config import config
+from .request_handler import RequestHandler
+from .response import APIResponse
+
+logger = logging.getLogger(__name__)
+
+
+class GitIgnoreAPI:
+    def __init__(self, cache_manager: Optional[CacheManager] = None):
+        self.base_url = config.get("api", "base_url")
+        self.timeout = config.get("api", "timeout")
+        self.user_agent = config.get("api", "user_agent")
+        self.retry_attempts = config.get("api", "retry_attempts")
+        self.cache_ttl = config.get("api", "cache_ttl")
+        self.request_handler = RequestHandler(
+            user_agent=self.user_agent,
+            timeout=self.timeout,
+            retry_attempts=self.retry_attempts,
+        )
+        self.cache_manager = cache_manager or CacheManager(
+            cache_dir=config.get_cache_dir(), default_ttl=self.cache_ttl
+        )
+        self.template_cache = TemplateCache(self.cache_manager)
+        self.stats = {"cache_hits": 0, "cache_misses": 0}
+
+    def list_templates(self, force_refresh: bool = False) -> APIResponse:
+        if not force_refresh:
+            cached_templates = self.template_cache.get_template_list()
+            if cached_templates is not None:
+                logger.debug("Using cached template list")
+                self.stats["cache_hits"] += 1
+                return APIResponse(success=True, data=cached_templates, from_cache=True)
+
+        self.stats["cache_misses"] += 1
+        url = f"{self.base_url}/list"
+
+        try:
+            response = self.request_handler.make_request_with_retry(url)
+
+            if response.success:
+                templates = self._parse_template_list(response.data)
+
+                self.template_cache.set_template_list(templates)
+
+                response.data = templates
+                logger.info(f"Fetched {len(templates)} templates from API")
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Failed to fetch template list: {e}")
+            return APIResponse(success=False, data=[], error_message=str(e))
+
+    def get_templates(
+        self, technologies: List[str], force_refresh: bool = False
+    ) -> APIResponse:
+        if not technologies:
+            return APIResponse(
+                success=True,
+                data="# No templates selected\n# Select templates from the Available Templates panel",
+            )
+
+        clean_techs = self._clean_technology_names(technologies)
+        if not clean_techs:
+            return APIResponse(
+                success=False, data="", error_message="No valid templates provided"
+            )
+
+        if not force_refresh:
+            cached_content = self.template_cache.get_template_content(clean_techs)
+            if cached_content is not None:
+                logger.debug(f"Using cached content for {len(clean_techs)} templates")
+                self.stats["cache_hits"] += 1
+                return APIResponse(success=True, data=cached_content, from_cache=True)
+
+        self.stats["cache_misses"] += 1
+        tech_string = ",".join(clean_techs).lower()
+        url = f"{self.base_url}/{tech_string}"
+
+        try:
+            response = self.request_handler.make_request_with_retry(url)
+
+            if response.success:
+                self.template_cache.set_template_content(clean_techs, response.data)
+                logger.info(f"Fetched content for templates: {', '.join(clean_techs)}")
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Failed to fetch template content: {e}")
+
+            fallback_content = f"""# Error generating content: {str(e)}
+# Selected templates: {', '.join(clean_techs)}
+#
+# This error typically means:
+# - Network connectivity issues
+# - Invalid template names
+# - API service temporarily unavailable
+#
+# Try refreshing the template list or check your internet connection."""
+
+            return APIResponse(
+                success=False, data=fallback_content, error_message=str(e)
+            )
+
+    def test_connection(self) -> APIResponse:
+        try:
+            logger.info("Testing API connectivity...")
+
+            response = self.request_handler.make_request(
+                f"{self.base_url}/list?limit=1"
+            )
+
+            if response.success:
+                test_results = {
+                    "status": "connected",
+                    "response_time": response.response_time,
+                    "api_url": self.base_url,
+                    "cache_stats": self.cache_manager.get_stats(),
+                }
+
+                return APIResponse(success=True, data=test_results)
+            else:
+                return APIResponse(
+                    success=False,
+                    data={"status": "failed"},
+                    error_message="API test request failed",
+                )
+
+        except Exception as e:
+            logger.error(f"API connection test failed: {e}")
+            return APIResponse(
+                success=False, data={"status": "error"}, error_message=str(e)
+            )
+
+    def get_stats(self) -> Dict[str, Any]:
+        request_stats = self.request_handler.get_stats()
+        total_requests = request_stats["requests_made"]
+        avg_response_time = (
+            request_stats["total_response_time"] / total_requests
+            if total_requests > 0
+            else 0.0
+        )
+
+        cache_stats = self.cache_manager.get_stats()
+
+        return {
+            "api_stats": {
+                "requests_made": total_requests,
+                "avg_response_time": avg_response_time,
+                "error_rate": request_stats["errors"] / max(1, total_requests),
+                "base_url": self.base_url,
+                "timeout": self.timeout,
+                "retry_attempts": self.retry_attempts,
+            },
+            "cache_stats": cache_stats,
+            "performance_stats": {
+                "cache_hit_rate": (
+                    self.stats["cache_hits"]
+                    / max(1, self.stats["cache_hits"] + self.stats["cache_misses"])
+                ),
+                "total_cache_operations": self.stats["cache_hits"]
+                + self.stats["cache_misses"],
+            },
+        }
+
+    def clear_cache(self) -> None:
+        self.cache_manager.clear()
+        logger.info("Cleared all API cache data")
+
+    def invalidate_template(self, template_name: str) -> int:
+        return self.template_cache.invalidate_template_content(template_name)
+
+    def _parse_template_list(self, response_text: str) -> List[str]:
+        all_templates = []
+
+        for line in response_text.strip().split("\n"):
+            for template in line.split(","):
+                clean_template = template.strip()
+                if clean_template and self._is_valid_template_name(clean_template):
+                    all_templates.append(clean_template)
+
+        unique_templates = sorted(set(all_templates), key=str.lower)
+
+        logger.debug(f"Parsed {len(unique_templates)} unique templates")
+        return unique_templates
+
+    def _clean_technology_names(self, technologies: List[str]) -> List[str]:
+        clean_techs = []
+
+        for tech in technologies:
+            clean_tech = str(tech).strip()
+
+            clean_tech = "".join(c for c in clean_tech if c.isalnum() or c in "-_+.")
+
+            if clean_tech and self._is_valid_template_name(clean_tech):
+                clean_techs.append(clean_tech)
+            else:
+                logger.warning(f"Skipping invalid template name: {tech}")
+
+        return clean_techs
+
+    def _is_valid_template_name(self, name: str) -> bool:
+        if not name or len(name) > 100:
+            return False
+
+        if not any(c.isalnum() for c in name):
+            return False
+
+        suspicious_patterns = ["..", "//", "\\\\", "<", ">", "|"]
+        if any(pattern in name for pattern in suspicious_patterns):
+            return False
+
+        return True

igntui/core/api/errors.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from typing import Optional
+
+
+class APIError(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        retry_after: Optional[int] = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.retry_after = retry_after
+
+
+class NetworkError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    pass
+
+
+class ServiceUnavailableError(APIError):
+    pass

igntui/core/api/rate_limiter.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import logging
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimiter:
+    def __init__(self, min_interval: float = 0.1):
+        self.min_interval = min_interval
+        self._last_request_time = 0
+
+    def wait_if_needed(self) -> None:
+        current_time = time.time()
+        time_since_last = current_time - self._last_request_time
+
+        if time_since_last < self.min_interval:
+            sleep_time = self.min_interval - time_since_last
+            logger.debug(f"Rate limiting: sleeping for {sleep_time:.3f}s")
+            time.sleep(sleep_time)
+
+    def mark_request(self) -> None:
+        self._last_request_time = time.time()
+
+    def reset(self) -> None:
+        self._last_request_time = 0

igntui/core/api/request_handler.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import logging
+import time
+import urllib.error
+import urllib.request
+from typing import Optional
+
+from .errors import APIError, NetworkError, RateLimitError, ServiceUnavailableError
+from .rate_limiter import RateLimiter
+from .response import APIResponse
+
+logger = logging.getLogger(__name__)
+
+
+class RequestHandler:
+    def __init__(self, user_agent: str, timeout: float = 30.0, retry_attempts: int = 3):
+        self.user_agent = user_agent
+        self.timeout = timeout
+        self.retry_attempts = retry_attempts
+        self.rate_limiter = RateLimiter(min_interval=0.1)
+        self.stats = {"requests_made": 0, "errors": 0, "total_response_time": 0.0}
+
+    def make_request(self, url: str, timeout: Optional[float] = None) -> APIResponse:
+        self.rate_limiter.wait_if_needed()
+
+        start_time = time.time()
+        timeout = timeout or self.timeout
+
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={
+                    "User-Agent": self.user_agent,
+                    "Accept": "text/plain",
+                    "Accept-Encoding": "identity",
+                },
+            )
+
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                content = response.read().decode("utf-8")
+                response_time = time.time() - start_time
+
+                self.rate_limiter.mark_request()
+                self.stats["requests_made"] += 1
+                self.stats["total_response_time"] += response_time
+
+                logger.debug(f"API request to {url} took {response_time:.3f}s")
+
+                return APIResponse(
+                    success=True,
+                    data=content,
+                    status_code=response.getcode(),
+                    response_time=response_time,
+                )
+
+        except urllib.error.HTTPError as e:
+            response_time = time.time() - start_time
+            self.stats["errors"] += 1
+
+            error_msg = f"HTTP {e.code}: {e.reason}"
+
+            if e.code == 429:
+                retry_after = int(e.headers.get("Retry-After", 60))
+                raise RateLimitError(error_msg, e.code, retry_after)
+            elif e.code >= 500:
+                raise ServiceUnavailableError(error_msg, e.code)
+            else:
+                raise APIError(error_msg, e.code)
+
+        except urllib.error.URLError as e:
+            response_time = time.time() - start_time
+            self.stats["errors"] += 1
+
+            if "timeout" in str(e.reason).lower():
+                raise NetworkError(f"Request timeout after {timeout}s")
+            else:
+                raise NetworkError(f"Network error: {e.reason}")
+
+        except Exception as e:
+            response_time = time.time() - start_time
+            self.stats["errors"] += 1
+            raise APIError(f"Unexpected error: {str(e)}")
+
+    def make_request_with_retry(self, url: str) -> APIResponse:
+        last_exception = None
+
+        for attempt in range(self.retry_attempts):
+            try:
+                return self.make_request(url)
+
+            except RateLimitError as e:
+                if attempt < self.retry_attempts - 1:
+                    wait_time = e.retry_after or (2**attempt)
+                    logger.warning(
+                        f"Rate limited, waiting {wait_time}s before retry {attempt + 1}"
+                    )
+                    time.sleep(wait_time)
+                    last_exception = e
+                else:
+                    raise
+
+            except (NetworkError, ServiceUnavailableError) as e:
+                if attempt < self.retry_attempts - 1:
+                    wait_time = 2**attempt
+                    logger.warning(
+                        f"Request failed, retrying in {wait_time}s (attempt {attempt + 1})"
+                    )
+                    time.sleep(wait_time)
+                    last_exception = e
+                else:
+                    raise
+
+            except APIError:
+                raise
+
+        if last_exception:
+            raise last_exception
+        raise APIError("All retry attempts failed")
+
+    def get_stats(self) -> dict:
+        return self.stats.copy()

igntui/core/api/response.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass
+class APIResponse:
+    success: bool
+    data: Any
+    error_message: Optional[str] = None
+    status_code: Optional[int] = None
+    response_time: Optional[float] = None
+    from_cache: bool = False