sqlalchemy-iris 0.5.0b3__py3-none-any.whl → 0.6.0b1__py3-none-any.whl

intersystems_iris/_LegacyIterator.py

@@ -0,0 +1,135 @@
+import collections.abc
+import intersystems_iris._IRISIterator
+
+class _LegacyIterator(collections.abc.Iterator, collections.abc.Iterable):
+    '''
+This class has been deprecated. Please call IRIS.node() in order to use IRISGlobalNode instead.
+
+LegacyIterator is an iterator over the immediate children of a global node.
+
+The iterator can be set to move forwards or backwards, and to return the subscript and value, just the subscript, or just the value for each node in the iteration. This is similar to using the $ORDER function in ObjectScript.
+'''
+
+    def __init__(self, irisnative, global_name, *subscripts):
+        self._irisnative = irisnative
+        self._global_name = global_name
+        self._subscripts = subscripts
+        self._start_from = None
+        self._reversed = False
+        self._view_type = intersystems_iris.IRISIterator.VIEW_ITEMS
+        self._at_end = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        if self._at_end:
+            raise StopIteration
+        key_value = self._irisnative._nextNode(self._reversed, self._global_name, *self._subscripts, self._start_from)
+        # check if we are at end
+        returned_value = key_value[0]
+        if returned_value == None or len(returned_value) == 0:
+            self._at_end = True
+            raise StopIteration
+        self._start_from = returned_value
+        # return value
+        if self._view_type == intersystems_iris.IRISIterator.VIEW_SUBSCRIPTS:
+            return key_value[0]
+        elif self._view_type == intersystems_iris.IRISIterator.VIEW_VALUES:
+            return key_value[1]
+        elif self._view_type == intersystems_iris.IRISIterator.VIEW_ITEMS:
+            return key_value
+        else:
+            raise TypeError("Unrecognized view type")
+
+    def startFrom(self, subscript):
+        '''
+Set the starting position and return the iterator.
+
+startFrom(subscript)
+
+Set the starting position to the specified subscript. After calling this
+method, use next() to advance the iterator to the next defined sub-node
+in alphabetic collating sequence. For example, for the following global
+and iterator:
+    ^gbl("a")=11
+    ^gbl("b")=22
+    ^gbl("e")=55
+    itr=iris.iterator("^gbl")
+The starting position may be a valid sub-node, in which case the next sub-node will be the next valid one.
+    itr.startFrom("a")
+    for sub, val in itr:
+        print(sub,"->",val)
+        // prints: b -> 22; e -> 55
+The starting position may also be an invalid sub-node, in which case the next sub-node will be the first valid one in alphabetic collating sequence after the given subscript.
+    itr.startFrom("c")
+    for sub, val in itr:
+        print(sub,"->",val)
+        // prints: e -> 55
+Calling this method with None as the argument is the same as using the default starting position, which is just before the first node, or just after the last node, depending on the iterator direction.
+
+Parameters
+----------
+subscript : a single subscript indicating a starting position
+
+Returns
+-------
+The same iterator object.
+'''
+        self._start_from = subscript
+        return self
+
+    def reversed(self):
+        '''
+Reverse the direction and return the iterator.
+
+reversed()
+
+Returns
+-------
+The same iterator object.
+'''
+        self._reversed = not self._reversed
+        return self
+
+    def subscripts(self):
+        ''''
+Set the iterator to return subscripts only and return the iterator.
+
+subscripts()
+
+Returns
+-------
+The same iterator object.
+'''
+        self._view_type = intersystems_iris.IRISIterator.VIEW_SUBSCRIPTS
+        return self
+
+    def values(self):
+        '''
+Set the iterator to return values only and return the iterator.
+
+values()
+
+Returns
+-------
+The same iterator object.
+'''
+        self._view_type = intersystems_iris.IRISIterator.VIEW_VALUES
+        return self
+
+    def items(self):
+        '''
+Set the iterator to return subscript and value tuples, and return the iterator.
+
+items()
+
+Returns
+-------
+The same iterator object.
+'''
+        self._view_type = intersystems_iris.IRISIterator.VIEW_ITEMS
+        return self

