home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_704 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  32.0 KB  |  1,041 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import string
  5. import exceptions
  6. import time
  7. import calendar
  8. import types
  9. import sys
  10. import traceback
  11. import datetime
  12.  
  13. try:
  14.     import decimal
  15. except ImportError:
  16.     import win32com.decimal_23 as decimal
  17.  
  18.  
  19. try:
  20.     import win32com.client as win32com
  21.     
  22.     def Dispatch(dispatch):
  23.         return win32com.client.Dispatch(dispatch)
  24.  
  25.     win32 = True
  26. except ImportError:
  27.     from System import Activator, Type
  28.     
  29.     def Dispatch(dispatch):
  30.         type = Type.GetTypeFromProgID(dispatch)
  31.         return Activator.CreateInstance(type)
  32.  
  33.     win32 = False
  34.  
  35. if win32:
  36.     import pythoncom
  37.     pythoncom.__future_currency__ = True
  38.  
  39.  
  40. def standardErrorHandler(connection, cursor, errorclass, errorvalue):
  41.     err = (errorclass, errorvalue)
  42.     connection.messages.append(err)
  43.     if cursor != None:
  44.         cursor.messages.append(err)
  45.     
  46.     raise errorclass(errorvalue)
  47.  
  48.  
  49. class TimeConverter:
  50.     
  51.     def __init__(self):
  52.         self.types = (type(self.Date(2000, 1, 1)), type(self.Time(12, 1, 1)), type(self.Timestamp(2000, 1, 1, 12, 1, 1)))
  53.  
  54.     
  55.     def COMDate(self, obj):
  56.         raise 'Abstract class'
  57.  
  58.     
  59.     def DateObjectFromCOMDate(self, comDate):
  60.         raise 'Abstract class'
  61.  
  62.     
  63.     def Date(self, year, month, day):
  64.         raise 'Abstract class'
  65.  
  66.     
  67.     def Time(self, hour, minute, second):
  68.         raise 'Abstract class'
  69.  
  70.     
  71.     def Timestamp(self, year, month, day, hour, minute, second):
  72.         raise 'Abstract class'
  73.  
  74.     
  75.     def DateObjectToIsoFormatString(self, obj):
  76.         raise 'Abstract class'
  77.  
  78.  
  79.  
  80. class mxDateTimeConverter(TimeConverter):
  81.     
  82.     def COMDate(self, obj):
  83.         return obj.COMDate()
  84.  
  85.     
  86.     def DateObjectFromCOMDate(self, comDate):
  87.         return mx.DateTime.DateTimeFromCOMDate(comDate)
  88.  
  89.     
  90.     def Date(self, year, month, day):
  91.         return mx.DateTime.Date(year, month, day)
  92.  
  93.     
  94.     def Time(self, hour, minute, second):
  95.         return mx.DateTime.Time(hour, minute, second)
  96.  
  97.     
  98.     def Timestamp(self, year, month, day, hour, minute, second):
  99.         return mx.DateTime.Timestamp(year, month, day, hour, minute, second)
  100.  
  101.     
  102.     def DateObjectToIsoFormatString(self, obj):
  103.         return obj.Format('%Y-%m-%d %H:%M:%S')
  104.  
  105.  
  106.  
  107. class pythonDateTimeConverter(TimeConverter):
  108.     
  109.     def __init__(self):
  110.         self._ordinal_1899_12_31 = datetime.date(1899, 12, 31).toordinal() - 1
  111.         TimeConverter.__init__(self)
  112.  
  113.     
  114.     def COMDate(self, obj):
  115.         tt = obj.timetuple()
  116.         
  117.         try:
  118.             ms = obj.microsecond
  119.         except:
  120.             ms = 0
  121.  
  122.         YMDHMSmsTuple = tuple(tt[:6] + (ms,))
  123.         return self.COMDateFromTuple(YMDHMSmsTuple)
  124.  
  125.     
  126.     def DateObjectFromCOMDate(self, comDate):
  127.         fComDate = float(comDate)
  128.         millisecondsperday = 86400000
  129.         integerPart = int(fComDate)
  130.         floatpart = fComDate - integerPart
  131.         if floatpart == 0:
  132.             return datetime.date.fromordinal(integerPart + self._ordinal_1899_12_31)
  133.         dte = datetime.datetime.fromordinal(integerPart + self._ordinal_1899_12_31)
  134.         dte = dte + datetime.timedelta(milliseconds = floatpart * millisecondsperday)
  135.         return dte
  136.  
  137.     
  138.     def Date(self, year, month, day):
  139.         return datetime.date(year, month, day)
  140.  
  141.     
  142.     def Time(self, hour, minute, second):
  143.         return datetime.time(hour, minute, second)
  144.  
  145.     
  146.     def Timestamp(self, year, month, day, hour, minute, second):
  147.         return datetime.datetime(year, month, day, hour, minute, second)
  148.  
  149.     
  150.     def COMDateFromTuple(self, YMDHMSmsTuple):
  151.         t = pythoncom.MakeTime(YMDHMSmsTuple)
  152.         return float(t)
  153.  
  154.     
  155.     def DateObjectToIsoFormatString(self, obj):
  156.         if isinstance(obj, datetime.datetime):
  157.             s = obj.strftime('%Y-%m-%d %H:%M:%S')
  158.         else:
  159.             
  160.             try:
  161.                 s = obj.isoformat()
  162.             except:
  163.                 s = obj.Format('%Y-%m-%d %H:%M:%S')
  164.  
  165.         return s
  166.  
  167.  
  168.  
  169. class pythonTimeConverter(TimeConverter):
  170.     
  171.     def __init__(self):
  172.         (year, month, day, hour, minute, second, weekday, julianday, daylightsaving) = time.gmtime(0)
  173.         self.com1970 = self.COMDateFromTuple((year, month, day, hour, minute, second))
  174.         daysInMonth = [
  175.             31,
  176.             28,
  177.             31,
  178.             30,
  179.             31,
  180.             30,
  181.             31,
  182.             30,
  183.             31,
  184.             30,
  185.             31,
  186.             30]
  187.         cumulative = 0
  188.         self.monthCumDays = { }
  189.         for i in range(12):
  190.             self.monthCumDays[i + 1] = cumulative
  191.             cumulative += daysInMonth[i]
  192.         
  193.         TimeConverter.__init__(self)
  194.  
  195.     
  196.     def COMDate(self, timeobj):
  197.         return float(pythoncom.MakeTime(time.mktime(timeobj)))
  198.  
  199.     
  200.     def COMDateFromTuple(self, YMDHMSmsTuple):
  201.         t = pythoncom.MakeTime(YMDHMSmsTuple)
  202.         return float(t)
  203.  
  204.     
  205.     def DateObjectFromCOMDate(self, comDate):
  206.         secondsperday = 86400
  207.         t = time.gmtime(secondsperday * (float(comDate) - self.com1970))
  208.         return t
  209.  
  210.     
  211.     def Date(self, year, month, day):
  212.         return self.Timestamp(year, month, day, 0, 0, 0)
  213.  
  214.     
  215.     def Time(self, hour, minute, second):
  216.         return time.gmtime((hour * 60 + minute) * 60 + second)
  217.  
  218.     
  219.     def Timestamp(self, year, month, day, hour, minute, second):
  220.         julian = self.monthCumDays[month] + day
  221.         if month > 2:
  222.             julian += calendar.isleap(year)
  223.         
  224.         weekday = calendar.weekday(year, month, day)
  225.         daylightsaving = -1
  226.         return time.localtime(time.mktime((year, month, day, hour, minute, second, weekday, julian, daylightsaving)))
  227.  
  228.     
  229.     def DateObjectToIsoFormatString(self, obj):
  230.         
  231.         try:
  232.             s = time.strftime('%Y-%m-%d %H:%M:%S', obj)
  233.         except:
  234.             s = obj.strftime('%Y-%m-%d')
  235.  
  236.         return s
  237.  
  238.  
  239.  
  240. class Error(exceptions.StandardError):
  241.     pass
  242.  
  243.  
  244. class Warning(exceptions.StandardError):
  245.     pass
  246.  
  247.  
  248. class InterfaceError(Error):
  249.     pass
  250.  
  251.  
  252. class DatabaseError(Error):
  253.     pass
  254.  
  255.  
  256. class InternalError(DatabaseError):
  257.     pass
  258.  
  259.  
  260. class OperationalError(DatabaseError):
  261.     pass
  262.  
  263.  
  264. class ProgrammingError(DatabaseError):
  265.     pass
  266.  
  267.  
  268. class IntegrityError(DatabaseError):
  269.     pass
  270.  
  271.  
  272. class DataError(DatabaseError):
  273.     pass
  274.  
  275.  
  276. class NotSupportedError(DatabaseError):
  277.     pass
  278.  
  279. verbose = False
  280. version = __doc__.split('-', 2)[0]
  281.  
  282. def connect(connstr, timeout = 30):
  283.     
  284.     try:
  285.         conn = Dispatch('ADODB.Connection')
  286.         if win32:
  287.             pythoncom.CoInitialize()
  288.     except:
  289.         raise InterfaceError
  290.  
  291.     
  292.     try:
  293.         conn.CommandTimeout = timeout
  294.         conn.ConnectionString = connstr
  295.     except:
  296.         raise Error
  297.  
  298.     if verbose:
  299.         print '%s attempting: "%s"' % (version, connstr)
  300.     
  301.     
  302.     try:
  303.         conn.Open()
  304.     except Exception:
  305.         e = None
  306.         raise DatabaseError(e)
  307.  
  308.     return Connection(conn)
  309.  
  310. apilevel = '2.0'
  311. threadsafety = 1
  312. paramstyle = 'qmark'
  313. adXactBrowse = 256
  314. adXactChaos = 16
  315. adXactCursorStability = 4096
  316. adXactIsolated = 1048576
  317. adXactReadCommitted = 4096
  318. adXactReadUncommitted = 256
  319. adXactRepeatableRead = 65536
  320. adXactSerializable = 1048576
  321. defaultIsolationLevel = adXactReadCommitted
  322. adUseClient = 3
  323. adUseServer = 2
  324. defaultCursorLocation = adUseServer
  325.  
  326. class Connection:
  327.     
  328.     def __init__(self, adoConn):
  329.         self.adoConn = adoConn
  330.         self.supportsTransactions = False
  331.         for indx in range(adoConn.Properties.Count):
  332.             if adoConn.Properties(indx).Name == 'Transaction DDL' and adoConn.Properties(indx).Value != 0:
  333.                 self.supportsTransactions = True
  334.                 continue
  335.         
  336.         self.adoConn.CursorLocation = defaultCursorLocation
  337.         if self.supportsTransactions:
  338.             self.adoConn.IsolationLevel = defaultIsolationLevel
  339.             self.adoConn.BeginTrans()
  340.         
  341.         self.errorhandler = None
  342.         self.messages = []
  343.         if verbose:
  344.             print 'adodbapi New connection at %X' % id(self)
  345.         
  346.  
  347.     
  348.     def _raiseConnectionError(self, errorclass, errorvalue):
  349.         eh = self.errorhandler
  350.         if eh == None:
  351.             eh = standardErrorHandler
  352.         
  353.         eh(self, None, errorclass, errorvalue)
  354.  
  355.     
  356.     def _closeAdoConnection(self):
  357.         if self.supportsTransactions:
  358.             self.adoConn.RollbackTrans()
  359.         
  360.         self.adoConn.Close()
  361.         if verbose:
  362.             print 'adodbapi Closed connection at %X' % id(self)
  363.         
  364.  
  365.     
  366.     def close(self):
  367.         self.messages = []
  368.         
  369.         try:
  370.             self._closeAdoConnection()
  371.         except Exception:
  372.             e = None
  373.             self._raiseConnectionError(InternalError, e)
  374.  
  375.         if win32:
  376.             pythoncom.CoUninitialize()
  377.         
  378.  
  379.     
  380.     def commit(self):
  381.         self.messages = []
  382.         
  383.         try:
  384.             if self.supportsTransactions:
  385.                 self.adoConn.CommitTrans()
  386.                 if not self.adoConn.Attributes & adXactCommitRetaining:
  387.                     self.adoConn.BeginTrans()
  388.                 
  389.         except Exception:
  390.             e = None
  391.             self._raiseConnectionError(Error, e)
  392.  
  393.  
  394.     
  395.     def rollback(self):
  396.         self.messages = []
  397.         if self.supportsTransactions:
  398.             self.adoConn.RollbackTrans()
  399.             if not self.adoConn.Attributes & adXactAbortRetaining:
  400.                 self.adoConn.BeginTrans()
  401.             
  402.         else:
  403.             self._raiseConnectionError(NotSupportedError, None)
  404.  
  405.     
  406.     def cursor(self):
  407.         self.messages = []
  408.         return Cursor(self)
  409.  
  410.     
  411.     def printADOerrors(self):
  412.         j = self.adoConn.Errors.Count
  413.         print 'ADO Errors:(%i)' % j
  414.         for i in range(j):
  415.             e = self.adoConn.Errors(i)
  416.             print 'Description: %s' % e.Description
  417.             print 'Number: %s ' % e.Number
  418.             
  419.             try:
  420.                 print 'Number constant:' % adoErrors[e.Number]
  421.             except:
  422.                 pass
  423.  
  424.             print 'Source: %s' % e.Source
  425.             print 'NativeError: %s' % e.NativeError
  426.             print 'SQL State: %s' % e.SQLState
  427.             if e.Number == -2147217871:
  428.                 print ' Error means that the Query timed out.\n Try using adodbpi.connect(constr,timeout=Nseconds)'
  429.                 continue
  430.         
  431.  
  432.     
  433.     def __del__(self):
  434.         
  435.         try:
  436.             self._closeAdoConnection()
  437.         except:
  438.             pass
  439.  
  440.         self.adoConn = None
  441.  
  442.  
  443.  
  444. class Cursor:
  445.     description = None
  446.     rowcount = -1
  447.     arraysize = 1
  448.     
  449.     def __init__(self, connection):
  450.         self.messages = []
  451.         self.conn = connection
  452.         self.rs = None
  453.         self.description = None
  454.         self.errorhandler = connection.errorhandler
  455.         if verbose:
  456.             print 'adodbapi New cursor at %X on conn %X' % (id(self), id(self.conn))
  457.         
  458.  
  459.     
  460.     def __iter__(self):
  461.         return iter(self.fetchone, None)
  462.  
  463.     
  464.     def _raiseCursorError(self, errorclass, errorvalue):
  465.         eh = self.errorhandler
  466.         if eh == None:
  467.             eh = standardErrorHandler
  468.         
  469.         eh(self.conn, self, errorclass, errorvalue)
  470.  
  471.     
  472.     def callproc(self, procname, parameters = None):
  473.         self.messages = []
  474.         return self._executeHelper(procname, True, parameters)
  475.  
  476.     
  477.     def _returnADOCommandParameters(self, adoCommand):
  478.         retLst = []
  479.         for i in range(adoCommand.Parameters.Count):
  480.             p = adoCommand.Parameters(i)
  481.             if verbose > 2:
  482.                 ('return', p.Name, p.Type, p.Direction, repr(p.Value))
  483.             
  484.             type_code = p.Type
  485.             pyObject = convertVariantToPython(p.Value, type_code)
  486.             if p.Direction == adParamReturnValue:
  487.                 self.returnValue = pyObject
  488.                 continue
  489.             retLst.append(pyObject)
  490.         
  491.         return retLst
  492.  
  493.     
  494.     def _makeDescriptionFromRS(self, rs):
  495.         if rs == None or rs.State == adStateClosed:
  496.             self.rs = None
  497.             self.description = None
  498.         else:
  499.             self.rowcount = -1
  500.             self.rs = rs
  501.             nOfFields = rs.Fields.Count
  502.             self.description = []
  503.             for i in range(nOfFields):
  504.                 f = rs.Fields(i)
  505.                 name = f.Name
  506.                 type_code = f.Type
  507.                 if not rs.EOF or rs.BOF:
  508.                     display_size = f.ActualSize
  509.                 else:
  510.                     display_size = None
  511.                 internal_size = f.DefinedSize
  512.                 precision = f.Precision
  513.                 scale = f.NumericScale
  514.                 null_ok = bool(f.Attributes & adFldMayBeNull)
  515.                 self.description.append((name, type_code, display_size, internal_size, precision, scale, null_ok))
  516.             
  517.  
  518.     
  519.     def close(self):
  520.         self.messages = []
  521.         self.conn = None
  522.         if self.rs and self.rs.State != adStateClosed:
  523.             self.rs.Close()
  524.             self.rs = None
  525.         
  526.  
  527.     
  528.     def _executeHelper(self, operation, isStoredProcedureCall, parameters = None):
  529.         if self.conn == None:
  530.             self._raiseCursorError(Error, None)
  531.             return None
  532.         returnValueIndex = None
  533.         parmIndx = -1
  534.         
  535.         try:
  536.             self.cmd = Dispatch('ADODB.Command')
  537.             self.cmd.ActiveConnection = self.conn.adoConn
  538.             self.cmd.CommandTimeout = self.conn.adoConn.CommandTimeout
  539.             self.cmd.CommandText = operation
  540.             if isStoredProcedureCall:
  541.                 self.cmd.CommandType = adCmdStoredProc
  542.             else:
  543.                 self.cmd.CommandType = adCmdText
  544.             returnValueIndex = -1
  545.             if parameters != None:
  546.                 
  547.                 try:
  548.                     self.cmd.Parameters.Refresh()
  549.                     defaultParameterList = False
  550.                 except:
  551.                     if verbose:
  552.                         print 'error in COM Refresh(). adodbapi building default parameter list'
  553.                     
  554.                     defaultParameterList = True
  555.                     for i, elem in enumerate(parameters):
  556.                         name = 'p%i' % i
  557.                         adotype = pyTypeToADOType(elem)
  558.                         p = self.cmd.CreateParameter(name, adotype)
  559.                         if isStoredProcedureCall:
  560.                             p.Direction = adParamUnknown
  561.                         
  562.                         self.cmd.Parameters.Append(p)
  563.                     
  564.  
  565.                 if verbose > 2:
  566.                     for i in range(self.cmd.Parameters.Count):
  567.                         P = self.cmd.Parameters(i)
  568.                         print 'adodbapi parameter attributes before=', P.Name, P.Type, P.Direction, P.Size
  569.                     
  570.                 
  571.                 if isStoredProcedureCall:
  572.                     cnt = self.cmd.Parameters.Count
  573.                     if cnt != len(parameters):
  574.                         for i in range(cnt):
  575.                             if self.cmd.Parameters(i).Direction == adParamReturnValue:
  576.                                 returnValueIndex = i
  577.                                 break
  578.                                 continue
  579.                         
  580.                     
  581.                 
  582.                 for elem in parameters:
  583.                     parmIndx += 1
  584.                     if parmIndx == returnValueIndex:
  585.                         parmIndx += 1
  586.                     
  587.                     p = self.cmd.Parameters(parmIndx)
  588.                     if p.Direction in [
  589.                         adParamInput,
  590.                         adParamInputOutput,
  591.                         adParamUnknown]:
  592.                         tp = type(elem)
  593.                         if tp in dateconverter.types:
  594.                             if not defaultParameterList and p.Type in adoDateTimeTypes:
  595.                                 p.Value = dateconverter.COMDate(elem)
  596.                             else:
  597.                                 s = dateconverter.DateObjectToIsoFormatString(elem)
  598.                                 p.Value = s
  599.                                 p.Size = len(s)
  600.                         elif tp in types.StringTypes:
  601.                             if defaultParameterList:
  602.                                 p.Value = elem
  603.                                 L = len(elem)
  604.                             else:
  605.                                 L = min(len(elem), p.Size)
  606.                                 p.Value = elem[:L]
  607.                             if L > 0:
  608.                                 p.Size = L
  609.                             
  610.                         elif tp == types.BufferType:
  611.                             p.Size = len(elem)
  612.                             p.AppendChunk(elem)
  613.                         else:
  614.                             p.Value = elem
  615.                         if verbose > 2:
  616.                             print 'Parameter %d type %d stored as: %s' % (parmIndx, p.Type, repr(p.Value))
  617.                         
  618.                     verbose > 2
  619.                 
  620.             
  621.             parmIndx = -2
  622.             adoRetVal = self.cmd.Execute()
  623.         except Exception:
  624.             None if verbose > 1 and parameters else self.conn == None
  625.             e = None if verbose > 1 and parameters else self.conn == None
  626.             tbk = u'\n--ADODBAPI\n'
  627.             if parmIndx >= 0:
  628.                 tbk += u'-- Trying parameter %d = %s\n' % (parmIndx, repr(parameters[parmIndx]))
  629.             
  630.             tblist = traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, 8)
  631.             tb = string.join(tblist)
  632.             tracebackhistory = tbk + tb + u'-- on command: "%s"\n-- with parameters: %s' % (operation, parameters)
  633.             self._raiseCursorError(DatabaseError, tracebackhistory)
  634.             return None
  635.  
  636.         rs = adoRetVal[0]
  637.         recs = adoRetVal[1]
  638.         self.rowcount = recs
  639.         self._makeDescriptionFromRS(rs)
  640.         if isStoredProcedureCall and parameters != None:
  641.             return self._returnADOCommandParameters(self.cmd)
  642.  
  643.     
  644.     def execute(self, operation, parameters = None):
  645.         self.messages = []
  646.         self._executeHelper(operation, False, parameters)
  647.  
  648.     
  649.     def executemany(self, operation, seq_of_parameters):
  650.         self.messages = []
  651.         totrecordcount = 0
  652.         canCount = True
  653.         for params in seq_of_parameters:
  654.             self.execute(operation, params)
  655.             if self.rowcount == -1:
  656.                 canCount = False
  657.                 continue
  658.             if canCount:
  659.                 totrecordcount += self.rowcount
  660.                 continue
  661.         
  662.         if canCount:
  663.             self.rowcount = totrecordcount
  664.         else:
  665.             self.rowcount = -1
  666.  
  667.     
  668.     def _fetch(self, rows = None):
  669.         rs = self.rs
  670.         if self.conn == None:
  671.             self._raiseCursorError(Error, None)
  672.             return None
  673.         if rs == None:
  674.             self._raiseCursorError(Error, None)
  675.             return None
  676.         if rs.State == adStateClosed and rs.BOF or rs.EOF:
  677.             if rows == 1:
  678.                 return None
  679.             return []
  680.         rs.EOF
  681.         d = self.description
  682.         returnList = []
  683.         i = 0
  684.         for descTuple in d:
  685.             type_code = descTuple[1]
  686.             []([ convertVariantToPython(r, type_code) for r in ado_results[i] ])
  687.             i += 1
  688.         
  689.         return tuple(zip(*returnList))
  690.  
  691.     
  692.     def fetchone(self):
  693.         self.messages = []
  694.         ret = self._fetch(1)
  695.         if ret:
  696.             return ret[0]
  697.         return ret
  698.  
  699.     
  700.     def fetchmany(self, size = None):
  701.         self.messages = []
  702.         if size == None:
  703.             size = self.arraysize
  704.         
  705.         return self._fetch(size)
  706.  
  707.     
  708.     def fetchall(self):
  709.         self.messages = []
  710.         return self._fetch()
  711.  
  712.     
  713.     def nextset(self):
  714.         self.messages = []
  715.         if self.conn == None:
  716.             self._raiseCursorError(Error, None)
  717.             return None
  718.         if self.rs == None:
  719.             self._raiseCursorError(Error, None)
  720.             return None
  721.         
  722.         try:
  723.             rsTuple = self.rs.NextRecordset()
  724.         except pywintypes.com_error:
  725.             self.rs == None
  726.             exc = self.rs == None
  727.             self.conn == None
  728.             self._raiseCursorError(NotSupportedError, exc.args)
  729.         except:
  730.             self.rs == None
  731.  
  732.         rs = rsTuple[0]
  733.         if rs == None:
  734.             return None
  735.         self._makeDescriptionFromRS(rs)
  736.         return 1
  737.  
  738.     
  739.     def setinputsizes(self, sizes):
  740.         pass
  741.  
  742.     
  743.     def setoutputsize(self, size, column = None):
  744.         pass
  745.  
  746.  
  747.  
  748. def Date(year, month, day):
  749.     return dateconverter.Date(year, month, day)
  750.  
  751.  
  752. def Time(hour, minute, second):
  753.     return dateconverter.Time(hour, minute, second)
  754.  
  755.  
  756. def Timestamp(year, month, day, hour, minute, second):
  757.     return dateconverter.Timestamp(year, month, day, hour, minute, second)
  758.  
  759.  
  760. def DateFromTicks(ticks):
  761.     return apply(Date, time.localtime(ticks)[:3])
  762.  
  763.  
  764. def TimeFromTicks(ticks):
  765.     return apply(Time, time.localtime(ticks)[3:6])
  766.  
  767.  
  768. def TimestampFromTicks(ticks):
  769.     return apply(Timestamp, time.localtime(ticks)[:6])
  770.  
  771.  
  772. def Binary(aString):
  773.     return buffer(aString)
  774.  
  775.  
  776. def pyTypeToADOType(d):
  777.     tp = type(d)
  778.     
  779.     try:
  780.         return typeMap[tp]
  781.     except KeyError:
  782.         if tp in dateconverter.types:
  783.             return adDate
  784.     except:
  785.         tp in dateconverter.types
  786.  
  787.     raise DataError
  788.  
  789.  
  790. def cvtCurrency(.0, decimal = 2):
  791.     (hi, lo) = .0
  792.     if lo < 0:
  793.         lo += 0x100000000L
  794.     
  795.     return decimal.Decimal((long(hi) << 32) + lo) / decimal.Decimal(1000)
  796.  
  797.  
  798. def cvtNumeric(variant):
  799.     
  800.     try:
  801.         return decimal.Decimal(variant)
  802.     except (ValueError, TypeError):
  803.         pass
  804.  
  805.     
  806.     try:
  807.         europeVsUS = str(variant).replace(',', '.')
  808.         return decimal.Decimal(europeVsUS)
  809.     except (ValueError, TypeError):
  810.         pass
  811.  
  812.  
  813.  
  814. def cvtFloat(variant):
  815.     
  816.     try:
  817.         return float(variant)
  818.     except (ValueError, TypeError):
  819.         pass
  820.  
  821.     
  822.     try:
  823.         europeVsUS = str(variant).replace(',', '.')
  824.         return float(europeVsUS)
  825.     except (ValueError, TypeError):
  826.         pass
  827.  
  828.  
  829.  
  830. def identity(x):
  831.     return x
  832.  
  833.  
  834. class VariantConversionMap(dict):
  835.     
  836.     def __init__(self, aDict):
  837.         for k, v in aDict.iteritems():
  838.             self[k] = v
  839.         
  840.  
  841.     
  842.     def __setitem__(self, adoType, cvtFn):
  843.         
  844.         try:
  845.             for type in adoType:
  846.                 dict.__setitem__(self, type, cvtFn)
  847.         except TypeError:
  848.             dict.__setitem__(self, adoType, cvtFn)
  849.  
  850.  
  851.     
  852.     def __getitem__(self, fromType):
  853.         
  854.         try:
  855.             return dict.__getitem__(self, fromType)
  856.         except KeyError:
  857.             return identity
  858.  
  859.  
  860.  
  861.  
  862. def convertVariantToPython(variant, adType):
  863.     if variant is None:
  864.         return None
  865.     return variantConversions[adType](variant)
  866.  
  867. adCmdText = 1
  868. adCmdStoredProc = 4
  869. adParamInput = 1
  870. adParamInputOutput = 3
  871. adParamOutput = 2
  872. adParamReturnValue = 4
  873. adParamUnknown = 0
  874. adStateClosed = 0
  875. adFldMayBeNull = 64
  876. adModeShareExclusive = 12
  877. adXactCommitRetaining = 131072
  878. adXactAbortRetaining = 262144
  879. adArray = 8192
  880. adBSTR = 8
  881. adBigInt = 20
  882. adBinary = 128
  883. adBoolean = 11
  884. adChapter = 136
  885. adChar = 129
  886. adCurrency = 6
  887. adDBDate = 133
  888. adDBTime = 134
  889. adDBTimeStamp = 135
  890. adDate = 7
  891. adDecimal = 14
  892. adDouble = 5
  893. adEmpty = 0
  894. adError = 10
  895. adFileTime = 64
  896. adGUID = 72
  897. adIDispatch = 9
  898. adIUnknown = 13
  899. adInteger = 3
  900. adLongVarBinary = 205
  901. adLongVarChar = 201
  902. adLongVarWChar = 203
  903. adNumeric = 131
  904. adPropVariant = 138
  905. adSingle = 4
  906. adSmallInt = 2
  907. adTinyInt = 16
  908. adUnsignedBigInt = 21
  909. adUnsignedInt = 19
  910. adUnsignedSmallInt = 18
  911. adUnsignedTinyInt = 17
  912. adUserDefined = 132
  913. adVarBinary = 204
  914. adVarChar = 200
  915. adVarNumeric = 139
  916. adVarWChar = 202
  917. adVariant = 12
  918. adWChar = 130
  919. adoErrors = {
  920.     3707: 'adErrBoundToCommand           ',
  921.     3732: 'adErrCannotComplete           ',
  922.     3748: 'adErrCantChangeConnection     ',
  923.     3220: 'adErrCantChangeProvider       ',
  924.     3724: 'adErrCantConvertvalue         ',
  925.     3725: 'adErrCantCreate               ',
  926.     3747: 'adErrCatalogNotSet            ',
  927.     3726: 'adErrColumnNotOnThisRow       ',
  928.     3421: 'adErrDataConversion           ',
  929.     3721: 'adErrDataOverflow             ',
  930.     3738: 'adErrDelResOutOfScope         ',
  931.     3750: 'adErrDenyNotSupported         ',
  932.     3751: 'adErrDenyTypeNotSupported     ',
  933.     3251: 'adErrFeatureNotAvailable      ',
  934.     3749: 'adErrFieldsUpdateFailed       ',
  935.     3219: 'adErrIllegalOperation         ',
  936.     3246: 'adErrInTransaction            ',
  937.     3719: 'adErrIntegrityViolation       ',
  938.     3001: 'adErrInvalidArgument          ',
  939.     3709: 'adErrInvalidConnection        ',
  940.     3708: 'adErrInvalidParamInfo         ',
  941.     3714: 'adErrInvalidTransaction       ',
  942.     3729: 'adErrInvalidURL               ',
  943.     3265: 'adErrItemNotFound             ',
  944.     3021: 'adErrNoCurrentRecord          ',
  945.     3715: 'adErrNotExecuting             ',
  946.     3710: 'adErrNotReentrant             ',
  947.     3704: 'adErrObjectClosed             ',
  948.     3367: 'adErrObjectInCollection       ',
  949.     3420: 'adErrObjectNotSet             ',
  950.     3705: 'adErrObjectOpen               ',
  951.     3002: 'adErrOpeningFile              ',
  952.     3712: 'adErrOperationCancelled       ',
  953.     3734: 'adErrOutOfSpace               ',
  954.     3720: 'adErrPermissionDenied         ',
  955.     3742: 'adErrPropConflicting          ',
  956.     3739: 'adErrPropInvalidColumn        ',
  957.     3740: 'adErrPropInvalidOption        ',
  958.     3741: 'adErrPropInvalidValue         ',
  959.     3743: 'adErrPropNotAllSettable       ',
  960.     3744: 'adErrPropNotSet               ',
  961.     3745: 'adErrPropNotSettable          ',
  962.     3746: 'adErrPropNotSupported         ',
  963.     3000: 'adErrProviderFailed           ',
  964.     3706: 'adErrProviderNotFound         ',
  965.     3003: 'adErrReadFile                 ',
  966.     3731: 'adErrResourceExists           ',
  967.     3730: 'adErrResourceLocked           ',
  968.     3735: 'adErrResourceOutOfScope       ',
  969.     3722: 'adErrSchemaViolation          ',
  970.     3723: 'adErrSignMismatch             ',
  971.     3713: 'adErrStillConnecting          ',
  972.     3711: 'adErrStillExecuting           ',
  973.     3728: 'adErrTreePermissionDenied     ',
  974.     3727: 'adErrURLDoesNotExist          ',
  975.     3737: 'adErrURLNamedRowDoesNotExist  ',
  976.     3736: 'adErrUnavailable              ',
  977.     3716: 'adErrUnsafeOperation          ',
  978.     3733: 'adErrVolumeNotFound           ',
  979.     3004: 'adErrWriteFile                ' }
  980.  
  981. class DBAPITypeObject:
  982.     
  983.     def __init__(self, valuesTuple):
  984.         self.values = valuesTuple
  985.  
  986.     
  987.     def __cmp__(self, other):
  988.         if other in self.values:
  989.             return 0
  990.         if other < self.values:
  991.             return 1
  992.         return -1
  993.  
  994.  
  995. adoIntegerTypes = (adInteger, adSmallInt, adTinyInt, adUnsignedInt, adUnsignedSmallInt, adUnsignedTinyInt, adBoolean, adError)
  996. adoRowIdTypes = (adChapter,)
  997. adoLongTypes = (adBigInt, adFileTime, adUnsignedBigInt)
  998. adoExactNumericTypes = (adDecimal, adNumeric, adVarNumeric, adCurrency)
  999. adoApproximateNumericTypes = (adDouble, adSingle)
  1000. adoStringTypes = (adBSTR, adChar, adLongVarChar, adLongVarWChar, adVarChar, adVarWChar, adWChar, adGUID)
  1001. adoBinaryTypes = (adBinary, adLongVarBinary, adVarBinary)
  1002. adoDateTimeTypes = (adDBTime, adDBTimeStamp, adDate, adDBDate)
  1003. adoRemainingTypes = (adEmpty, adIDispatch, adIUnknown, adPropVariant, adArray, adUserDefined, adVariant)
  1004. STRING = DBAPITypeObject(adoStringTypes)
  1005. BINARY = DBAPITypeObject(adoBinaryTypes)
  1006. NUMBER = DBAPITypeObject(adoIntegerTypes + adoLongTypes + adoExactNumericTypes + adoApproximateNumericTypes)
  1007. DATETIME = DBAPITypeObject(adoDateTimeTypes)
  1008. ROWID = DBAPITypeObject(adoRowIdTypes)
  1009. typeMap = {
  1010.     types.BufferType: adBinary,
  1011.     types.FloatType: adNumeric,
  1012.     types.IntType: adInteger,
  1013.     types.LongType: adBigInt,
  1014.     types.StringType: adBSTR,
  1015.     types.NoneType: adEmpty,
  1016.     types.UnicodeType: adBSTR,
  1017.     types.BooleanType: adBoolean,
  1018.     type(decimal.Decimal): adNumeric }
  1019.  
  1020. try:
  1021.     import mx.DateTime as mx
  1022.     dateconverter = mxDateTimeConverter()
  1023. except:
  1024.     dateconverter = pythonDateTimeConverter()
  1025.  
  1026.  
  1027. def variantConvertDate(v):
  1028.     return dateconverter.DateObjectFromCOMDate(v)
  1029.  
  1030. variantConversions = VariantConversionMap({
  1031.     adoDateTimeTypes: variantConvertDate,
  1032.     adoApproximateNumericTypes: cvtFloat,
  1033.     adCurrency: cvtCurrency,
  1034.     adoExactNumericTypes: identity,
  1035.     adoLongTypes: long,
  1036.     adoIntegerTypes: int,
  1037.     adoRowIdTypes: int,
  1038.     adoStringTypes: identity,
  1039.     adoBinaryTypes: identity,
  1040.     adoRemainingTypes: identity })
  1041.