zope.hookable 6.0__cp312-cp312-win_amd64.whl

zope/hookable/__init__.py

@@ -0,0 +1,75 @@
+##############################################################################
+#
+# 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
+
+
+_PYPY = platform.python_implementation() in ('PyPy', 'Jython')
+_PURE_PYTHON = os.environ.get('PURE_PYTHON', _PYPY)
+
+
+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 ImportError:  # pragma: no cover
+    _c_hookable = None
+
+if _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,264 @@
+/*############################################################################
+ #
+ #  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.
+ #
+ ############################################################################*/
+
+/* _zope_hookable.c
+
+   Provide an efficient implementation for hookable objects
+
+ */
+
+#include "Python.h"
+#include "structmember.h"
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *old;
+    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;
+
+  Py_INCREF(implementation);
+  Py_INCREF(implementation);
+  Py_XDECREF(self->old);
+  self->old = implementation;
+  Py_XDECREF(self->implementation);
+  self->implementation = implementation;
+
+  return 0;
+}
+
+static int
+hookable_traverse(hookable *self, visitproc visit, void *arg)
+{
+  if (self->implementation != NULL && visit(self->implementation, arg) < 0)
+    return -1;
+  if (self->old != NULL
+      && self->old != self->implementation
+      && visit(self->old, arg) < 0
+      )
+    return -1;
+
+  return 0;
+}
+
+static int
+hookable_clear(hookable *self)
+{
+  Py_XDECREF(self->old);
+  self->old = NULL;
+  Py_XDECREF(self->implementation);
+  self->implementation = NULL;
+  return 0;
+}
+
+
+static void
+hookable_dealloc(hookable *self)
+{
+  PyObject_GC_UnTrack((PyObject *)self);
+  Py_XDECREF(self->old);
+  Py_XDECREF(self->implementation);
+  Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject *
+hookable_sethook(hookable *self, PyObject *implementation)
+{
+  PyObject *old;
+
+  old = self->implementation;
+  Py_INCREF(implementation);
+  self->implementation = implementation;
+
+  if (old == NULL)
+    {
+      Py_INCREF(Py_None);
+      return Py_None;
+    }
+
+  return old;
+}
+
+static PyObject *
+hookable_reset(hookable *self)
+{
+  Py_XINCREF(self->old);
+  Py_XDECREF(self->implementation);
+  self->implementation = self->old;
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static struct PyMethodDef hookable_methods[] = {
+  {"sethook",   (PyCFunction)hookable_sethook, METH_O,
+   "Set the hook implementation for the hookable object"},
+  {"reset", (PyCFunction)hookable_reset, METH_NOARGS,
+   "Reset the hook to the original value"},
+  {NULL,        NULL}       /* sentinel */
+};
+
+
+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->old, name);
+        }
+        /* synthesize __base__ and __dict__ if the original fails */
+        if (strcmp("__bases__", name_as_string) == 0) {
+            result = PyObject_GetAttr(self->old, name);
+            if (result == NULL) {
+                PyErr_Clear();
+                result = PyTuple_New(0);
+            }
+            return result;
+        }
+        if (strcmp("__dict__", name_as_string) == 0) {
+            result = PyObject_GetAttr(self->old, name);
+            if (result == NULL) {
+                PyErr_Clear();
+                result = PyDict_New();
+            }
+            return result;
+        }
+    }
+
+    return PyObject_GenericGetAttr((PyObject*)self, name);
+}
+
+static PyMemberDef hookable_members[] = {
+  { "original", T_OBJECT_EX, offsetof(hookable, old), READONLY },
+  { "implementation", T_OBJECT_EX, offsetof(hookable, implementation), READONLY },
+  {NULL}    /* Sentinel */
+};
+
+
+static char Hookabletype__doc__[] =
+"Callable objects that support being overridden"
+;
+
+static PyTypeObject hookabletype = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    /* tp_name           */ "zope.hookable."
+                                "hookable",
+    /* tp_basicsize      */ sizeof(hookable),
+    /* tp_itemsize       */ 0,
+    /* tp_dealloc        */ (destructor)&hookable_dealloc,
+    /* tp_print          */ (printfunc)0,
+    /* tp_getattr        */ (getattrfunc)0,
+    /* tp_setattr        */ (setattrfunc)0,
+    /* tp_compare        */ 0,
+    /* tp_repr           */ (reprfunc)0,
+    /* tp_as_number      */ 0,
+    /* tp_as_sequence    */ 0,
+    /* tp_as_mapping     */ 0,
+    /* tp_hash           */ (hashfunc)0,
+    /* tp_call           */ (ternaryfunc)hookable_call,
+    /* tp_str            */ (reprfunc)0,
+    /* tp_getattro       */ (getattrofunc)hookable_getattro,
+    /* tp_setattro       */ (setattrofunc)0,
+    /* tp_as_buffer      */ 0,
+    /* tp_flags          */ Py_TPFLAGS_DEFAULT
+                                | Py_TPFLAGS_BASETYPE
+                                | Py_TPFLAGS_HAVE_GC,
+    /* tp_doc            */ Hookabletype__doc__,
+    /* tp_traverse       */ (traverseproc)hookable_traverse,
+    /* tp_clear          */ (inquiry)hookable_clear,
+    /* tp_richcompare    */ (richcmpfunc)0,
+    /* tp_weaklistoffset */ (long)0,
+    /* tp_iter           */ (getiterfunc)0,
+    /* tp_iternext       */ (iternextfunc)0,
+    /* tp_methods        */ hookable_methods,
+    /* tp_members        */ hookable_members,
+    /* tp_getset         */ 0,
+    /* tp_base           */ 0,
+    /* tp_dict           */ 0, /* internal use */
+    /* tp_descr_get      */ (descrgetfunc)0,
+    /* tp_descr_set      */ (descrsetfunc)0,
+    /* tp_dictoffset     */ 0,
+    /* tp_init           */ (initproc)hookable_init,
+    /* tp_alloc          */ (allocfunc)0,
+    /* tp_new            */ (newfunc)0 /*PyType_GenericNew*/,
+    /* tp_free           */ 0/*PyObject_GC_Del*/,
+};
+
+
+  #define MOD_ERROR_VAL NULL
+  #define MOD_SUCCESS_VAL(val) val
+  #define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
+  #define MOD_DEF(ob, name, doc, methods) \
+      static struct PyModuleDef moduledef = { \
+        PyModuleDef_HEAD_INIT, name, doc, -1, methods, }; \
+      ob = PyModule_Create(&moduledef);
+
+static struct PyMethodDef module_methods[] = {
+    {NULL, NULL}
+};
+
+MOD_INIT(_zope_hookable)
+{
+  PyObject *m;
+
+  MOD_DEF(m, "_zope_hookable",
+    "Provide an efficient implementation for hookable objects",
+    module_methods)
+
+  if (m == NULL)
+    return MOD_ERROR_VAL;
+
+  hookabletype.tp_new = PyType_GenericNew;
+  hookabletype.tp_free = PyObject_GC_Del;
+
+  if (PyType_Ready(&hookabletype) < 0)
+    return MOD_ERROR_VAL;
+
+  if (PyModule_AddObject(m, "hookable", (PyObject *)&hookabletype) < 0)
+    return MOD_ERROR_VAL;
+
+  return MOD_SUCCESS_VAL(m);
+
+}

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,198 @@
+##############################################################################
+#
+# 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 _c_hookable
+        from zope.hookable import _py_hookable
+        from zope.hookable import hookable
+        self.assertIs(hookable, _py_hookable if _PURE_PYTHON else _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-6.0-py3.12-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;has_mfs = sys.version_info > (3, 5);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zope',));importlib = has_mfs and __import__('importlib.util');has_mfs and __import__('importlib.machinery');m = has_mfs and sys.modules.setdefault('zope', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('zope', [os.path.dirname(p)])));m = m or sys.modules.setdefault('zope', types.ModuleType('zope'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

zope.hookable-6.0.dist-info/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-6.0.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.1
+Name: zope.hookable
+Version: 6.0
+Summary: Zope hookable
+Home-page: http://github.com/zopefoundation/zope.hookable
+Author: Zope Foundation and Contributors
+Author-email: zope-dev@zope.org
+License: ZPL 2.1
+Keywords: function hook replacement loose coupled
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Zope Public License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Framework :: Zope :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+License-File: LICENSE.txt
+Requires-Dist: setuptools
+Provides-Extra: docs
+Requires-Dist: Sphinx ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: zope.testing ; extra == 'test'
+Requires-Dist: zope.testrunner ; extra == 'test'
+Provides-Extra: testing
+Requires-Dist: zope.testing ; extra == 'testing'
+Requires-Dist: zope.testrunner ; extra == 'testing'
+Requires-Dist: coverage ; extra == 'testing'
+
+===============
+ 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
+
+
+=========
+ Changes
+=========
+
+6.0 (2023-10-05)
+================
+
+- Drop support for Python 2.7, 3.5, 3.6.
+
+- Add support for Python 3.12.
+
+
+5.4 (2022-11-17)
+================
+
+- Add support for building arm64 wheels on macOS.
+
+
+5.3 (2022-11-03)
+================
+
+- Add support for the final release of Python 3.11.
+
+
+5.2 (2022-09-13)
+================
+
+- Add support for Python 3.10 and 3.11 (as of 3.11.0rc1).
+
+- Disable unsafe math optimizations in C code.  See `pull request 25
+  <https://github.com/zopefoundation/zope.hookable/pull/25>`_.
+
+
+5.1.0 (2021-07-20)
+==================
+
+- Add support for Python 3.9.
+
+- Create Linux aarch64 wheels.
+
+
+5.0.1 (2020-03-10)
+==================
+
+- Stop using the setuptools ``Feature`` class, allowing this
+  project to be built from source with newer versions of setuptools
+  that remove that functionality.
+
+
+5.0.0 (2019-11-12)
+==================
+
+- Add support for Python 3.7 and 3.8.
+
+- Drop support for Python 3.4.
+
+
+4.2.0 (2017-11-07)
+==================
+
+- Expose the ``__doc__`` (and, where applicable, ``__bases__`` and
+  ``__dict__``) of the hooked object. This lets Sphinx document them.
+  See `issue 6 <https://github.com/zopefoundation/zope.hookable/issues/6>`_.
+
+- Respect ``PURE_PYTHON`` at runtime. At build time, always try to
+  build the C extensions on supported platforms, but allow it to fail.
+  See `issue 7
+  <https://github.com/zopefoundation/zope.hookable/issues/7>`_.
+
+
+4.1.0 (2017-07-26)
+==================
+
+- Drop support for Python 2.6, 3.2 and 3.3.
+
+- Add support for Python 3.5 and 3.6.
+
+4.0.4 (2014-03-19)
+==================
+
+- Add support for Python 3.4.
+
+4.0.3 (2014-03-17)
+==================
+
+- Update ``boostrap.py`` to version 2.2.
+
+- Fix extension compilation on Py3k.
+
+4.0.2 (2012-12-31)
+==================
+
+- Flesh out PyPI Trove classifiers.
+
+4.0.1 (2012-11-21)
+==================
+
+- Add support for Python 3.3.
+
+- Avoid building the C extension explicitly (use the "feature" indirection
+  instead).  https://bugs.launchpad.net/zope.hookable/+bug/1025470
+
+4.0.0 (2012-06-04)
+==================
+
+- Add support for PyPy.
+
+- Add support for continuous integration using ``tox`` and ``jenkins``.
+
+- Add a pure-Python reference implementation.
+
+- Move doctests to Sphinx documentation.
+
+- Bring unit test coverage to 100%.
+
+- Add 'setup.py docs' alias (installs ``Sphinx`` and dependencies).
+
+- Add 'setup.py dev' alias (runs ``setup.py develop`` plus installs
+  ``nose`` and ``coverage``).
+
+- Drop support for Python 2.4 / 2.5.
+
+- Remove of 'zope.testing.doctestunit' in favor of stdlib's 'doctest.
+
+- Add Python 3 support.
+
+3.4.1 (2009-04-05)
+==================
+
+- Update for compatibility with Python 2.6 traceback formats.
+
+- Use Jython-compatible ``bootstrap.py``.
+
+3.4.0 (2007-07-20)
+==================
+
+- Initial release as a separate project.

zope.hookable-6.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+zope.hookable-6.0-py3.12-nspkg.pth,sha256=v_t1oIorEnrHsL8_S45xOGNzLyFVAQCg1XkrPrk0VV8,530
+zope/hookable/__init__.py,sha256=pb0kMg3D0-cDl4VLrYtYpaV499J8DpITbW01Wxc3_SA,2190
+zope/hookable/_zope_hookable.c,sha256=3N5DrcP1lhrczu0yDqUshuuZ8GoCkWpf67lYzvkS8ao,7431
+zope/hookable/_zope_hookable.cp312-win_amd64.pyd,sha256=PX1qFbREfBhSKn1J2Jk1MYr-52dGMIqcV3gAHSIZgBs,13824
+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=Y7G2Z9CeZ4JBxaQSXi2AUvIN3ELP49T3_M9vBS2oQAk,6205
+zope.hookable-6.0.dist-info/LICENSE.txt,sha256=PmcdsR32h1FswdtbPWXkqjg-rKPCDOo_r1Og9zNdCjw,2070
+zope.hookable-6.0.dist-info/METADATA,sha256=xr9vKUXHxn6H02gmzIem7QXg0W137AyhoG93IToZ6Tc,6035
+zope.hookable-6.0.dist-info/WHEEL,sha256=aDrgWfEd5Ac7WJzHsr90rcMGiH4MHbAXoCWpyP5CEBc,102
+zope.hookable-6.0.dist-info/namespace_packages.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
+zope.hookable-6.0.dist-info/top_level.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
+zope.hookable-6.0.dist-info/RECORD,,

zope.hookable-6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

zope.hookable-6.0.dist-info/namespace_packages.txt

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

zope.hookable-6.0.dist-info/top_level.txt

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