COM Client Support

  This package contains support for Python as a COM client.

  This is the ability to use other COM servers, not necessarily implemented 
  in Python. For example, the client support can be used to talk to Microsoft 
  Office, Visual Basic Servers, OCX controls, etc.

  Currently, there are 2 primary ways to use Python as a COM client - using
  generated .py files as supported in the @makepy@ module, or using dynamic
  COM objects, as supported in the @dynamic@ module.  An overview of each of the 
  techniques is provided below.

  Generated File Support -- Using a COM object's type information, 
    the @makepy@ module can be used to
    generate a .py source file which interfaces to the server.  This module
    generates full classes and constants defined in the type library.

    A key advantage of this approach is the "type checking" or pre-built knowledge
    that the Python then has about the server.  The operations are very fast, and
    in may cases, smart handling of paramaters and return types is performed.

    The key disadvantages to this approach is that the .py files must be generated
    before the modules can be used.  This can type some time to generate, and significant
    memory and machine resources may be needed to 'compile' (ie, generate a .pyc) file
    first time Python uses the module.  Also, there is no standard place or process for
    automatic (ie, on the fly) generatiion of these files

  Dynamic COM Support -- Dynamic COM support is the ability of Python to 
    talk to COM servers, given
    no prior knowledge of the COM server (ie, given no more than an IDispatch
    pointer).  This is implemented by the @dynamic@ module.

    In general, Python does a reasonable job using this approach.  In fact, Python
    does an almost perfect job when the IDispatch has type information available at
    run time - although this fact is invisible to the user.

    But in some cases, Python and COM do not get on so well.

    The key advantage to this approach is that no prior knowledge of a COM server,
    and no type information is necessary.  This allows you to get running much faster.

    The key disadvantage is that Python and COM occasionally can not agree on certain
    details, providing less than optimal results.
