pyobjc-framework-Automator 10.0__tar.gz → 10.2__tar.gz

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/LICENSE.txt

@@ -1,7 +1,7 @@
 (This is the MIT license, note that libffi-src is a separate product with its own license)
 
 Copyright 2002, 2003 - Bill Bumgarner, Ronald Oussoren, Steve Majewski, Lele Gaifax, et.al.
-Copyright 2003-2022 - Ronald Oussoren
+Copyright 2003-2024 - Ronald Oussoren
 
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/Lib/Automator/__init__.py

@@ -11,7 +11,7 @@ def _setup():
 
     import AppKit
     import objc
-    from . import _metadata
+    from . import _metadata, _Automator
 
     dir_func, getattr_func = objc.createFrameworkDirAndGetattr(
         name="Automator",
@@ -21,7 +21,10 @@ def _setup():
         ),
         globals_dict=globals(),
         inline_list=None,
-        parents=(AppKit,),
+        parents=(
+            _Automator,
+            AppKit,
+        ),
         metadict=_metadata.__dict__,
     )
 

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/Lib/pyobjc_framework_Automator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyobjc-framework-Automator
-Version: 10.0
+Version: 10.2
 Summary: Wrappers for the framework Automator on macOS
 Home-page: https://github.com/ronaldoussoren/pyobjc
 Author: Ronald Oussoren
@@ -23,6 +23,7 @@ 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 :: Objective C
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -30,8 +31,8 @@ Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
-Requires-Dist: pyobjc-core>=10.0
-Requires-Dist: pyobjc-framework-Cocoa>=10.0
+Requires-Dist: pyobjc-core>=10.2
+Requires-Dist: pyobjc-framework-Cocoa>=10.2
 Project-URL: Documentation, https://pyobjc.readthedocs.io/en/latest/
 Project-URL: Issue tracker, https://github.com/ronaldoussoren/pyobjc/issues
 Project-URL: Repository, https://github.com/ronaldoussoren/pyobjc

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/Lib/pyobjc_framework_Automator.egg-info/SOURCES.txt

@@ -31,6 +31,10 @@ Lib/pyobjc_framework_Automator.egg-info/dependency_links.txt
 Lib/pyobjc_framework_Automator.egg-info/not-zip-safe
 Lib/pyobjc_framework_Automator.egg-info/requires.txt
 Lib/pyobjc_framework_Automator.egg-info/top_level.txt
+Modules/_Automator.m
+Modules/_Automator_protocols.m
+Modules/pyobjc-api.h
+Modules/pyobjc-compat.h
 PyObjCTest/__init__.py
 PyObjCTest/test_amaction.py
 PyObjCTest/test_ambundleaction.py

pyobjc-framework-Automator-10.2/Lib/pyobjc_framework_Automator.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyobjc-core>=10.2
+pyobjc-framework-Cocoa>=10.2

pyobjc-framework-Automator-10.2/Modules/_Automator.m

@@ -0,0 +1,35 @@
+#define Py_LIMITED_API 0x03060000
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "pyobjc-api.h"
+
+#import <Automator/Automator.h>
+
+/* We include the source code here instead of
+ * using the linker due to limitations in pyobjc-api.h
+ */
+#include "_Automator_protocols.m"
+
+static PyMethodDef mod_methods[] = {
+    {0, 0, 0, 0} /* sentinel */
+};
+
+/* Python glue */
+static struct PyModuleDef mod_module = {
+    PyModuleDef_HEAD_INIT, "_Automator", NULL, 0, mod_methods, NULL, NULL, NULL, NULL};
+
+PyObject* PyInit__Automator(void);
+
+PyObject* __attribute__((__visibility__("default"))) PyInit__Automator(void)
+{
+    PyObject* m;
+    m = PyModule_Create(&mod_module);
+    if (!m) {
+        return NULL;
+    }
+
+    if (PyObjC_ImportAPI(m) == -1)
+        return NULL;
+
+    return m;
+}

