zope.hookable 5.4__cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 7.0__cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

zope/hookable/__init__.py

@@ -17,11 +17,15 @@ import os
 import platform
 
 
-_PYPY = platform.python_implementation() in ('PyPy', 'Jython')
-_PURE_PYTHON = os.environ.get('PURE_PYTHON', _PYPY)
+# 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(object):
+class _py_hookable:
     __slots__ = ('_original', '_implementation')
 
     def __init__(self, *args, **kw):
@@ -69,7 +73,7 @@ try:
 except ImportError:  # pragma: no cover
     _c_hookable = None
 
-if _PURE_PYTHON or _c_hookable is 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

@@ -12,149 +12,113 @@
  #
  ############################################################################*/
 
-/* _zope_hookable.c
-
-   Provide an efficient implementation for hookable objects
-
- */
+static char module__doc__[] = (
+    "Provide an efficient implementation for hookable objects"
+);
 
 #include "Python.h"
 #include "structmember.h"
 
-typedef struct {
+typedef struct
+{
     PyObject_HEAD
-    PyObject *old;
-    PyObject *implementation;
+    PyObject* original;
+    PyObject* implementation;
 } hookable;
 
 static int
-hookable_init(hookable *self, PyObject *args, PyObject *kwds)
+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 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)
+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;
+#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)
+hookable_clear(hookable* self)
 {
-  Py_XDECREF(self->old);
-  self->old = NULL;
-  Py_XDECREF(self->implementation);
-  self->implementation = NULL;
-  return 0;
-}
+    Py_XDECREF(self->original);
+    self->original = NULL;
 
+    Py_XDECREF(self->implementation);
+    self->implementation = NULL;
 
-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);
+    return 0;
 }
 
-static PyObject *
-hookable_sethook(hookable *self, PyObject *implementation)
+static void
+hookable_dealloc(hookable* self)
 {
-  PyObject *old;
+    PyObject_GC_UnTrack((PyObject*)self);
+    PyTypeObject* tp = Py_TYPE(self);
 
-  old = self->implementation;
-  Py_INCREF(implementation);
-  self->implementation = implementation;
+    Py_XDECREF(self->original);
+    Py_XDECREF(self->implementation);
 
-  if (old == NULL)
-    {
-      Py_INCREF(Py_None);
-      return Py_None;
-    }
+    tp->tp_free((PyObject*)self);
 
-  return old;
+    /* heap types must decref their type when dealloc'ed */
+    Py_DECREF(tp);
 }
 
-static PyObject *
-hookable_reset(hookable *self)
+static PyObject*
+hookable_call(hookable* self, PyObject* args, PyObject* kw)
 {
-  Py_XINCREF(self->old);
-  Py_XDECREF(self->implementation);
-  self->implementation = self->old;
-  Py_INCREF(Py_None);
-  return Py_None;
-}
+    if (self->implementation != NULL)
+        return PyObject_Call(self->implementation, args, kw);
 
-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;
+    PyErr_SetString(PyExc_TypeError, "Hookable has no implementation");
+    return NULL;
 }
 
-
-static PyObject *
-hookable_getattro(hookable *self, PyObject *name)
+static PyObject*
+hookable_getattro(hookable* self, PyObject* name)
 {
-    PyObject *result = NULL;
-    const char *name_as_string;
+    PyObject* result = NULL;
+    const char* name_as_string;
     int maybe_special_name;
 
-#if PY_MAJOR_VERSION < 3
-    name_as_string = PyString_AsString(name);
-#else
     name_as_string = PyUnicode_AsUTF8(name);
-#endif
-
-    if (name_as_string == NULL) {
-        return NULL;
-    }
+    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);
+            return PyObject_GetAttr(self->original, name);
         }
-        /* synthesize __base__ and __dict__ if the original fails */
+        /* synthesize __bases__ and __dict__ if the original fails */
         if (strcmp("__bases__", name_as_string) == 0) {
-            result = PyObject_GetAttr(self->old, name);
+            result = PyObject_GetAttr(self->original, name);
             if (result == NULL) {
                 PyErr_Clear();
                 result = PyTuple_New(0);
@@ -162,7 +126,7 @@ hookable_getattro(hookable *self, PyObject *name)
             return result;
         }
         if (strcmp("__dict__", name_as_string) == 0) {
-            result = PyObject_GetAttr(self->old, name);
+            result = PyObject_GetAttr(self->original, name);
             if (result == NULL) {
                 PyErr_Clear();
                 result = PyDict_New();
@@ -174,103 +138,148 @@ hookable_getattro(hookable *self, PyObject *name)
     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, old), READONLY },
-  { "implementation", T_OBJECT_EX, offsetof(hookable, implementation), READONLY },
-  {NULL}    /* Sentinel */
+    { "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";
 
-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*/,
-};
 
+/*
+ * 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}
+};
 
-#if PY_MAJOR_VERSION >= 3
-  #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);
-#else
-  #define MOD_ERROR_VAL
-  #define MOD_SUCCESS_VAL(val)
-  #define MOD_INIT(name) void init##name(void)
-  #define MOD_DEF(ob, name, doc, methods) \
-          ob = Py_InitModule3(name, methods, doc);
+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 module_methods[] = {
-    {NULL, NULL}
+static struct PyMethodDef hookable_module_methods[] = {
+    { NULL, NULL }  /* sentinel */
 };
 