intersystems_iris/_ListItem.py

@@ -0,0 +1,15 @@
+import intersystems_iris._DBList
+
+class _ListItem(object):
+
+    def __init__(self, buffer):
+        self.buffer = buffer
+        self.list_buffer_end = len(buffer)
+        self.is_null = False
+        self.type = intersystems_iris._DBList._DBList.ITEM_PLACEHOLDER
+        self.data_offset = 0
+        self.data_length = 0
+        self.next_offset = 0
+
+
+

intersystems_iris/_ListReader.py

@@ -0,0 +1,84 @@
+import intersystems_iris._DBList
+import intersystems_iris._ListItem
+
+
+class _ListReader(object):
+
+    def __init__(self, bufferarray, locale="latin-1"):
+        self.list_item = intersystems_iris._ListItem._ListItem(bufferarray)
+        self._locale = locale
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._is_end():
+            raise StopIteration
+        else:
+            return self._get()
+
+    def _get(self, asBytes=False, retainAsciiZero=False):
+        intersystems_iris._DBList._DBList._get_list_element(self.list_item)
+        return intersystems_iris._DBList._DBList._get(self.list_item, self._locale, asBytes, retainAsciiZero)
+
+    def get_inner_list(self):
+        ba = self._get(True)
+        if not ba:
+            return None
+        return _ListReader(ba, self._locale)
+
+    def _get_raw_bytes(self, length):
+        self.is_null = False
+        self.list_item.type = intersystems_iris._DBList._DBList.ITEM_PLACEHOLDER
+        self.list_item.data_offset = 0
+        self.list_item.data_length = 0
+        self.list_item.next_offset = self.list_item.next_offset + length
+        return self.list_item.buffer[self.list_item.next_offset - length:self.list_item.next_offset]
+
+    def _get_raw(self):
+        return self.list_item.buffer
+
+    def _is_end(self):
+        return (self.list_item.next_offset >= self.list_item.list_buffer_end)
+    def _get_at_offset(self, offset, asBytes = False):
+        self.list_item.next_offset = offset
+        intersystems_iris._DBList._DBList._get_list_element(self.list_item)
+        return intersystems_iris._DBList._DBList._get(self.list_item, self._locale, asBytes)
+
+    def _move_to_end(self):
+        self.list_item.next_offset = self.list_item.list_buffer_end 
+
+    def _get_offset(self):
+        return self.list_item.next_offset
+
+    def _next(self):
+        return intersystems_iris._DBList._DBList._get_list_element(self.list_item)
+
+    def _get_output_parameter_list(self, begin, add_null):
+        len = self.list_item.next_offset - begin
+        offset = 3 if add_null else 0
+        ba = bytearray(len + offset)
+        if add_null:
+            quote_quote = bytearray([3, 1, 0])
+            ba = quote_quote
+        ba[offset:len] = self.list_item.buffer[begin:len]
+        return intersystems_iris._ListReader._ListReader(ba, self._locale)
+
+    def _is_past_last_item(self):
+        return (self.list_item.data_offset >= self.list_item.list_buffer_end)
+
+    def _is_undefined(self):
+        return (self.list_item.type == intersystems_iris._DBList._DBList.ITEM_UNDEF)
+
+    def _next_unless_undefined(self):
+        self._next()
+        if self._is_past_last_item():
+            raise Exception("No more data")
+        if self._is_undefined():
+            raise Exception("Output/Default parameter not assigned a value")
+        return
+
+    def _clear_list(self):
+        self.list_item.list_buffer_end = 0
+        self.list_item.next_offset = 0
+        return

intersystems_iris/_ListWriter.py

