zope.hookable 6.0__tar.gz → 7.0__tar.gz

{zope.hookable-6.0 → zope_hookable-7.0}/.manylinux-install.sh

@@ -28,12 +28,12 @@ yum -y install libffi-devel
 
 tox_env_map() {
     case $1 in
-        *"cp37"*) echo 'py37';;
         *"cp38"*) echo 'py38';;
         *"cp39"*) echo 'py39';;
         *"cp310"*) echo 'py310';;
         *"cp311"*) echo 'py311';;
         *"cp312"*) echo 'py312';;
+        *"cp313"*) echo 'py313';;
         *) echo 'py';;
     esac
 }
@@ -41,12 +41,12 @@ tox_env_map() {
 # Compile wheels
 for PYBIN in /opt/python/*/bin; do
     if \
-       [[ "${PYBIN}" == *"cp311"* ]] || \
-       [[ "${PYBIN}" == *"cp312"* ]] || \
-       [[ "${PYBIN}" == *"cp37"* ]] || \
-       [[ "${PYBIN}" == *"cp38"* ]] || \
-       [[ "${PYBIN}" == *"cp39"* ]] || \
-       [[ "${PYBIN}" == *"cp310"* ]] ; then
+       [[ "${PYBIN}" == *"cp38/"* ]] || \
+       [[ "${PYBIN}" == *"cp39/"* ]] || \
+       [[ "${PYBIN}" == *"cp310/"* ]] || \
+       [[ "${PYBIN}" == *"cp311/"* ]] || \
+       [[ "${PYBIN}" == *"cp312/"* ]] || \
+       [[ "${PYBIN}" == *"cp313/"* ]] ; then
         "${PYBIN}/pip" install -e /io/
         "${PYBIN}/pip" wheel /io/ -w wheelhouse/
         if [ `uname -m` == 'aarch64' ]; then

zope_hookable-7.0/.pre-commit-config.yaml

@@ -0,0 +1,28 @@
+# Generated from:
+# https://github.com/zopefoundation/meta/tree/master/config/c-code
+minimum_pre_commit_version: '3.6'
+repos:
+  - repo: https://github.com/pycqa/isort
+    rev: "5.13.2"
+    hooks:
+    - id: isort
+  - repo: https://github.com/hhatto/autopep8
+    rev: "v2.3.1"
+    hooks:
+    - id: autopep8
+      args: [--in-place, --aggressive, --aggressive]
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.17.0
+    hooks:
+    - id: pyupgrade
+      args: [--py38-plus]
+  - repo: https://github.com/isidentical/teyit
+    rev: 0.4.3
+    hooks:
+    - id: teyit
+  - repo: https://github.com/PyCQA/flake8
+    rev: "7.1.1"
+    hooks:
+    - id: flake8
+      additional_dependencies:
+        - flake8-debugger == 4.1.2

{zope.hookable-6.0 → zope_hookable-7.0}/CHANGES.rst

@@ -2,6 +2,20 @@
  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)
 ================
 

{zope.hookable-6.0 → zope_hookable-7.0}/MANIFEST.in

@@ -5,8 +5,7 @@ include *.rst
 include *.txt
 include buildout.cfg
 include tox.ini
-include appveyor.yml
-include .coveragerc
+include .pre-commit-config.yaml
 
 recursive-include docs *.py
 recursive-include docs *.rst

{zope.hookable-6.0 → zope_hookable-7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zope.hookable
-Version: 6.0
+Version: 7.0
 Summary: Zope hookable
 Home-page: http://github.com/zopefoundation/zope.hookable
 Author: Zope Foundation and Contributors
@@ -13,17 +13,17 @@ 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 :: 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: >=3.7
+Requires-Python: >=3.8
 License-File: LICENSE.txt
 Requires-Dist: setuptools
 Provides-Extra: docs
@@ -75,6 +75,20 @@ 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)
 ================
 

{zope.hookable-6.0 → zope_hookable-7.0}/docs/_build/doctest/output.txt

@@ -1,4 +1,4 @@
-Results of doctest builder run on 2023-10-05 13:43:00
+Results of doctest builder run on 2024-09-17 08:22:56
 =====================================================
 
 Document: narr

zope_hookable-7.0/docs/conf.py

@@ -0,0 +1,37 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+import datetime
+
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+year = datetime.datetime.now().year
+
+project = 'zope.hookable'
+copyright = f'2012-{year}, Zope Foundation and contributors'
+author = 'Zope Foundation and contributors'
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.doctest',
+    'sphinx.ext.intersphinx',
+]
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'sphinx_rtd_theme'
+html_static_path = ['_static']
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {'python': ('https://docs.python.org/3/', None)}

zope_hookable-7.0/pyproject.toml

@@ -0,0 +1,25 @@
+# 
+# Generated from:
+# https://github.com/zopefoundation/meta/tree/master/config/c-code
+
+[build-system]
+requires = ["setuptools<74"]
+build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+branch = true
+source = ["zope.hookable"]
+relative_files = true
+
+[tool.coverage.report]
+fail_under = 98
+precision = 2
+ignore_errors = true
+show_missing = true
+exclude_lines = ["pragma: no cover", "pragma: nocover", "except ImportError:", "raise NotImplementedError", "if __name__ == '__main__':", "self.fail", "raise AssertionError", "raise unittest.Skip"]
+
+[tool.coverage.html]
+directory = "parts/htmlcov"
+
+[tool.coverage.paths]
+source = ["src/", ".tox/*/lib/python*/site-packages/", ".tox/pypy*/site-packages/"]

{zope.hookable-6.0 → zope_hookable-7.0}/setup.cfg

@@ -1,6 +1,3 @@
-[bdist_wheel]
-universal = 0
-
 [zest.releaser]
 create-wheel = no
 

{zope.hookable-6.0 → zope_hookable-7.0}/setup.py

@@ -85,7 +85,7 @@ TESTS_REQUIRE = [
 ]
 
 setup(name='zope.hookable',
-      version='6.0',
+      version='7.0',
       url='http://github.com/zopefoundation/zope.hookable',
       license='ZPL 2.1',
       description='Zope hookable',
@@ -101,12 +101,12 @@ setup(name='zope.hookable',
           "Operating System :: OS Independent",
           "Programming Language :: Python",
           "Programming Language :: Python :: 3",
-          "Programming Language :: Python :: 3.7",
           "Programming Language :: Python :: 3.8",
           "Programming Language :: Python :: 3.9",
           "Programming Language :: Python :: 3.10",
           "Programming Language :: Python :: 3.11",
           "Programming Language :: Python :: 3.12",
+          "Programming Language :: Python :: 3.13",
           "Programming Language :: Python :: Implementation :: CPython",
           "Programming Language :: Python :: Implementation :: PyPy",
           "Framework :: Zope :: 3",
@@ -124,11 +124,10 @@ setup(name='zope.hookable',
       ],
       include_package_data=True,
       zip_safe=False,
-      test_suite='zope.hookable.tests.test_hookable.test_suite',
       extras_require={
           'docs': ['Sphinx', 'sphinx_rtd_theme'],
           'testing': TESTS_REQUIRE + ['coverage'],
           'test': TESTS_REQUIRE,
       },
-      python_requires='>=3.7',
+      python_requires='>=3.8',
       )

{zope.hookable-6.0 → zope_hookable-7.0}/src/zope/hookable/__init__.py

@@ -17,8 +17,12 @@ 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:
@@ -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-7.0/src/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-6.0 → zope_hookable-7.0}/src/zope/hookable/tests/test_hookable.py

@@ -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)

{zope.hookable-6.0 → zope_hookable-7.0}/src/zope.hookable.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zope.hookable
-Version: 6.0
+Version: 7.0
 Summary: Zope hookable
 Home-page: http://github.com/zopefoundation/zope.hookable
 Author: Zope Foundation and Contributors
@@ -13,17 +13,17 @@ 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 :: 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: >=3.7
+Requires-Python: >=3.8
 License-File: LICENSE.txt
 Requires-Dist: setuptools
 Provides-Extra: docs
@@ -75,6 +75,20 @@ 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)
 ================
 

{zope.hookable-6.0 → zope_hookable-7.0}/src/zope.hookable.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
-.coveragerc
 .manylinux-install.sh
 .manylinux.sh
+.pre-commit-config.yaml
 .readthedocs.yaml
 CHANGES.rst
 CONTRIBUTING.md
@@ -8,8 +8,8 @@ COPYRIGHT.txt
 LICENSE.txt
 MANIFEST.in
 README.rst
-appveyor.yml
 buildout.cfg
+pyproject.toml
 setup.cfg
 setup.py
 tox.ini