-MOD_INIT(_zope_hookable)
+
+/* 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 *m;
+    PyObject* hookable_type;
+
+    hookable_type = PyType_FromSpec(&hookable_type_spec);
+    if (hookable_type == NULL) { return -1; }
 
-  MOD_DEF(m, "_zope_hookable",
-    "Provide an efficient implementation for hookable objects",
-    module_methods)
+    if (PyModule_AddObject(module, "hookable", hookable_type) < 0)
+        return -1;
 
-  if (m == NULL)
-    return MOD_ERROR_VAL;
+    return 0;
+}
 
-  hookabletype.tp_new = PyType_GenericNew;
-  hookabletype.tp_free = PyObject_GC_Del;
 
-  if (PyType_Ready(&hookabletype) < 0)
-    return MOD_ERROR_VAL;
+/* 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}
+};
 
-  if (PyModule_AddObject(m, "hookable", (PyObject *)&hookabletype) < 0)
-    return MOD_ERROR_VAL;
+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
+};
 
-  return MOD_SUCCESS_VAL(m);
+static PyObject*
+init(void)
+{
+    return PyModuleDef_Init(&hookable_module_def);
+}
 
+PyMODINIT_FUNC
+PyInit__zope_hookable(void)
+{
+    return init();
 }

zope/hookable/tests/test_hookable.py

@@ -28,14 +28,14 @@ def not_called():
     raise AssertionError("This should not be called")
 
 
-class PyHookableMixin(object):
+class PyHookableMixin:
 
     def _callFUT(self, *args, **kw):
         from zope.hookable import _py_hookable
         return _py_hookable(*args, **kw)
 
 
-class HookableMixin(object):
+class HookableMixin:
 
     def _callFUT(self, *args, **kw):
         from zope.hookable import _py_hookable
@@ -50,10 +50,15 @@ class PyHookableTests(PyHookableMixin,
 
     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
-        self.assertIs(hookable, _py_hookable if _PURE_PYTHON else _c_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)
@@ -107,7 +112,7 @@ class PyHookableTests(PyHookableMixin,
             self._callFUT(nonesuch=42)
 
     def test_class(self):
-        class C(object):
+        class C:
             pass
 
         hooked = self._callFUT(C)
@@ -137,7 +142,7 @@ class TestIssue6Py(PyHookableMixin,
         self._check_preserves_doc(docs)
 
     def test_preserves_doc_class(self):
-        class Docs(object):
+        class Docs:
             """I have some docs"""
 
         self._check_preserves_doc(Docs)
@@ -151,14 +156,14 @@ class TestIssue6Py(PyHookableMixin,
         self.assertEqual({}, hooked.__dict__)
 
     def test_bases_class(self):
-        class C(object):
+        class C:
             pass
         self.assertEqual(C.__bases__, (object,))
         hooked = self._callFUT(C)
         self.assertEqual(hooked.__bases__, (object,))
 
     def test_dict_class(self):
-        class C(object):
+        class C:
             pass
 
         hooked = self._callFUT(C)
@@ -176,7 +181,7 @@ class TestIssue6Py(PyHookableMixin,
     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__(u'__bases__')
+        result = hooked.__getattribute__('__bases__')
         self.assertEqual(result, ())
 
     def test_short_name(self):

zope.hookable-7.0-py3.9-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zope',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = 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-5.4.dist-info → zope.hookable-7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zope.hookable
-Version: 5.4
+Version: 7.0
 Summary: Zope hookable
 Home-page: http://github.com/zopefoundation/zope.hookable
 Author: Zope Foundation and Contributors
@@ -12,25 +12,23 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Zope Public License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-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 :: 3.13
 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: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*
+Requires-Python: >=3.8
 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'
@@ -77,6 +75,28 @@ Documentation is hosted at https://zopehookable.readthedocs.io
  Changes
 =========
 
+7.0 (2024-09-17)
+================
+
+- C extension now enables multi-phase module initialization (PEP 489).
+  For CPython >= 3.11, the ``hookable`` type is now a heap-allocated
+  type.  See:
+  https://docs.python.org/3.13/howto/isolating-extensions.html
+
+- Drop support for Python 3.7.
+
+- Add support for Python 3.13.
+
+- Build windows wheels on GHA.
+
+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)
 ================
 

zope.hookable-7.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+zope.hookable-7.0-py3.9-nspkg.pth,sha256=_l6EZJaefCi1yytmDbFQGX_jfS2gAtFyaDmlK1uFLec,457
+zope.hookable-7.0.dist-info/namespace_packages.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
+zope.hookable-7.0.dist-info/METADATA,sha256=ME_ifGrs1PRetGtNQEXQdxX76U5nPoeCoIciUaGre14,6175
+zope.hookable-7.0.dist-info/top_level.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
+zope.hookable-7.0.dist-info/RECORD,,
+zope.hookable-7.0.dist-info/WHEEL,sha256=zw3m_8TS5Ligqz7c1oaFc6d0ApnSUTui8wLygn7hFqw,149
+zope.hookable-7.0.dist-info/LICENSE.txt,sha256=PmcdsR32h1FswdtbPWXkqjg-rKPCDOo_r1Og9zNdCjw,2070
+zope/hookable/_zope_hookable.cpython-39-aarch64-linux-gnu.so,sha256=7i8gvNzNcysAEh18kAeYjKyPI6AjJ2FhcPQrYGuFsXU,93152
+zope/hookable/__init__.py,sha256=MCERh1crK21EutC4dfGTpE3-IkeiJ-UV7NQZnHj860Q,2452
+zope/hookable/_zope_hookable.c,sha256=N9LOxTLZ-fZN8o_iNg8mjUNCX4na4UoGO0eDrkIqLic,7452
+zope/hookable/tests/test_hookable.py,sha256=3FdXSprA60j5eX3LftT6MZG80moqG-0tTwQn_KjNLQc,6330
+zope/hookable/tests/test_compile_flags.py,sha256=91siNUs2kotDUYpVV1vAZ_opWhZ50X4_DYkIiNMh6h0,1289
+zope/hookable/tests/__init__.py,sha256=Z9EJNKBQorYcdV6oaIRTRgF41SMRZEEoLltZCKyVPI8,47

{zope.hookable-5.4.dist-info → zope.hookable-7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: false
 Tag: cp39-cp39-manylinux_2_17_aarch64
 Tag: cp39-cp39-manylinux2014_aarch64

zope.hookable-5.4-py3.9-nspkg.pth

@@ -1 +0,0 @@
-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-5.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-zope.hookable-5.4-py3.9-nspkg.pth,sha256=SWEVH-jEWsKYrL0qoC6GBJaStx_iKxGoAY9PQycFVC4,529
-zope/hookable/_zope_hookable.c,sha256=rnXI_8dreoBTWz15HB-WW69WDtcE-4tpODtb-_R0eVQ,7751
-zope/hookable/_zope_hookable.cpython-39-aarch64-linux-gnu.so,sha256=7mKBM9Owd1SduRqiKqC_MIuNfxst7hJvme0Ugv04P88,91336
-zope/hookable/__init__.py,sha256=2Ti7Bb9moOaABz-5j3068ILhZnjE10nwXEAuBzVH7kE,2198
-zope/hookable/tests/test_hookable.py,sha256=juJLN3MLc369HF3VQE9njjEI2E2NPdzLDuz2vxYQ1KY,6254
-zope/hookable/tests/test_compile_flags.py,sha256=91siNUs2kotDUYpVV1vAZ_opWhZ50X4_DYkIiNMh6h0,1289
-zope/hookable/tests/__init__.py,sha256=Z9EJNKBQorYcdV6oaIRTRgF41SMRZEEoLltZCKyVPI8,47
-zope.hookable-5.4.dist-info/LICENSE.txt,sha256=PmcdsR32h1FswdtbPWXkqjg-rKPCDOo_r1Og9zNdCjw,2070
-zope.hookable-5.4.dist-info/top_level.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
-zope.hookable-5.4.dist-info/namespace_packages.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5
-zope.hookable-5.4.dist-info/WHEEL,sha256=SIpKeEMEn5d6wEWNi6guiW3hSiu5nA1wuuKXWVovQCE,150
-zope.hookable-5.4.dist-info/RECORD,,
-zope.hookable-5.4.dist-info/METADATA,sha256=RaXfq9Dxa_r6tktciVzwIfjk7wpPtquBhD3NFVn2ENE,5852