zope.hookable 8.2__cp311-cp311-macosx_11_0_arm64.whl

zope/hookable/__init__.py

@@ -0,0 +1,79 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Hookable object support
+"""
+import os
+import platform
+
+
+# Keep these two flags separate:  we want the `_PURE_PYTHON` one
+# to represent that the flag is explicitly set to '1' in the environment,
+# since our 'tox.ini' sets it to '0' for its environments which expect
+# to test the C extension.
+_PYPY_OR_JAVA = platform.python_implementation() in ('PyPy', 'Jython')
+_PURE_PYTHON = os.environ.get('PURE_PYTHON') == '1'
+
+
+class _py_hookable:
+    __slots__ = ('_original', '_implementation')
+
+    def __init__(self, *args, **kw):
+        if not args and 'implementation' in kw:
+            args = (kw.pop('implementation'),)
+        if kw:
+            raise TypeError('Unknown keyword arguments')
+        if len(args) != 1:
+            raise TypeError('Exactly one argument required')
+        self._original = self._implementation = args[0]
+
+    @property
+    def original(self):
+        return self._original
+
+    @property
+    def implementation(self):
+        return self._implementation
+
+    @property
+    def __doc__(self):
+        return self._original.__doc__
+
+    @property
+    def __dict__(self):
+        return getattr(self._original, '__dict__', {})
+
+    @property
+    def __bases__(self):
+        return getattr(self._original, '__bases__', ())
+
+    def sethook(self, new_callable):
+        old, self._implementation = self._implementation, new_callable
+        return old
+
+    def reset(self):
+        self._implementation = self._original
+
+    def __call__(self, *args, **kw):
+        return self._implementation(*args, **kw)
+
+
+try:
+    from zope.hookable._zope_hookable import hookable as _c_hookable
+except ModuleNotFoundError:  # pragma: no cover
+    _c_hookable = None
+
+if _PYPY_OR_JAVA or _PURE_PYTHON or _c_hookable is None:
+    hookable = _py_hookable
+else:  # pragma: no cover
+    hookable = _c_hookable

zope/hookable/_zope_hookable.c

@@ -0,0 +1,285 @@
+/*############################################################################
+ #
+ #  Copyright (c) 2003 Zope Foundation and Contributors.
+ #  All Rights Reserved.
+ #
+ #  This software is subject to the provisions of the Zope Public License,
+ #  Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+ #  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+ #  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ #  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+ #  FOR A PARTICULAR PURPOSE.
+ #
+ ############################################################################*/
+
+static char module__doc__[] = (
+    "Provide an efficient implementation for hookable objects"
+);
+
+#include "Python.h"
+#include "structmember.h"
+
+typedef struct
+{
+    PyObject_HEAD
+    PyObject* original;
+    PyObject* implementation;
+} hookable;
+
+static int
+hookable_init(hookable* self, PyObject* args, PyObject* kwds)
+{
+    static char* kwlist[] = { "implementation", NULL };
+    PyObject* implementation;
+
+    if (!PyArg_ParseTupleAndKeywords(
+          args, kwds, "O:hookable", kwlist, &implementation))
+        return -1;
+
+    /* Both 'self->original' and 'self->implementation' are originally
+     * set to the passed-in 'implementation', hence the need for
+     * two increfs.
+     */
+    Py_INCREF(implementation);
+    Py_XDECREF(self->original);
+    self->original = implementation;
+
+    Py_INCREF(implementation);
+    Py_XDECREF(self->implementation);
+    self->implementation = implementation;
+
+    return 0;
+}
+
+static int
+hookable_traverse(hookable* self, visitproc visit, void* arg)
+{
+#if PY_VERSION_HEX >= 0x03090000
+    Py_VISIT(Py_TYPE(self));
+#endif
+    Py_VISIT(self->implementation);
+    Py_VISIT(self->original);
+    return 0;
+}
+
+static int
+hookable_clear(hookable* self)
+{
+    Py_XDECREF(self->original);
+    self->original = NULL;
+
+    Py_XDECREF(self->implementation);
+    self->implementation = NULL;
+
+    return 0;
+}
+
+static void
+hookable_dealloc(hookable* self)
+{
+    PyObject_GC_UnTrack((PyObject*)self);
+    PyTypeObject* tp = Py_TYPE(self);
+
+    Py_XDECREF(self->original);
+    Py_XDECREF(self->implementation);
+
+    tp->tp_free((PyObject*)self);
+
+    /* heap types must decref their type when dealloc'ed */
+    Py_DECREF(tp);
+}
+
+static PyObject*
+hookable_call(hookable* self, PyObject* args, PyObject* kw)
+{
+    if (self->implementation != NULL)
+        return PyObject_Call(self->implementation, args, kw);
+
+    PyErr_SetString(PyExc_TypeError, "Hookable has no implementation");
+    return NULL;
+}
+
+static PyObject*
+hookable_getattro(hookable* self, PyObject* name)
+{
+    PyObject* result = NULL;
+    const char* name_as_string;
+    int maybe_special_name;
+
+    name_as_string = PyUnicode_AsUTF8(name);
+    if (name_as_string == NULL) { return NULL; }
+
+    maybe_special_name = name_as_string[0] == '_' && name_as_string[1] == '_';
+
+    if (maybe_special_name) {
+        /* pass through __doc__ to the original implementation */
+        if (strcmp("__doc__", name_as_string) == 0) {
+            return PyObject_GetAttr(self->original, name);
+        }
+        /* synthesize __bases__ and __dict__ if the original fails */
+        if (strcmp("__bases__", name_as_string) == 0) {
+            result = PyObject_GetAttr(self->original, name);
+            if (result == NULL) {
+                PyErr_Clear();
+                result = PyTuple_New(0);
+            }
+            return result;
+        }
+        if (strcmp("__dict__", name_as_string) == 0) {
+            result = PyObject_GetAttr(self->original, name);
+            if (result == NULL) {
+                PyErr_Clear();
+                result = PyDict_New();
+            }
+            return result;
+        }
+    }
+
+    return PyObject_GenericGetAttr((PyObject*)self, name);
+}
+
+static char hookable_sethook__doc__[] = (
+    "Set the hook implementation for the hookable object\n\n"
+    "Return the previous hook implementation, or None."
+);
+
+static PyObject*
+hookable_sethook(hookable* self, PyObject* implementation)
+{
+    PyObject* current;
+
+    current = self->implementation;
+    Py_INCREF(implementation);
+    self->implementation = implementation;
+
+    if (current == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    return current;
+}
+
+static char hookable_reset__doc__[] = (
+    "Reset the hook to the original value"
+);
+
+static PyObject*
+hookable_reset(hookable* self)
+{
+    Py_XINCREF(self->original);
+    Py_XDECREF(self->implementation);
+
+    self->implementation = self->original;
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static struct PyMethodDef hookable_methods[] = {
+    { "sethook",
+        (PyCFunction)hookable_sethook, METH_O, hookable_sethook__doc__ },
+    { "reset",
+        (PyCFunction)hookable_reset, METH_NOARGS, hookable_reset__doc__},
+    { NULL, NULL } /* sentinel */
+};
+
+static PyMemberDef hookable_members[] = {
+    { "original",
+        T_OBJECT_EX, offsetof(hookable, original), READONLY },
+    { "implementation",
+        T_OBJECT_EX, offsetof(hookable, implementation), READONLY },
+    { NULL } /* Sentinel */
+};
+
+static char hookable__name__[] = "zope.hookable.hookable";
+static char hookable__doc__[] =
+  "Callable objects that support being overridden";
+
+
+/*
+ * Heap type: hookable
+ */
+static PyType_Slot hookable_type_slots[] = {
+    {Py_tp_doc,         hookable__doc__},
+    {Py_tp_init,        hookable_init},
+    {Py_tp_call,        hookable_call},
+    {Py_tp_getattro,    hookable_getattro},
+    {Py_tp_traverse,    hookable_traverse},
+    {Py_tp_clear,       hookable_clear},
+    {Py_tp_dealloc,     hookable_dealloc},
+    {Py_tp_members,     hookable_members},
+    {Py_tp_methods,     hookable_methods},
+    {0,                 NULL}
+};
+
+static PyType_Spec hookable_type_spec = {
+    .name       = hookable__name__,
+    .basicsize  = sizeof(hookable),
+    .flags      = Py_TPFLAGS_DEFAULT |
+                  Py_TPFLAGS_BASETYPE |
+#if PY_VERSION_HEX >= 0x030c0000
+                  Py_TPFLAGS_MANAGED_WEAKREF |
+#endif
+                  Py_TPFLAGS_HAVE_GC,
+    .slots      = hookable_type_slots
+};
+
+/*
+ * Module initialization
+ */
+
+static struct PyMethodDef hookable_module_methods[] = {
+    { NULL, NULL }  /* sentinel */
+};
+
+
+/* Handler for the 'execute' phase of multi-phase initialization
+ *
+ * See: https://docs.python.org/3/c-api/module.html#multi-phase-initialization
+ * and: https://peps.python.org/pep-0489/#module-execution-phase
+ */
+static int
+hookable_module_exec(PyObject* module)
+{
+    PyObject* hookable_type;
+
+    hookable_type = PyType_FromSpec(&hookable_type_spec);
+    if (hookable_type == NULL) { return -1; }
+
+    if (PyModule_AddObject(module, "hookable", hookable_type) < 0)
+        return -1;
+
+    return 0;
+}
+
+
+/* Slot definitions for multi-phase initialization
+ *
+ * See: https://docs.python.org/3/c-api/module.html#multi-phase-initialization
+ * and: https://peps.python.org/pep-0489
+ */
+static PyModuleDef_Slot hookable_module_slots[] = {
+    {Py_mod_exec,       hookable_module_exec},
+    {0,                 NULL}
+};
+
+static struct PyModuleDef hookable_module_def = {
+    PyModuleDef_HEAD_INIT,
+    .m_name     = "_zope_hookable",
+    .m_doc      = module__doc__,
+    .m_methods  = hookable_module_methods,
+    .m_slots    = hookable_module_slots
+};
+
+static PyObject*
+init(void)
+{
+    return PyModuleDef_Init(&hookable_module_def);
+}
+
+PyMODINIT_FUNC
+PyInit__zope_hookable(void)
+{
+    return init();
+}

zope/hookable/tests/__init__.py

@@ -0,0 +1 @@
+# This line required to prevent an empty file.

zope/hookable/tests/test_compile_flags.py

@@ -0,0 +1,29 @@
+##############################################################################
+#
+# Copyright (c) 2022 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+import struct
+import unittest
+
+import zope.hookable  # noqa: try to load a C module for side effects
+
+
+class TestFloatingPoint(unittest.TestCase):
+
+    def test_no_fast_math_optimization(self):
+        # Building with -Ofast enables -ffast-math, which sets certain FPU
+        # flags that can cause breakage elsewhere.  A library such as BTrees
+        # has no business changing global FPU flags for the entire process.
+        zero_bits = struct.unpack("!Q", struct.pack("!d", 0.0))[0]
+        next_up = zero_bits + 1
+        smallest_subnormal = struct.unpack("!d", struct.pack("!Q", next_up))[0]
+        self.assertNotEqual(smallest_subnormal, 0.0)

zope/hookable/tests/test_hookable.py

@@ -0,0 +1,203 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Test the hookable support Extension
+"""
+import unittest
+
+
+def return_foo():
+    return 'FOO'
+
+
+def return_bar():
+    return 'BAR'
+
+
+def not_called():
+    raise AssertionError("This should not be called")
+
+
+class PyHookableMixin:
+
+    def _callFUT(self, *args, **kw):
+        from zope.hookable import _py_hookable
+        return _py_hookable(*args, **kw)
+
+
+class HookableMixin:
+
+    def _callFUT(self, *args, **kw):
+        from zope.hookable import _py_hookable
+        from zope.hookable import hookable
+        if hookable is _py_hookable:
+            raise unittest.SkipTest("Hookable and PyHookable are the same")
+        return hookable(*args, **kw)  # pragma: no cover
+
+
+class PyHookableTests(PyHookableMixin,
+                      unittest.TestCase):
+
+    def test_pure_python(self):
+        from zope.hookable import _PURE_PYTHON
+        from zope.hookable import _PYPY_OR_JAVA
+        from zope.hookable import _c_hookable
+        from zope.hookable import _py_hookable
+        from zope.hookable import hookable
+
+        if _PYPY_OR_JAVA or _PURE_PYTHON:
+            self.assertIs(hookable, _py_hookable)
+        else:
+            self.assertIs(hookable, _c_hookable)
+
+    def test_before_hook(self):
+        hooked = self._callFUT(return_foo)
+        self.assertIs(hooked.original, return_foo)
+        self.assertIs(hooked.implementation, return_foo)
+        self.assertEqual(hooked(), 'FOO')
+
+    def test_after_hook(self):
+        hooked = self._callFUT(not_called)
+        old = hooked.sethook(return_bar)
+        self.assertIs(old, not_called)
+        self.assertIs(hooked.original, not_called)
+        self.assertIs(hooked.implementation, return_bar)
+        self.assertEqual(hooked(), 'BAR')
+
+    def test_after_hook_and_reset(self):
+        hooked = self._callFUT(return_foo)
+        old = hooked.sethook(not_called)
+        hooked.reset()
+        self.assertIs(old, return_foo)
+        self.assertIs(hooked.original, return_foo)
+        self.assertIs(hooked.implementation, return_foo)
+        self.assertEqual(hooked(), 'FOO')
+
+    def test_original_cannot_be_deleted(self):
+        hooked = self._callFUT(not_called)
+        with self.assertRaises((TypeError, AttributeError)):
+            del hooked.original
+
+    def test_implementation_cannot_be_deleted(self):
+        hooked = self._callFUT(not_called)
+        with self.assertRaises((TypeError, AttributeError)):
+            del hooked.implementation
+
+    def test_no_args(self):
+        with self.assertRaises(TypeError):
+            self._callFUT()
+
+    def test_too_many_args(self):
+        with self.assertRaises(TypeError):
+            self._callFUT(not_called, not_called)
+
+    def test_w_implementation_kwarg(self):
+        hooked = self._callFUT(implementation=return_foo)
+        self.assertIs(hooked.original, return_foo)
+        self.assertIs(hooked.implementation, return_foo)
+        self.assertEqual(hooked(), 'FOO')
+
+    def test_w_unknown_kwarg(self):
+        with self.assertRaises(TypeError):
+            self._callFUT(nonesuch=42)
+
+    def test_class(self):
+        class C:
+            pass
+
+        hooked = self._callFUT(C)
+        self.assertIsInstance(hooked(), C)
+
+        hooked.sethook(return_bar)
+        self.assertEqual(hooked(), 'BAR')
+
+
+class TestIssue6Py(PyHookableMixin,
+                   unittest.TestCase):
+    # Make sphinx docs for hooked objects work.
+    # https://github.com/zopefoundation/zope.hookable/issues/6
+    # We need to proxy __doc__ to the original,
+    # and synthesize an empty __bases__ and a __dict__ attribute
+    # if they're not present.
+
+    def _check_preserves_doc(self, docs):
+        self.assertEqual("I have some docs", docs.__doc__)
+
+        hooked = self._callFUT(docs)
+        self.assertEqual(hooked.__doc__, docs.__doc__)
+
+    def test_preserves_doc_function(self):
+        def docs():
+            """I have some docs"""
+        self._check_preserves_doc(docs)
+
+    def test_preserves_doc_class(self):
+        class Docs:
+            """I have some docs"""
+
+        self._check_preserves_doc(Docs)
+
+    def test_empty_bases_function(self):
+        hooked = self._callFUT(return_foo)
+        self.assertEqual((), hooked.__bases__)
+
+    def test_empty_dict_function(self):
+        hooked = self._callFUT(return_foo)
+        self.assertEqual({}, hooked.__dict__)
+
+    def test_bases_class(self):
+        class C:
+            pass
+        self.assertEqual(C.__bases__, (object,))
+        hooked = self._callFUT(C)
+        self.assertEqual(hooked.__bases__, (object,))
+
+    def test_dict_class(self):
+        class C:
+            pass
+
+        hooked = self._callFUT(C)
+        self.assertEqual(hooked.__dict__, C.__dict__)
+
+    def test_non_string_attr_name(self):
+        # Specifically for the C implementation, which has to deal with this
+        hooked = self._callFUT(return_foo)
+        with self.assertRaises(TypeError):
+            getattr(hooked, 42)
+
+        with self.assertRaises(TypeError):
+            hooked.__getattribute__(42)
+
+    def test_unicode_attribute_name(self):
+        # Specifically for the C implementation, which has to deal with this
+        hooked = self._callFUT(return_foo)
+        result = hooked.__getattribute__('__bases__')
+        self.assertEqual(result, ())
+
+    def test_short_name(self):
+        # Specifically for the C implementation, which has to deal with this
+        hooked = self._callFUT(return_foo)
+        with self.assertRaises(AttributeError):
+            hooked.__getattribute__('')
+
+
+class HookableTests(HookableMixin, PyHookableTests):
+    pass
+
+
+class TestIssue6(HookableMixin, TestIssue6Py):
+    pass
+
+
+def test_suite():
+    return unittest.defaultTestLoader.loadTestsFromName(__name__)

