🧠 Python DeepCuts — 💡 Introspection With Inspect

One of Python’s superpowers is introspection — the ability to examine objects, code, and execution state while the program is running. This capability is not a hack or an afterthought. It is a first-class feature of the language, and it’s what enables:

• debuggers
• test frameworks
• CLI generators
• dependency injection systems
• ORMs and serializers
• decorators that adapt to function signatures

At the center of this is the inspect module.

---

🧩 Inspecting Function Signatures

Functions in Python carry rich metadata about:

• parameters
• default values
• annotations
• return types

def greet(name: str, age: int = 30) -> str:
    return f"Hello {name}, age {age}"

sig = inspect.signature(greet)

From the signature object, frameworks can:

• validate inputs
• auto-generate help text
• map CLI arguments
• enforce contracts dynamically

This is how libraries like argparse, click, and FastAPI understand your functions without configuration files.

---

🧠 Retrieving Source Code at Runtime

When source code is available, Python lets you retrieve it directly.

inspect.getsource(greet)

This is commonly used by:

• debuggers
• documentation generators
• code analyzers
• hot-reload systems

It’s important to note that this works only when the original source is accessible (not for built-in or compiled extensions).

---

🔍 Inspecting the Call Stack

Python tracks every active function call using stack frames.

inspect.stack()

Each frame contains:

• function name
• file name
• line number
• local and global variables

This is how:

• stack traces are generated
• debuggers step through code
• logging frameworks report caller context

Understanding this helps explain how Python knows where errors happen.

---

🧱 Working with Frames and Execution Context

Frames expose the live execution state of a function.

inspect.currentframe()

From a frame, you can access:

• local variables (f_locals)
• global variables (f_globals)
• the code object being executed

This power must be used carefully — but it’s invaluable for advanced debugging and tracing.

---

🧬 Identifying Object Types Dynamically

Python can distinguish objects at runtime without explicit type declarations.

inspect.isfunction(obj)
inspect.isclass(obj)
inspect.ismethod(obj)

This capability enables:

• plugin systems
• runtime dispatch
• serialization logic
• dynamic API discovery

It’s one reason Python frameworks feel “smart” with very little configuration.

---

🔄 Enumerating Members of Modules and Classes

Introspection allows Python to discover what attributes, methods, and classes exist inside an object.

inspect.getmembers(module_or_class)

This is how:

• IDEs provide autocomplete
• documentation tools list APIs
• frameworks auto-register handlers and hooks

Discovery is dynamic — not hardcoded.

---

🧠 Real-World Use Case: Adaptive Decorators

Decorators can use inspect to adapt behavior based on a function’s signature.

sig = inspect.signature(func)
sig.bind(*args, **kwargs)

This allows decorators to:

• validate arguments
• log named parameters
• enforce runtime rules
• remain generic and reusable

Many production-grade decorators rely on this pattern.

---

⚠️ Power Comes with Responsibility

Introspection is powerful — but it has trade-offs:

• It can impact performance if overused
• It may break with aggressive optimizations
• It can expose internal details unintentionally

This is why introspection is often used at:

• startup
• configuration time

• debugging paths

  —not in tight loops.

---

✅ Key Points

• Python supports deep introspection at runtime
• inspect reveals signatures, source code, frames, and metadata
• Frameworks depend heavily on introspection
• Call stacks and frames explain how Python tracks execution
• Introspection enables flexible, declarative APIs
• Use it thoughtfully to avoid performance pitfalls

Introspection is one of the reasons Python feels expressive, adaptive, and powerful — especially at scale.

---

# Python DeepCuts — Introspection with inspect
# Programmer: python_scripts (Abhijith Warrier)

import inspect

# 1 — Function signature inspection
def greet(name: str, age: int = 30) -> str:
    return f"Hello {name}, age {age}"

sig = inspect.signature(greet)
print(sig)

for name, param in sig.parameters.items():
    print(name, param.annotation, param.default)

# 2 — Source code inspection
print(inspect.getsource(greet))

# 3 — Call stack inspection
def level_one():
    level_two()

def level_two():
    stack = inspect.stack()
    for frame in stack:
        print(frame.function)

level_one()

# 4 — Working with frames
def compute():
    x = 10
    y = 20
    frame = inspect.currentframe()
    print("Locals:", frame.f_locals)

compute()

# 5 — Object type detection
class User:
    pass

def fn():
    pass

print("Is function:", inspect.isfunction(fn))
print("Is class:", inspect.isclass(User))
print("Is method:", inspect.ismethod(User.__init__))

# 6 — Enumerating members
members = inspect.getmembers(inspect)
for name, value in members[:10]:
    print(name, type(value))

# 7 — Adaptive decorator example
def log_call(func):
    sig = inspect.signature(func)

    def wrapper(*args, **kwargs):
        bound = sig.bind(*args, **kwargs)
        print(f"Calling {func.__name__} with {bound.arguments}")
        return func(*args, **kwargs)

    return wrapper

@log_call
def add(a, b):
    return a + b

add(2, 3)