This is the list of all changes since the first release:

----------------------------------------------------------------------
1.2   error handling in run component
----------------------------------------------------------------------
1.3   Inserted functionality and definitions got from
      Grzegorz Makarewicz
      mak@mikroplan.com.pl
      http://www.mikroplan.com.pl/home/mak/python
      Thank you for permission and help!
----------------------------------------------------------------------
1.4   Cleaning up, eliminating German comments, further tests
      Inserted some ideas from Andrew Robinson,
      andy@hps1.demon.co.uk
----------------------------------------------------------------------
1.5   Initialization String, some minor functionalities
----------------------------------------------------------------------
2.0   18/12/1997
      Extended by Morgan Martinet (mmm@imaginet.fr)
      The architecture of the system was changed a lot !
      See the text files (Documentation and tutorial) for more infos.
      * Works with Python 1.5 Beta 2
      * Renamed unit as PythonEngine
      * Cleaned the formatting of the source code
      * Reorganized some parts of the source
      * Reorganized the content of the components
      * Used exceptions instead of error variables
      * Suppressed the script, methods and InitModule of TPytRun,
        because there are new components for that.
      * We use the ExitProcess function instead of Halt, because
        Halt does not unload the Dlls before it leaves.
      * When defining methods, there's no need to add a blank method
        for the last one, because we allways allocate n+1 methods,
        and the new allocated data is allways cleared.
      * Renamed classes, in order to avoid name conflicts
        with the previous components, which can coexist:
            TDynDll   -->  TDynamicDll
            TPytDll   -->  TPythonInterface
            TPytRun   -->  TPythonEngine (It hosts the interpreter)

      * Added components
            TEngineClient
            TMethodsContainer
            TPythonType         --> Lets you create a new Type object
            TPythonModule       --> Lets you create a new module
            TPythonDelphiVar    --> Lets you create Python variables
                                    that are bound to Delphi.
            TPythonOutput       --> Works as a console for displaying
                                    Python outputs.

----------------------------------------------------------------------
2.01
      * Py_BuildValue modified to support floats thanks to Grzegorz Makarewicz
      * Renamed the functions Exec_command -> ExecString
                              Eval_command -> EvalString
      * Added the functions EvalStringAsStr and EvalStringsAsStr
      * Added a delay mechanism for the output, in order to let threads write
        to output. There are 2 new functions in the module pyio:
            SetDelayWrites(1/0) -> (de)activates the delaying
            SetMaxLines(val) -> sets the # of lines of the output
      * Added 2 functions to convert Python objects to variants and vice versa:
            PyObjectAsVariant
            VariantAsPyObject
            VarRecAsPyObject
      * Removed the flag argument of the AddMethod procedure, because it must
        be always 1.
      * Checked if the VarName attribute of a TPythonDelphiVar does already
        exist and raise an exception.
      * Added functions CheckSyntax, CheckEvalSyntax, CheckExecSyntax.
      * Added functions MakePyTuple, MakePyList,
                        ArrayToPyTuple, ArrayToPyList, ArrayToPyDict
                        StringsToPyList, StringsToPyTuple,
                        PyListToStrings, PyTupleToStrings
      * Added a function ReturnNone that returns a
        Py_None object, correctly incremented.
      * Extended the exception classes in Delphi that map the exceptions of Python.
        Now, there's a one to one maping.

----------------------------------------------------------------------
2.02  07/01/1998
      * modified Py_BuildValue to handle currencies as python doubles.
      * Added method TMethodsContainer.MethodWrap to call Delphi Methods
        from Python.

----------------------------------------------------------------------
2.03  09/01/1998
      * Removed MethodWrap and added AddDelphiMethod.
        I added a new type TDelphiMethod wich will constrain
        to declare a valid delphi method to pass to Python.
        Now it simplifies the declaration of a method, and it
        checks the type of the method passed.
      * Added Demo7 to show the new functionality of the Delphi
        methods. I show in this demo how to use ArrayToPyTuple
        in the getlong2 function.

----------------------------------------------------------------------
2.04  12/01/1998
      * Removed the DelphiObject argument of the AddDelphiMethod because
        it could be extracted from the DelphiMethod arg (look at the trick !).

