Refactoring: formatting, print statements

Author: maciejlach

qpython/_pandas.py

@@ -183,7 +183,7 @@ def _write_pandas_data_frame(self, data, qtype = None):
             self._buffer.write(struct.pack('=bxi', QGENERAL_LIST, len(index_columns)))
             for column in index_columns:
                 self._write_pandas_series(data[column], qtype = data.meta[column] if hasattr(data, 'meta') else None)
-            
+
             data.set_index(index_columns, inplace = True)
 
         self._buffer.write(struct.pack('=bxb', QTABLE, QDICTIONARY))
@@ -198,4 +198,4 @@ def _write_generic_list(self, data):
         self._buffer.write(struct.pack('=bxi', QGENERAL_LIST, len(data)))
         for element in data:
             # assume nan represents a string null
-            self._write(' ' if type(element) in [float, numpy.float32, numpy.float64] and numpy.isnan(element) else element)
+            self._write(' ' if type(element) in [float, numpy.float32, numpy.float64] and numpy.isnan(element) else element)

qpython/qcollection.py

@@ -54,9 +54,9 @@ def raw(self, idx):
         index.
         
            >>> t = qlist(numpy.array([366, 121, qnull(QDATE)]), qtype=QDATE_LIST)
-           >>> print t[0]
+           >>> print(t[0])
            2001-01-01 [metadata(qtype=-14)]
-           >>> print t.raw(0)
+           >>> print(t.raw(0))
            366
         
         :Parameters:
@@ -121,31 +121,31 @@ def qlist(array, adjust_dtype = True, **meta):
     - `byte numpy.array`:
        
        >>> v = qlist(numpy.array([0x01, 0x02, 0xff], dtype=numpy.byte))
