PyObjC

Warnings

• breaking PyObjC has dropped support for older Python versions in recent major releases. Version 12.0 dropped Python 3.9, and Version 11.0 dropped Python 3.8. Ensure your Python environment meets the minimum requirement (Python 3.10+ for PyObjC 12.x).
  Fix: Upgrade your Python interpreter to 3.10 or later for PyObjC 12.x. Always check the official PyObjC documentation for the latest supported Python versions for your PyObjC release.
• breaking PyObjC 11.1 introduced significant changes to align with `clang`'s documentation for Automatic Reference Counting (ARC) for initializer methods. Methods in the 'init' family now correctly model stealing a reference to `self` and returning a new one. This can cause reference counting bugs to surface or lead to crashes if existing code relied on previous, incorrect behavior.
  Fix: Review Objective-C initializer method calls and reference counting in your Python code, especially if manually managing object lifetimes or dealing with 'partially initialized' objects. Prefer the Pythonic `SomeClass(...)` initialization over `SomeClass.alloc().init()` where possible.
• gotcha Objective-C method names containing colons (e.g., `doSomething:withSomethingElse:`) are translated to Python by replacing colons with underscores (e.g., `doSomething_withSomethingElse_`). Each underscore signifies an argument. Missing an underscore or an argument will result in `AttributeError` or unexpected behavior.
  Fix: Always convert Objective-C selectors by replacing colons with underscores. The number of underscores in the Python method name must match the number of arguments (including the implicit `self`).
• gotcha Using `__init__` in Python subclasses of Objective-C classes can have subtle interactions with `__new__`. While PyObjC 10.3 initially removed support for calling `__init__` when a user-defined `__new__` was present, this was partially reintroduced in 10.3.1. Code relying on PyObjC's provided `__new__` still cannot use `__init__`.
  Fix: If implementing custom `__new__` methods in Objective-C subclasses, be cautious with `__init__` behavior. Prefer using Objective-C's `init` methods directly or the `SomeClass(...)` factory when possible, rather than relying on Python's `__init__` for complex initialization logic.
• breaking The `AVFAudio` framework, previously merged into `AVFoundation` bindings, was split into its own top-level package (`pyobjc-framework-AVFAudio`) starting with PyObjC 12.0.
  Fix: If your application explicitly uses `AVFAudio` components, you may need to adjust your imports and ensure `pyobjc-framework-AVFAudio` is installed, although it's typically included with `pyobjc-framework-AVFoundation`.
• gotcha PyObjC is specifically designed for CPython on macOS. It does not support alternative Python runtimes like PyPy, Jython, or IronPython, and this is unlikely to change.
  Fix: Ensure you are using a standard CPython installation on macOS for PyObjC development.

Install

• pip install pyobjc Install core PyObjC and common frameworks
• pip install pyobjc-core pyobjc-framework-Cocoa pyobjc-framework-AVFoundation Install specific components

Imports

• objc

  import objc

  Core bridge module for PyObjC utilities and functions.
• Foundation

  from Foundation import NSObject, NSString

  Commonly imported framework for basic Objective-C types and utilities.
• AppKit

  from AppKit import NSApplication, NSWindow

  Commonly imported framework for macOS user interface elements (Cocoa applications).

Quickstart

This example demonstrates fundamental PyObjC interactions: creating Objective-C `NSString` and `NSArray` objects, calling their methods, accessing PyObjC's `objc.YES`/`NO`/`nil` constants, and using `objc.autorelease_pool` for memory management.

import objc
from Foundation import NSString, NSArray

# Working with Objective-C classes
hello = NSString.stringWithString_("Hello, World!")
print(f"Hello string length: {hello.length()}") # Expected: 13

# Creating and using Objective-C objects
# Note the 'None' to signify the end of the variadic arguments for arrayWithObjects_
my_array = NSArray.arrayWithObjects_("foo", "bar", "baz", None)
print(f"Array count: {my_array.count()}") # Expected: 3
print(f"Object at index 1: {my_array.objectAtIndex_(1)}") # Expected: bar

# Using the bridge constants
print(f"objc.YES: {objc.YES}") # Expected: True
print(f"objc.NO: {objc.NO}")  # Expected: False
print(f"objc.nil: {objc.nil}") # Expected: None

# Proper memory management with autorelease pools (good practice for intensive ops)
with objc.autorelease_pool():
    temp_strings = []
    for i in range(5):
        temp_string = NSString.stringWithFormat_("Item %d", i)
        temp_strings.append(temp_string)
    print(f"Temporary strings created: {len(temp_strings)}")
    # Objects are automatically released when the pool exits