@@ -0,0 +1,157 @@
+import datetime
+import decimal
+import intersystems_iris._DBList
+import intersystems_iris.dbapi._DBAPI
+from .dbapi._SQLType import SQLType
+class _ListWriter(object):
+
+    CHUNKSIZE = 256
+
+    def __init__(self, locale = "latin-1", is_unicode = True, compact_double = False):
+        self.buffer = bytearray(self.CHUNKSIZE)
+        self.offset = 0
+        self._locale = locale
+        self._is_unicode = is_unicode
+        self._compact_double = compact_double
+
+    def _clear_list(self):
+        self.offset = 0
+
+    def _set(self, data, retainEmptyString=False):
+        if retainEmptyString and type(data) == str and len(data) == 0:
+            self._set_null()
+        else:
+            self.__check_buffer_size(self.__estimate_size(data))
+            self.offset = intersystems_iris._DBList._DBList._set(self.buffer, self.offset, data, self._locale, self._is_unicode, self._compact_double)
+        return
+
+    def _set_list(self, data):
+        if data is None:
+            self._set_null()
+        else:
+            self.__check_buffer_size(data.offset)
+            self.offset = intersystems_iris._DBList._DBList._stuff_bytes(self.buffer, self.offset, data._get_buffer())
+
+    def _set_undefined(self):
+        self.__check_buffer_size(1)
+        self.offset = intersystems_iris._DBList._DBList._set_undefined(self.buffer, self.offset)
+
+    def _set_null(self):
+        self.__check_buffer_size(2)
+        self.offset = intersystems_iris._DBList._DBList._set_null(self.buffer, self.offset)
+
+    def _set_raw_bytes(self, data):
+        length = len(data)
+        self.__check_buffer_size(length)
+        self.buffer[self.offset:self.offset+length] = data[0:length]
+        self.offset = self.offset + length
+        return
+
+    def _set_parameter(self, param):
+        param_switcher = {
+            SQLType.LONGVARBINARY: self._set_stream,
+            SQLType.LONGVARCHAR: self._set_stream,
+            SQLType.DATE: None,
+            SQLType.TIME: None,
+            SQLType.TIMESTAMP: None,
+            SQLType.TYPE_DATE: None,
+            SQLType.TYPE_TIME: None,
+            SQLType.TYPE_TIMESTAMP: None,
+            SQLType.DATE_HOROLOG: self._set_date_h,
+            SQLType.TIME_HOROLOG: self._set_time_h,
+            SQLType.TIMESTAMP_POSIX: self._set_posix
+        }
+        param_func = param_switcher.get(param.type, None)
+        if param_func is None:
+            self._set(param.value)
+        else:
+            param_func(param.value)
+
+    def _set_parameter_type(self, param_type, value):
+        param_switcher = {
+            SQLType.LONGVARBINARY: self._set_stream,
+            SQLType.LONGVARCHAR: self._set_stream,
+            SQLType.DATE: None,
+            SQLType.TIME: None,
+            SQLType.TIMESTAMP: None,
+            SQLType.TYPE_DATE: None,
+            SQLType.TYPE_TIME: None,
+            SQLType.TYPE_TIMESTAMP: None,
+            SQLType.DATE_HOROLOG: self._set_date_h,
+            SQLType.TIME_HOROLOG: self._set_time_h,
+            SQLType.TIMESTAMP_POSIX: self._set_posix
+        }
+        param_func = param_switcher.get(param_type, None)
+        if param_func is None:
+            self._set(value)
+        else:
+            param_func(value)
+
+    def _set_stream(self, stream):
+        self._set(stream)
+        # raise NotImplementedError("Stream functionality not yet available with iris.dbapi")
+    
+    def _set_date_h(self, date):
+        HOROLOG_ORDINAL = datetime.date(1840, 12, 31).toordinal()
+        if isinstance(date, datetime.date):
+            date_h = date.toordinal() - HOROLOG_ORDINAL
+            self._set(date_h)
+        else:
+            self._set(date)
+
+    def _set_time_h(self, time):
+        if isinstance(time, datetime.time) or isinstance(time, datetime.datetime):
+            time_h = 3600 * time.hour + 60 * time.minute + time.second
+            self._set(time_h)
+        else:
+            self._set(time)
+
+    def _set_posix(self, timestamp):
+        if isinstance(timestamp, datetime.datetime):
+            self._set(timestamp.strftime('%Y-%m-%d %H:%M:%S.%f'))
+        else:
+            self._set(timestamp)
+
+    def _size(self):
+        return self.offset
+
+    def _get_buffer(self):
+        return self.buffer[0:self.offset]
+
+    def __estimate_size(self, data):
+        if type(data) == int and (data > 0x7fffffffffffffff or data < -0x8000000000000000):
+            data = str(data)
+        if type(data) is str or type(data) is bytes or type(data) is bytearray:
+            estimated = len(data)*2+8
+        else:
+            estimated = self._estimate_size_switcher.get(type(data), 0)
+        return estimated
+
+    def __check_buffer_size(self, additional):
+        if self.offset + additional > len(self.buffer):
+            size_needed = self.offset + additional
+            size_to_allocate = len(self.buffer)*2
+            while True:
+                if size_to_allocate > size_needed:
+                    break
+                size_to_allocate = size_to_allocate*2
+            new_buffer = bytearray(size_to_allocate)
+            new_buffer[0:len(self.buffer)] = self.buffer
+            self.buffer = new_buffer
+        return
+
+    def _save_current_offset(self):
+        self.__saved_offset = self.offset
+        return
+
+    def _set_saved_offset_type_as_pass_by_reference(self):
+        intersystems_iris._DBList._DBList._set_type_as_pass_by_reference(self.buffer, self.__saved_offset)
+        return
+
+_ListWriter._estimate_size_switcher = {
+    type(None): 2,
+    bool: 3,
+    int: 10,
+    float: 10,
+    decimal.Decimal: 11
+}

