Configuration and Utilities

class ConfigParserWithCase:
    """
    Case-sensitive configuration parser for IMDb settings.
    
    Inherits from configparser.ConfigParser but preserves key case sensitivity
    and provides enhanced value processing.
    """
    
    def __init__(defaults=None, confFile=None, *args, **kwds):
        """
        Initialize the configuration parser.
        
        Parameters:
        - defaults: dict, optional - Default configuration values
        - confFile: str/list, optional - Configuration file(s) to parse
        """
    
    def get(section, option, *args, **kwds):
        """
        Get configuration value with automatic type conversion.
        
        Parameters:
        - section: str - Configuration section name
        - option: str - Option name (case-sensitive)
        
        Returns:
        Value with appropriate type (bool, int, str, None)
        """
    
    def getDict(section):
        """
        Get entire configuration section as dictionary.
        
        Parameters:
        - section: str - Section name
        
        Returns:
        dict: Section contents as key-value pairs
        """
    
    def items(section, *args, **kwds):
        """
        Get section items as list of tuples.
        
        Parameters:
        - section: str - Section name
        
        Returns:
        list: List of (key, value) tuples
        """

from imdb import ConfigParserWithCase

# Create configuration parser
config = ConfigParserWithCase()

# Manually set configuration
config.read_string("""
[imdbpy]
accessSystem = http
results = 30
reraiseExceptions = true
customOption = MyValue
""")

# Access configuration values
access_system = config.get('imdbpy', 'accessSystem')
results = config.get('imdbpy', 'results')  # Automatically converted to int
reraise = config.get('imdbpy', 'reraiseExceptions')  # Automatically converted to bool

print(f"Access System: {access_system}")
print(f"Results: {results} (type: {type(results)})")
print(f"Reraise: {reraise} (type: {type(reraise)})")

# Get section as dictionary
imdb_config = config.getDict('imdbpy')
print(f"Full config: {imdb_config}")

def canonicalName(name):
    """
    Convert person name to canonical format.
    
    Parameters:
    - name: str - Person name to convert
    
    Returns:
    str: Canonical form of the name
    """

def analyze_name(name, canonical=None):
    """
    Parse person name into components.
    
    Parameters:
    - name: str - Name to analyze
    - canonical: bool, optional - Whether to use canonical format
    
    Returns:
    dict: Name components (name, imdbIndex, etc.)
    """

def build_name(name_dict, canonical=None):
    """
    Build formatted name from components.
    
    Parameters:
    - name_dict: dict - Name components dictionary
    - canonical: bool, optional - Whether to use canonical format
    
    Returns:
    str: Formatted name string
    """

def normalizeName(name):
    """
    Normalize name format for consistent processing.
    
    Parameters:
    - name: str - Name to normalize
    
    Returns:
    str: Normalized name
    """

def canonicalTitle(title, lang=None, imdbIndex=None):
    """
    Convert movie title to canonical format.
    
    Parameters:
    - title: str - Movie title to convert
    - lang: str, optional - Language code
    - imdbIndex: str, optional - IMDb index for disambiguation
    
    Returns:
    str: Canonical form of the title
    """

def analyze_title(title, canonical=None):
    """
    Parse movie title into components.
    
    Parameters:
    - title: str - Title to analyze
    - canonical: bool, optional - Whether to use canonical format
    
    Returns:
    dict: Title components (title, year, kind, imdbIndex, etc.)
    """

def build_title(title_dict, canonical=None, ptdf=0, appendKind=True):
    """
    Build formatted title from components.
    
    Parameters:
    - title_dict: dict - Title components dictionary
    - canonical: bool, optional - Whether to use canonical format
    - ptdf: int - Plain Text Data File format flag
    - appendKind: bool - Whether to append kind information
    
    Returns:
    str: Formatted title string
    """

def analyze_company_name(name, stripNotes=True):
    """
    Parse company name into components.
    
    Parameters:
    - name: str - Company name to analyze
    - stripNotes: bool - Whether to strip notes from name
    
    Returns:
    dict: Company name components
    """

def build_company_name(name_dict):
    """
    Build formatted company name from components.
    
    Parameters:
    - name_dict: dict - Company name components dictionary
    
    Returns:
    str: Formatted company name
    """

def split_company_name_notes(name):
    """
    Split company name and notes.
    
    Parameters:
    - name: str - Company name with potential notes
    
    Returns:
    tuple: (name, notes) tuple
    """

from imdb.utils import canonicalName, canonicalTitle, analyze_name, build_title

# Name processing
name = "Downey Jr., Robert"
canonical = canonicalName(name)
print(f"Canonical name: {canonical}")

# Name analysis
name_parts = analyze_name("Robert Downey Jr.")
print(f"Name parts: {name_parts}")

# Title processing
title = "The Matrix (1999)"
canonical_title = canonicalTitle(title)
print(f"Canonical title: {canonical_title}")

