additory 0.1.0a4__py3-none-any.whl → 0.1.1a1__py3-none-any.whl

additory/common/lists.py

@@ -1,229 +0,0 @@
-"""
-List File Management
-
-Handles loading and parsing of .list files containing static value lists.
-
-File Format (.list):
-    [lists]
-    first_names = Arjun, Vikram, Samuel, James, Mary
-    last_names = Sharma, Kumar, Smith, Johnson
-    
-    [relationships]
-    first_names[0] = last_names[0, 1]
-
-Usage:
-    from additory.common.lists import load_list_file, get_list_values
-    
-    lists = load_list_file("reference/schema_definitions/global.list")
-    first_names = get_list_values("first_names", lists)
-"""
-
-from typing import Dict, List, Optional
-from pathlib import Path
-import re
-
-
-class ListFileError(Exception):
-    """Raised when list file parsing fails."""
-    pass
-
-
-def parse_list_file(content: str) -> Dict[str, List[str]]:
-    """
-    Parse .list file content into dictionary of lists.
-    
-    Format:
-        [lists]
-        list_name = value1, value2, value3
-        
-        [relationships]
-        list1[0] = list2[1, 2]
-    
-    Args:
-        content: File content as string
-        
-    Returns:
-        Dictionary mapping list names to value lists
-        
-    Raises:
-        ListFileError: If parsing fails
-        
-    Example:
-        >>> content = '''
-        ... [lists]
-        ... names = Alice, Bob, Charlie
-        ... statuses = Active, Inactive
-        ... '''
-        >>> lists = parse_list_file(content)
-        >>> lists['names']
-        ['Alice', 'Bob', 'Charlie']
-    """
-    lists = {}
-    current_section = None
-    
-    for line_num, line in enumerate(content.split('\n'), 1):
-        # Remove comments and strip whitespace
-        line = line.split('#')[0].strip()
-        
-        # Skip empty lines
-        if not line:
-            continue
-        
-        # Check for section headers
-        if line.startswith('[') and line.endswith(']'):
-            current_section = line[1:-1].strip()
-            continue
-        
-        # Parse list definitions (only in [lists] section)
-        if current_section == 'lists':
-            if '=' not in line:
-                raise ListFileError(
-                    f"Line {line_num}: Invalid format. Expected 'name = value1, value2, ...'"
-                )
-            
-            name, values_str = line.split('=', 1)
-            name = name.strip()
-            
-            # Validate list name
-            if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
-                raise ListFileError(
-                    f"Line {line_num}: Invalid list name '{name}'. "
-                    f"Must start with letter/underscore and contain only alphanumeric/underscore."
-                )
-            
-            # Parse comma-separated values
-            values = [v.strip() for v in values_str.split(',')]
-            values = [v for v in values if v]  # Remove empty strings
-            
-            if not values:
-                raise ListFileError(
-                    f"Line {line_num}: List '{name}' has no values"
-                )
-            
-            lists[name] = values
-        
-        # Skip relationships section for now (Phase II)
-        elif current_section == 'relationships':
-            continue
-        
-        # Unknown section
-        elif current_section is not None:
-            # Allow unknown sections (for future extensions)
-            continue
-    
-    return lists
-
-
-def load_list_file(filepath: str) -> Dict[str, List[str]]:
-    """
-    Load and parse a .list file.
-    
-    Args:
-        filepath: Path to .list file
-        
-    Returns:
-        Dictionary mapping list names to value lists
-        
-    Raises:
-        ListFileError: If file not found or parsing fails
-        
-    Example:
-        >>> lists = load_list_file("reference/schema_definitions/global.list")
-        >>> lists['first_names']
-        ['Arjun', 'Vikram', 'Samuel', ...]
-    """
-    path = Path(filepath)
-    
-    if not path.exists():
-        raise ListFileError(f"List file not found: {filepath}")
-    
-    if not path.suffix == '.list':
-        raise ListFileError(f"File must have .list extension: {filepath}")
-    
-    try:
-        content = path.read_text(encoding='utf-8')
-        return parse_list_file(content)
-    except UnicodeDecodeError as e:
-        raise ListFileError(f"Failed to read file {filepath}: {e}")
-    except Exception as e:
-        if isinstance(e, ListFileError):
-            raise
-        raise ListFileError(f"Failed to parse {filepath}: {e}")
-
-
-def get_list_values(list_name: str, lists: Dict[str, List[str]]) -> Optional[List[str]]:
-    """
-    Get values for a specific list.
-    
-    Args:
-        list_name: Name of the list
-        lists: Dictionary of lists (from load_list_file or parse_list_file)
-        
-    Returns:
-        List of values or None if not found
-        
-    Example:
-        >>> lists = load_list_file("global.list")
-        >>> values = get_list_values("first_names", lists)
-        >>> print(values[:3])
-        ['Arjun', 'Vikram', 'Samuel']
-    """
-    return lists.get(list_name)
-
-
-def list_all_lists(lists: Dict[str, List[str]]) -> List[str]:
-    """
-    Get names of all available lists.
-    
-    Args:
-        lists: Dictionary of lists
-        
-    Returns:
-        List of list names
-        
-    Example:
-        >>> lists = load_list_file("global.list")
-        >>> names = list_all_lists(lists)
-        >>> print(names)
-        ['first_names', 'last_names', 'banks', 'statuses', ...]
-    """
-    return list(lists.keys())
-
-
-def validate_list_file(filepath: str) -> tuple[bool, List[str]]:
-    """
-    Validate a .list file and return any errors.
-    
-    Args:
-        filepath: Path to .list file
-        
-    Returns:
-        Tuple of (is_valid, error_messages)
-        
-    Example:
-        >>> is_valid, errors = validate_list_file("global.list")
-        >>> if not is_valid:
-        ...     for error in errors:
-        ...         print(error)
-    """
-    errors = []
-    
-    try:
-        lists = load_list_file(filepath)
-        
-        # Check for empty file
-        if not lists:
-            errors.append("File contains no lists")
-        
-        # Check for duplicate names (already handled by dict)
-        # Check for empty lists
-        for name, values in lists.items():
-            if not values:
-                errors.append(f"List '{name}' is empty")
-        
-        return (len(errors) == 0, errors)
-    
-    except ListFileError as e:
-        return (False, [str(e)])
-    except Exception as e:
-        return (False, [f"Unexpected error: {e}"])