intersystems_iris/_LogFileStream.py

@@ -0,0 +1,115 @@
+import io
+import os
+import datetime
+import threading
+import platform
+
+class _LogFileStream(object):
+
+    LOG_RECEIVED = 0
+    LOG_SENT = 1
+    LINE_SEPARATOR = '\n'
+    BUFFER_SIZE = io.DEFAULT_BUFFER_SIZE
+
+    def __init__(self, path):
+        b_new_file = False
+        if (path.startswith("+")):
+            b_new_file = True
+            path = path[1:]
+        if (path.startswith("-")):
+            self.b_skip_logging = True
+            path = path[1:]
+        if b_new_file and os.path.exists(path):
+            os.remove(path)
+        self.path = path
+        self.bytesPerLine = 14 if os.path.splitext(path)[0].endswith("14") else 16
+        self.__dump_start()
+    
+    def __dump_start(self):
+        with open(self.path, 'a') as f:
+            f.write(
+                self.LINE_SEPARATOR 
+                + "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-")
+            f.write(
+                self.LINE_SEPARATOR 
+                + "\tStarted At:     " + datetime.datetime.now().strftime("%b %d, %Y %I:%M:%S %p"))
+            f.write(
+                self.LINE_SEPARATOR 
+                + "\tPython Version: " + platform.python_version())
+            f.write(
+                self.LINE_SEPARATOR 
+                + "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" 
+                + self.LINE_SEPARATOR)
+
+    def __dump_info(self, type, connection):
+        if type == self.LOG_SENT:
+            type_text = "Sent"
+        else:
+            type_text = "Received"
+        with open(self.path, 'a') as f:
+            f.write(
+                self.LINE_SEPARATOR + type_text + ": (" 
+                + datetime.datetime.now().strftime("%H:%M:%S:%f")[:-3] + ")"
+                + " [ThreadID = " + str(threading.get_ident()) + " ]"
+                + " [JobNumber = " + str(connection._connection_info._server_job_number) + " ]"
+                + " [DeviceID = " + str(id(connection._device)) + " ]"
+                + self.LINE_SEPARATOR)
+
+    def _logApi(self, text):
+        with open(self.path, 'a') as f:
+            f.write(self.LINE_SEPARATOR + text + self.LINE_SEPARATOR)
+
+    def _dump_header(self, buffer, type, connection):
+        if buffer is None:
+            return
+        self.__dump_info(type, connection)
+        line = "Header:"
+        self._dump(line, buffer, False)
+
+    def _dump_message(self, buffer):
+        if buffer is None:
+            return
+        line = "Message:"
+        self._dump(line, buffer, True)
+
+    def _dump(self, line, buffer, is_message):
+        asciistr = ""
+        i = 0
+        f = open(self.path, 'a')
+        while i < len(buffer):
+            if i % self.bytesPerLine == 0:
+                if i != 0:
+                    line += "     "
+                line += asciistr + self.LINE_SEPARATOR
+                asciistr = ""
+                line += _LogFileStream.__format_offset(i)
+            x = '{:02X}'.format(int(buffer[i]))
+            asciistr += _LogFileStream.__convert_to_ascii(int(buffer[i]))
+            line += " " + x + " "
+            if i % _LogFileStream.BUFFER_SIZE == 0:
+                f.write(line)
+                line = ""
+            i += 1
+        line += self.__format_last_line(i)
+        line += "     " + asciistr + self.LINE_SEPARATOR
+        if is_message:
+            line += self.LINE_SEPARATOR
+        f.write(line)
+        f.close()
+
+    @staticmethod
+    def __format_offset(value):
+        return '  {:04X}: '.format(value)
+
+    @staticmethod
+    def __convert_to_ascii(value):
+        if value >= 32 and value < 127:
+            return chr(value)
+        return "."
+
+    def __format_last_line(self, count):
+        spaces = ""
+        while count % self.bytesPerLine != 0:
+            spaces += "    "
+            count += 1
+        return spaces

