home *** CD-ROM | disk | FTP | other *** search
/ PC User 2004 November / PCU1104CD1.iso / software / online / files / jyte.exe / gencache.py < prev    next >
Encoding:
Python Source  |  2004-01-26  |  23.8 KB  |  690 lines
  1. """Manages the cache of generated Python code.
  2.  
  3. Description
  4.   This file manages the cache of generated Python code.  When run from the 
  5.   command line, it also provides a number of options for managing that cache.
  6.   
  7. Implementation
  8.   Each typelib is generated into a filename of format "{guid}x{lcid}x{major}x{minor}.py"
  9.   
  10.   An external persistant dictionary maps from all known IIDs in all known type libraries
  11.   to the type library itself.
  12.   
  13.   Thus, whenever Python code knows the IID of an object, it can find the IID, LCID and version of
  14.   the type library which supports it.  Given this information, it can find the Python module
  15.   with the support.
  16.   
  17.   If necessary, this support can be generated on the fly.
  18.   
  19. Hacks, to do, etc
  20.   Currently just uses a pickled dictionary, but should used some sort of indexed file.
  21.   Maybe an OLE2 compound file, or a bsddb file?
  22. """
  23. import pywintypes, os, string, sys
  24. import pythoncom
  25. import win32com, win32com.client
  26. import glob
  27. import traceback
  28. import CLSIDToClass
  29. import operator
  30.  
  31. bForDemandDefault = 0 # Default value of bForDemand - toggle this to change the world - see also makepy.py
  32.  
  33. # The global dictionary
  34. clsidToTypelib = {}
  35.  
  36. # If we have a different version of the typelib generated, this
  37. # maps the "requested version" to the "generated version".
  38. versionRedirectMap = {}
  39.  
  40. # There is no reason we *must* be readonly in a .zip, but we are now,
  41. # Rather than check for ".zip" or other tricks, PEP302 defines
  42. # a "__loader__" attribute, so we use that.
  43. # (Later, it may become necessary to check if the __loader__ can update files,
  44. # as a .zip loader potentially could - but punt all that until a need arises)
  45. is_readonly = hasattr(win32com, "__loader__")
  46.  
  47. # A dictionary of ITypeLibrary objects for demand generation explicitly handed to us
  48. # Keyed by usual clsid, lcid, major, minor
  49. demandGeneratedTypeLibraries = {}
  50.  
  51. def __init__():
  52.     # Initialize the module.  Called once explicitly at module import below.
  53.     try:
  54.         _LoadDicts()
  55.     except IOError:
  56.         Rebuild()
  57.  
  58. pickleVersion = 1
  59. def _SaveDicts():
  60.     if is_readonly:
  61.         raise RuntimeError, "Trying to write to a readonly gencache ('%s')!" \
  62.                             % win32com.__gen_path__
  63.     import cPickle
  64.     f = open(os.path.join(GetGeneratePath(), "dicts.dat"), "wb")
  65.     try:
  66.         p = cPickle.Pickler(f)
  67.         p.dump(pickleVersion)
  68.         p.dump(clsidToTypelib)
  69.     finally:
  70.         f.close()
  71.  
  72. def _LoadDicts():
  73.     import cPickle
  74.     # Load the dictionary from a .zip file if that is where we live.
  75.     if hasattr(win32com, "__loader__"):
  76.         import cStringIO
  77.         loader = win32com.__loader__
  78.         arc_path = loader.archive
  79.         dicts_path = os.path.join(win32com.__gen_path__, "dicts.dat")
  80.         if dicts_path.startswith(arc_path):
  81.             dicts_path = dicts_path[len(arc_path)+1:]
  82.         else:
  83.             # Hm. See below.
  84.             return
  85.         try:
  86.             data = loader.get_data(dicts_path)
  87.         except AttributeError:
  88.             # The __loader__ has no get_data method.  See below.
  89.             return
  90.         except IOError:
  91.             # Our gencache is in a .zip file (and almost certainly readonly)
  92.             # but no dicts file.  That actually needn't be fatal for a frozen
  93.             # application.  Assuming they call "EnsureModule" with the same
  94.             # typelib IDs they have been frozen with, that EnsureModule will
  95.             # correctly re-build the dicts on the fly.  However, objects that
  96.             # rely on the gencache but have not done an EnsureModule will
  97.             # fail (but their apps are likely to fail running from source
  98.             # with a clean gencache anyway, as then they would be getting
  99.             # Dynamic objects until the cache is built - so the best answer
  100.             # for these apps is to call EnsureModule, rather than freezing
  101.             # the dict)
  102.             return
  103.         f = cStringIO.StringIO(data)
  104.     else:
  105.         # NOTE: IOError on file open must be caught by caller.
  106.         f = open(os.path.join(win32com.__gen_path__, "dicts.dat"), "rb")
  107.     try:
  108.         p = cPickle.Unpickler(f)
  109.         version = p.load()
  110.         global clsidToTypelib
  111.         clsidToTypelib = p.load()
  112.         versionRedirectMap.clear()
  113.     finally:
  114.         f.close()
  115.  
  116. def GetGeneratedFileName(clsid, lcid, major, minor):
  117.     """Given the clsid, lcid, major and  minor for a type lib, return
  118.     the file name (no extension) providing this support.
  119.     """
  120.     return string.upper(str(clsid))[1:-1] + "x%sx%sx%s" % (lcid, major, minor)
  121.  
  122. def SplitGeneratedFileName(fname):
  123.     """Reverse of GetGeneratedFileName()
  124.     """
  125.     return tuple(string.split(fname,'x',4))
  126.     
  127. def GetGeneratePath():
  128.     """Returns the name of the path to generate to.
  129.     Checks the directory is OK.
  130.     """
  131.     assert not is_readonly, "Why do you want the genpath for a readonly store?"
  132.     try:
  133.         os.makedirs(win32com.__gen_path__)
  134.         #os.mkdir(win32com.__gen_path__)
  135.     except os.error:
  136.         pass
  137.     try:
  138.         fname = os.path.join(win32com.__gen_path__, "__init__.py")
  139.         os.stat(fname)
  140.     except os.error:
  141.         f = open(fname,"w")
  142.         f.write('# Generated file - this directory may be deleted to reset the COM cache...\n')
  143.         f.write('import win32com\n')
  144.         f.write('if __path__[:-1] != win32com.__gen_path__: __path__.append(win32com.__gen_path__)\n')
  145.         f.close()
  146.     
  147.     return win32com.__gen_path__
  148.  
  149. #
  150. # The helpers for win32com.client.Dispatch and OCX clients.
  151. #
  152. def GetClassForProgID(progid):
  153.     """Get a Python class for a Program ID
  154.     
  155.     Given a Program ID, return a Python class which wraps the COM object
  156.     
  157.     Returns the Python class, or None if no module is available.
  158.     
  159.     Params
  160.     progid -- A COM ProgramID or IID (eg, "Word.Application")
  161.     """
  162.     clsid = pywintypes.IID(progid) # This auto-converts named to IDs.
  163.     return GetClassForCLSID(clsid)
  164.  
  165. def GetClassForCLSID(clsid):
  166.     """Get a Python class for a CLSID
  167.     
  168.     Given a CLSID, return a Python class which wraps the COM object
  169.     
  170.     Returns the Python class, or None if no module is available.
  171.     
  172.     Params
  173.     clsid -- A COM CLSID (or string repr of one)
  174.     """
  175.     # first, take a short-cut - we may already have generated support ready-to-roll.
  176.     clsid = str(clsid)
  177.     if CLSIDToClass.HasClass(clsid):
  178.         return CLSIDToClass.GetClass(clsid)
  179.     mod = GetModuleForCLSID(clsid)
  180.     if mod is None:
  181.         return None
  182.     try:
  183.         return CLSIDToClass.GetClass(clsid)
  184.     except KeyError:
  185.         return None
  186.  
  187. def GetModuleForProgID(progid):
  188.     """Get a Python module for a Program ID
  189.     
  190.     Given a Program ID, return a Python module which contains the
  191.     class which wraps the COM object.
  192.     
  193.     Returns the Python module, or None if no module is available.
  194.     
  195.     Params
  196.     progid -- A COM ProgramID or IID (eg, "Word.Application")
  197.     """
  198.     try:
  199.         iid = pywintypes.IID(progid)
  200.     except pywintypes.com_error:
  201.         return None
  202.     return GetModuleForCLSID(iid)
  203.     
  204. def GetModuleForCLSID(clsid):
  205.     """Get a Python module for a CLSID
  206.     
  207.     Given a CLSID, return a Python module which contains the
  208.     class which wraps the COM object.
  209.     
  210.     Returns the Python module, or None if no module is available.
  211.     
  212.     Params
  213.     progid -- A COM CLSID (ie, not the description)
  214.     """
  215.     clsid_str = str(clsid)
  216.     try:
  217.         typelibCLSID, lcid, major, minor = clsidToTypelib[clsid_str]
  218.     except KeyError:
  219.         return None
  220.  
  221.     try:
  222.         mod = GetModuleForTypelib(typelibCLSID, lcid, major, minor)
  223.     except ImportError:
  224.         mod = None
  225.     if mod is not None:
  226.         sub_mod = mod.CLSIDToPackageMap.get(clsid_str)
  227.         if sub_mod is None:
  228.             sub_mod = mod.VTablesToPackageMap.get(clsid_str)
  229.         if sub_mod is not None:
  230.             sub_mod_name = mod.__name__ + "." + sub_mod
  231.             try:
  232.                 __import__(sub_mod_name)
  233.             except ImportError:
  234.                 info = typelibCLSID, lcid, major, minor
  235.                 # Force the generation.  If this typelibrary has explicitly been added,
  236.                 # use it (it may not be registered, causing a lookup by clsid to fail)
  237.                 if demandGeneratedTypeLibraries.has_key(info):
  238.                     info = demandGeneratedTypeLibraries[info]
  239.                 import makepy
  240.                 makepy.GenerateChildFromTypeLibSpec(sub_mod, info)
  241.                 # Generate does an import...
  242.             mod = sys.modules[sub_mod_name]
  243.     return mod
  244.  
  245. def GetModuleForTypelib(typelibCLSID, lcid, major, minor):
  246.     """Get a Python module for a type library ID
  247.     
  248.     Given the CLSID of a typelibrary, return an imported Python module, 
  249.     else None
  250.     
  251.     Params
  252.     typelibCLSID -- IID of the type library.
  253.     major -- Integer major version.
  254.     minor -- Integer minor version
  255.     lcid -- Integer LCID for the library.
  256.     """
  257.     modName = GetGeneratedFileName(typelibCLSID, lcid, major, minor)
  258.     mod = _GetModule(modName)
  259.     # If the import worked, it doesn't mean we have actually added this
  260.     # module to our cache though - check that here.
  261.     if not mod.__dict__.has_key("_in_gencache_"):
  262.         AddModuleToCache(typelibCLSID, lcid, major, minor)
  263.         assert mod.__dict__.has_key("_in_gencache_")
  264.     return mod
  265.  
  266. def MakeModuleForTypelib(typelibCLSID, lcid, major, minor, progressInstance = None, bGUIProgress = None, bForDemand = bForDemandDefault, bBuildHidden = 1):
  267.     """Generate support for a type library.
  268.     
  269.     Given the IID, LCID and version information for a type library, generate
  270.     and import the necessary support files.
  271.     
  272.     Returns the Python module.  No exceptions are caught.
  273.  
  274.     Params
  275.     typelibCLSID -- IID of the type library.
  276.     major -- Integer major version.
  277.     minor -- Integer minor version.
  278.     lcid -- Integer LCID for the library.
  279.     progressInstance -- Instance to use as progress indicator, or None to
  280.                         use the GUI progress bar.
  281.     """
  282.     if bGUIProgress is not None:
  283.         print "The 'bGuiProgress' param to 'MakeModuleForTypelib' is obsolete."
  284.  
  285.     import makepy
  286.     try:
  287.         makepy.GenerateFromTypeLibSpec( (typelibCLSID, lcid, major, minor), progressInstance=progressInstance, bForDemand = bForDemand, bBuildHidden = bBuildHidden)
  288.     except pywintypes.com_error:
  289.         return None
  290.     return GetModuleForTypelib(typelibCLSID, lcid, major, minor)
  291.  
  292. def MakeModuleForTypelibInterface(typelib_ob, progressInstance = None, bForDemand = bForDemandDefault, bBuildHidden = 1):
  293.     """Generate support for a type library.
  294.     
  295.     Given a PyITypeLib interface generate and import the necessary support files.  This is useful
  296.     for getting makepy support for a typelibrary that is not registered - the caller can locate
  297.     and load the type library itself, rather than relying on COM to find it.
  298.     
  299.     Returns the Python module.
  300.  
  301.     Params
  302.     typelib_ob -- The type library itself
  303.     progressInstance -- Instance to use as progress indicator, or None to
  304.                         use the GUI progress bar.
  305.     """
  306.     import makepy
  307.     try:
  308.         makepy.GenerateFromTypeLibSpec( typelib_ob, progressInstance=progressInstance, bForDemand = bForDemandDefault, bBuildHidden = bBuildHidden)
  309.     except pywintypes.com_error:
  310.         return None
  311.     tla = typelib_ob.GetLibAttr()
  312.     guid = tla[0]
  313.     lcid = tla[1]
  314.     major = tla[3]
  315.     minor = tla[4]
  316.     return GetModuleForTypelib(guid, lcid, major, minor)
  317.  
  318. def EnsureModuleForTypelibInterface(typelib_ob, progressInstance = None, bForDemand = bForDemandDefault, bBuildHidden = 1):
  319.     """Check we have support for a type library, generating if not.
  320.     
  321.     Given a PyITypeLib interface generate and import the necessary
  322.     support files if necessary. This is useful for getting makepy support
  323.     for a typelibrary that is not registered - the caller can locate and
  324.     load the type library itself, rather than relying on COM to find it.
  325.     
  326.     Returns the Python module.
  327.  
  328.     Params
  329.     typelib_ob -- The type library itself
  330.     progressInstance -- Instance to use as progress indicator, or None to
  331.                         use the GUI progress bar.
  332.     """
  333.     tla = typelib_ob.GetLibAttr()
  334.     guid = tla[0]
  335.     lcid = tla[1]
  336.     major = tla[3]
  337.     minor = tla[4]
  338.  
  339.     #If demand generated, save the typelib interface away for later use
  340.     if bForDemand:
  341.         demandGeneratedTypeLibraries[(str(guid), lcid, major, minor)] = typelib_ob
  342.  
  343.     try:
  344.         return GetModuleForTypelib(guid, lcid, major, minor)
  345.     except ImportError:
  346.         pass
  347.     # Generate it.
  348.     return MakeModuleForTypelibInterface(typelib_ob, progressInstance, bForDemand, bBuildHidden)
  349.  
  350. def ForgetAboutTypelibInterface(typelib_ob):
  351.     """Drop any references to a typelib previously added with EnsureModuleForTypelibInterface and forDemand"""
  352.     tla = typelib_ob.GetLibAttr()
  353.     guid = tla[0]
  354.     lcid = tla[1]
  355.     major = tla[3]
  356.     minor = tla[4]
  357.     info = str(guid), lcid, major, minor
  358.     try:
  359.         del demandGeneratedTypeLibraries[info]
  360.     except KeyError:
  361.         # Not worth raising an exception - maybe they dont know we only remember for demand generated, etc.
  362.         print "ForgetAboutTypelibInterface:: Warning - type library with info %s is not being remembered!" % (info,)
  363.     # and drop any version redirects to it
  364.     for key, val in versionRedirectMap.items():
  365.         if val==info:
  366.             del versionRedirectMap[key]
  367.  
  368. def EnsureModule(typelibCLSID, lcid, major, minor, progressInstance = None, bValidateFile=not is_readonly, bForDemand = bForDemandDefault, bBuildHidden = 1):
  369.     """Ensure Python support is loaded for a type library, generating if necessary.
  370.     
  371.     Given the IID, LCID and version information for a type library, check and if
  372.     necessary (re)generate, then import the necessary support files. If we regenerate the file, there
  373.     is no way to totally snuff out all instances of the old module in Python, and thus we will regenerate the file more than necessary,
  374.     unless makepy/genpy is modified accordingly.
  375.     
  376.     
  377.     Returns the Python module.  No exceptions are caught during the generate process.
  378.  
  379.     Params
  380.     typelibCLSID -- IID of the type library.
  381.     major -- Integer major version.
  382.     minor -- Integer minor version
  383.     lcid -- Integer LCID for the library.
  384.     progressInstance -- Instance to use as progress indicator, or None to
  385.                         use the GUI progress bar.
  386.     bValidateFile -- Whether or not to perform cache validation or not
  387.     bForDemand -- Should a complete generation happen now, or on demand?
  388.     bBuildHidden -- Should hidden members/attributes etc be generated?
  389.     """
  390.     bReloadNeeded = 0
  391.     try:
  392.         try:
  393.             module = GetModuleForTypelib(typelibCLSID, lcid, major, minor)
  394.         except ImportError:
  395.             # If we get an ImportError
  396.             # We may still find a valid cache file under a different MinorVersion #
  397.             # (which windows will search out for us)
  398.             #print "Loading reg typelib", typelibCLSID, major, minor, lcid
  399.             module = None
  400.             try:
  401.                 tlbAttr = pythoncom.LoadRegTypeLib(typelibCLSID, major, minor, lcid).GetLibAttr()
  402.                 # if the above line doesn't throw a pythoncom.com_error, check if
  403.                 # it is actually a different lib than we requested, and if so, suck it in
  404.                 if tlbAttr[1] != lcid or tlbAttr[4]!=minor:
  405.                     #print "Trying 2nd minor #", tlbAttr[1], tlbAttr[3], tlbAttr[4]
  406.                     try:
  407.                         module = GetModuleForTypelib(typelibCLSID, tlbAttr[1], tlbAttr[3], tlbAttr[4])
  408.                     except ImportError:
  409.                         # We don't have a module, but we do have a better minor
  410.                         # version - remember that.
  411.                         minor = tlbAttr[4]
  412.                 # else module remains None
  413.             except pythoncom.com_error:
  414.                 # couldn't load any typelib - mod remains None
  415.                 pass
  416.         if module is not None and bValidateFile:
  417.             assert not is_readonly, "Can't validate in a read-only gencache"
  418.             try:
  419.                 typLibPath = pythoncom.QueryPathOfRegTypeLib(typelibCLSID, major, minor, lcid)
  420.                 tlbAttributes = pythoncom.LoadRegTypeLib(typelibCLSID, major, minor, lcid).GetLibAttr()
  421.             except pythoncom.com_error:
  422.                 # We have a module, but no type lib - we should still
  423.                 # run with what we have though - the typelib may not be
  424.                 # deployed here.
  425.                 bValidateFile = 0
  426.         if module is not None and bValidateFile:
  427.             assert not is_readonly, "Can't validate in a read-only gencache"
  428.             filePathPrefix  = "%s\\%s" % (GetGeneratePath(), GetGeneratedFileName(typelibCLSID, lcid, major, minor))
  429.             filePath = filePathPrefix + ".py"
  430.             filePathPyc = filePathPrefix + ".py"
  431.             if __debug__:
  432.                 filePathPyc = filePathPyc + "c"
  433.             else:
  434.                 filePathPyc = filePathPyc + "o"
  435.             # Verify that type library is up to date.
  436.             #print "Grabbing typelib"
  437.             # If the following doesn't throw an exception, then we have a valid type library
  438.             typLibPath = pythoncom.QueryPathOfRegTypeLib(typelibCLSID, major, minor, lcid)
  439.             tlbAttributes = pythoncom.LoadRegTypeLib(typelibCLSID, major, minor, lcid).GetLibAttr()
  440.             #print "Grabbed typelib: ", tlbAttributes[3], tlbAttributes[4]
  441.             ##print module.MinorVersion
  442.             # If we have a differing MinorVersion or genpy has bumped versions, update the file
  443.             import genpy
  444.             if module.MinorVersion != tlbAttributes[4] or genpy.makepy_version != module.makepy_version:
  445.                 #print "Version skew: %d, %d" % (module.MinorVersion, tlbAttributes[4])
  446.                 # try to erase the bad file from the cache
  447.                 try:
  448.                     os.unlink(filePath)
  449.                 except os.error:
  450.                     pass
  451.                 try:
  452.                     os.unlink(filePathPyc)
  453.                 except os.error:
  454.                     pass
  455.                 if os.path.isdir(filePathPrefix):
  456.                     import shutil
  457.                     shutil.rmtree(filePathPrefix)
  458.                 minor = tlbAttributes[4]
  459.                 module = None
  460.                 bReloadNeeded = 1
  461.             else:
  462.                 minor = module.MinorVersion
  463.                 filePathPrefix  = "%s\\%s" % (GetGeneratePath(), GetGeneratedFileName(typelibCLSID, lcid, major, minor))
  464.                 filePath = filePathPrefix + ".py"
  465.                 filePathPyc = filePathPrefix + ".pyc"
  466.                 #print "Trying py stat: ", filePath
  467.                 fModTimeSet = 0
  468.                 try:
  469.                     pyModTime = os.stat(filePath)[8]
  470.                     fModTimeSet = 1
  471.                 except os.error, e:
  472.                     # If .py file fails, try .pyc file
  473.                     #print "Trying pyc stat", filePathPyc
  474.                     try:
  475.                         pyModTime = os.stat(filePathPyc)[8]
  476.                         fModTimeSet = 1
  477.                     except os.error, e:
  478.                         pass
  479.                 #print "Trying stat typelib", pyModTime
  480.                 #print str(typLibPath)
  481.                 typLibModTime = os.stat(str(typLibPath[:-1]))[8]
  482.                 if fModTimeSet and (typLibModTime > pyModTime):
  483.                     bReloadNeeded = 1
  484.                     module = None
  485.     except (ImportError, os.error):    
  486.         module = None
  487.     if module is None:
  488.         # We need to build an item.  If we are in a read-only cache, we
  489.         # can't/don't want to do this - so before giving up, check for
  490.         # a different minor version in our cache - according to COM, this is OK
  491.         if is_readonly:
  492.             key = str(typelibCLSID), lcid, major, minor
  493.             # If we have been asked before, get last result.
  494.             try:
  495.                 return versionRedirectMap[key]
  496.             except KeyError:
  497.                 pass
  498.             # Find other candidates.
  499.             items = []
  500.             for desc in GetGeneratedInfos():
  501.                 if key[0]==desc[0] and key[1]==desc[1] and key[2]==desc[2]:
  502.                     items.append(desc)
  503.             if items:
  504.                 # Items are all identical, except for last tuple element
  505.                 # We want the latest minor version we have - so just sort and grab last
  506.                 items.sort()
  507.                 new_minor = items[-1][3]
  508.                 ret = GetModuleForTypelib(typelibCLSID, lcid, major, new_minor)
  509.             else:
  510.                 ret = None
  511.             # remember and return
  512.             versionRedirectMap[key] = ret
  513.             return ret
  514.         #print "Rebuilding: ", major, minor
  515.         module = MakeModuleForTypelib(typelibCLSID, lcid, major, minor, progressInstance, bForDemand = bForDemand, bBuildHidden = bBuildHidden)
  516.         # If we replaced something, reload it
  517.         if bReloadNeeded:
  518.             module = reload(module)
  519.             AddModuleToCache(typelibCLSID, lcid, major, minor)
  520.     return module
  521.  
  522. def EnsureDispatch(prog_id, bForDemand = 1): # New fn, so we default the new demand feature to on!
  523.     """Given a COM prog_id, return an object that is using makepy support, building if necessary"""
  524.     disp = win32com.client.Dispatch(prog_id)
  525.     if not disp.__dict__.get("CLSID"): # Eeek - no makepy support - try and build it.
  526.         try:
  527.             ti = disp._oleobj_.GetTypeInfo()
  528.             disp_clsid = ti.GetTypeAttr()[0]
  529.             tlb, index = ti.GetContainingTypeLib()
  530.             tla = tlb.GetLibAttr()
  531.             mod = EnsureModule(tla[0], tla[1], tla[3], tla[4], bForDemand=bForDemand)
  532.             GetModuleForCLSID(disp_clsid)
  533.             # Get the class from the module.
  534.             import CLSIDToClass
  535.             disp_class = CLSIDToClass.GetClass(str(disp_clsid))
  536.             disp = disp_class(disp._oleobj_)
  537.         except pythoncom.com_error:
  538.             raise TypeError, "This COM object can not automate the makepy process - please run makepy manually for this object"
  539.     return disp
  540.  
  541. def AddModuleToCache(typelibclsid, lcid, major, minor, verbose = 1, bFlushNow = not is_readonly):
  542.     """Add a newly generated file to the cache dictionary.
  543.     """
  544.     fname = GetGeneratedFileName(typelibclsid, lcid, major, minor)
  545.     mod = _GetModule(fname)
  546.     assert not mod.__dict__.has_key("_in_gencache_"), \
  547.            "This module has already been processed by this process"
  548.     mod._in_gencache_ = 1
  549.     dict = mod.CLSIDToClassMap
  550.     info = str(typelibclsid), lcid, major, minor
  551.     for clsid, cls in dict.items():
  552.         clsidToTypelib[clsid] = info
  553.  
  554.     dict = mod.CLSIDToPackageMap
  555.     for clsid, name in dict.items():
  556.         clsidToTypelib[clsid] = info
  557.  
  558.     dict = mod.VTablesToClassMap
  559.     for clsid, cls in dict.items():
  560.         clsidToTypelib[clsid] = info
  561.  
  562.     dict = mod.VTablesToPackageMap
  563.     for clsid, cls in dict.items():
  564.         clsidToTypelib[clsid] = info
  565.  
  566.     # If this lib was previously redirected, drop it
  567.     if versionRedirectMap.has_key(info):
  568.         del versionRedirectMap[info]
  569.     if bFlushNow:
  570.         _SaveDicts()
  571.  
  572. def GetGeneratedInfos():
  573.     zip_pos = win32com.__gen_path__.find(".zip\\")
  574.     if zip_pos >= 0:
  575.         import zipfile, cStringIO
  576.         zip_file = win32com.__gen_path__[:zip_pos+4]
  577.         zip_path = win32com.__gen_path__[zip_pos+5:].replace("\\", "/")
  578.         zf = zipfile.ZipFile(zip_file)
  579.         infos = {}
  580.         for n in zf.namelist():
  581.             if not n.startswith(zip_path):
  582.                 continue
  583.             base = n[len(zip_path)+1:].split("/")[0]
  584.             try:
  585.                 iid, lcid, major, minor = base.split("x")
  586.                 lcid = int(lcid)
  587.                 major = int(major)
  588.                 minor = int(minor)
  589.                 iid = pywintypes.IID("{" + iid + "}")
  590.             except ValueError:
  591.                 continue
  592.             except pywintypes.com_error:
  593.                 # invalid IID
  594.                 continue
  595.             infos[(iid, lcid, major, minor)] = 1
  596.         zf.close()
  597.         return infos.keys()
  598.     else:
  599.         # on the file system
  600.         files = glob.glob(win32com.__gen_path__+ "\\*")
  601.         ret = []
  602.         for file in files:
  603.             if not os.path.isdir(file) and not os.path.splitext(file)==".py":
  604.                 continue
  605.             name = os.path.splitext(os.path.split(file)[1])[0]
  606.             try:
  607.                 iid, lcid, major, minor = string.split(name, "x")
  608.                 iid = pywintypes.IID("{" + iid + "}")
  609.                 lcid = int(lcid)
  610.                 major = int(major)
  611.                 minor = int(minor)
  612.             except ValueError:
  613.                 continue
  614.             except pywintypes.com_error:
  615.                 # invalid IID
  616.                 continue
  617.             ret.append((iid, lcid, major, minor))
  618.         return ret
  619.  
  620. def _GetModule(fname):
  621.     """Given the name of a module in the gen_py directory, import and return it.
  622.     """
  623.     mod_name = "win32com.gen_py.%s" % fname
  624.     mod = __import__(mod_name)
  625.     return sys.modules[mod_name]
  626.  
  627. def Rebuild(verbose = 1):
  628.     """Rebuild the cache indexes from the file system.
  629.     """
  630.     clsidToTypelib.clear()
  631.     infos = GetGeneratedInfos()
  632.     if verbose and len(infos): # Dont bother reporting this when directory is empty!
  633.         print "Rebuilding cache of generated files for COM support..."
  634.     for info in infos:
  635.         iid, lcid, major, minor = info
  636.         if verbose:
  637.             print "Checking", GetGeneratedFileName(*info)
  638.         try:
  639.             AddModuleToCache(iid, lcid, major, minor, verbose, 0)
  640.         except:
  641.             print "Could not add module %s - %s: %s" % (name, sys.exc_info()[0],sys.exc_info()[1])
  642.     if verbose and len(infos): # Dont bother reporting this when directory is empty!
  643.         print "Done."
  644.     _SaveDicts()
  645.  
  646. def _Dump():
  647.     print "Cache is in directory", win32com.__gen_path__
  648.     # Build a unique dir
  649.     d = {}
  650.     for clsid, (typelibCLSID, lcid, major, minor) in clsidToTypelib.items():
  651.         d[typelibCLSID, lcid, major, minor] = None
  652.     for typelibCLSID, lcid, major, minor in d.keys():
  653.         mod = GetModuleForTypelib(typelibCLSID, lcid, major, minor)
  654.         print "%s - %s" % (mod.__doc__, typelibCLSID)
  655.  
  656. # Boot up
  657. __init__()
  658.  
  659. def usage():
  660.     usageString = """\
  661.       Usage: gencache [-q] [-d] [-r]
  662.       
  663.              -q         - Quiet
  664.              -d         - Dump the cache (typelibrary description and filename).
  665.              -r         - Rebuild the cache dictionary from the existing .py files
  666.     """
  667.     print usageString
  668.     sys.exit(1)
  669.  
  670. if __name__=='__main__':
  671.     import getopt
  672.     try:
  673.         opts, args = getopt.getopt(sys.argv[1:], "qrd")
  674.     except getopt.error, message:
  675.         print message
  676.         usage()
  677.  
  678.     # we only have options - complain about real args, or none at all!
  679.     if len(sys.argv)==1 or args:
  680.         print usage()
  681.         
  682.     verbose = 1
  683.     for opt, val in opts:
  684.         if opt=='-d': # Dump
  685.             _Dump()
  686.         if opt=='-r':
  687.             Rebuild(verbose)
  688.         if opt=='-q':
  689.             verbose = 0
  690.