Decorators

def execution_wrapper(target_func):
    """Higher-order function accepting a function reference as an argument."""
    print(f"[METAPROGRAMMING] Invoking target function object: '{target_func.__name__}'")
    # Executing the function reference passed as a parameter
    return target_func()

def greet_service():
    return "Hello, Enterprise System!"

# Passing 'greet_service' as a raw function object pointer (without parentheses!)
result = execution_wrapper(greet_service)
print("Returned Result:", result)

[METAPROGRAMMING] Invoking target function object: 'greet_service'
Returned Result: Hello, Enterprise System!

import time

def performance_timer_decorator(original_func):
    """
    Decorator function that measures and prints execution duration.
    Uses *args and **kwargs to accept arbitrary function signatures!
    """
    def wrapper_closure(*args, **kwargs):
        start_time = time.perf_counter()
        
        # Executing the original target function
        result = original_func(*args, **kwargs)
        
        end_time = time.perf_counter()
        elapsed = end_time - start_time
        print(f"[BENCHMARK] Function '{original_func.__name__}' executed in {elapsed:.6f} seconds.")
        
        return result  # Return original function output
        
    return wrapper_closure  # Return wrapper function pointer

# Applying decorator using @ syntax
@performance_timer_decorator
def compute_sum_of_squares(limit_n: int) -> int:
    return sum(i * i for i in range(limit_n))

# Invoking decorated function
total = compute_sum_of_squares(500_000)
print(f"Calculated Sum: {total}")

[BENCHMARK] Function 'compute_sum_of_squares' executed in 0.024512 seconds.
Calculated Sum: 41666541666250000

from functools import wraps

def audit_logger_decorator(func):
    @wraps(func)  # Preserves func.__name__, func.__doc__, func.__annotations__
    def wrapper(*args, **kwargs):
        print(f"[AUDIT LOG] Calling function '{func.__name__}' with args={args}, kwargs={kwargs}")
        return func(*args, **kwargs)
    return wrapper

@audit_logger_decorator
def transfer_funds(sender_id: str, receiver_id: str, amount: float) -> bool:
    """Transfers financial capital securely between user accounts."""
    print(f"--> Transferred ${amount:,.2f} from {sender_id} to {receiver_id}")
    return True

# Testing function execution
transfer_funds("ACC_101", "ACC_202", 500.00)

print("\n=== Metadata Introspection Checks ===")
print("Function Name     :", transfer_funds.__name__)  # Correctly retains 'transfer_funds'!
print("Function Docstring:", transfer_funds.__doc__)   # Retains original docstring!

[AUDIT LOG] Calling function 'transfer_funds' with args=('ACC_101', 'ACC_202', 500.0), kwargs={}
--> Transferred $500.00 from ACC_101 to ACC_202

=== Metadata Introspection Checks ===
Function Name     : transfer_funds
Function Docstring: Transfers financial capital securely between user accounts.

from functools import wraps

# Level 1: Decorator Factory accepting custom configuration arguments
def repeat_execution(num_times: int = 3):
    # Level 2: Actual Decorator accepting target function
    def actual_decorator(func):
        # Level 3: Wrapper Closure executing inner logic
        @wraps(func)
        def wrapper(*args, **kwargs):
            print(f"=== Repeating '{func.__name__}' {num_times} times ===")
            last_result = None
            for attempt in range(1, num_times + 1):
                print(f"  Attempt #{attempt}:")
                last_result = func(*args, **kwargs)
            return last_result
        return wrapper
    return actual_decorator

# Applying Decorator with Arguments
@repeat_execution(num_times=2)
def send_ping_heartbeat():
    print("  --> Ping heartbeat packet sent to server.")
    return True

send_ping_heartbeat()

=== Repeating 'send_ping_heartbeat' 2 times ===
  Attempt #1:
  --> Ping heartbeat packet sent to server.
  Attempt #2:
  --> Ping heartbeat packet sent to server.

from functools import wraps

class ExecutionCounterDecorator:
    """Class-based stateful decorator tracking function call frequency."""
    def __init__(self, func):
        self.func = func
        self.call_count = 0
        wraps(func)(self)  # Preserve function metadata on class instance

    def __call__(self, *args, **kwargs):
        self.call_count += 1
        print(f"[STATEFUL DECORATOR] Calling '{self.func.__name__}' | Total Calls So Far: {self.call_count}")
        return self.func(*args, **kwargs)

@ExecutionCounterDecorator
def execute_database_query(query_str: str):
    print(f"Executing SQL: {query_str}")

# Testing Class-Based Stateful Decorator
execute_database_query("SELECT * FROM users;")
execute_database_query("UPDATE users SET status='ACTIVE';")
print("Preserved Call Count State:", execute_database_query.call_count)

[STATEFUL DECORATOR] Calling 'execute_database_query' | Total Calls So Far: 1
Executing SQL: SELECT * FROM users;
[STATEFUL DECORATOR] Calling 'execute_database_query' | Total Calls So Far: 2
Executing SQL: UPDATE users SET status='ACTIVE';
Preserved Call Count State: 2

from functools import wraps

# Security Validation Decorator
def enforce_admin_role(func):
    @wraps(func)
    def wrapper(user_role: str, *args, **kwargs):
        if user_role.upper() != "ADMIN":
            print(f"[SECURITY DENIAL] Role '{user_role}' lacks permission to execute '{func.__name__}'!")
            return False
        return func(user_role, *args, **kwargs)
    return wrapper

@enforce_admin_role
def purge_system_logs(user_role: str, target_dir: str):
    print(f"SUCCESS: System logs in '{target_dir}' purged by {user_role}.")
    return True

@enforce_admin_role
def update_system_config(user_role: str, config_key: str, new_val: str):
    print(f"SUCCESS: Updated config '{config_key}' to '{new_val}' by {user_role}.")
    return True

def dispatch_service_command(command_payload: list):
    """
    Routes commands using match-case and invokes role-guarded decorated functions.
    Demonstrates combining pattern matching with decorated security methods.
    """
    match command_payload:
        case ["PURGE", role, target_path]:
            return purge_system_logs(role, target_path)
            
        case ["CONFIG", role, key_str, val_str]:
            return update_system_config(role, key_str, val_str)
            
        case _:
            print("ERROR: Unrecognized command payload format.")
            return False

# Testing Decorated Dispatcher
print("=== Attempt 1: Standard User Execution ===")
dispatch_service_command(["PURGE", "MEMBER", "/var/logs"])

print("\n=== Attempt 2: Admin User Execution ===")
dispatch_service_command(["PURGE", "ADMIN", "/var/logs"])

=== Attempt 1: Standard User Execution ===
[SECURITY DENIAL] Role 'MEMBER' lacks permission to execute 'purge_system_logs'!

=== Attempt 2: Admin User Execution ===
SUCCESS: System logs in '/var/logs' purged by ADMIN.