zope_hookable-8.2.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: zope.hookable
+Version: 8.2
+Summary: Zope hookable
+Author-email: Zope Foundation and contributors <zope-dev@zope.dev>
+Maintainer-email: Plone Foundation and contributors <zope-dev@zope.dev>
+License-Expression: ZPL-2.1
+Project-URL: Documentation, https://zopehookable.readthedocs.io
+Project-URL: Issues, https://github.com/zopefoundation/zope.hookable/issues
+Project-URL: Source, https://github.com/zopefoundation/zope.hookable
+Project-URL: Changelog, https://github.com/zopefoundation/zope.hookable/blob/master/CHANGES.rst
+Keywords: zope,function,hook,replacement,loose,coupled
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Zope :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Provides-Extra: docs
+Requires-Dist: Sphinx; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Provides-Extra: test
+Requires-Dist: zope.testing; extra == "test"
+Requires-Dist: zope.testrunner>=6.4; extra == "test"
+Provides-Extra: testing
+Requires-Dist: coverage; extra == "testing"
+Requires-Dist: zope.testing; extra == "testing"
+Requires-Dist: zope.testrunner>=6.4; extra == "testing"
+Dynamic: license-file
+
+===============
+ zope.hookable
+===============
+
+.. image:: https://img.shields.io/pypi/v/zope.hookable.svg
+        :target: https://pypi.python.org/pypi/zope.hookable/
+        :alt: Latest release
+
+.. image:: https://img.shields.io/pypi/pyversions/zope.hookable.svg
+        :target: https://pypi.org/project/zope.hookable/
+        :alt: Supported Python versions
+
+.. image:: https://github.com/zopefoundation/zope.hookable/actions/workflows/tests.yml/badge.svg
+        :target: https://github.com/zopefoundation/zope.hookable/actions/workflows/tests.yml
+
+.. image:: https://readthedocs.org/projects/zopehookable/badge/?version=latest
+        :target: https://zopehookable.readthedocs.io/en/latest/
+        :alt: Documentation Status
+
+.. image:: https://coveralls.io/repos/github/zopefoundation/zope.hookable/badge.svg?branch=master
+        :target: https://coveralls.io/github/zopefoundation/zope.hookable?branch=master
+
+
+This package supports the efficient creation of "hookable" objects, which
+are callable objects that are meant to be optionally replaced.
+
+The idea is that you create a function that does some default thing and make it
+hookable. Later, someone can modify what it does by calling its sethook method
+and changing its implementation.  All users of the function, including those
+that imported it, will see the change.
+
+Documentation is hosted at https://zopehookable.readthedocs.io