# Title building
title_dict = {'title': 'The Matrix', 'year': '1999', 'kind': 'movie'}
formatted_title = build_title(title_dict)
print(f"Built title: {formatted_title}")

def cmpMovies(m1, m2):
    """
    Compare two Movie objects.
    
    Parameters:
    - m1: Movie - First movie
    - m2: Movie - Second movie
    
    Returns:
    int: Comparison result (-1, 0, 1)
    """

def cmpPeople(p1, p2):
    """
    Compare two Person objects.
    
    Parameters:
    - p1: Person - First person
    - p2: Person - Second person
    
    Returns:
    int: Comparison result (-1, 0, 1)
    """

def cmpCompanies(c1, c2):
    """
    Compare two Company objects.
    
    Parameters:
    - c1: Company - First company
    - c2: Company - Second company
    
    Returns:
    int: Comparison result (-1, 0, 1)
    """

def flatten(seq, toDescend=None, yieldDictKeys=False, scalar=None):
    """
    Flatten nested data structures.
    
    Parameters:
    - seq: Sequence to flatten
    - toDescend: Types to descend into
    - yieldDictKeys: bool - Whether to yield dictionary keys
    - scalar: Scalar types to treat as terminal
    
    Returns:
    Generator yielding flattened elements
    """

def modifyStrings(obj, modFunct, titlesRefs, namesRefs, charactersRefs):
    """
    Modify string references in objects.
    
    Parameters:
    - obj: Object to modify
    - modFunct: Function to apply to strings
    - titlesRefs: Title references dictionary
    - namesRefs: Name references dictionary  
    - charactersRefs: Character references dictionary
    
    Returns:
    Modified object
    """

from imdb.utils import cmpMovies, flatten

# Compare movies
from imdb import IMDb
ia = IMDb()

movie1 = ia.search_movie('The Matrix')[0]
movie2 = ia.search_movie('The Matrix Reloaded')[0]

comparison = cmpMovies(movie1, movie2)
print(f"Movie comparison result: {comparison}")

# Flatten nested data
nested_data = [1, [2, 3], {'a': 4, 'b': [5, 6]}]
flattened = list(flatten(nested_data))
print(f"Flattened: {flattened}")

class _Container:
    """
    Base container class with dictionary-like interface.
    
    Provides common functionality for Movie, Person, Character, and Company classes
    including data access, modification functions, and reference management.
    """
    
    def keys():
        """Return list of available data keys."""
    
    def values():
        """Return list of data values."""
    
    def items():
        """Return list of (key, value) tuples."""
    
    def get(key, default=None):
        """Get value for key with optional default."""
    
    def set_mod_funct(modFunct):
        """Set string modification function."""
    
    def clear_mod_funct():
        """Clear string modification function."""
    
    def set_data(data, override=0):
        """Set object data."""
    
    def add_to_current_info(info, keys=None, mainInfoset=None):
        """Add information set to current info tracking."""

def guessLanguage(text):
    """
    Guess the language of text.
    
    Parameters:
    - text: str - Text to analyze
    
    Returns:
    str: Detected language code
    """

from imdb.linguistics import guessLanguage

# Language detection
title1 = "Le Fabuleux Destin d'Amélie Poulain"
title2 = "Crouching Tiger, Hidden Dragon"

lang1 = guessLanguage(title1)
lang2 = guessLanguage(title2)

print(f"'{title1}' detected as: {lang1}")
print(f"'{title2}' detected as: {lang2}")

def main():
    """
    Main entry point for imdbpy command-line interface.
    
    Provides interactive and command-line access to IMDb functionality
    including search, retrieval, and data display operations.
    """

# Search for movies
imdbpy search movie "The Matrix"

# Get movie information
imdbpy get movie 0133093

# Search for people
imdbpy search person "Keanu Reeves"

# Get person information  
imdbpy get person 0000206

# Get top charts
imdbpy top movies
imdbpy bottom movies

import logging
from imdb import IMDb

# Configure logging level
logging.basicConfig(level=logging.DEBUG)

# Create IMDb instance with logging
ia = IMDb(loggingLevel=logging.DEBUG)

# Operations will now produce detailed logs
movies = ia.search_movie('The Matrix')

from imdb import IMDb

# Create instance with custom base URL
ia = IMDb(imdbURL_base='https://pro.imdb.com/')

# Set URLs after creation
ia.set_imdb_urls('https://www.imdb.com/')

# Access configured URL patterns
print(f"Base URL: {ia.urls['movie_base']}")
print(f"Movie URL pattern: {ia.urls['movie_main']}")

from imdb import IMDb

# Configure result limits and performance settings
ia = IMDb(
    results=50,              # Default search results
    keywordsResults=200,     # Default keyword results
    reraiseExceptions=False  # Handle exceptions gracefully
)

# These settings affect all operations
movies = ia.search_movie('Matrix')  # Returns up to 50 results
keywords = ia.search_keyword('action')  # Returns up to 200 results