Code Introspection & Metadata

class Service:
    def run(self):
        return 'Service running'

class AuthService(Service):
    pass

auth = AuthService()

# 1. type() checks exact class (ignores inheritance)
print('type(auth) is AuthService?', type(auth) is AuthService)
print('type(auth) is Service?', type(auth) is Service)  # False!

# 2. isinstance() respects class inheritance
print('isinstance(auth, Service)?', isinstance(auth, Service))  # True!
print('isinstance(auth, (int, Service))?', isinstance(auth, (int, Service)))  # Tuple check

# 3. callable() tests if an object can be invoked
print('Is auth callable?', callable(auth))
print('Is auth.run callable?', callable(auth.run))
print('Is AuthService class callable?', callable(AuthService))  # Classes are callable!

class ServerConfig:
    host = '127.0.0.1'
    port = 8080

cfg = ServerConfig()

# Checking attribute existence
print('Has host?', hasattr(cfg, 'host'))
print('Has timeout?', hasattr(cfg, 'timeout'))

# Safely retrieving attributes with fallback defaults
timeout = getattr(cfg, 'timeout', 30)
print('Resolved timeout:', timeout)

# Setting dynamic attributes at runtime
setattr(cfg, 'environment', 'production')
print('Dynamically set environment:', getattr(cfg, 'environment'))

# Safe attribute cleanup
delattr(cfg, 'environment')
print('Still has environment?', hasattr(cfg, 'environment'))

def process_transaction(sender: str, recipient: str, amount: float = 0.0) -> bool:
    """Transfer funds between two verified customer accounts."""
    return amount > 0

print('Function name (__name__):', process_transaction.__name__)
print('Module origin (__module__):', process_transaction.__module__)
print('Docstring (__doc__):', process_transaction.__doc__.strip())

# Inspecting the underlying code object
co = process_transaction.__code__
print('Positional parameter count:', co.co_argcount)
print('Local variable names:', co.co_varnames)
print('Defined in file:', co.co_filename.split('\\')[-1])

def fetch_records(query: str, limit: int = 100, active_only: bool = True) -> list:
    """Query database for records matching criteria."""
    return []

annotations = fetch_records.__annotations__
print('Raw __annotations__ mapping:', annotations)
print('Parameter "query" expected type:', annotations['query'].__name__)
print('Return expected type:', annotations['return'].__name__)

# Notice: Python does NOT enforce these types at runtime automatically!
result = fetch_records(12345)  # Calling with int instead of str executes without error
print('Executed without type enforcement:', result)

import inspect

def endpoint_handler(request_id: str, timeout: int = 30, *tags, verbose: bool = False, **extra):
    pass

sig = inspect.signature(endpoint_handler)
print('Full signature:', sig)
print('Parameters breakdown:')
for name, param in sig.parameters.items():
    print(f'  {name:12} | Kind: {param.kind.name:18} | Default: {param.default} | Type: {param.annotation}')

class ServiceManager:
    def do_start(self, service_name):
        return f'Service "{service_name}" started successfully.'
    
    def do_stop(self, service_name):
        return f'Service "{service_name}" stopped.'
    
    def execute(self, action, service_name):
        method_name = f'do_{action}'
        # Introspect whether handler method exists on self
        if not hasattr(self, method_name):
            return f'Unknown action: "{action}"'
        handler = getattr(self, method_name)
        return handler(service_name)

manager = ServiceManager()
print(manager.execute('start', 'auth-worker'))
print(manager.execute('stop', 'auth-worker'))
print(manager.execute('restart', 'auth-worker'))  # Unrecognized

import functools, inspect

def enforce_types(func):
    sig = inspect.signature(func)
    
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        bound = sig.bind(*args, **kwargs)
        bound.apply_defaults()
        for name, value in bound.arguments.items():
            expected = sig.parameters[name].annotation
            if expected is not inspect.Parameter.empty and not isinstance(value, expected):
                raise TypeError(f'Argument "{name}" must be {expected.__name__}, got {type(value).__name__}')
        return func(*args, **kwargs)
    return wrapper

@enforce_types
def send_alert(message: str, code: int):
    return f'[{code}] {message}'

print(send_alert('Disk space low', 500))
try:
    send_alert('Disk space low', 'FIVE_HUNDRED')  # Passing str for int
except TypeError as err:
    print('Type validation failed:', err)