zope_hookable-8.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+zope/hookable/__init__.py,sha256=AlGd7CUrQFdO8X82n8At-Fb4oVU1woiE2AoKQUPiNYg,2460
+zope/hookable/_zope_hookable.c,sha256=N9LOxTLZ-fZN8o_iNg8mjUNCX4na4UoGO0eDrkIqLic,7452
+zope/hookable/_zope_hookable.cpython-311-darwin.so,sha256=vyZKr6BYTwqJ5QMNBfmsB3BE11E4Er_bMdTHz8VWbB8,51832
+zope/hookable/tests/__init__.py,sha256=Z9EJNKBQorYcdV6oaIRTRgF41SMRZEEoLltZCKyVPI8,47
+zope/hookable/tests/test_compile_flags.py,sha256=91siNUs2kotDUYpVV1vAZ_opWhZ50X4_DYkIiNMh6h0,1289
+zope/hookable/tests/test_hookable.py,sha256=3FdXSprA60j5eX3LftT6MZG80moqG-0tTwQn_KjNLQc,6330
+zope_hookable-8.2.dist-info/licenses/LICENSE.txt,sha256=PmcdsR32h1FswdtbPWXkqjg-rKPCDOo_r1Og9zNdCjw,2070
+zope_hookable-8.2.dist-info/METADATA,sha256=rA2zvcVZQj1pbYq2ZKD1zod2o2EnI30bYvArUh7-kl0,3227
+zope_hookable-8.2.dist-info/WHEEL,sha256=qxQkdhERtGxJzqnVOBnucx1aUmU2n3HmuzYdln_LyOw,109
+zope_hookable-8.2.dist-info/top_level.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
+zope_hookable-8.2.dist-info/RECORD,,

zope_hookable-8.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+

zope_hookable-8.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,44 @@
+Zope Public License (ZPL) Version 2.1
+
+A copyright notice accompanies this license document that identifies the
+copyright holders.
+
+This license has been certified as open source. It has also been designated as
+GPL compatible by the Free Software Foundation (FSF).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions in source code must retain the accompanying copyright
+notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the accompanying copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Names of the copyright holders must not be used to endorse or promote
+products derived from this software without prior written permission from the
+copyright holders.
+
+4. The right to distribute this software or to use it for any purpose does not
+give you the right to use Servicemarks (sm) or Trademarks (tm) of the
+copyright
+holders. Use of them is covered by separate agreement with the copyright
+holders.
+
+5. If any files are modified, you must cause the modified files to carry
+prominent notices stating that you changed the files and the date of any
+change.
+
+Disclaimer
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

zope_hookable-8.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+zope