-copyThis document contains an (incomplete) list of work items.
The test suite needs to be enhanced.
Modules/*/*Mapping*.m
(including IMPs)The first two bullets require at least some GUI tests.
From the top of my head:
pyobjc_classMethods, you should be able to call
class methods in the obvious way. This would (finally) close 836247.SessionWrapper in
Modules/AppKit. Should add a function for creating these types,
possibly exposed to C code.The current SVN version contains some support for GNUstep, this needs to be enhanced.
Unless somebody actually starts working on this GNUstep support will slowly fade away.
Nobody seems to care enough about the templates to actually maintain them, this is a shame.
(some work to this end exists in the svn sandbox)
I prefer updating them, by rebuilding the Xcode templates in Project Builder.
This would require Python 2.3 on Jaguar.
We do not yet have a 100% coverage of the Cocoa API's. We also need code in the testsuite that checks if the function wrappers are working as expected.
Not all constants and enums from Cocoa are currently wrapped. The annotations for input/output arguments are not all checked and may not be complete or correct.
We also don't support all "difficult" methods yet, implementing these is not too hard but it is a lot of work.
Note that even though we do not have 100% coverage of Cocoa, the majority of useful functions, constants, and "difficult" methods are wrapped. If you run across a missing or incorrectly wrapped constant, function, or method please report it as a bug and/or post to pyobjc-dev about the issue. This is one area we intend to improve after the release of 1.2 when our new wrapper-generators are in a more complete state.
Objective-C objects don't support pickling.
This is post-1.2 work, in general this is a hard problem because it may involve object cycles that cross the Python-ObjC boundary.
It might be useful to add default implementations of encodeWithCoder: and
initWithCoder: methods to Python subclasses of Objective-C classes that
implement these. Note that property list types should already be serializable
(int, long, unicode, list, tuple, dict).
See also Pickle support.
-copyThere are issues with implementing -copy in python, these need to be fixed.
Specifically, overriding an existing -copy implementation does not work
unless __slots__ == ()
It is impossible to support methods with a variable number of arguments in the generic code (you have to re-implement almost all of the logic of these methods in order to know how many and which types of arguments are expected). Luckily there are not many varargs methods and most (if no all) of them can be easily avoided.
All existing varargs methods should be located and documented. Where possible we should provide custom wrappers, otherwise we should document alternatives.
Limitations such as the above should be clearly documented elsewhere, these are not necessarily TODO items.
Modules/AppKit) is one of several types that wrap
a single pointer, create a function to build such types (similar to
Modules/objc/struct-wrapper.m)CArray API whenever appropriate.The CurrencyConverter example should be removed, this should be the same as the final step of the tutorial. It isn't at the moment because additional cruft in the example.
Add examples that demonstrate:
Design and implement a set of performance tests for the bridge. Use this to investigate and fix any possible performance problems.
PyObjCSelector objects and PyObjCObject objects are created on a regular basis, we should check if using freelists would speed this up. See also Performance tuning/testing.
DO seems to use formal protocols, we don't fully support those. There is
an equivalent to @protocol(Foo), but it is not yet possible to define
new protocols in Python.
Links to Apple documentation are not stable, can we add a layer of indirection here, e.g. link to the PyObjC website that will redirect to the right location?
We should also provide links to locally installed documentation, especially in the documentation that will be installed on the users machine.
The implementation of OC_PythonDictionary is very minimal, we should add additional methods in the NSMutableDictionary interface if those can be implemented efficiently. The default implementation will take care of the methods we cannot implement efficiently.
And the same is true of OC_PythonArray
The code is a mess.
This is a script for finding 'difficult' methods. The script should be refactored to make it easier to create readable reports.
PyObjCTools, to make it easier
for others to generate wrappers.pyobjc-api.h.Some Cocoa/CoreFoundation API's basically require that a[0] is a[0]. The
container wrappers contain support for that, but we should try to move that
into the generic core: there should be at most one Objective-C proxy object
alive for every Python object (just like there's at most one Python proxy for
every Objective-C object).
Check if it is possible to wrap NSSet using set (and v.v.).
Only implement this when it is possible to convert without loss of information.
Python 2.4 introduces a decorator syntax. Add convenience functions that make it easier to use decorators with PyObjC.
Also add example programs using decorators. Actually, first add the example(s) and extract useful convenience functions from those.
An example of a convenience function would be:
import objc
def method_signature(signature):
def make_selector(func):
return objc.selector(func, signature=signature)
return make_selector
Which can be used like this:
class FooClass (NSObject):
@method_signature("v@:i")
def myIntMethod_(self, value):
pass
Functions and methods that use format strings are not properly wrapped. Fix that.