  It's a draft that's not been extended since the first release.
  So, look at the tutorial and the demos, and then at the source code.

  Here's the class diagram:

  TDynamicDll
     |_ TPythonInterface
            |_ TPythonEngine

  TEngineClient
     |_ TMethodsContainer
     |      |_ TPythonType
     |      |_ TPythonModule
     |_ TPythonDelphiVar

  TPythonInputOutput
     |_   TPythonGUIInputOutput


  All TEngineClient classes (or descendents) are
  attached to a TPythonEngine, which does the initialization
  and finalization of its clients.

  The initialization is done when the dll is correctly
  loaded and after that the Python interpreter has been
  initialized (Py_Initialize).

  The finalization is done before the dll is unloaded,
  and before the Py_Finalize.

  Each EngineClient can initialize itself (prepare a new
  type, or add methods) with the OnInitialize event.
  If it allocated Python ressources, they can be freed with
  the OnFinalize event.
  You can use OnCreate/OnDestroy events to allocate/free
  private resources.

  The PythonEngine component can only be instanciated once.

  There are new events for the PythonEngine:
    OnAfterLoad     is fired when the Dll is correctly loaded
    OnBeforeUnload  is fired before the Dll is unloaded
    OnAfterInit     is fired after that the Dll has been loaded
                    and the Python interpreter has been initialized
                    (Py_Initialize).

  There are new methods for the PythonEngine:

    function   EvalStringAsStr(const command : String) : String;
      --> Evaluates a string and returns a string representation of the result

    function   EvalString(const command : String) : PPyObject;
      --> Evaluates a string and returns a Python object pointer

    procedure  ExecString(const command : String);
      --> Execute a string

    function   Run_CommandAsString(const command : String; mode : Integer) : String;
      --> Executes or Evaluates a string according to the mode argument,
          and returns a string representation of the result

    function   Run_CommandAsObject(const command : String; mode : Integer) : PPyObject;
      --> Executes or Evaluates a string according to the mode argument,
          and returns a Python object

    procedure  ExecStrings( strings : TStrings );
      --> Executes a TStrings (Lines of a Memo, ListBox...)

    function   EvalStrings( strings : TStrings ) : PPyObject;
      --> Evaluates a TStrings (Lines of a Memo, ListBox...) and
          returns a Python Object pointer

    function   EvalStringsAsStr( strings : TStrings ) : String;
      --> Evaluates a TStrings (Lines of a Memo, ListBox...) and
          returns a string representation of the result

    procedure  RaiseError;
      --> Builds an exception object from a Python error.

    function   PyObjectAsString( obj : PPyObject ) : String;
      --> Returns a string representation of obj

    procedure  DoRedirectIO;
      --> Redirects inputs/outputs of Python in a TPythonOutput Memo

    function   TypeByName( const aTypeName : String ) : PPyTypeObject;
      --> Returns the type's pointer of a TPythonObject whose TypeName is
          aTypeName. Throws an exception if aTypeName does not exist.

    function   ModuleByName( const aModuleName : String ) : PPyObject;
      --> Returns the module object of a TPythonModule whose ModuleName is
          aModuleName. Throws an exception if aModuleName does not exist.

    function   MethodsByName( const aMethodsContainer: String ) : PPyMethodDef;
      --> Returns the MethodsData pointer of a TMethodsContainer whose Name is
          aMethodsContainer. Throws an exception if aMethodsContainer does not exist.

  The output of Python may be automatically redericted into a TPythonOutput
  component, if you define the IO attribute of the TPythonEngine.

  The output is effectively redirected according to the property RedirectIO

  The attribute InitScript can contain Python source code that is executed
  after Python's initialization.

  Use the global function GetPythonEngine to access the engine, as
  there's only one Engine. This function checks if the engine was allocated
  and initialized, else it raises an exception.