additory/common/patterns.py

@@ -1,240 +0,0 @@
-"""
-Pattern File Management
-
-Handles loading and parsing of .properties files containing regex patterns.
-
-File Format (.properties):
-    # Email patterns
-    email_generic = [A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Z|a-z]{2,}
-    email_us = [A-Za-z0-9._%+-]+@(gmail|yahoo|outlook)\\.com
-    
-    # Phone patterns
-    phone_us = \\+1-\\d{3}-\\d{3}-\\d{4}
-    phone_in = \\+91-\\d{10}
-
-Usage:
-    from additory.common.patterns import load_properties_file, get_pattern
-    
-    patterns = load_properties_file("reference/schema_definitions/global.properties")
-    email_pattern = get_pattern("email_generic", patterns)
-"""
-
-from typing import Dict, Optional, List
-from pathlib import Path
-import re
-
-
-class PatternFileError(Exception):
-    """Raised when pattern file parsing fails."""
-    pass
-
-
-def parse_properties_file(content: str) -> Dict[str, str]:
-    """
-    Parse .properties file content into dictionary of patterns.
-    
-    Format:
-        # Comment
-        pattern_name = regex_pattern
-        another_pattern = another_regex
-    
-    Args:
-        content: File content as string
-        
-    Returns:
-        Dictionary mapping pattern names to regex patterns
-        
-    Raises:
-        PatternFileError: If parsing fails
-        
-    Example:
-        >>> content = '''
-        ... # Email patterns
-        ... email = [A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}
-        ... phone = \\+1-\\d{3}-\\d{3}-\\d{4}
-        ... '''
-        >>> patterns = parse_properties_file(content)
-        >>> patterns['email']
-        '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\\.[A-Z|a-z]{2,}'
-    """
-    patterns = {}
-    
-    for line_num, line in enumerate(content.split('\n'), 1):
-        # Remove comments and strip whitespace
-        line = line.split('#')[0].strip()
-        
-        # Skip empty lines
-        if not line:
-            continue
-        
-        # Parse pattern definitions
-        if '=' not in line:
-            raise PatternFileError(
-                f"Line {line_num}: Invalid format. Expected 'name = pattern'"
-            )
-        
-        name, pattern = line.split('=', 1)
-        name = name.strip()
-        pattern = pattern.strip()
-        
-        # Validate pattern name
-        if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
-            raise PatternFileError(
-                f"Line {line_num}: Invalid pattern name '{name}'. "
-                f"Must start with letter/underscore and contain only alphanumeric/underscore."
-            )
-        
-        # Check for empty pattern
-        if not pattern:
-            raise PatternFileError(
-                f"Line {line_num}: Pattern '{name}' has no value"
-            )
-        
-        # Check for duplicate names
-        if name in patterns:
-            raise PatternFileError(
-                f"Line {line_num}: Duplicate pattern name '{name}'"
-            )
-        
-        patterns[name] = pattern
-    
-    return patterns
-
-
-def load_properties_file(filepath: str) -> Dict[str, str]:
-    """
-    Load and parse a .properties file.
-    
-    Args:
-        filepath: Path to .properties file
-        
-    Returns:
-        Dictionary mapping pattern names to regex patterns
-        
-    Raises:
-        PatternFileError: If file not found or parsing fails
-        
-    Example:
-        >>> patterns = load_properties_file("reference/schema_definitions/global.properties")
-        >>> patterns['email_generic']
-        '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}'
-    """
-    path = Path(filepath)
-    
-    if not path.exists():
-        raise PatternFileError(f"Pattern file not found: {filepath}")
-    
-    if not path.suffix == '.properties':
-        raise PatternFileError(f"File must have .properties extension: {filepath}")
-    
-    try:
-        content = path.read_text(encoding='utf-8')
-        return parse_properties_file(content)
-    except UnicodeDecodeError as e:
-        raise PatternFileError(f"Failed to read file {filepath}: {e}")
-    except Exception as e:
-        if isinstance(e, PatternFileError):
-            raise
-        raise PatternFileError(f"Failed to parse {filepath}: {e}")
-
-
-def get_pattern(pattern_name: str, patterns: Dict[str, str]) -> Optional[str]:
-    """
-    Get regex pattern for a specific name.
-    
-    Args:
-        pattern_name: Name of the pattern
-        patterns: Dictionary of patterns (from load_properties_file or parse_properties_file)
-        
-    Returns:
-        Regex pattern string or None if not found
-        
-    Example:
-        >>> patterns = load_properties_file("global.properties")
-        >>> pattern = get_pattern("email_generic", patterns)
-        >>> print(pattern)
-        [A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}
-    """
-    return patterns.get(pattern_name)
-
-
-def list_all_patterns(patterns: Dict[str, str]) -> List[str]:
-    """
-    Get names of all available patterns.
-    
-    Args:
-        patterns: Dictionary of patterns
-        
-    Returns:
-        List of pattern names
-        
-    Example:
-        >>> patterns = load_properties_file("global.properties")
-        >>> names = list_all_patterns(patterns)
-        >>> print(names)
-        ['email_generic', 'email_us', 'phone_us', 'phone_in', ...]
-    """
-    return list(patterns.keys())
-
-
-def validate_properties_file(filepath: str) -> tuple[bool, List[str]]:
-    """
-    Validate a .properties file and return any errors.
-    
-    Args:
-        filepath: Path to .properties file
-        
-    Returns:
-        Tuple of (is_valid, error_messages)
-        
-    Example:
-        >>> is_valid, errors = validate_properties_file("global.properties")
-        >>> if not is_valid:
-        ...     for error in errors:
-        ...         print(error)
-    """
-    errors = []
-    
-    try:
-        patterns = load_properties_file(filepath)
-        
-        # Check for empty file
-        if not patterns:
-            errors.append("File contains no patterns")
-        
-        # Check for empty patterns
-        for name, pattern in patterns.items():
-            if not pattern:
-                errors.append(f"Pattern '{name}' is empty")
-        
-        return (len(errors) == 0, errors)
-    
-    except PatternFileError as e:
-        return (False, [str(e)])
-    except Exception as e:
-        return (False, [f"Unexpected error: {e}"])
-
-
-def is_regex_pattern(value: str) -> bool:
-    r"""
-    Check if a string looks like a regex pattern.
-    
-    Detects special regex characters: \\ [ ] ( ) { } + * ? ^ $ | .
-    
-    Args:
-        value: String to check
-        
-    Returns:
-        True if string contains regex special characters
-        
-    Example:
-        >>> is_regex_pattern("CUST\\d{8}")
-        True
-        >>> is_regex_pattern("first_names")
-        False
-        >>> is_regex_pattern("[A-Z]+")
-        True
-    """
-    # Check for regex special characters
-    regex_chars = r'[\\[\](){}+*?^$|.]'
-    return bool(re.search(regex_chars, value))