-       >>> print '%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v)
+       >>> print('%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v))
        <class 'qpython.qcollection.QList'> dtype: int8 qtype: -4: [ 1  2 -1]
     
     - `int32 numpy.array` with explicit conversion to `QBYTE_LIST`:   
       
        >>> v = qlist(numpy.array([1, 2, -1]), qtype = QBYTE_LIST)
-       >>> print '%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v)
+       >>> print('%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v))
        <class 'qpython.qcollection.QList'> dtype: int8 qtype: -4: [ 1  2 -1]
     
     - plain Python `integer` list with explicit conversion to `QBYTE_LIST`:   
        
        >>> v = qlist([1, 2, -1], qtype = QBYTE_LIST)
-       >>> print '%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v)
+       >>> print('%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v))
        <class 'qpython.qcollection.QList'> dtype: int8 qtype: -4: [ 1  2 -1]
 
     - numpy datetime64 array with implicit conversion to `QDATE_LIST`:   
        
        >>> v = qlist(numpy.array([numpy.datetime64('2001-01-01'), numpy.datetime64('2000-05-01'), numpy.datetime64('NaT')], dtype='datetime64[D]'))
-       >>> print '%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v)
+       >>> print('%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v))
        <class 'qpython.qcollection.QList'> dtype: datetime64[D] qtype: -14: ['2001-01-01' '2000-05-01' 'NaT']
        
     - numpy datetime64 array with explicit conversion to `QDATE_LIST`:   
        
        >>> v = qlist(numpy.array([numpy.datetime64('2001-01-01'), numpy.datetime64('2000-05-01'), numpy.datetime64('NaT')], dtype='datetime64[D]'), qtype = QDATE_LIST)
-       >>> print '%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v)
+       >>> print('%s dtype: %s qtype: %d: %s' % (type(v), v.dtype, v.meta.qtype, v))
        <class 'qpython.qcollection.QList'> dtype: datetime64[D] qtype: -14: ['2001-01-01' '2000-05-01' 'NaT']
 
     
@@ -171,7 +171,7 @@ def qlist(array, adjust_dtype = True, **meta):
             for i in xrange(len(array)):
                 tarray[i] = array[i]
             array = tarray
-        else:        
+        else:
             array = numpy.array(array)
 
     if not isinstance(array, numpy.ndarray):
@@ -203,13 +203,13 @@ class QDictionary(object):
     Dictionary examples:
     
     >>> # q: 1 2!`abc`cdefgh
-    >>> print QDictionary(qlist(numpy.array([1, 2], dtype=numpy.int64), qtype=QLONG_LIST), 
-    ...                   qlist(numpy.array(['abc', 'cdefgh']), qtype = QSYMBOL_LIST))
+    >>> print(QDictionary(qlist(numpy.array([1, 2], dtype=numpy.int64), qtype=QLONG_LIST), 
+    ...                    qlist(numpy.array(['abc', 'cdefgh']), qtype = QSYMBOL_LIST)))
     [1 2]!['abc' 'cdefgh']
        
     >>> # q: (1;2h;3.234;"4")!(`one;2 3;"456";(7;8 9))
-    >>> print QDictionary([numpy.int64(1), numpy.int16(2), numpy.float64(3.234), '4'], 
-    ...                   [numpy.string_('one'), qlist(numpy.array([2, 3]), qtype=QLONG_LIST), '456', [numpy.int64(7), qlist(numpy.array([8, 9]), qtype=QLONG_LIST)]])
+    >>> print(QDictionary([numpy.int64(1), numpy.int16(2), numpy.float64(3.234), '4'], 
+    ...                    [numpy.string_('one'), qlist(numpy.array([2, 3]), qtype=QLONG_LIST), '456', [numpy.int64(7), qlist(numpy.array([8, 9]), qtype=QLONG_LIST)]]))
     [1, 2, 3.234, '4']!['one', QList([2, 3], dtype=int64), '456', [7, QList([8, 9], dtype=int64)]]
     
     :Parameters:
@@ -320,22 +320,22 @@ def qtable(columns, data, **meta):
       >>> t = qtable(qlist(numpy.array(['name', 'iq']), qtype = QSYMBOL_LIST), 
       ...     [qlist(numpy.array(['Dent', 'Beeblebrox', 'Prefect'])), 
       ...      qlist(numpy.array([98, 42, 126], dtype=numpy.int64))])
-      >>> print '%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t)
+      >>> print('%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t))
       <class 'qpython.qcollection.QTable'> dtype: [('name', 'S10'), ('iq', '<i8')] meta: metadata(iq=-7, qtype=98, name=-11): [('Dent', 98L) ('Beeblebrox', 42L) ('Prefect', 126L)]
       
       >>> # q: flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
       >>> t = qtable(qlist(numpy.array(['name', 'iq']), qtype = QSYMBOL_LIST),
       ...           [qlist(['Dent', 'Beeblebrox', 'Prefect'], qtype = QSYMBOL_LIST), 
       ...            qlist([98, 42, 126], qtype = QLONG_LIST)])
-      >>> print '%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t)
+      >>> print('%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t))
       <class 'qpython.qcollection.QTable'> dtype: [('name', 'S10'), ('iq', '<i8')] meta: metadata(iq=-7, qtype=98, name=-11): [('Dent', 98L) ('Beeblebrox', 42L) ('Prefect', 126L)]
       
       >>> # q: flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
       >>> t = qtable(['name', 'iq'],
       ...            [['Dent', 'Beeblebrox', 'Prefect'], 
       ...             [98, 42, 126]],
       ...            name = QSYMBOL, iq = QLONG)
-      >>> print '%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t) 
+      >>> print('%s dtype: %s meta: %s: %s' % (type(t), t.dtype, t.meta, t)) 
       <class 'qpython.qcollection.QTable'> dtype: [('name', 'S10'), ('iq', '<i8')] meta: metadata(iq=-7, qtype=98, name=-11): [('Dent', 98L) ('Beeblebrox', 42L) ('Prefect', 126L)]
       
       >>> # q: flip `name`iq`fullname!(`Dent`Beeblebrox`Prefect;98 42 126;("Arthur Dent"; "Zaphod Beeblebrox"; "Ford Prefect"))
@@ -377,7 +377,7 @@ def qtable(columns, data, **meta):
                 data[i] = qlist(data[i], qtype = QGENERAL_LIST)
             else:
                 data[i] = qlist(data[i])
-        
+
         meta[columns[i]] = data[i].meta.qtype
         dtypes.append((columns[i], data[i].dtype))
 
@@ -403,9 +403,9 @@ class QKeyedTable(object):
         ...         qtable(['pos', 'dates'],
         ...                [qlist(numpy.array(['d1', 'd2', 'd3']), qtype = QSYMBOL_LIST), 
         ...                 qlist(numpy.array([366, 121, qnull(QDATE)]), qtype = QDATE_LIST)]))
-        >>> print '%s: %s' % (type(t), t)
-        >>> print '%s dtype: %s meta: %s' % (type(t.keys), t.keys.dtype, t.keys.meta)
-        >>> print '%s dtype: %s meta: %s' % (type(t.values), t.values.dtype, t.values.meta)
+        >>> print('%s: %s' % (type(t), t))
+        >>> print('%s dtype: %s meta: %s' % (type(t.keys), t.keys.dtype, t.keys.meta))
+        >>> print('%s dtype: %s meta: %s' % (type(t.values), t.values.dtype, t.values.meta))
         <class 'qpython.qcollection.QKeyedTable'>: [(1001L,) (1002L,) (1003L,)]![('d1', 366) ('d2', 121) ('d3', -2147483648)]
         <class 'qpython.qcollection.QTable'> dtype: [('eid', '<i8')] meta: metadata(qtype=98, eid=-7)
         <class 'qpython.qcollection.QTable'> dtype: [('pos', 'S2'), ('dates', '<i4')] meta: metadata(dates=-14, qtype=98, pos=-11)

qpython/qconnection.py

@@ -52,8 +52,8 @@ class QConnection(object):
     used with a ``with`` statement::
     
         with qconnection.QConnection(host = 'localhost', port = 5000) as q:
-            print q
-            print q('{`int$ til x}', 10)
+            print(q)
+            print(q('{`int$ til x}', 10))
     
     :Parameters:
      - `host` (`string`) - q service hostname
@@ -222,27 +222,27 @@ def sync(self, query, *parameters, **options):
         
         Executes a q expression:
         
-            >>> print q.sync('til 10')
+            >>> print(q.sync('til 10'))
             [0 1 2 3 4 5 6 7 8 9]
         
         Executes an anonymous q function with a single parameter:
         
-            >>> print q.sync('{til x}', 10)
+            >>> print(q.sync('{til x}', 10))
             [0 1 2 3 4 5 6 7 8 9]
             
         Executes an anonymous q function with two parameters:
         
-            >>> print q.sync('{y + til x}', 10, 1)
+            >>> print(q.sync('{y + til x}', 10, 1))
             [ 1  2  3  4  5  6  7  8  9 10]
             
-            >>> print q.sync('{y + til x}', *[10, 1])
+            >>> print(q.sync('{y + til x}', *[10, 1]))
             [ 1  2  3  4  5  6  7  8  9 10]
         
         The :func:`.sync` is called from the overloaded :func:`.__call__` 
         function. This allows :class:`.QConnection` instance to be called as 
         a function:
         
-            >>> print q('{y + til x}', 10, 1)
+            >>> print(q('{y + til x}', 10, 1))
             [ 1  2  3  4  5  6  7  8  9 10]
         
         
@@ -304,20 +304,20 @@ def receive(self, data_only = True, **options):
         Retrieves query result along with meta-information:
         
             >>> q.query(qconnection.MessageType.SYNC,'{x}', 10)
-            >>> print q.receive(data_only = False, raw = False)
+            >>> print(q.receive(data_only = False, raw = False))
             QMessage: message type: 2, data size: 13, is_compressed: False, data: 10
 
         Retrieves parsed query result:
 
             >>> q.query(qconnection.MessageType.SYNC,'{x}', 10)
-            >>> print q.receive(data_only = True, raw = False)
+            >>> print(q.receive(data_only = True, raw = False))
             10
 
         Retrieves not-parsed (raw) query result:
         
             >>> from binascii import hexlify
             >>> q.query(qconnection.MessageType.SYNC,'{x}', 10)
-            >>> print hexlify(q.receive(data_only = True, raw = True))
+            >>> print(hexlify(q.receive(data_only = True, raw = True)))
             fa0a000000
                 
         :Parameters:

qpython/qtemporal.py

@@ -148,7 +148,7 @@ def array_from_raw_qtemporal(raw, qtype):
     Examples:
     
       >>> raw = numpy.array([366, 121, qnull(QDATE)])
-      >>> print array_from_raw_qtemporal(raw, qtype = QDATE)
+      >>> print(array_from_raw_qtemporal(raw, qtype = QDATE))
       ['2001-01-01' '2000-05-01' 'NaT']
     
     :Parameters:
@@ -185,7 +185,7 @@ def array_to_raw_qtemporal(array, qtype):
     Examples:
     
       >>> na_dt = numpy.arange('1999-01-01', '2005-12-31', dtype='datetime64[D]')
-      >>> print array_to_raw_qtemporal(na_dt, qtype = QDATE_LIST)
+      >>> print(array_to_raw_qtemporal(na_dt, qtype = QDATE_LIST))
       [-365 -364 -363 ..., 2188 2189 2190]
       >>> array_to_raw_qtemporal(numpy.arange(-20, 30, dtype='int32'), qtype = QDATE_LIST)
       Traceback (most recent call last):

qpython/qtype.py

@@ -1,18 +1,18 @@
-# 
+#
 #  Copyright (c) 2011-2014 Exxeleron GmbH
-# 
+#
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
 #  You may obtain a copy of the License at
-# 
+#
 #    http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 #  Unless required by applicable law or agreed to in writing, software
 #  distributed under the License is distributed on an "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
-# 
+#
 
 '''
 The `qpython.qtype` module defines number of utility function which help to work
@@ -152,15 +152,15 @@
 
 
 
-ATOM_SIZE = ( 0, 1, 16, 0, 1, 2, 4, 8, 4, 8, 1, 0, 8, 4, 4, 8, 8, 4, 4, 4 )
+ATOM_SIZE = (0, 1, 16, 0, 1, 2, 4, 8, 4, 8, 1, 0, 8, 4, 4, 8, 8, 4, 4, 4)
 
 
 
-# mapping of q atoms to corresponding Python types 
+# mapping of q atoms to corresponding Python types
 PY_TYPE = {
     QBOOL:          numpy.bool_,
     QBYTE:          numpy.byte,
-    QGUID:          numpy.object_, 
+    QGUID:          numpy.object_,
     QSHORT:         numpy.int16,
     QINT:           numpy.int32,
     QLONG:          numpy.int64,
@@ -181,7 +181,7 @@
     }
 
 
-# mapping of Python types to corresponding q atoms 
+# mapping of Python types to corresponding q atoms
 Q_TYPE = {
     bool             : QBOOL,
     numpy.bool       : QBOOL,
@@ -233,12 +233,12 @@
     QSHORT:     'h',
     QINT:       'i',
     QLONG:      'q',
-    QFLOAT:     'f',  
-    QDOUBLE:    'd',  
+    QFLOAT:     'f',
+    QDOUBLE:    'd',
     QSTRING:    's',
     QSYMBOL:    'S',
     QCHAR:      'b',
-                
+
     QMONTH:     'i',
     QDATE:      'i',
     QDATETIME:  'd',
@@ -251,12 +251,12 @@
 
 
 # null definitions
-_QNULL1 = numpy.int8(-2**7)
-_QNULL2 = numpy.int16(-2**15)
-_QNULL4 = numpy.int32(-2**31)
-_QNULL8 = numpy.int64(-2**63)
-_QNAN32 = numpy.fromstring('\x00\x00\xc0\x7f', dtype=numpy.float32)[0]
-_QNAN64 = numpy.fromstring('\x00\x00\x00\x00\x00\x00\xf8\x7f', dtype=numpy.float64)[0]
+_QNULL1 = numpy.int8(-2 ** 7)
+_QNULL2 = numpy.int16(-2 ** 15)
+_QNULL4 = numpy.int32(-2 ** 31)
+_QNULL8 = numpy.int64(-2 ** 63)
+_QNAN32 = numpy.fromstring('\x00\x00\xc0\x7f', dtype = numpy.float32)[0]
+_QNAN64 = numpy.fromstring('\x00\x00\x00\x00\x00\x00\xf8\x7f', dtype = numpy.float64)[0]
 _QNULL_BOOL = numpy.bool_(False)
 _QNULL_SYM = numpy.string_('')
 _QNULL_GUID = uuid.UUID('00000000-0000-0000-0000-000000000000')
@@ -318,7 +318,7 @@ class QException(Exception):
 
 class QFunction(object):
     '''Represents a q function.'''
-    
+
     def __init__(self, qtype):
         self.qtype = qtype
 
@@ -329,7 +329,7 @@ def __str__(self):
 
 
 class QLambda(QFunction):
-    
+
     '''Represents a q lambda expression.
     
     .. note:: `expression` is trimmed and required to be valid q function 
@@ -342,15 +342,15 @@ class QLambda(QFunction):
     '''
     def __init__(self, expression):
         QFunction.__init__(self, QLAMBDA)
-        
+
         if not expression:
             raise ValueError('Lambda expression cannot be None or empty')
-        
+
         expression = expression.strip()
-        
+
         if not QLambda._EXPRESSION_REGEX.match(expression):
             raise ValueError('Invalid lambda expression: %s' % expression)
-        
+
         self.expression = expression
 
 
@@ -367,31 +367,31 @@ def __eq__(self, other):
 
 
 class QProjection(QFunction):
-    
+
     '''Represents a q projection.
     
     :Parameters:
      - `parameters` (`list`) - list of parameters for lambda expression
     '''
     def __init__(self, parameters):
         QFunction.__init__(self, QPROJECTION)
-        
+
         self.parameters = parameters
 
-        
+
     def __str__(self):
         parameters_str = []
         for arg in self.parameters:
             parameters_str.append('%s' % arg)
-            
+
         return '%s(%s)' % (self.__class__.__name__, ', '.join(parameters_str))
 
 
     def __eq__(self, other):
         return (not self.parameters and not other.parameters) or \
-                reduce(lambda v1,v2: v1 or v2, map(lambda v: v in self.parameters, other.parameters))
+                reduce(lambda v1, v2: v1 or v2, map(lambda v: v in self.parameters, other.parameters))
+
 
-        
     def __ne__(self, other):
         return not self.__eq__(other)