comtypes 1.1.0__zip → 1.1.3__zip

comtypes-1.1.3/LICENSE.txt

@@ -0,0 +1,24 @@
+This software is OSI Certified Open Source Software.
+OSI Certified is a certification mark of the Open Source Initiative.
+
+Copyright (c) 2006-2013, Thomas Heller.
+Copyright (c) 2014, Comtypes Developers.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

comtypes-1.1.3/MANIFEST.in

@@ -0,0 +1 @@
+include *.txt

{comtypes-1.1.0 → comtypes-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: comtypes
-Version: 1.1.0
+Version: 1.1.3
 Summary: Pure Python COM package
 Home-page: http://starship.python.net/crew/theller/comtypes
 Author: Thomas Heller

{comtypes-1.1.0 → comtypes-1.1.3}/comtypes/__init__.py

@@ -2,8 +2,8 @@ import types
 import sys
 import os
 
-# comtypes version numbers follow semver (http://semver.org/)
-__version__ = "1.1.0"
+# comtypes version numbers follow semver (http://semver.org/) and PEP 440
+__version__ = "1.1.3"
 
 import logging
 class NullHandler(logging.Handler):
@@ -653,6 +653,11 @@ class _cominterface_meta(type):
                     outnum += 1
 
             rescode = func(self_, *args, **kw)
+            # If there is only a single output value, then do not expect it to
+            # be iterable.
+            if len(outargs) == 1:  # rescode is not iterable
+                return rescode.__ctypes_from_outparam__()
+
             rescode = list(rescode)
             for outnum, o in outargs.items():
                 rescode[outnum] = o.__ctypes_from_outparam__()

{comtypes-1.1.0 → comtypes-1.1.3}/comtypes/_comobject.py

@@ -1,8 +1,21 @@
-from ctypes import *
-from comtypes.hresult import *
-
-import os
+from ctypes import (
+    FormatError, POINTER, Structure, WINFUNCTYPE, byref, c_long, c_void_p,
+    oledll, pointer, windll
+)
+from _ctypes import CopyComPointer
 import logging
+import os
+
+from comtypes import COMError, ReturnHRESULT, instancemethod, _encode_idl
+from comtypes.errorinfo import ISupportErrorInfo, ReportException, ReportError
+from comtypes import IPersist
+from comtypes.hresult import (
+    DISP_E_BADINDEX, DISP_E_MEMBERNOTFOUND, E_FAIL, E_NOINTERFACE,
+    E_INVALIDARG, E_NOTIMPL, RPC_E_CHANGED_MODE, S_FALSE, S_OK
+)
+from comtypes.typeinfo import IProvideClassInfo, IProvideClassInfo2
+
+
 logger = logging.getLogger(__name__)
 _debug = logger.debug
 _warning = logger.warning
@@ -10,12 +23,6 @@ _error = logger.error
 
 ################################################################
 # COM object implementation
-from _ctypes import CopyComPointer
-
-from comtypes import COMError, ReturnHRESULT, instancemethod, _encode_idl
-from comtypes.errorinfo import ISupportErrorInfo, ReportException, ReportError
-from comtypes.typeinfo import IProvideClassInfo, IProvideClassInfo2
-from comtypes import IPersist
 
 # so we don't have to import comtypes.automation
 DISPATCH_METHOD = 1
@@ -23,9 +30,11 @@ DISPATCH_PROPERTYGET = 2
 DISPATCH_PROPERTYPUT = 4
 DISPATCH_PROPERTYPUTREF = 8
 
+
 class E_NotImplemented(Exception):
     """COM method is not implemented"""
 
+
 def HRESULT_FROM_WIN32(errcode):
     "Convert a Windows error code into a HRESULT value."
     if errcode is None:
@@ -34,6 +43,7 @@ def HRESULT_FROM_WIN32(errcode):
         return errcode
     return (errcode & 0xFFFF) | 0x80070000
 
+
 def winerror(exc):
     """Return the windows error code from a WindowsError or COMError
     instance."""
@@ -48,34 +58,42 @@ def winerror(exc):
     # cases we return a generic error code.
     return E_FAIL
 
+
 def _do_implement(interface_name, method_name):
     def _not_implemented(*args):
         """Return E_NOTIMPL because the method is not implemented."""
-        _debug("unimplemented method %s_%s called", interface_name, method_name)
+        _debug("unimplemented method %s_%s called", interface_name,
+               method_name)
         return E_NOTIMPL
     return _not_implemented
 
+
 def catch_errors(obj, mth, paramflags, interface, mthname):
     clsid = getattr(obj, "_reg_clsid_", None)
+
     def call_with_this(*args, **kw):
         try:
             result = mth(*args, **kw)
         except ReturnHRESULT, err:
             (hresult, text) = err.args
-            return ReportError(text, iid=interface._iid_, clsid=clsid, hresult=hresult)
+            return ReportError(text, iid=interface._iid_, clsid=clsid,
+                               hresult=hresult)
         except (COMError, WindowsError), details:
-            _error("Exception in %s.%s implementation:", interface.__name__, mthname, exc_info=True)
+            _error("Exception in %s.%s implementation:", interface.__name__,
+                   mthname, exc_info=True)
             return HRESULT_FROM_WIN32(winerror(details))
         except E_NotImplemented:
-            _warning("Unimplemented method %s.%s called", interface.__name__, mthname)
+            _warning("Unimplemented method %s.%s called", interface.__name__,
+                     mthname)
             return E_NOTIMPL
         except:
-            _error("Exception in %s.%s implementation:", interface.__name__, mthname, exc_info=True)
+            _error("Exception in %s.%s implementation:", interface.__name__,
+                   mthname, exc_info=True)
             return ReportException(E_FAIL, interface._iid_, clsid=clsid)
         if result is None:
             return S_OK
         return result
-    if paramflags == None:
+    if paramflags is None:
         has_outargs = False
     else:
         has_outargs = bool([x[0] for x in paramflags
@@ -83,6 +101,7 @@ def catch_errors(obj, mth, paramflags, interface, mthname):
     call_with_this.has_outargs = has_outargs
     return call_with_this
 
+
 ################################################################
 
 def hack(inst, mth, paramflags, interface, mthname):
@@ -97,9 +116,9 @@ def hack(inst, mth, paramflags, interface, mthname):
     # direction flag is either exactly '0' or has the '1' bit set:
     # Output arguments have flag '2'
 
-    args_out_idx=[]
-    args_in_idx=[]
-    for i,a in enumerate(dirflags):
+    args_out_idx = []
+    args_in_idx = []
+    for i, a in enumerate(dirflags):
         if a&2:
             args_out_idx.append(i)
         if a&1 or a==0:
@@ -111,6 +130,7 @@ def hack(inst, mth, paramflags, interface, mthname):
 ##        return catch_errors(inst, mth, interface, mthname)
 
     clsid = getattr(inst, "_reg_clsid_", None)
+
     def call_without_this(this, *args):
         # Method implementations could check for and return E_POINTER
         # themselves.  Or an error will be raised when
@@ -120,7 +140,7 @@ def hack(inst, mth, paramflags, interface, mthname):
 ##                return E_POINTER
 
         #make argument list for handler by index array built above
-        inargs=[]
+        inargs = []
         for a in args_in_idx:
             inargs.append(args[a])
         try:
@@ -129,15 +149,18 @@ def hack(inst, mth, paramflags, interface, mthname):
                 args[args_out_idx[0]][0] = result
             elif args_out != 0:
                 if len(result) != args_out:
-                    raise ValueError("Method should have returned a %s-tuple" % args_out)
+                    msg = "Method should have returned a %s-tuple" % args_out
+                    raise ValueError(msg)
                 for i, value in enumerate(result):
                     args[args_out_idx[i]][0] = value
         except ReturnHRESULT, err:
             (hresult, text) = err.args
-            return ReportError(text, iid=interface._iid_, clsid=clsid, hresult=hresult)
+            return ReportError(text, iid=interface._iid_, clsid=clsid,
+                               hresult=hresult)
         except COMError, err:
             (hr, text, details) = err.args
-            _error("Exception in %s.%s implementation:", interface.__name__, mthname, exc_info=True)
+            _error("Exception in %s.%s implementation:", interface.__name__,
+                   mthname, exc_info=True)
             try:
                 descr, source, helpfile, helpcontext, progid = details
             except (ValueError, TypeError):
@@ -145,22 +168,27 @@ def hack(inst, mth, paramflags, interface, mthname):
             else:
                 msg = "%s: %s" % (source, descr)
             hr = HRESULT_FROM_WIN32(hr)
-            return ReportError(msg, iid=interface._iid_, clsid=clsid, hresult=hr)
+            return ReportError(msg, iid=interface._iid_, clsid=clsid,
+                               hresult=hr)
         except WindowsError, details:
-            _error("Exception in %s.%s implementation:", interface.__name__, mthname, exc_info=True)
+            _error("Exception in %s.%s implementation:", interface.__name__,
+                   mthname, exc_info=True)
             hr = HRESULT_FROM_WIN32(winerror(details))
             return ReportException(hr, interface._iid_, clsid=clsid)
         except E_NotImplemented:
-            _warning("Unimplemented method %s.%s called", interface.__name__, mthname)
+            _warning("Unimplemented method %s.%s called", interface.__name__,
+                     mthname)
             return E_NOTIMPL
         except:
-            _error("Exception in %s.%s implementation:", interface.__name__, mthname, exc_info=True)
+            _error("Exception in %s.%s implementation:", interface.__name__,
+                   mthname, exc_info=True)
             return ReportException(E_FAIL, interface._iid_, clsid=clsid)
         return S_OK
     if args_out:
         call_without_this.has_outargs = True
     return call_without_this
 
+
 class _MethodFinder(object):
     def __init__(self, inst):
         self.inst = inst
@@ -195,7 +223,7 @@ class _MethodFinder(object):
             return self.find_method(fq_name, mthname)
         except AttributeError:
             pass
-        propname = mthname[5:] # strip the '_get_' or '_set' prefix
+        propname = mthname[5:]  # strip the '_get_' or '_set' prefix
         if interface._case_insensitive_:
             propname = self.names.get(propname.lower(), propname)
         # propput and propget is done with 'normal' attribute access,
@@ -206,7 +234,8 @@ class _MethodFinder(object):
             return self.getter(propname)
         if "propput" in idlflags and len(paramflags) == 1:
             return self.setter(propname)
-        _debug("%r: %s.%s not implemented", self.inst, interface.__name__, mthname)
+        _debug("%r: %s.%s not implemented", self.inst, interface.__name__,
+               mthname)
         return None
 
     def setter(self, propname):
@@ -221,7 +250,6 @@ class _MethodFinder(object):
         return instancemethod(set, self.inst, type(self.inst))
 
     def getter(self, propname):
-        #
         def get(self):
             try:
                 return getattr(self, propname)
@@ -229,6 +257,7 @@ class _MethodFinder(object):
                 raise E_NotImplemented()
         return instancemethod(get, self.inst, type(self.inst))
 
+
 def _create_vtbl_type(fields, itf):
     try:
         return _vtbl_types[fields]
@@ -257,12 +286,14 @@ except AttributeError:
     _acquire = _lock.acquire
     _release = _lock.release
     # win 64 doesn't have these functions
+
     def _InterlockedIncrement(ob):
         _acquire()
         refcnt = ob.value + 1
         ob.value = refcnt
         _release()
         return refcnt
+
     def _InterlockedDecrement(ob):
         _acquire()
         refcnt = ob.value - 1
@@ -275,9 +306,11 @@ else:
     _InterlockedIncrement.restype = c_long
     _InterlockedDecrement.restype = c_long
 
+
 class LocalServer(object):
 
     _queue = None
+
     def run(self, classobjects):
         # Use windll instead of oledll so that we don't get an
         # exception on a FAILED hresult:
@@ -290,7 +323,8 @@ class LocalServer(object):
             # we're running in STA: need a message pump
             _debug("Server running in STA")
             if result >= 0:
-                # we need a matching CoUninitialize() call for a successful CoInitialize().
+                # we need a matching CoUninitialize() call for a successful
+                # CoInitialize().
                 windll.ole32.CoUninitialize()
             self.run_sta()
 
@@ -317,6 +351,7 @@ class LocalServer(object):
             else:
                 windll.user32.PostQuitMessage(0)
 
+
 class InprocServer(object):
 
     def __init__(self):
@@ -335,6 +370,7 @@ class InprocServer(object):
             return S_FALSE
         return S_OK
 
+
 class COMObject(object):
     _instances_ = {}
 
@@ -364,7 +400,8 @@ class COMObject(object):
         # - ISupportErrorInfo
         # - IPersist (if the subclass has a _reg_clsid_ attribute)
         # - IProvideClassInfo (if the subclass has a _reg_clsid_ attribute)
-        # - IProvideClassInfo2 (if the subclass has a _outgoing_interfaces_ attribute)
+        # - IProvideClassInfo2 (if the subclass has a _outgoing_interfaces_
+        #   attribute)
         #
         # Add these if they are not listed in _com_interfaces_.
         interfaces = tuple(self._com_interfaces_)
@@ -386,9 +423,9 @@ class COMObject(object):
             self.__make_interface_pointer(itf)
 
     def __make_interface_pointer(self, itf):
-        methods = [] # method implementations
-        fields = [] # (name, prototype) for virtual function table
-        iids = [] # interface identifiers.
+        methods = []  # method implementations
+        fields = []  # (name, prototype) for virtual function table
+        iids = []  # interface identifiers.
         # iterate over interface inheritance in reverse order to build the
         # virtual function table, and leave out the 'object' base class.
         finder = self._get_method_finder_(itf)
@@ -412,7 +449,8 @@ class COMObject(object):
                 # What we have:
                 #
                 # restypes is a ctypes type or None
-                # argspec is seq. of (['in'], paramtype, paramname) tuples (or lists?)
+                # argspec is seq. of (['in'], paramtype, paramname) tuples (or
+                # lists?)
                 #################
                 # What we need:
                 #
@@ -432,43 +470,46 @@ class COMObject(object):
 
                 if what == "DISPMETHOD":
                     if 'propget' in idlflags:
-                        invkind = 2 # DISPATCH_PROPERTYGET
+                        invkind = 2  # DISPATCH_PROPERTYGET
                         mthname = "_get_" + mthname
                     elif 'propput' in idlflags:
-                        invkind = 4 # DISPATCH_PROPERTYPUT
+                        invkind = 4  # DISPATCH_PROPERTYPUT
                         mthname = "_set_" + mthname
                     elif 'propputref' in idlflags:
-                        invkind = 8 # DISPATCH_PROPERTYPUTREF
+                        invkind = 8  # DISPATCH_PROPERTYPUTREF
                         mthname = "_setref_" + mthname
                     else:
-                        invkind = 1 # DISPATCH_METHOD
+                        invkind = 1  # DISPATCH_METHOD
                         if restype:
                             argspec = argspec + ((['out'], restype, ""),)
                     self.__make_dispentry(finder, interface, mthname,
                                           idlflags, argspec, invkind)
                 elif what == "DISPPROPERTY":
+                    # DISPPROPERTY have implicit "out"
+                    if restype:
+                        argspec += ((['out'], restype, ""),)
                     self.__make_dispentry(finder, interface,
                                           "_get_" + mthname,
                                           idlflags, argspec,
-                                          2 # DISPATCH_PROPERTYGET
+                                          2  # DISPATCH_PROPERTYGET
                                           )
                     if not 'readonly' in idlflags:
                         self.__make_dispentry(finder, interface,
                                               "_set_" + mthname,
                                               idlflags, argspec,
-                                              4) # DISPATCH_PROPERTYPUT
+                                              4)  # DISPATCH_PROPERTYPUT
                         # Add DISPATCH_PROPERTYPUTREF also?
 
-
     def __make_dispentry(self,
                          finder, interface, mthname,
                          idlflags, argspec, invkind):
         # We build a _dispmap_ entry now that maps invkind and
         # dispid to implementations that the finder finds;
         # IDispatch_Invoke will later call it.
-        paramflags = [((_encode_idl(x[0]), x[1]) + tuple(x[3:])) for x in argspec]
-
-        dispid = idlflags[0] # XXX can the dispid be at a different index?  Check codegenerator.
+        paramflags = [((_encode_idl(x[0]), x[1]) + tuple(x[3:]))
+                      for x in argspec]
+        # XXX can the dispid be at a different index?  Check codegenerator.
+        dispid = idlflags[0]
         impl = finder.get_impl(interface, mthname, paramflags, idlflags)
         self._dispimpl_[(dispid, invkind)] = impl
         # invkind is really a set of flags; we allow both
@@ -485,7 +526,8 @@ class COMObject(object):
     ################################################################
     # LocalServer / InprocServer stuff
     __server__ = None
-##2.3    @staticmethod
+
+    @staticmethod
     def __run_inprocserver__():
         if COMObject.__server__ is None:
             COMObject.__server__ = InprocServer()
@@ -493,37 +535,35 @@ class COMObject(object):
             pass
         else:
             raise RuntimeError("Wrong server type")
-    __run_inprocserver__ = staticmethod(__run_inprocserver__)
 
-##2.3    @staticmethod
+    @staticmethod
     def __run_localserver__(classobjects):
         assert COMObject.__server__ is None
         # XXX Decide whether we are in STA or MTA
         server = COMObject.__server__ = LocalServer()
         server.run(classobjects)
         COMObject.__server__ = None
-    __run_localserver__ = staticmethod(__run_localserver__)
 
-##2.3    @staticmethod
+    @staticmethod
     def __keep__(obj):
         COMObject._instances_[obj] = None
-        _debug("%d active COM objects: Added   %r", len(COMObject._instances_), obj)
+        _debug("%d active COM objects: Added   %r", len(COMObject._instances_),
+               obj)
         if COMObject.__server__:
             COMObject.__server__.Lock()
-    __keep__ = staticmethod(__keep__)
 
-##2.3    @staticmethod
+    @staticmethod
     def __unkeep__(obj):
         try:
             del COMObject._instances_[obj]
         except AttributeError:
             _debug("? active COM objects: Removed %r", obj)
         else:
-            _debug("%d active COM objects: Removed %r", len(COMObject._instances_), obj)
+            _debug("%d active COM objects: Removed %r",
+                   len(COMObject._instances_), obj)
         _debug("Remaining: %s", COMObject._instances_.keys())
         if COMObject.__server__:
             COMObject.__server__.Unlock()
-    __unkeep__ = staticmethod(__unkeep__)
     #
     ################################################################
 
@@ -545,7 +585,7 @@ class COMObject(object):
 
     def IUnknown_Release(self, this,
                          __InterlockedDecrement=_InterlockedDecrement,
-                        _debug=_debug):
+                         _debug=_debug):
         # If this is called at COM shutdown, _InterlockedDecrement()
         # must still be available, although module level variables may
         # have been deleted already - so we supply it as default
@@ -559,8 +599,7 @@ class COMObject(object):
             self._com_pointers_ = {}
         return result
 
-    def IUnknown_QueryInterface(self, this, riid, ppvObj,
-                        _debug=_debug):
+    def IUnknown_QueryInterface(self, this, riid, ppvObj, _debug=_debug):
         # XXX This is probably too slow.
         # riid[0].hashcode() alone takes 33 us!
         iid = riid[0]
@@ -614,13 +653,12 @@ class COMObject(object):
 
     ################################################################
     # IDispatch methods
-##2.3    @property
+    @property
     def __typeinfo(self):
         # XXX Looks like this better be a static property, set by the
         # code that sets __typelib also...
         iid = self._com_interfaces_[0]._iid_
         return self.__typelib.GetTypeInfoOfGuid(iid)
-    __typeinfo = property(__typeinfo)
 
     def IDispatch_GetTypeInfoCount(self):
         try:
@@ -639,7 +677,8 @@ class COMObject(object):
         except AttributeError:
             return E_NOTIMPL
 
-    def IDispatch_GetIDsOfNames(self, this, riid, rgszNames, cNames, lcid, rgDispId):
+    def IDispatch_GetIDsOfNames(self, this, riid, rgszNames, cNames, lcid,
+                                rgDispId):
         # This call uses windll instead of oledll so that a failed
         # call to DispGetIDsOfNames will return a HRESULT instead of
         # raising an error.
@@ -669,10 +708,10 @@ class COMObject(object):
             # an error.
             interface = self._com_interfaces_[0]
             ptr = self._com_pointers_[interface._iid_]
-            return windll.oleaut32.DispInvoke(ptr,
-                                              tinfo,
-                                              dispIdMember, wFlags, pDispParams,
-                                              pVarResult, pExcepInfo, puArgErr)
+            return windll.oleaut32.DispInvoke(
+                ptr, tinfo, dispIdMember, wFlags, pDispParams, pVarResult,
+                pExcepInfo, puArgErr
+            )
 
         try:
             # XXX Hm, wFlags should be considered a SET of flags...
@@ -699,11 +738,8 @@ class COMObject(object):
             # How are the parameters unpacked for propertyput
             # operations with additional parameters?  Can propput
             # have additional args?
-            #
-            # 2to3 has problems to translate 'range(...)[::-1]'
-            # correctly, so use 'list(range)[::-1]' instead (will be
-            # fixed in Python 3.1, probably):
-            args = [params.rgvarg[i].value for i in list(range(params.cNamedArgs))[::-1]]
+            args = [params.rgvarg[i].value
+                    for i in reversed(range(params.cNamedArgs))]
             # MSDN: pVarResult is ignored if DISPATCH_PROPERTYPUT or
             # DISPATCH_PROPERTYPUTREF is specified.
             return mth(this, *args)
@@ -716,13 +752,15 @@ class COMObject(object):
             # 2to3 has problems to translate 'range(...)[::-1]'
             # correctly, so use 'list(range)[::-1]' instead (will be
             # fixed in Python 3.1, probably):
-            named_indexes = [params.rgdispidNamedArgs[i] for i in range(params.cNamedArgs)]
+            named_indexes = [params.rgdispidNamedArgs[i]
+                             for i in range(params.cNamedArgs)]
             # the positions of unnamed arguments
-            unnamed_indexes = list(range(params.cArgs - params.cNamedArgs))[::-1]
+            num_unnamed = params.cArgs - params.cNamedArgs
+            unnamed_indexes = list(reversed(range(num_unnamed)))
             # It seems that this code calculates the indexes of the
             # parameters in the params.rgvarg array correctly.
             indexes = named_indexes + unnamed_indexes
-            args = [params.rgvarg[i].value for i in named_indexes + unnamed_indexes]
+            args = [params.rgvarg[i].value for i in indexes]
 
             if pVarResult and getattr(mth, "has_outargs", False):
                 args.append(pVarResult)

{comtypes-1.1.0 → comtypes-1.1.3}/comtypes/automation.py

@@ -218,7 +218,8 @@ class tagVARIANT(Structure):
         _VariantClear(self)
         if value is None:
             self.vt = VT_NULL
-        elif hasattr(value, '__len__') and len(value) == 0:
+        elif (hasattr(value, '__len__') and len(value) == 0
+                and not isinstance(value, basestring)):
             self.vt = VT_NULL
         # since bool is a subclass of int, this check must come before
         # the check for int
@@ -857,6 +858,9 @@ _ctype_to_vartype = {
     # such an array cannot be created.
     POINTER(VARIANT): VT_BYREF|VT_VARIANT,
 
+    # This is needed to import Esri ArcObjects (esriSystem.olb).
+    POINTER(BSTR): VT_BYREF|VT_BSTR,
+
     # These are not yet implemented:
 ##    POINTER(IUnknown): VT_UNKNOWN,
 ##    POINTER(IDispatch): VT_DISPATCH,

{comtypes-1.1.0 → comtypes-1.1.3}/comtypes/client/_code_cache.py

@@ -108,7 +108,7 @@ def _is_writeable(path):
         return False
     try:
         tempfile.TemporaryFile(dir=path[0])
-    except OSError, details:
+    except (OSError, IOError), details:
         logger.debug("Path is unwriteable: %s", details)
         return False
     return True

{comtypes-1.1.0 → comtypes-1.1.3}/comtypes/npsupport.py

@@ -11,6 +11,7 @@ HAVE_NUMPY = numpy is not None
 
 is_64bits = sys.maxsize > 2**32
 
+
 def _make_variant_dtype():
     """ Create a dtype for VARIANT. This requires support for Unions, which is
     available in numpy version 1.7 or greater.
@@ -32,14 +33,14 @@ def _make_variant_dtype():
     # overlapping typecodes only allowed in numpy version 1.7 or greater
     U_VARIANT_format = dict(
         names=[
-        'VT_BOOL', 'VT_I1', 'VT_I2', 'VT_I4', 'VT_I8', 'VT_INT', 'VT_UI1',
-        'VT_UI2', 'VT_UI4', 'VT_UI8', 'VT_UINT', 'VT_R4', 'VT_R8', 'VT_CY',
-        'c_wchar_p', 'c_void_p', 'pparray', 'bstrVal', '_tagBRECORD',
+            'VT_BOOL', 'VT_I1', 'VT_I2', 'VT_I4', 'VT_I8', 'VT_INT', 'VT_UI1',
+            'VT_UI2', 'VT_UI4', 'VT_UI8', 'VT_UINT', 'VT_R4', 'VT_R8', 'VT_CY',
+            'c_wchar_p', 'c_void_p', 'pparray', 'bstrVal', '_tagBRECORD',
         ],
         formats=[
-        '<i2', '<i1', '<i2', '<i4', '<i8', '<i4', '<u1', '<u2', '<u4', '<u8',
-        '<u4', '<f4', '<f8', '<i8', ptr_typecode, ptr_typecode, ptr_typecode,
-        ptr_typecode, _tagBRECORD_format,
+            '<i2', '<i1', '<i2', '<i4', '<i8', '<i4', '<u1', '<u2', '<u4',
+            '<u8', '<u4', '<f4', '<f8', '<i8', ptr_typecode, ptr_typecode,
+            ptr_typecode, ptr_typecode, _tagBRECORD_format,
         ],
         offsets=[0] * 19  # This is what makes it a union
     )
@@ -72,9 +73,15 @@ def isdatetime64(value):
     This cannot succeed if datetime64 is not available.
 
     """
+    if not HAVE_NUMPY:
+        return False
     return isinstance(value, datetime64)
 
 
+com_null_date64 = None
+datetime64 = None
+VARIANT_dtype = None
+
 if HAVE_NUMPY:
 
     # dtype for VARIANT. This allows for packing of variants into an array, and
@@ -82,18 +89,16 @@ if HAVE_NUMPY:
     try:
         VARIANT_dtype = _make_variant_dtype()
     except ValueError:
-        VARIANT_dtype = None
+        pass
 
     # This simplifies dependent modules
     try:
         from numpy import datetime64
     except ImportError:
-        datetime64 = None
-        com_null_date64 = None
+        pass
     else:
-        com_null_date64 = datetime64("1899-12-30T00:00:00", "ns")
-
-else:
-
-    VARIANT_dtype = None
-    datetime64 = None
+        try:
+            # This does not work on numpy 1.6
+            com_null_date64 = datetime64("1899-12-30T00:00:00", "ns")
+        except TypeError:
+            pass