Ansys-pythonnet

Changed

- Implemented a workaround for the fact that exceptions cannot be new-style
classes in the CPython interpreter. Managed exceptions can now be raised
and caught naturally from Python (hooray!)

- Implemented support for invoking methods with out and ref parameters.
Because there is no real equivalent to these in Python, methods that
have out or ref parameters will return a tuple. The tuple will contain
the result of the method as its first item, followed by out parameter
values in the order of their declaration in the method signature.

- Fixed a refcount problem that caused a crash when CLR was imported in
an existing installed Python interpreter.

- Added an automatic conversion from Python strings to `byte[]`. This makes
it easier to pass `byte[]` data to managed methods (or set properties,
etc.) as a Python string without having to write explicit conversion
code. Also works for sbyte arrays. Note that `byte` and `sbyte` arrays
returned from managed methods or obtained from properties or fields
do _not_ get converted to Python strings - they remain instances of
`Byte[]` or `SByte[]`.

- Added conversion of generic Python sequences to object arrays when
appropriate (thanks to Mackenzie Straight for the patch).

- Added a bit of cautionary documentation for embedders, focused on
correct handling of the Python global interpreter lock from managed
code for code that calls into Python.

- `PyObject.FromManagedObject` now correctly returns the Python None object
if the input is a null reference. Also added a new `AsManagedObject`
method to `PyObject`, making it easier to convert a Python-wrapped managed
object to the real managed object.

- Created a simple installer for windows platforms.

Changed

- Refactored and fixed threading and global interpreter lock handling,
which was badly broken before. Also added a number of threading and
GIL-handling tests.

- Related to the GIL fixes, added a note to embedders in the README
about using the AcquireLock and ReleaseLock methods of the PythonEngine
class to manage the GIL.

- Fixed a problem in `Single <--> float` conversion for cultures that use
different decimal symbols than Python.

- Added a new `ReloadModule` method to the `PythonEngine` class that hooks
Python module reloading (`PyImport_ReloadModule`).

- Added a new `StringAsModule` method to the PythonEngine class that can
create a module from a managed string of code.

- Added a default `__str__` implementation for Python wrappers of managed
objects that calls the `ToString` method of the managed object.

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.

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.

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.

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.