intersystems_iris/_MessageHeader.py

@@ -0,0 +1,51 @@
+class _MessageHeader(object):
+    
+    HEADER_SIZE = 14
+
+    def __init__(self):
+        self.buffer = bytearray(self.HEADER_SIZE)
+
+    def _get_message_length(self):
+        return self.__get_4_byte_int_raw(0)
+
+    def _get_message_id(self):
+        return self.__get_4_byte_int_raw(4)
+
+    # TODO: remove this method, use _get_message_id()
+    def _get_count(self):
+        return self.__get_4_byte_int_raw(4)
+
+    def _get_statement_id(self):
+        return self.__get_4_byte_int_raw(8) & ~(0x80000000)
+
+    def _get_function_code(self):
+        return (self.buffer[12] & 0x00FF) | ((self.buffer[13] & 0x00FF) << 8)
+
+    # TODO: remove this method, use _get_function_code()
+    def _get_error(self):
+        return (self.buffer[12] & 0x00FF) | ((self.buffer[13] & 0x00FF) << 8)
+
+    @classmethod
+    def _set_count(cls, buffer, value):
+        cls.__set_raw_4_byte_int(buffer, 4, value)
+    
+    @classmethod
+    def _set_message_length(cls, buffer, value):
+        cls.__set_raw_4_byte_int(buffer, 0, value)
+
+    @classmethod
+    def _set_statement_id(cls, buffer, value):
+        cls.__set_raw_4_byte_int(buffer, 8, value)
+
+    def __get_4_byte_int_raw(self, offset):
+        return ((self.buffer[offset] & 0x000000FF) | 
+          ((self.buffer[offset + 1] & 0x000000FF) << 8) |
+          ((self.buffer[offset + 2] & 0x000000FF) << 16) | 
+          ((self.buffer[offset + 3] & 0x000000FF) << 24))
+
+    @staticmethod
+    def __set_raw_4_byte_int(buffer, offset, value):
+        buffer[offset] = value & 0xFF
+        buffer[offset + 1] = (value >> 8) & 0xFF
+        buffer[offset + 2] = (value >> 16) & 0xFF
+        buffer[offset + 3] = (value >> 24) & 0xFF

