Python’s builtins module is the namespace that contains all built-in functions, exceptions, and types — everything available without an import. import builtins. Access: builtins.print, builtins.len, builtins.open, builtins.isinstance, etc. Replace for testing: builtins.input = lambda _: "mocked" — patches input() globally; restore with the original builtins.input. Custom print: replace builtins.print to intercept all print calls system-wide without modifying call sites. __import__: builtins.__import__ is the hook called by all import statements — replace it to intercept imports, add logging, or redirect to a virtual filesystem. Dynamic type creation: builtins.type("MyClass", (base1,), {"attr": value}) — three-argument type() creates a new class. Namespace introspection: vars(builtins) → all built-in names dict; dir(builtins) → sorted list. The __builtins__ attribute on a module is either the builtins module object (in __main__) or the module’s __dict__ (in other modules) — use import builtins for reliable access. Claude Code generates custom print hooks, test stubs, import interceptors, and namespace introspection tools.
CLAUDE.md for builtins
## builtins Stack
- Stdlib: import builtins
- Access: builtins.print, builtins.len, builtins.open, builtins.__import__
- Patch: _orig = builtins.print; builtins.print = my_print
- Restore: builtins.print = _orig
- Inspect: vars(builtins) # dict of all builtins
- dir(builtins) # sorted list
- Note: prefer contextmanager wrappers over persistent global patchesbuiltins Namespace Pipeline
# app/builtinsutil.py — print hooks, input stub, import interceptor, type builder
from __future__ import annotations
import builtins
import functools
import sys
import time
from contextlib import contextmanager
from dataclasses import dataclass, field
from typing import Any, Callable, Generator, TextIO
# ─────────────────────────────────────────────────────────────────────────────
# 1. Print hook context managers
# ─────────────────────────────────────────────────────────────────────────────
@contextmanager
def capture_print() -> Generator[list[str], None, None]:
"""
Context manager: capture all builtins.print() calls into a list.
Yields the list; restores builtins.print on exit.
Example:
with capture_print() as lines:
print("hello")
print("world")
assert lines == ["hello", "world"]
"""
lines: list[str] = []
original = builtins.print
def _capturing(*args: object, sep: str = " ", end: str = "\n", **kw: object) -> None:
lines.append(sep.join(str(a) for a in args))
builtins.print = _capturing # type: ignore[assignment]
try:
yield lines
finally:
builtins.print = original
@contextmanager
def prefix_print(prefix: str) -> Generator[None, None, None]:
"""
Context manager: prepend prefix to every print() call.
Example:
with prefix_print("[DEBUG] "):
print("something happened") # prints "[DEBUG] something happened"
"""
original = builtins.print
def _prefixed(*args: object, sep: str = " ", end: str = "\n", **kw: object) -> None:
original(prefix + sep.join(str(a) for a in args), end=end, **kw)
builtins.print = _prefixed # type: ignore[assignment]
try:
yield
finally:
builtins.print = original
@contextmanager
def timestamped_print(fmt: str = "%H:%M:%S") -> Generator[None, None, None]:
"""
Context manager: add a timestamp prefix to every print() call.
Example:
with timestamped_print():
print("server started") # "12:34:56 server started"
"""
import datetime
original = builtins.print
def _ts(*args: object, sep: str = " ", end: str = "\n", **kw: object) -> None:
ts = datetime.datetime.now().strftime(fmt)
original(f"{ts} " + sep.join(str(a) for a in args), end=end, **kw)
builtins.print = _ts # type: ignore[assignment]
try:
yield
finally:
builtins.print = original
# ─────────────────────────────────────────────────────────────────────────────
# 2. Input stubbing for tests
# ─────────────────────────────────────────────────────────────────────────────
@contextmanager
def stub_input(responses: "list[str] | str") -> Generator[None, None, None]:
"""
Context manager: replace builtins.input() with a stub that returns
items from responses in order. Raises EOFError when exhausted.
Example:
with stub_input(["Alice", "30"]):
name = input("Name: ")
age = input("Age: ")
assert name == "Alice" and age == "30"
"""
if isinstance(responses, str):
responses = [responses]
queue = list(responses)
original = builtins.input
def _stub(prompt: str = "") -> str:
if not queue:
raise EOFError("stub_input: no more responses")
return queue.pop(0)
builtins.input = _stub # type: ignore[assignment]
try:
yield
finally:
builtins.input = original
# ─────────────────────────────────────────────────────────────────────────────
# 3. Import interceptor
# ─────────────────────────────────────────────────────────────────────────────
@dataclass
class ImportLog:
entries: list[dict] = field(default_factory=list)
def names(self) -> list[str]:
return [e["name"] for e in self.entries]
@contextmanager
def log_imports() -> Generator[ImportLog, None, None]:
"""
Context manager: log every import() call made within the block.
Example:
with log_imports() as log:
import json
import os.path
print(log.names())
"""
original = builtins.__import__
record = ImportLog()
def _logging_import(name: str, *args: object, **kwargs: object) -> object:
record.entries.append({"name": name, "time": time.time()})
return original(name, *args, **kwargs)
builtins.__import__ = _logging_import # type: ignore[assignment]
try:
yield record
finally:
builtins.__import__ = original
# ─────────────────────────────────────────────────────────────────────────────
# 4. Namespace introspection
# ─────────────────────────────────────────────────────────────────────────────
def list_builtins(category: str = "all") -> list[str]:
"""
Return built-in names by category.
category: "functions", "types", "exceptions", "constants", "all"
Example:
print(list_builtins("functions"))
"""
names = dir(builtins)
if category == "all":
return names
results = []
for name in names:
obj = getattr(builtins, name)
if category == "functions" and callable(obj) and not isinstance(obj, type):
results.append(name)
elif category == "types" and isinstance(obj, type) and not issubclass(obj, BaseException):
results.append(name)
elif category == "exceptions" and isinstance(obj, type) and issubclass(obj, BaseException):
results.append(name)
elif category == "constants" and not callable(obj):
results.append(name)
return results
def builtin_doc(name: str) -> str:
"""
Return the docstring (first line) of a built-in by name.
Example:
print(builtin_doc("sorted"))
"""
obj = getattr(builtins, name, None)
if obj is None:
return f"<no builtin named {name!r}>"
doc = getattr(obj, "__doc__", "") or ""
return doc.strip().split("\n")[0]
# ─────────────────────────────────────────────────────────────────────────────
# 5. Dynamic class builder using type()
# ─────────────────────────────────────────────────────────────────────────────
def make_class(
name: str,
bases: tuple = (),
attrs: "dict | None" = None,
) -> type:
"""
Create a new class dynamically using builtins.type().
Example:
Point = make_class("Point", attrs={"x": 0, "y": 0})
p = Point(); p.x = 3; p.y = 4
print(p.x, p.y)
"""
return builtins.type(name, bases or (object,), attrs or {})
def make_enum_class(name: str, members: list[str]) -> type:
"""
Create a simple enum-like class with integer values 0, 1, 2, ...
Example:
Status = make_enum_class("Status", ["PENDING", "ACTIVE", "DONE"])
print(Status.ACTIVE) # 1
"""
attrs = {member: i for i, member in enumerate(members)}
attrs["_members"] = members
@staticmethod # type: ignore[misc]
def _name(val: int) -> str:
if 0 <= val < len(members):
return members[val]
return f"<unknown {val}>"
attrs["name"] = _name
return builtins.type(name, (object,), attrs)
# ─────────────────────────────────────────────────────────────────────────────
# Demo
# ─────────────────────────────────────────────────────────────────────────────
if __name__ == "__main__":
print("=== builtins demo ===")
# ── list_builtins ─────────────────────────────────────────────────────────
print("\n--- list_builtins ---")
fns = list_builtins("functions")
types_ = list_builtins("types")
excs = list_builtins("exceptions")
print(f" functions: {len(fns)} — {fns[:5]}")
print(f" types: {len(types_)} — {types_[:5]}")
print(f" exceptions: {len(excs)} — {excs[:5]}")
# ── builtin_doc ───────────────────────────────────────────────────────────
print("\n--- builtin_doc ---")
for name in ["sorted", "enumerate", "zip", "map"]:
print(f" {name}: {builtin_doc(name)[:60]}")
# ── capture_print ─────────────────────────────────────────────────────────
print("\n--- capture_print ---")
with capture_print() as lines:
print("alpha")
print("beta", "gamma")
print(f" captured: {lines}")
# ── prefix_print ──────────────────────────────────────────────────────────
print("\n--- prefix_print ---")
with prefix_print("[LOG] "):
print("application started")
print("ready")
# ── stub_input ────────────────────────────────────────────────────────────
print("\n--- stub_input ---")
with stub_input(["Alice", "42"]):
name = input("Name: ")
age = input("Age: ")
print(f" name={name!r} age={age!r}")
# ── log_imports ───────────────────────────────────────────────────────────
print("\n--- log_imports ---")
with log_imports() as log:
import decimal # noqa: F401
import fractions # noqa: F401
print(f" imported: {log.names()}")
# ── make_class / make_enum_class ──────────────────────────────────────────
print("\n--- dynamic class creation ---")
Point = make_class("Point", attrs={"x": 0, "y": 0, "__repr__": lambda self: f"Point({self.x},{self.y})"})
p = Point(); p.x = 3; p.y = 4
print(f" Point instance: {p}")
print(f" isinstance check: {isinstance(p, Point)}")
Status = make_enum_class("Status", ["PENDING", "ACTIVE", "DONE"])
print(f" Status.ACTIVE={Status.ACTIVE} name={Status.name(Status.ACTIVE)}")
print("\n=== done ===")For the __builtins__ module attribute alternative — inside a module body, __builtins__ refers to either the builtins module (__main__) or the module’s __dict__ (other modules); the inconsistency makes it unreliable — always import builtins explicitly for reliable cross-module access to the built-in namespace. For the unittest.mock.patch / monkeypatch (pytest) alternative — unittest.mock.patch("builtins.print", ...) and pytest’s monkeypatch.setattr(builtins, "print", ...) patch built-in names per test with automatic teardown — use mock.patch for test-scoped patches integrated with the test framework; use the contextmanager wrappers shown above in production code or cross-framework test utilities where pytest/unittest are not available. The Claude Skills 360 bundle includes builtins skill sets covering capture_print()/prefix_print()/timestamped_print() print hook managers, stub_input() input replacement for testing, log_imports() import interceptor, list_builtins()/builtin_doc() namespace introspection, and make_class()/make_enum_class() dynamic type builders. Start with the free tier to try built-in namespace patterns and builtins pipeline code generation.