Zope Proxy

7.1 · active · verified Tue Apr 14

zope.proxy is a Python library providing generic, transparent proxies. It allows you to wrap an object with a proxy that delegates most operations to the underlying object, while still allowing for custom behavior or interception. The current version is 7.1, with releases typically tied to Python version support and bug fixes.

Warnings

breaking Major versions (5.x, 6.x, 7.x) of zope.proxy have progressively dropped support for older Python versions. Version 7.x (including 7.1) requires Python 3.10 or newer. Attempting to install or use it on older Python versions will fail.
Fix: Ensure your project's Python environment is 3.10 or newer. For older Python versions, you may need to pin to an earlier zope.proxy version (e.g., 6.x for Python 3.7-3.9, 5.x for Python 3.6).
breaking Starting with version 5.0.0, the `zope.interface` dependency and its integration (like `zope.proxy.non_proxied` and automatic interface implementation) were removed. If your application relied on proxies automatically adapting to or implementing `zope.interface` definitions, this will break.
Fix: Manually implement `zope.interface` concerns on your proxied objects or manage interface registration directly. Review code that assumed `zope.proxy` handled `zope.interface` aspects implicitly.
gotcha While `zope.proxy` aims for transparency, `type(proxied_object)` will return `<class 'zope.proxy.Proxy'>`, not the type of the underlying proxied object. Code that strictly checks `type()` for identity will not see the original object's type.
Fix: Prefer `isinstance(proxied_object, OriginalClass)` for type checks, as `zope.proxy` typically handles this transparently. If you need the exact type of the original object, retrieve it first using `getProxiedObject(proxied_object)` and then call `type()` on the result.

Install

pip install zope-proxy Install latest version

Imports

Proxy
```
from zope.proxy import Proxy
```
getProxiedObject
```
from zope.proxy import getProxiedObject
```
isproxy
```
from zope.proxy import isproxy
```

Quickstart

This quickstart demonstrates how to create a transparent proxy for an object using `zope.proxy.Proxy`, interact with it, and retrieve the original object using `zope.proxy.getProxiedObject`. It also shows how `isinstance` works transparently.

from zope.proxy import Proxy, getProxiedObject

class MyObject:
    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

    def __repr__(self):
        return f"<MyObject value={self.value}>"

# Create an instance of MyObject
obj = MyObject(42)
print(f"Original object: {obj}")

# Wrap it with a Proxy
proxied_obj = Proxy(obj)
print(f"Proxied object: {proxied_obj}")

# Interact with the proxy - it behaves like the original object
print(f"Value via proxy: {proxied_obj.value}")
print(f"Method call via proxy: {proxied_obj.get_value()}")

# Check if it's a proxy
from zope.proxy import isproxy
print(f"Is proxied_obj a proxy? {isproxy(proxied_obj)}")

# Get the original object back from the proxy
original_from_proxy = getProxiedObject(proxied_obj)
print(f"Original object retrieved from proxy: {original_from_proxy}")
assert original_from_proxy is obj

# Demonstrate transparency for isinstance
print(f"isinstance(proxied_obj, MyObject)? {isinstance(proxied_obj, MyObject)}")

view raw JSON →