intersystems_iris/_OutStream.py

@@ -0,0 +1,25 @@
+import intersystems_iris._BufferWriter
+import intersystems_iris._LogFileStream
+
+class _OutStream(object):
+
+    def __init__(self, connection):
+        self._connection = connection
+        self._device = connection._device
+        self._log_stream = connection._log_stream
+        self.wire = intersystems_iris._BufferWriter._BufferWriter(self._connection._connection_info._locale,self._connection._connection_info._is_unicode,self._connection._connection_info._compact_double)
+
+    def _send(self, sequence_number):
+        list_len = self.wire._size() - intersystems_iris._MessageHeader._MessageHeader.HEADER_SIZE
+        intersystems_iris._MessageHeader._MessageHeader._set_message_length(self.wire.buffer, list_len)
+        intersystems_iris._MessageHeader._MessageHeader._set_count(self.wire.buffer, sequence_number)
+        if self._device is None:
+            raise RuntimeError("no longer connected to server")
+        self._device.sendall(self.wire._get_buffer())
+        if self._log_stream is not None:
+            self._log_stream._dump_header(self.wire._get_header_buffer(), intersystems_iris._LogFileStream._LogFileStream.LOG_SENT, self._connection)
+        if list_len > 0:
+            if self._log_stream is not None:
+                self._log_stream._dump_message(self.wire._get_data_buffer())
+        return
+

intersystems_iris/_PrintStream.py

@@ -0,0 +1,65 @@
+import io
+import os
+import sys
+import threading
+import intersystems_iris._GatewayContext
+
+class _PrintStream(io.StringIO):
+
+    def __init__(self, type):
+        super().__init__()
+        self.hmap = {}
+        self.type = type
+
+    def _register(self):
+        thread_id = threading.get_ident()
+        out = ""
+        self.hmap[thread_id] = out
+
+    def _unregister(self):
+        thread_id = threading.get_ident()
+        self.hmap.pop(thread_id, None)
+        
+    def _was_written_to(self):
+        output_buffer = self.__get_out_buffer()
+        if output_buffer is None:
+            return False
+        else:
+            return len(output_buffer) != 0
+
+    def __get_out_buffer(self):
+        thread_id = threading.get_ident()
+        return self.hmap.get(thread_id)
+
+    def __empty_buffer(self):
+        thread_id = threading.get_ident()
+        del self.hmap[thread_id]
+        self._register()
+
+    def _get_buffer_contents(self):
+        output_buffer = self.__get_out_buffer()
+        if output_buffer is None: return ""
+        formatted_output_buffer = "\r\n".join(output_buffer.splitlines())
+        if output_buffer.endswith("\n"):
+            formatted_output_buffer += "\r\n"
+        self.__empty_buffer()
+        return formatted_output_buffer
+
+    def write(self, value):
+        thread_id = threading.get_ident()
+        if thread_id not in self.hmap.keys():
+            if self.type == 0:
+                sys.__stdout__.write(value)
+            else:
+                sys.__stderr__.write(value)
+            return
+        try:
+            native = intersystems_iris.GatewayContext.getIRIS()
+            formatted_value = "\r\n".join(value.splitlines())
+            if value.endswith("\n"): formatted_value += "\r\n"
+            native.classMethodVoid("%Net.Remote.Gateway", "%WriteOutput", formatted_value);
+            return
+        except BaseException as e:
+            self.hmap[thread_id] += str(value)
+            return
+