Zope Component Architecture

7.1 · active · verified Tue Apr 14

zope.component, along with zope.interface, provides a robust component architecture for Python, enabling the definition, registration, and lookup of loosely coupled components such as adapters and utilities. It is a core part of the Zope Toolkit project. The current version is 7.1. New minor versions are released roughly every 2-6 months, and major versions every 2-3 years, following semantic versioning.

Warnings

breaking Backwards compatibility imports from `zope.component.interfaces`, `zope.component.registry`, and the entire `zope.component.hookable` module were removed.
Fix: Update imports to directly use `zope.interface.interfaces` or `zope.interface.registry`. Replace usage of `zope.component.hookable` with modern alternatives.
breaking Dropped support for older Python versions, requiring Python 3.7+ (for 6.1+), Python 3.10+ (for 7.1+).
Fix: Ensure your project runs on a supported Python version (currently >=3.10 for zope.component 7.x).
breaking Replaced `pkg_resources` namespace with PEP 420 native namespace.
Fix: This is primarily an internal packaging change. If you rely on internal `pkg_resources` mechanisms related to `zope.component`'s namespace, you may need to update your code to reflect PEP 420 standards.
gotcha The declaration-order of interfaces being adapted to is important for adapter lookup. It must be the same as the order of parameters given to the adapter and used to query the adapter.
Fix: Always ensure the order of interfaces specified in adapter declarations and subsequent lookups matches precisely.

Install

pip install zope.component Install latest version

Imports

getUtility
```
from zope.component import getUtility
```

provideUtility

from zope.component import provideUtility

queryUtility
```
from zope.component import queryUtility
```
IComponent
```
from zope.interface.interfaces import IComponent
```
Backwards compatibility imports for zope.component.interfaces were removed in version 5.0.0. These interfaces should now be imported directly from zope.interface.interfaces.
ComponentRegistry
```
from zope.interface.registry import ComponentRegistry
```
Backwards compatibility imports for zope.component.registry were removed in version 5.0.0. These classes should now be imported directly from zope.interface.registry.

Quickstart

This quickstart demonstrates the core functionality of zope.component: defining an interface, implementing it, and then registering and retrieving a utility. Utilities are singletons or named instances that provide a specific interface and can be looked up through the component registry.

from zope.interface import Interface, implementer
from zope.component import provideUtility, getUtility, queryUtility, ComponentLookupError

# 1. Define an Interface
class IGreeter(Interface):
    """The Greeter interface provides a greeting method."""
    def greet(name: str) -> str:
        """Say hello to the given name."""

# 2. Implement the Interface
@implementer(IGreeter)
class HelloGreeter:
    """A simple greeter component."""
    def greet(self, name: str) -> str:
        return f"Hello, {name}!"

# 3. Register the Utility
# A utility is a component looked up by an interface and an optional name.
# We can register an instance of the Greeter.
my_greeter_instance = HelloGreeter()
provideUtility(my_greeter_instance, IGreeter, name='default-greeter')

# You can also register without a name for a singleton utility for the interface
provideUtility(HelloGreeter(), IGreeter) # No name, becomes default for IGreeter

# 4. Look up and use the Utility
# Using getUtility (raises ComponentLookupError if not found)
try:
    default_greeter = getUtility(IGreeter)
    print(f"Default greeting: {default_greeter.greet('World')}")
except ComponentLookupError:
    print("Default greeter not found.")

try:
    named_greeter = getUtility(IGreeter, name='default-greeter')
    print(f"Named greeting: {named_greeter.greet('Alice')}")
except ComponentLookupError:
    print("Named greeter not found.")

# Using queryUtility (returns None if not found, or a default value if specified)
missing_greeter = queryUtility(IGreeter, name='non-existent')
print(f"Querying missing greeter (should be None): {missing_greeter}")

fallback_greeter = queryUtility(IGreeter, name='non-existent', default='Fallback')
print(f"Querying with fallback: {fallback_greeter}")

view raw JSON →