pyobjc-framework-Automator-10.2/Modules/_Automator_protocols.m

@@ -0,0 +1,8 @@
+static void __attribute__((__used__)) use_protocols(void)
+{
+    PyObject* p __attribute__((__unused__));
+#if PyObjC_BUILD_RELEASE >= 1013
+    p = PyObjC_IdToPython(@protocol(AMWorkflowControllerDelegate));
+    Py_XDECREF(p);
+#endif
+}

pyobjc-framework-Automator-10.2/Modules/pyobjc-api.h

@@ -0,0 +1,214 @@
+#ifndef PyObjC_API_H
+#define PyObjC_API_H
+
+/*
+ * Use this in helper modules for the objc package, and in wrappers
+ * for functions that deal with objective-C objects/classes
+ *
+ * This header defines some utility wrappers for importing and using
+ * the core bridge.
+ *
+ * This is the *only* header file that should be used to access
+ * functionality in the core bridge.
+ *
+ * WARNING: this file is not part of the public interface of PyObjC and
+ * might change or be removed without warning or regard for backward
+ * compatibility.
+ */
+
+#include <objc/objc.h>
+
+#import <Foundation/Foundation.h>
+
+#include "pyobjc-compat.h"
+
+#ifdef Py_LIMITED_API
+/*
+ * Make sure PyObjC framework wrappers can build using the limited API
+ */
+typedef void Py_buffer;
+#endif
+
+#include <objc/objc-runtime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/* Current API version, increase whenever:
+ * - Semantics of current functions change
+ * - Functions are removed
+ *
+ * Do not increase when adding a new function, the struct_len field
+ * can be used for detecting if a function has been added.
+ */
+#ifndef PYOBJC_API_VERSION
+#define PYOBJC_API_VERSION 25
+#endif
+
+#define PYOBJC_API_NAME "__C_API__"
+
+#ifndef PyObjC_EXPECTED_STRUCT_SIZE
+#define PyObjC_EXPECTED_STRUCT_SIZE (sizeof(struct pyobjc_api))
+#endif
+
+/*
+ * Only add items to the end of this list!
+ */
+typedef int(RegisterMethodMappingFunctionType)(
+    Class, SEL,
+    PyObject* _Nullable (*_Nonnull)(PyObject* _Nonnull, PyObject* _Nonnull,
+                                    PyObject* _Nonnull const* _Nonnull, size_t),
+    IMP _Nullable (*_Nonnull)(PyObject* _Nonnull, PyObject* _Nonnull));
+
+struct pyobjc_api {
+    int                                api_version; /* API version */
+    size_t                             struct_len;  /* Length of this struct */
+    RegisterMethodMappingFunctionType* register_method_mapping;
+    id _Nullable (*_Nonnull obj_get_object)(PyObject* _Nonnull);
+    Class _Nullable (*_Nonnull cls_get_class)(PyObject* _Nonnull);
+    int (*_Nonnull depythonify_python_object)(PyObject* _Nonnull, id _Nullable* _Nonnull);
+    PyObject* _Nullable (*_Nonnull id_to_python)(id _Nullable);
+    void (*_Nonnull err_objc_to_python)(NSObject* _Nonnull);
+    int (*_Nonnull py_to_objc)(const char* _Nonnull, PyObject* _Nonnull, void* _Nonnull);
+    PyObject* _Nullable (*_Nonnull objc_to_py)(const char* _Nonnull,
+                                               const void* _Nonnull);
+    Py_ssize_t (*_Nonnull sizeof_type)(const char* _Nonnull);
+    Class _Nullable (*_Nonnull sel_get_class)(PyObject* _Nonnull sel);
+    SEL _Nullable (*_Nonnull sel_get_sel)(PyObject* _Nonnull sel);
+    int (*_Nonnull register_pointer_wrapper)(
+        const char* _Nonnull, const char* _Nonnull,
+        PyObject* _Nullable (*_Nonnull pythonify)(void* _Nonnull),
+        int (*_Nonnull depythonify)(PyObject* _Nonnull, void* _Nonnull));
+    IMP _Nullable (*_Nonnull unsupported_method_imp)(PyObject* _Nonnull,
+                                                     PyObject* _Nonnull);
+    PyObject* _Nullable (*_Nonnull unsupported_method_caller)(
+        PyObject* _Nonnull, PyObject* _Nonnull, PyObject* _Nonnull const* _Nonnull,
+        size_t);
+    void (*_Nonnull err_python_to_objc_gil)(PyGILState_STATE* _Nonnull state);
+    int (*_Nonnull simplify_sig)(const char* signature, char* buf, size_t buflen);
+    void (*_Nonnull free_c_array)(int, Py_buffer*);
+    int (*_Nonnull py_to_c_array)(BOOL, BOOL, const char* _Nonnull, PyObject* _Nonnull,
+                                  void* _Nullable* _Nonnull, Py_ssize_t* _Nullable,
+                                  PyObject* _Nonnull* _Nonnull, Py_buffer* _Nonnull);
+    PyObject* _Nullable (*_Nonnull c_array_to_py)(const char* _Nonnull,
+                                                  const void* _Nonnull, Py_ssize_t);
+    PyTypeObject* _Nonnull imp_type;
+    IMP _Nullable (*_Nonnull imp_get_imp)(PyObject* _Nonnull);
+    SEL _Nullable (*_Nonnull imp_get_sel)(PyObject* _Nonnull);
+    PyObject* _Nullable (*_Nonnull newtransient)(id _Nullable objc_object,
+                                                 int* _Nonnull cookie);
+    void (*_Nonnull releasetransient)(PyObject* _Nonnull proxy, int cookie);
+    PyObject* _Nonnull* _Nonnull pyobjc_null;
+    int (*_Nonnull dep_c_array_count)(const char* _Nonnull type, Py_ssize_t count,
+                                      BOOL strict, PyObject* _Nonnull value,
+                                      void* _Nonnull datum, BOOL, BOOL);
+    PyObject* _Nullable (*_Nonnull varlistnew)(const char* _Nonnull tp,
+                                               void* _Nonnull array);
+    int (*_Nonnull pyobjcobject_convert)(PyObject* _Nonnull, void* _Nonnull);
+    int (*_Nonnull register_id_alias)(const char* _Nonnull, const char* _Nonnull);
+    int (*_Nonnull memview_check)(PyObject* _Nonnull);
+    PyObject* _Nullable (*_Nonnull memview_new)(void);
+    Py_buffer* _Nullable (*_Nonnull memview_getbuffer)(PyObject* _Nonnull);
+    int (*_Nonnull checkargcount)(PyObject* _Nonnull callable, size_t min_args,
+                                  size_t max_args, size_t nargsf);
+    int (*_Nonnull checknokwnames)(PyObject* _Nonnull callable,
+                                   PyObject* _Nullable kwnames);
+
+    PyObject* _Nullable (*_Nonnull createopaquepointertype)(const char*, const char*, const char*);
+};
+
+#ifndef PYOBJC_BUILD
+
+#ifndef PYOBJC_METHOD_STUB_IMPL
+static struct pyobjc_api* PyObjC_API;
+#endif /* PYOBJC_METHOD_STUB_IMPL */
+
+#define PyObjCIMP_Check(obj) PyObject_TypeCheck(obj, PyObjC_API->imp_type)
+#define PyObjCObject_GetObject (PyObjC_API->obj_get_object)
+#define PyObjCClass_GetClass (PyObjC_API->cls_get_class)
+#define PyObjCSelector_GetClass (PyObjC_API->sel_get_class)
+#define PyObjCSelector_GetSelector (PyObjC_API->sel_get_sel)
+#define depythonify_python_object (PyObjC_API->depythonify_python_object)
+#define PyObjC_IdToPython (PyObjC_API->id_to_python)
+#define PyObjCErr_FromObjC (PyObjC_API->err_objc_to_python)
+#define PyObjCErr_ToObjCWithGILState (PyObjC_API->err_python_to_objc_gil)
+#define PyObjC_PythonToObjC (PyObjC_API->py_to_objc)
+#define PyObjC_ObjCToPython (PyObjC_API->objc_to_py)
+#define PyObjC_RegisterMethodMapping (PyObjC_API->register_method_mapping)
+#define PyObjCPointerWrapper_Register (PyObjC_API->register_pointer_wrapper)
+#define PyObjCUnsupportedMethod_IMP (PyObjC_API->unsupported_method_imp)
+#define PyObjCUnsupportedMethod_Caller (PyObjC_API->unsupported_method_caller)
+#define PyObjCRT_SizeOfType (PyObjC_API->sizeof_type)
+#define PyObjC_FreeCArray (PyObjC_API->free_c_array)
+#define PyObjC_PythonToCArray (PyObjC_API->py_to_c_array)
+#define PyObjC_CArrayToPython (PyObjC_API->c_array_to_py)
+#define PyObjCIMP_GetIMP (PyObjC_API->imp_get_imp)
+#define PyObjCIMP_GetSelector (PyObjC_API->imp_get_sel)
+#define PyObjCObject_NewTransient (PyObjC_API->newtransient)
+#define PyObjCObject_ReleaseTransient (PyObjC_API->releasetransient)
+#define PyObjC_NULL (*(PyObjC_API->pyobjc_null))
+#define PyObjC_DepythonifyCArray (PyObjC_API->dep_c_array_count)
+#define PyObjCVarList_New (PyObjC_API->varlistnew)
+#define PyObjCObject_Convert (PyObjC_API->pyobjcobject_convert)
+#define PyObjCPointerWrapper_RegisterID (PyObjC_API->register_id_alias)
+#define PyObjCMemView_Check (PyObjC_API->memview_check)
+#define PyObjCMemView_New (PyObjC_API->memview_new)
+#define PyObjCMemView_GetBuffer (PyObjC_API->memview_getbuffer)
+#define PyObjC_CheckArgCount (PyObjC_API->checkargcount)
+#define PyObjC_CheckNoKwnames (PyObjC_API->checknokwnames)
+#define PyObjCCreateOpaquePointerType (PyObjC_API->createopaquepointertype)
+
+typedef void (*PyObjC_Function_Pointer)(void);
+typedef struct PyObjC_function_map {
+    const char*             name;
+    PyObjC_Function_Pointer function;
+} PyObjC_function_map;
+
+#ifndef PYOBJC_METHOD_STUB_IMPL
+
+static inline PyObject*
+PyObjC_CreateInlineTab(PyObjC_function_map* map)
+{
+    return PyCapsule_New(map, "objc.__inline__", NULL);
+}
+
+static inline int
+PyObjC_ImportAPI(PyObject* calling_module)
+{
+    PyObjC_API = (struct pyobjc_api*)PyCapsule_Import("objc." PYOBJC_API_NAME, 0);
+    if (PyObjC_API == NULL) {
+        return -1;
+    }
+    if (PyObjC_API->api_version != PYOBJC_API_VERSION) {
+        PyErr_Format(PyExc_RuntimeError,
+                     "Wrong version of PyObjC C API (got %d, expected %d)",
+                     (int)PyObjC_API->api_version, (int)PYOBJC_API_VERSION);
+        return -1;
+    }
+
+    if (PyObjC_API->struct_len < PyObjC_EXPECTED_STRUCT_SIZE) {
+        PyErr_Format(PyExc_RuntimeError,
+                     "Wrong struct-size of PyObjC C API (got %d, expected %d)",
+                     (int)PyObjC_API->struct_len, (int)sizeof(struct pyobjc_api));
+        return -1;
+    }
+
+    /* Current pyobjc implementation doesn't allow deregistering
+     * information, avoid unloading of users of the C-API.
+     * (Yes this is ugle, patches to fix this situation are apriciated)
+     */
+    Py_INCREF(calling_module);
+
+    return 0;
+}
+#endif /* PYOBJC_METHOD_STUB_IMPL */
+
+#else /* PyObjC_BUILD */
+
+extern struct pyobjc_api objc_api;
+extern int               PyObjCAPI_Register(PyObject* module);
+
+#endif /* !PYOBJC_BUILD */
+
+NS_ASSUME_NONNULL_END
+
+#endif /* PyObjC_API_H */