----------------------------------------------------------------------
2.05  13/01/1998
      * Added a property APIVersion in order to use different versions of
        Python.
      * Added GetOfObjectCallBack in the MethodCallback.pas and used it in
        the AddDelphiMethod.

----------------------------------------------------------------------
2.06  27/01/1998
      * Changed how TPythonEngine checks if it already exists.
        Now you can open several forms containing each a TPythonEngine,
        but you can't drop 2 TPythonEngine on the same form, and when
        your application will execute it will check that there's only one
        instance of TPythonEngine.
      * Added a new property "ExecModule" that lets you specify in which
        module your code will be executed. By default it's "__main__".
      * Added a new system that lets you create new Python types with
        Delphi classes. So, you can use the inheritence and polymorphism
        in your Python types ! And it is more easier to build !
      * Changed the tutorial, and added a demo8 that shows you how to use
        the Delphi classes.
----------------------------------------------------------------------
2.07  02/02/1998
      * Added a property "AutoFinalize" to TPythonEngine that enables or not
        the call to Py_Finalize in the destructor of TPythonEngine.
        It's usefull for the Python modules as Dlls.
      * Added a Demo9 to show how to build a Python module as a Dll
        and explained it in the tutorial.
      * Changed TPythonType so that it automatically creates a variable
        containing the type and labelled with the TypeName in its
        linked module. Now you can check the type of an object like this:
           if type(obj) is spam.Point:
             ...
----------------------------------------------------------------------
2.08  05/02/1998
      * Changed the Input/Output mechanism thanks to Mark Watts.
        Renamed TPythonOutput as TPythonInputOutput. It is now a
        base class that can be derived in order to output on what
        you want (a RichEdit for instance).
        There's a 2 new events OnSendData and OnReceiveData that let
        you send/receive data to/from Python where you want without
        deriving a new class. You can use it if you want to send
        the output to a file for debuging purposes.
        There's a new component TPythonGUIInputOutput that has a property
        Output that redirects the output to a RichEdit.
      * Changed all demos to reflect the new design.
      * Changed tutorial
      * Changed Demo9, use module.Initialize instead of module.MakeModule
      * cleaned up the "uses" part of the units. Used MessageBox instead of
        MessageDlg.
----------------------------------------------------------------------
2.09  08/02/1998
      * Added a property "Errors" to TPythonModule that lets you
        define python errors and then raise them easily with the
        3 methods RaiseError, RaiseErrorFmt and RaiseErrorObj of TPythonModule.
        Errors is a collection of TError items.
        TError must have a Name (that will be used to define a string
        variable into the module). You can define the property "Text"
        that will define the content of the string error, if it is of type String.
        If you don't define it, then we will use the property "Name" instead.
        The property "ErrorType" lets you select between a String error or
        a class error. The latter has the advantage of containing instance variables
        that provide infos when we catch an error. And because of the class hierarchy,
        we can catch a parent class. So, if you define the ErrorType to etClass, then
        you can provide the name of the parent class. If it is empty, then there's no
        parent ! You can define in which module the parent class can be found (we will
        IMPORT this module, so it can be any module, internal or external), else it
        will use the module's name of the TPythonModule where the errors are located.
      * Changed demo8 to show the use of errors inside an object.
      * Updated tutorial.txt
      * Updated PyDelphi for the new input/output mechanism.
----------------------------------------------------------------------
2.10  12/02/1998
      * When the Name of an Error is changed, then we update all Errors that
        are derived from. We check if this Name does not already exist in the
        TError collection.
      * When the Module of an Error is changed, then we update all Errors that
        where referencing it.
      * Reactived the AddClient/RemoveClient of a TClientEngine when in
        design mode. It seems that there's no crash.
----------------------------------------------------------------------
2.11  19/03/1998
      * Corrected a bug in TMethodsContainer.ReallocMethods, because the
        function realloc did not clear the new allocated memory.
      * Imported function Py_malloc of the python15.dll
      * Made procedure TEngineClient.SetEngine virtual
----------------------------------------------------------------------
2.12  06/04/1998
      * Added PyFunction_Check to TPythonInterface
      * Added FindFunction, EvalPyFunction, EvalFunction and EvalFunctionNoArgs
        to TPythonEngine for a more sophisticated interface from Delphi
        to Python functions




