All Versions
26
Latest Version
Avg Release Cycle
140 days
Latest Release
703 days ago

Changelog History
Page 3

  • v1.0.0-beta.4 Changes

    🔄 Changed

    • 🛠 Fixed a problem that made it impossible to override "special" methods like __getitem__ in subclasses of managed classes. Now the tests all pass, and there is much rejoicing.

    • Managed classes reflected to Python now have an __doc__ attribute that contains a listing of the class constructor signatures.

    • 🛠 Fixed a problem that prevented passing null (None) for array arguments.

    • ✅ Added a number of new argument conversion tests. Thanks to Laurent Caumont for giving Python for .NET a good workout with managed DirectX.

    • ⚡️ Updated the bundled C Python runtime and libraries to Python 2.4. The current release is known to also run with Python 2.3. It is known not to work with older versions due to changes in CPython type object structure.

    • 🛠 Mostly fixed the differences in the way that import works depending on whether you are using the bundled interpreter or an existing Python interpreter. The hack I used makes import work uniformly for imports done in Python modules. Unfortunately, there is still a limitation when using the interpreter interactively: you need to do import CLR first before importing any sub-names when running with an existing Python interpreter.

      The reason is that the first import of CLR installs the CLR import hook, but for an existing interpreter the standard importer is still in control for the duration of that first import, so sub-names won't be found until the next import, which will use the now-installed hook.

    • 👍 Added support to directly iterate over objects that support IEnumerator (as well as IEnumerable). Thanks to Greg Chapman for prodding me ;)

    • Added a section to the README dealing with rebuilding Python for .NET against other CPython versions.

    • 🛠 Fixed a problem with accessing properties when only the interface for an object is known. For example, ICollection(ob).Count failed because Python for .NET mistakenly decided that Count was abstract.

    • 🛠 Fixed some problems with how COM-based objects are exposed and how members of inherited interfaces are exposed. Thanks to Bruce Dodson for patches on this.

    • Changed the Runtime class to use a const string to target the appropriate CPython dll in DllImport attributes. Now you only have to change one line to target a new Python version.

  • v1.0.0-beta.3 Changes

    🔄 Changed

    • A dumb bug that could cause a crash on startup on some platforms was fixed. Decided to update the beta for this, as a number of people were running into the problem.
  • v1.0.0-beta.2 Changes

    🔄 Changed

    • Exceptions raised as a result of getting or setting properties were not very helpful (target invokation exception). This has been changed to pass through the inner exception the way that methods do, which is much more likely to be the real exception that caused the problem.

    • 🔨 Events were refactored as the implementation was based on some bad assumptions. As a result, subscription and unsubscription now works correctly. A change from beta 1 is that event objects are no longer directly callable - this was not appropriate, since the internal implementation of an event is private and cant work reliably. Instead, you should the appropriate OnSomeEvent method published by a class to fire an event.

    • The distribution did not include the key file, making it a pain for people to build from source. Added the key file to the distribution buildout for beta 2.

    • Assemblies can now be found and loaded if they are on the PYTHONPATH. Previously only the appbase and the GAC were checked. The system now checks PYTHONPATH first, then the appbase, then the GAC.

    • 🛠 Fixed a bug in constructor invokation during object instantiation.

  • v1.0.0-beta.1 Changes

    🔄 Changed

    • Added the baseline of the managed embedding API. Some of the details are still subject to change based on some real-world use and feedback.

      The embedding API is based on the PyObject class, along with a number of specific PyDict, PyList, (etc.) classes that expose the respective interfaces of the built-in Python types. The basic structure and usage is intended be familar to anyone who has used Python / C++ wrapper libraries like CXX or Boost.

    • ✅ Started integrating NUnit2 to support unit tests for the embedding layer - still need to add the embedding tests (many already exist, but were written for an older version of NUnit).

    • 👍 Added Python iteration protocol support for arrays and managed objects that implement IEnumerable. This means that you can now use the Python idiom for item in object: on any array or IEnumerable object.

    • Added automatic conversion from Python sequence types to managed array types. This means, for example, that you can now call a managed method like AddRange that expects an array with any Python object that supports the Python sequence protocol, provided the items of the sequence are convertible to the item type of the managed array.

    • Added new demo scripts, mostly more substantial winforms examples.

    • ✅ Finished the unit tests for event support, and fixed lots of problems with events and delegates as a result. This is one of the trickier parts of the integration layer, and there is good coverage of these in the unit tests now.

    • Did a fair amount of profiling with an eval version of ANTS (which is quite nice, BTW) and made a few changes as a result.

    • 🔨 Type management was refactored, fixing the issue that caused segfaults when GC was enabled. Unit tests, stress tests and demo apps now all run nicely with Python GC enabled. There are one or two things left to fix, but the fixes should not have any user impact.

    • Changed to base PythonNet on Python 2.3.2. This is considered the most stable release, and a good 25 - 30% faster as well.

    • Added a new CLR.dll that acts as an extension module that allows an existing unmodified Python 2.3 installation to simply import CLR to bootstrap the managed integration layer.

    • A bug was causing managed methods to only expose overloads declared in a particular class, hiding inherited overloads of the same name. Fixed the bug and added some unit tests.

    • Added a virtual __doc__ attribute to managed methods that contains the signature of the method. This also means that the Python help function now provides signature info when used on a managed class.

    • Calling managed methods and events unbound (passing the instance as the first argument) now works. There is a caveat for methods - if a class declares both static and instance methods with the same name, it is not possible to call that instance method unbound (the static method will always be called).

    • 👍 Overload selection for overloaded methods is now much better and uses a method resolution algorithm similar to that used by Jython.

    • Changed the managed python.exe wrapper to run as an STA thread, which seems to be more compatible with winforms apps. This needs a better solution long-term. One possibility would be a command line switch so that -sta or -mta could control the python.exe apartment state.

    • 👍 Added support for the Python boolean type (True, False). Bool values now appear as True or False to Python.

  • v1.0.0-alpha.2 Changes

    🔄 Changed

    • ✅ Added a Mono makefile. Thanks to Camilo Uribe for help in testing and working out problems on Mono. Note that it not currently possible to build PythonNet using mono, due to the use of some IL attributes that the mono assembler / disassembler doesn't support yet.

    • Preliminary tests show that PythonNet does actually run under mono, though the test suite bombs out before the end with an "out of memory" error from the mono runtime. It's just a guess at this point, but I suspect there may be a limited pool for allocating certain reflection structures, and Python uses the reflection infrastructure quite heavily.

    • 🚚 Removed decoys like the non-working embedding APIs; lots of internal refactoring.

    • 👍 Implemented indexer support. Managed instances that implement indexers can now be used naturally from Python (e.g. someobject[0]).

    • 👍 Implemented sequence protocol support for managed arrays.

    • Implemented basic thread state management; calls to managed methods no longer block Python. I won't go so far as to say the thread choreography is "finished", as I don't have a comprehensive set of tests to back that up yet (and it will take some work to write a sufficiently large and evil set of tests).

    • 🛠 Fixed a bug that caused conversions of managed strings to PyUnicode to produce mangled values in certain situations.

    • 🛠 Fixed a number of problems related to subclassing a managed class, including the fact that it didn't work :)

    • 🚀 Fixed all of the bugs that were causing tests to fail. This release contains all new bugs and new failing tests. Progress! :)

  • v1.0.0-alpha.1 Changes

    ➕ Added

    • 🚀 Initial (mostly) working experimental release.

    🚀 [unreleased]: ../../compare/v2.3.0...HEAD

    🚀 [1.0.0]: https://github.com/pythonnet/pythonnet/releases/tag/1.0