pyobjc-framework-Automator-10.2/Modules/pyobjc-compat.h

@@ -0,0 +1,245 @@
+#ifndef PyObjC_COMPAT_H
+#define PyObjC_COMPAT_H
+
+#ifndef NS_ASSUME_NONNULL_BEGIN
+/* Old compiler without the Nullability attributes */
+#define NS_ASSUME_NONNULL_BEGIN
+#define NS_ASSUME_NONNULL_END
+#define _Nullable
+#define _Nonnull
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*
+ *
+ * Start of compiler definitions
+ *
+ */
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+#ifndef __has_extension
+#define __has_extension(x) __has_feature(x)
+#endif
+
+#if __has_extension(c_static_assert)
+#define STATIC_ASSERT(test, message) _Static_assert(test, message)
+#else
+#define STATIC_ASSERT(test, message)                                                     \
+    switch (0) {                                                                         \
+    case 0:                                                                              \
+    case test:;                                                                          \
+    }
+#endif
+
+#if !__has_feature(objc_instancetype)
+#define instancetype id
+#endif
+
+#ifdef __has_attribute
+#if __has_attribute(objc_subclassing_restricted)
+#define PyObjC_FINAL_CLASS __attribute__((__objc_subclassing_restricted__))
+#endif
+#endif
+#ifndef PyObjC_FINAL_CLASS
+#define PyObjC_FINAL_CLASS
+#endif
+
+/*
+ *
+ * Start of compiler support helpers
+ *
+ * XXX: Are these needed?
+ */
+
+#ifdef __GNUC__
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#define likely(x) __builtin_expect(!!(x), 1)
+#else
+#define likely(x) x
+#define likely(x) x
+#endif
+
+/* On some versions of GCC <limits.h> defines LONG_LONG_MAX but not LLONG_MAX, compensate.
+ */
+#ifndef LLONG_MIN
+#ifdef LONG_LONG_MIN
+#define LLONG_MIN LONG_LONG_MIN
+#define LLONG_MAX LONG_LONG_MAX
+#define ULLONG_MAX ULONG_LONG_MAX
+#endif
+#endif
+
+/*
+ *
+ * End of compiler support helpers
+ *
+ * XXX: These two are no longer needed, all supported platforms
+ *      are 64-bit
+ */
+
+#if __LP64__
+#define Py_ARG_NSInteger "l"
+#define Py_ARG_NSUInteger "k"
+#else
+#define Py_ARG_NSInteger "i"
+#define Py_ARG_NSUInteger "I"
+#endif
+
+#define PyObjC__STR(x) #x
+#define PyObjC_STR(x) PyObjC__STR(x)
+
+/*
+ *
+ * Python version compatibility
+ *
+ */
+
+#ifndef Py_SET_TYPE
+#define Py_SET_TYPE(obj, type)                                                           \
+    do {                                                                                 \
+        Py_TYPE((obj)) = (type);                                                         \
+    } while (0)
+#endif
+
+#ifndef Py_SET_SIZE
+#define Py_SET_SIZE(obj, size)                                                           \
+    do {                                                                                 \
+        Py_SIZE((obj)) = (size);                                                         \
+    } while (0)
+#endif
+
+#ifndef Py_SET_REFCNT
+#define Py_SET_REFCNT(obj, count)                                                        \
+    do {                                                                                 \
+        Py_REFCNT((obj)) = (count);                                                      \
+    } while (0)
+#endif
+
+#if PY_VERSION_HEX < 0x03090000
+
+/* For use on Python 3.8 and earlier. PyObjC doesn't use the
+ * "flag" bit internally.
+ */
+
+#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET
+#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
+#endif
+
+#define PyVectorcall_NARGS(nargsf) ((nargsf) & ~PY_VECTORCALL_ARGUMENTS_OFFSET)
+
+#ifdef OBJC_VERSION
+/* Don't use PyObject prefixed symbols in our binaries */
+#define PyObject_Vectorcall PyObjC_Vectorcall
+#define PyObject_VectorcallMethod PyObjC_VectorcallMethod
+
+extern PyObject* _Nullable PyObject_Vectorcall(PyObject* callable,
+                                               PyObject* _Nonnull const* _Nonnull args,
+                                               size_t nargsf,
+                                               PyObject* _Nullable kwnames);
+extern PyObject* _Nullable PyObject_VectorcallMethod(
+    PyObject* name, PyObject* _Nonnull const* _Nonnull args, size_t nargsf,
+    PyObject* _Nullable kwnames);
+#endif
+
+#endif /* Python < 3.9 */
+
+/* Use CLINIC_SEP between the prototype and
+ * description in doc strings, to get clean
+ * docstrings.
+ */
+#define CLINIC_SEP "--\n"
+
+extern int PyObjC_Cmp(PyObject* o1, PyObject* o2, int* result);
+
+extern PyObject* _Nullable PyObjCBytes_InternFromString(const char* v);
+extern PyObject* _Nullable PyObjCBytes_InternFromStringAndSize(const char* v,
+                                                               Py_ssize_t  l);
+
+/*
+ * A micro optimization: when using Python 3.3 or later it
+ * is possible to access a 'char*' with an ASCII representation
+ * of a unicode object without first converting it to a bytes
+ * string (if the string can be encoded as ASCII in the first
+ * place.
+ *
+ * This slightly reduces the object allocation rate during
+ * attribute access.
+ *
+ * XXX: Use PyUnicode_AsUTF8 instead.
+ */
+extern const char* _Nullable PyObjC_Unicode_Fast_Bytes(PyObject* object);
+
+#ifdef __clang__
+
+#ifndef Py_LIMITED_API
+
+static inline PyObject* _Nullable* _Nonnull PyTuple_ITEMS(PyObject* tuple)
+{
+    return &PyTuple_GET_ITEM(tuple, 0);
+}
+
+/* This is a crude hack to disable a otherwise useful warning in the context of
+ * PyTuple_SET_ITEM, without disabling it everywhere
+ */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warray-bounds"
+static inline void
+_PyObjCTuple_SetItem(PyObject* tuple, Py_ssize_t idx, PyObject* _Nullable value)
+{
+    PyTuple_SET_ITEM(tuple, idx, value);
+}
+#undef PyTuple_SET_ITEM
+#define PyTuple_SET_ITEM(a, b, c) _PyObjCTuple_SetItem(a, b, c)
+
+static inline PyObject*
+_PyObjCTuple_GetItem(PyObject* tuple, Py_ssize_t idx)
+{
+    return PyTuple_GET_ITEM(tuple, idx);
+}
+#undef PyTuple_GET_ITEM
+#define PyTuple_GET_ITEM(a, b) _PyObjCTuple_GetItem(a, b)
+
+#pragma clang diagnostic pop
+
+#endif /* !Py_LIMITED_API */
+
+#endif /* __clang__ */
+
+#define PyObjC_BEGIN_WITH_GIL                                                            \
+    {                                                                                    \
+        PyGILState_STATE _GILState;                                                      \
+        _GILState = PyGILState_Ensure();
+
+#define PyObjC_GIL_FORWARD_EXC()                                                         \
+    do {                                                                                 \
+        PyObjCErr_ToObjCWithGILState(&_GILState);                                        \
+    } while (0)
+
+#define PyObjC_GIL_RETURN(val)                                                           \
+    do {                                                                                 \
+        PyGILState_Release(_GILState);                                                   \
+        return (val);                                                                    \
+    } while (0)
+
+#define PyObjC_GIL_RETURNVOID                                                            \
+    do {                                                                                 \
+        PyGILState_Release(_GILState);                                                   \
+        return;                                                                          \
+    } while (0)
+
+#define PyObjC_END_WITH_GIL                                                              \
+    PyGILState_Release(_GILState);                                                       \
+    }
+
+#define PyObjC_LEAVE_GIL                                                                 \
+    do {                                                                                 \
+        PyGILState_Release(_GILState);                                                   \
+    } while (0)
+
+extern PyObject* _Nullable PyObjC_get_tp_dict(PyTypeObject* _Nonnull tp);
+
+NS_ASSUME_NONNULL_END
+
+#endif /* PyObjC_COMPAT_H */

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyobjc-framework-Automator
-Version: 10.0
+Version: 10.2
 Summary: Wrappers for the framework Automator on macOS
 Home-page: https://github.com/ronaldoussoren/pyobjc
 Author: Ronald Oussoren
@@ -23,6 +23,7 @@ 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 :: Objective C
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -30,8 +31,8 @@ Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
-Requires-Dist: pyobjc-core>=10.0
-Requires-Dist: pyobjc-framework-Cocoa>=10.0
+Requires-Dist: pyobjc-core>=10.2
+Requires-Dist: pyobjc-framework-Cocoa>=10.2
 
 
 Wrappers for the "Automator" framework on macOS. The Automator framework

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/pyobjc_setup.py

@@ -213,6 +213,7 @@ 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 :: Objective C
 Topic :: Software Development :: Libraries :: Python Modules
@@ -576,19 +577,19 @@ def setup(min_os_level=None, max_os_level=None, cmdclass=None, **kwds):
         if min_os_level is not None:
             if max_os_level is not None:
                 msg = (
-                    "This distribution is only supported on MacOSX "
+                    "This distribution is only supported on macOS "
                     "versions %s up to and including %s" % (min_os_level, max_os_level)
                 )
             else:
-                msg = "This distribution is only supported on MacOSX >= {}".format(
+                msg = "This distribution is only supported on macOS >= {}".format(
                     min_os_level,
                 )
         elif max_os_level is not None:
-            msg = "This distribution is only supported on MacOSX <= {}".format(
+            msg = "This distribution is only supported on macOS <= {}".format(
                 max_os_level,
             )
         else:
-            msg = "This distribution is only supported on MacOSX"
+            msg = "This distribution is only supported on macOS"
 
         def create_command_subclass(base_class):
             class subcommand(base_class):

{pyobjc-framework-Automator-10.0 → pyobjc-framework-Automator-10.2}/setup.py

@@ -15,15 +15,29 @@ import sys
 sys.path.insert(0, os.path.dirname(__file__))
 
 
-from pyobjc_setup import setup  # noqa: E402
+from pyobjc_setup import setup, Extension  # noqa: E402
 
-VERSION = "10.0"
+VERSION = "10.2"
 
 setup(
     name="pyobjc-framework-Automator",
     description="Wrappers for the framework Automator on macOS",
     packages=["Automator"],
+    ext_modules=[
+        Extension(
+            "Automator._Automator",
+            ["Modules/_Automator.m"],
+            extra_link_args=["-framework", "Automator"],
+            py_limited_api=True,
+            depends=[
+                os.path.join("Modules", fn)
+                for fn in os.listdir("Modules")
+                if fn.startswith("_Automator")
+            ],
+        )
+    ],
     version=VERSION,
     install_requires=["pyobjc-core>=" + VERSION, "pyobjc-framework-Cocoa>=" + VERSION],
     long_description=__doc__,
+    options={"bdist_wheel": {"py_limited_api": "cp36"}},
 )

pyobjc-framework-Automator-10.0/Lib/pyobjc_framework_Automator.egg-info/requires.txt

@@ -1,2 +0,0 @@
-pyobjc-core>=10.0
-pyobjc-framework-Cocoa>=10.0