e6data-python-connector 1.0.0__py3-none-any.whl

e6xdb/common.py

@@ -0,0 +1,269 @@
+"""Package private common utilities. Do not use directly.
+Many docstrings in this file are based on PEP-249, which is in the public domain.
+"""
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+import abc
+import collections
+import datetime
+import logging
+import time
+from builtins import bytes
+from builtins import int
+from builtins import object
+from builtins import str
+
+from future.utils import with_metaclass
+from past.builtins import basestring
+
+from e6xdb.exceptions import ProgrammingError
+
+_logger = logging.getLogger(__name__)
+
+
+class DBAPICursor(with_metaclass(abc.ABCMeta, object)):
+    """Base class for some common DB-API logic"""
+
+    _STATE_NONE = 0
+    _STATE_RUNNING = 1
+    _STATE_FINISHED = 2
+
+    def __init__(self, poll_interval=1):
+        self._poll_interval = poll_interval
+        self._reset_state()
+        self.lastrowid = None
+        self._data = None
+
+    def _reset_state(self):
+        """Reset state about the previous query in preparation for running another query"""
+        # State to return as part of DB-API
+        self._rownumber = 0
+
+        # Internal helper state
+        self._data = collections.deque()
+        self._columns = None
+
+    def _fetch_while(self, fn):
+        _logger.info("Commons - fetch while.... fn type - {}".format(type(fn)))
+        while fn():
+            _logger.info("fetching next fetch more from fetch while")
+            self._fetch_more()
+            if fn():
+                time.sleep(self._poll_interval)
+
+    @abc.abstractmethod
+    def description(self):
+        raise NotImplementedError  # pragma: no cover
+
+    def close(self):
+        """By default, do nothing"""
+        pass
+
+    @abc.abstractmethod
+    def _fetch_more(self):
+        """Get more results, append it to ``self._data``, and update ``self._state``."""
+        raise NotImplementedError  # pragma: no cover
+
+    @property
+    def rowcount(self):
+        """By default, return -1 to indicate that this is not supported."""
+        return self.rowcount
+
+    @abc.abstractmethod
+    def execute(self, operation, parameters=None):
+        """Prepare and execute a database operation (query or command).
+        Parameters may be provided as sequence or mapping and will be bound to variables in the
+        operation. Variables are specified in a database-specific notation (see the e6xdb's
+        ``paramstyle`` attribute for details).
+        Return values are not defined.
+        """
+        raise NotImplementedError  # pragma: no cover
+
+    def executemany(self, operation, seq_of_parameters):
+        """Prepare a database operation (query or command) and then execute it against all parameter
+        sequences or mappings found in the sequence ``seq_of_parameters``.
+        Only the final result set is retained.
+        Return values are not defined.
+        """
+        for parameters in seq_of_parameters[:-1]:
+            self.execute(operation, parameters)
+            # while self._state != self._STATE_FINISHED:
+            #     self._fetch_more()
+        if seq_of_parameters:
+            self.execute(operation, seq_of_parameters[-1])
+
+    def fetchone(self):
+        """Fetch the next row of a query result set, returning a single sequence, or ``None`` when
+        no more data is available.
+        An :py:class:`~pyhive.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        # if self._state == self._STATE_NONE:
+        #     raise ProgrammingError("No query yet")
+        #
+        # # Sleep until we're done or we have some data to return
+        # self._fetch_while(lambda: not self._data and self._state != self._STATE_FINISHED)
+
+        # Sleep until we're done or we have some data to return
+        # self._fetch_while(lambda: not self._data and self._state != self._STATE_FINISHED)
+        if not self._data:
+            return None
+        else:
+            # if self._rownumber <= 1000:
+            #     _logger.info("Commons - Breaking the loop after 1000Commons - fetch many records")
+            #     return None
+            self._rownumber += 1
+            return self._data.popleft()
+
+    def fetchmany(self, size=None):
+        """Fetch the next set of rows of a query result, returning a sequence of sequences (e.g. a
+        list of tuples). An empty sequence is returned when no more rows are available.
+        The number of rows to fetch per call is specified by the parameter. If it is not given, the
+        cursor's arraysize determines the number of rows to be fetched. The method should try to
+        fetch as many rows as indicated by the size parameter. If this is not possible due to the
+        specified number of rows not being available, fewer rows may be returned.
+        An :py:class:`~pyhive.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        _logger.info("Commons - fetch many.... size - {}".format(size))
+        rowsToReturn = self.fetchone()
+
+        if rowsToReturn is None:
+            return list()
+        return list(rowsToReturn)
+
+    def fetchall(self):
+        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences
+        (e.g. a list of tuples).
+        An :py:class:`~pyhive.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        _logger.info("Commons - fetch all")
+        return list(iter(self.fetchone, None))
+
+    @property
+    def arraysize(self):
+        """This read/write attribute specifies the number of rows to fetch at a time with
+        :py:meth:`fetchmany`. It defaults to 1 meaning to fetch a single row at a time.
+        """
+        return self._arraysize
+
+    @arraysize.setter
+    def arraysize(self, value):
+        self._arraysize = value
+
+    def setinputsizes(self, sizes):
+        """Does nothing by default"""
+        pass
+
+    def setoutputsize(self, size, column=None):
+        """Does nothing by default"""
+        pass
+
+    #
+    # Optional DB API Extensions
+    #
+
+    @property
+    def rownumber(self):
+        """This read-only attribute should provide the current 0-based index of the cursor in the
+        result set.
+        The index can be seen as index of the cursor in a sequence (the result set). The next fetch
+        operation will fetch the row indexed by ``rownumber`` in that sequence.
+        """
+        return self._rownumber
+
+    def __next__(self):
+        """Return the next row from the currently executing SQL statement using the same semantics
+        as :py:meth:`fetchone`. A ``StopIteration`` exception is raised when the result set is
+        exhausted.
+        """
+        _logger.info("Commons - fetching the next row")
+        one = self.fetchone()
+        if one is None:
+            raise StopIteration
+        else:
+            return one
+
+    next = __next__
+
+    def __iter__(self):
+        """Return self to make cursors compatible to the iteration protocol."""
+        return self
+
+
+class DBAPITypeObject(object):
+    # Taken from http://www.python.org/dev/peps/pep-0249/#implementation-hints
+    def __init__(self, *values):
+        self.values = values
+
+    def __cmp__(self, other):
+        if other in self.values:
+            return 0
+        if other < self.values:
+            return 1
+        else:
+            return -1
+
+
+class ParamEscaper(object):
+    _DATE_FORMAT = "%Y-%m-%d"
+    _TIME_FORMAT = "%H:%M:%S.%f"
+    _DATETIME_FORMAT = "{} {}".format(_DATE_FORMAT, _TIME_FORMAT)
+
+    def escape_args(self, parameters):
+        if isinstance(parameters, dict):
+            return {k: self.escape_item(v) for k, v in parameters.items()}
+        elif isinstance(parameters, (list, tuple)):
+            return tuple(self.escape_item(x) for x in parameters)
+        else:
+            raise ProgrammingError("Unsupported param format: {}".format(parameters))
+
+    def escape_number(self, item):
+        return item
+
+    def escape_string(self, item):
+        # Need to decode UTF-8 because of old sqlalchemy.
+        # Newer SQLAlchemy checks dialect.supports_unicode_binds before encoding Unicode strings
+        # as byte strings. The old version always encodes Unicode as byte strings, which breaks
+        # string formatting here.
+        if isinstance(item, bytes):
+            item = item.decode('utf-8')
+        # This is good enough when backslashes are literal, newlines are just followed, and the way
+        # to escape a single quote is to put two single quotes.
+        # (i.e. only special character is single quote)
+        return "'{}'".format(item.replace("'", "''"))
+
+    def escape_sequence(self, item):
+        l = map(str, map(self.escape_item, item))
+        return '(' + ','.join(l) + ')'
+
+    def escape_datetime(self, item, format, cutoff=0):
+        dt_str = item.strftime(format)
+        formatted = dt_str[:-cutoff] if cutoff and format.endswith(".%f") else dt_str
+        return "'{}'".format(formatted)
+
+    def escape_item(self, item):
+        if item is None:
+            return 'NULL'
+        elif isinstance(item, (int, float)):
+            return self.escape_number(item)
+        elif isinstance(item, basestring):
+            return self.escape_string(item)
+        elif isinstance(item, collections.Iterable):
+            return self.escape_sequence(item)
+        elif isinstance(item, datetime.datetime):
+            return self.escape_datetime(item, self._DATETIME_FORMAT)
+        elif isinstance(item, datetime.date):
+            return self.escape_datetime(item, self._DATE_FORMAT)
+        else:
+            raise ProgrammingError("Unsupported object {}".format(item))
+
+
+class UniversalSet(object):
+    """set containing everything"""
+
+    def __contains__(self, item):
+        return True

e6xdb/constants.py

@@ -0,0 +1,32 @@
+import pytz
+
+PRIMITIVE_TYPES = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20, 21}
+COMPLEX_TYPES = {10, 11, 12, 13, 14}
+COLLECTION_TYPES = {10, 11}
+TYPE_NAMES = {
+    0: "BOOLEAN",
+    1: "TINYINT",
+    2: "SMALLINT",
+    3: "INT",
+    4: "BIGINT",
+    5: "FLOAT",
+    6: "DOUBLE",
+    7: "STRING",
+    8: "TIMESTAMP",
+    9: "BINARY",
+    10: "ARRAY",
+    11: "MAP",
+    12: "STRUCT",
+    13: "UNIONTYPE",
+    15: "DECIMAL",
+    16: "NULL",
+    17: "DATE",
+    18: "VARCHAR",
+    19: "CHAR",
+    20: "INTERVAL_YEAR_MONTH",
+    21: "INTERVAL_DAY_TIME",
+}
+CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength"
+PRECISION = "precision"
+SCALE = "scale"
+ZONE = pytz.timezone('UTC')

e6xdb/datainputstream.py

@@ -0,0 +1,170 @@
+import struct
+import logging
+from e6xdb.date_time_utils import FORMATS, floor_div, floor_mod
+from datetime import datetime, timedelta
+from e6xdb.constants import ZONE
+
+_logger = logging.getLogger(__name__)
+
+
+class DataInputStream:
+    def __init__(self, stream):
+        self.stream = stream
+
+    def read_boolean(self):
+        return struct.unpack('?', self.stream.read(1))[0]
+
+    def read_bytes(self, byte_array):
+        for i in range(len(byte_array)):
+            byte_array[i] = struct.unpack('B', self.stream.read(1))[0]
+        return byte_array
+
+    def read_int_96(self):
+        return struct.unpack('B', self.stream.read(12))[0]
+
+    def read_byte(self):
+        return struct.unpack('b', self.stream.read(1))[0]
+
+    def read_unsigned_byte(self):
+        return struct.unpack('B', self.stream.read(1))[0]
+
+    def read_char(self):
+        return chr(struct.unpack('>H', self.stream.read(2))[0])
+
+    def read_double(self):
+        return struct.unpack('>d', self.stream.read(8))[0]
+
+    def read_float(self):
+        return struct.unpack('>f', self.stream.read(4))[0]
+
+    def read_short(self):
+        return struct.unpack('>h', self.stream.read(2))[0]
+
+    def read_unsigned_short(self):
+        return struct.unpack('>H', self.stream.read(2))[0]
+
+    def read_long(self):
+        return struct.unpack('>q', self.stream.read(8))[0]
+
+    def read_utf(self):
+        utf_length = struct.unpack('>H', self.stream.read(2))[0]
+        return self.stream.read(utf_length)
+
+    def read_int(self):
+        return struct.unpack('>i', self.stream.read(4))[0]
+
+    def read_unsigned_int(self):
+        return struct.unpack('>I', self.stream.read(4))[0]
+
+
+class FieldInfo:
+    def __init__(self, name, field_type, date_format, zone):
+        self.name = name
+        self.field_type = field_type
+        self.date_format = date_format
+        self.zone = zone
+
+    def get_zone(self):
+        if self.field_type == 'DATE' or self.field_type == 'DATETIME':
+            return self.zone
+        return None
+
+    def get_format(self):
+        if self.field_type == 'DATE' or self.field_type == 'DATETIME':
+            return self.date_format
+        return None
+
+    def get_field_type(self):
+        return self.field_type
+
+    def get_name(self):
+        return self.name
+
+
+def get_query_columns_info(buffer):
+    result_meta_bytes = DataInputStream(buffer)
+    rowcount = result_meta_bytes.read_long()
+    field_count = result_meta_bytes.read_int()
+    columns_description = list()
+
+    for i in range(field_count):
+        name = result_meta_bytes.read_utf().decode()
+        field_type = result_meta_bytes.read_utf().decode()
+        zone = result_meta_bytes.read_utf().decode()
+        date_format = result_meta_bytes.read_utf().decode()
+        field_info = FieldInfo(name, field_type, date_format, zone)
+        columns_description.append(field_info)
+    return rowcount, columns_description
+
+
+def read_values_from_array(query_columns_description: list, dis: DataInputStream) -> list:
+    value_array = list()
+    for i in query_columns_description:
+        dtype = i.get_field_type()
+        isPresent = dis.read_byte()
+        date_format = i.get_format()
+        if isPresent == 0:
+            value_array.append(None)
+            continue
+        try:
+            if dtype == "LONG":
+                value_array.append(dis.read_long())
+            elif dtype == "DATE":
+                epoch_seconds = floor_div(dis.read_long(), 1000_000)
+                date = datetime.fromtimestamp(epoch_seconds, ZONE)
+                value_array.append(date.strftime("%Y-%m-%d"))
+            elif dtype == "DATETIME":
+                epoch_micros = dis.read_long()
+                epoch_seconds = floor_div(epoch_micros, 1000_000)
+                micros_of_the_day = floor_mod(epoch_micros, 1000_000)
+                date_time = datetime.fromtimestamp(epoch_seconds, ZONE)
+                date_time = date_time + timedelta(microseconds=micros_of_the_day)
+                value_array.append(date_time.strftime("%Y-%m-%d %H:%M:%S"))
+            elif dtype == "STRING" or dtype == "ARRAY" or dtype == "MAP" or dtype == "STRUCT":
+                value_array.append(dis.read_utf().decode())
+            elif dtype == "INT":
+                value_array.append(dis.read_int())
+            elif dtype == "DOUBLE":
+                value_array.append(dis.read_double())
+            elif dtype == "BINARY":
+                value_array.append(dis.read_utf())
+            elif dtype == "FLOAT":
+                value_array.append(dis.read_float())
+            elif dtype == "CHAR":
+                value_array.append(dis.read_char())
+            elif dtype == "BOOLEAN":
+                value_array.append(dis.read_boolean())
+            elif dtype == "SHORT":
+                value_array.append(dis.read_short())
+            elif dtype == "BYTE":
+                value_array.append(dis.read_byte())
+            elif dtype == "INT96":
+                julian_day = dis.read_int()
+                time = dis.read_long()
+                date_time = datetime.fromtimestamp((julian_day - 2440588) * 86400)
+                date_time_with_nanos = date_time + timedelta(microseconds=(time / 1000))
+                value_array.append(date_time_with_nanos)
+            elif dtype == "INTEGER":
+                value_array.append(dis.read_int())
+        except Exception as e:
+            _logger.error(e)
+            value_array.append('Failed to parse.')
+
+    return value_array
+
+
+def read_rows_from_batch(query_columns_description: list, dis: DataInputStream):
+    is_row_present = dis.read_byte()
+    if not is_row_present:
+        return None
+    rows = list()
+    while is_row_present == 1:
+        if is_row_present:
+            row = read_values_from_array(query_columns_description, dis)
+            rows.append(row)
+            #   if rows become 1000, break it
+            # if len(rows) == 1000:
+            #     _logger.info("Read Batch - Breaking the loop after 1000 records")
+            #     break
+        is_row_present = dis.read_byte()
+    return rows

e6xdb/date_time_utils.py

@@ -0,0 +1,167 @@
+TIME_ZONES = {
+    "+12:00": ["Pacific/Kwajalein", "Pacific/Wallis", "Pacific/Funafuti", "Pacific/Nauru", "Kwajalein", "Pacific/Wake",
+               "Pacific/Norfolk", "Pacific/Tarawa", "Asia/Kamchatka", "Etc/GMT-12", "Asia/Anadyr", "Pacific/Majuro", ],
+    "+14:00": ["Pacific/Kiritimati", "Etc/GMT-14", ],
+    "UTC": ["UTC"],
+    "-01:00": ["Etc/GMT+1", "Atlantic/Cape_Verde", "Atlantic/Azores", "America/Scoresbysund", ],
+    "-03:00": ["Chile/Continental", "America/Miquelon", "America/Argentina/Catamarca", "America/Argentina/Cordoba",
+               "America/Araguaina", "America/Argentina/Salta", "Etc/GMT+3", "America/Montevideo", "Brazil/East",
+               "America/Argentina/Mendoza", "America/Argentina/Rio_Gallegos", "America/Catamarca", "America/Godthab",
+               "America/Cordoba", "America/Sao_Paulo", "America/Argentina/Jujuy", "America/Cayenne", "America/Recife",
+               "America/Buenos_Aires", "America/Paramaribo", "America/Mendoza", "America/Santarem", "America/Asuncion",
+               "America/Maceio", "Atlantic/Stanley", "Antarctica/Rothera", "America/Argentina/San_Luis",
+               "America/Santiago", "America/Argentina/Ushuaia", "Antarctica/Palmer", "America/Punta_Arenas",
+               "America/Fortaleza", "America/Argentina/La_Rioja", "America/Belem", "America/Jujuy", "America/Bahia",
+               "America/Argentina/San_Juan", "America/Argentina/ComodRivadavia", "America/Argentina/Tucuman",
+               "America/Nuuk", "America/Rosario", "America/Argentina/Buenos_Aires", ],
+    "-09:00": ["Etc/GMT+9", "US/Alaska", "America/Juneau", "America/Metlakatla", "Pacific/Gambier", "America/Yakutat",
+               "America/Sitka", "SystemV/YST9", "America/Anchorage", "America/Nome", "SystemV/YST9YDT", ],
+    "-07:00": ["Canada/Yukon", "Etc/GMT+7", "US/Arizona", "Mexico/BajaSur", "America/Dawson_Creek", "America/Denver",
+               "America/Yellowknife", "America/Inuvik", "America/Mazatlan", "SystemV/MST7", "America/Boise",
+               "America/Dawson", "MST7MDT", "America/Chihuahua", "America/Ojinaga", "US/Mountain", "America/Creston",
+               "America/Edmonton", "America/Hermosillo", "Canada/Mountain", "America/Cambridge_Bay", "Navajo",
+               "America/Phoenix", "America/Whitehorse", "SystemV/MST7MDT", "America/Fort_Nelson", "America/Shiprock", ],
+    "-05:00": ["America/Panama", "America/Indiana/Petersburg", "America/Eirunepe", "America/Grand_Turk", "Cuba",
+               "Etc/GMT+5", "Pacific/Easter", "America/Fort_Wayne", "America/Havana", "America/Porto_Acre",
+               "US/Michigan", "America/Louisville", "America/Guayaquil", "America/Indiana/Vevay",
+               "America/Indiana/Vincennes", "America/Indianapolis", "America/Iqaluit", "America/Kentucky/Louisville",
+               "EST5EDT", "America/Nassau", "America/Jamaica", "America/Atikokan", "America/Kentucky/Monticello",
+               "America/Coral_Harbour", "America/Cayman", "Chile/EasterIsland", "America/Indiana/Indianapolis",
+               "America/Thunder_Bay", "America/Indiana/Marengo", "America/Bogota", "SystemV/EST5", "US/Eastern",
+               "Canada/Eastern", "America/Port-au-Prince", "America/Nipigon", "Brazil/Acre", "US/East-Indiana",
+               "America/Cancun", "America/Lima", "America/Rio_Branco", "America/Detroit", "Jamaica",
+               "America/Pangnirtung", "America/Montreal", "America/Indiana/Winamac", "America/New_York",
+               "America/Toronto", "SystemV/EST5EDT", ],
+    "+03:00": ["Asia/Aden", "Africa/Nairobi", "Europe/Istanbul", "Etc/GMT-3", "Indian/Comoro", "Antarctica/Syowa",
+               "Africa/Mogadishu", "Africa/Asmera", "Asia/Istanbul", "Europe/Moscow", "Africa/Djibouti",
+               "Europe/Simferopol", "Africa/Asmara", "Asia/Baghdad", "Africa/Dar_es_Salaam", "Africa/Addis_Ababa",
+               "Asia/Riyadh", "Asia/Kuwait", "Europe/Kirov", "Africa/Kampala", "Europe/Minsk", "Asia/Qatar",
+               "Asia/Bahrain", "Indian/Antananarivo", "Indian/Mayotte", "Europe/Volgograd", "Turkey", "W-SU", ],
+    "+01:00": ["Europe/Brussels", "Europe/Warsaw", "CET", "Etc/GMT-1", "Europe/Luxembourg", "Africa/Tunis",
+               "Europe/Malta", "Europe/Busingen", "Africa/Malabo", "Europe/Skopje", "Europe/Sarajevo", "Africa/Lagos",
+               "Europe/Rome", "Africa/Algiers", "Europe/Zurich", "Europe/Gibraltar", "Europe/Vaduz", "Europe/Ljubljana",
+               "Europe/Berlin", "Europe/Stockholm", "Europe/Budapest", "Europe/Zagreb", "Europe/Paris",
+               "Africa/Ndjamena", "Africa/Ceuta", "Europe/Prague", "Europe/Copenhagen", "Europe/Vienna",
+               "Europe/Tirane", "MET", "Europe/Amsterdam", "Africa/Libreville", "Africa/El_Aaiun", "Europe/San_Marino",
+               "Africa/Douala", "Africa/Brazzaville", "Africa/Porto-Novo", "Poland", "Europe/Andorra", "Europe/Oslo",
+               "Europe/Podgorica", "Africa/Casablanca", "Africa/Luanda", "Atlantic/Jan_Mayen", "Africa/Kinshasa",
+               "Europe/Madrid", "Africa/Bangui", "Europe/Belgrade", "Africa/Niamey", "Europe/Bratislava",
+               "Arctic/Longyearbyen", "Europe/Vatican", "Europe/Monaco", ],
+    "+04:30": ["Asia/Kabul", ],
+    "+07:00": ["Asia/Pontianak", "Etc/GMT-7", "Asia/Phnom_Penh", "Asia/Novosibirsk", "Antarctica/Davis", "Asia/Tomsk",
+               "Asia/Jakarta", "Asia/Barnaul", "Indian/Christmas", "Asia/Ho_Chi_Minh", "Asia/Hovd", "Asia/Bangkok",
+               "Asia/Vientiane", "Asia/Novokuznetsk", "Asia/Krasnoyarsk", "Asia/Saigon", ],
+    "+05:45": ["Asia/Kathmandu", "Asia/Katmandu", ],
+    "+05:00": ["Asia/Aqtau", "Etc/GMT-5", "Asia/Samarkand", "Asia/Karachi", "Asia/Yekaterinburg", "Asia/Dushanbe",
+               "Indian/Maldives", "Asia/Oral", "Asia/Tashkent", "Antarctica/Mawson", "Asia/Qyzylorda", "Asia/Aqtobe",
+               "Asia/Ashkhabad", "Asia/Ashgabat", "Asia/Atyrau", "Indian/Kerguelen", ],
+    "+06:30": ["Asia/Yangon", "Asia/Rangoon", "Indian/Cocos", ],
+    "+10:00": ["Pacific/Yap", "Pacific/Port_Moresby", "Pacific/Chuuk", "Australia/Queensland", "Pacific/Guam",
+               "Pacific/Truk", "Asia/Vladivostok", "Pacific/Saipan", "Antarctica/DumontDUrville", "Australia/Brisbane",
+               "Etc/GMT-10", "Asia/Ust-Nera", "Australia/Lindeman", ],
+    "+09:00": ["Etc/GMT-9", "Pacific/Palau", "Asia/Chita", "Asia/Dili", "Asia/Jayapura", "Asia/Yakutsk",
+               "Asia/Pyongyang", "ROK", "Asia/Seoul", "Asia/Khandyga", "Japan", "Asia/Tokyo", ],
+    "Z": ["UTC", "Europe/London", "GMT", "Etc/GMT-0", "Europe/Jersey", "Atlantic/St_Helena", "Europe/Guernsey",
+          "Europe/Isle_of_Man", "Etc/GMT+0", "Africa/Banjul", "Etc/GMT", "Africa/Freetown", "GB-Eire", "Africa/Bamako",
+          "GB", "Africa/Conakry", "Portugal", "Universal", "Africa/Sao_Tome", "Africa/Nouakchott", "Antarctica/Troll",
+          "UTC", "Etc/Universal", "Atlantic/Faeroe", "Africa/Abidjan", "Eire", "Africa/Accra", "Atlantic/Faroe",
+          "Etc/UCT", "GMT0", "Europe/Dublin", "Zulu", "Africa/Ouagadougou", "Atlantic/Reykjavik", "Atlantic/Madeira",
+          "Etc/Zulu", "Iceland", "Europe/Lisbon", "Atlantic/Canary", "Africa/Lome", "Greenwich", "Europe/Belfast",
+          "Etc/GMT0", "America/Danmarkshavn", "Africa/Dakar", "Africa/Bissau", "WET", "Etc/Greenwich",
+          "Africa/Timbuktu", "UCT", "Africa/Monrovia", "Etc/UTC", ],
+    "-11:00": ["Pacific/Pago_Pago", "Pacific/Samoa", "Pacific/Niue", "US/Samoa", "Etc/GMT+11", "Pacific/Midway", ],
+    "-06:00": ["America/El_Salvador", "America/Guatemala", "America/Belize", "America/Managua", "America/Chicago",
+               "America/Tegucigalpa", "Etc/GMT+6", "America/Regina", "Mexico/General", "America/Rankin_Inlet",
+               "US/Central", "Pacific/Galapagos", "America/Rainy_River", "America/Swift_Current", "America/Costa_Rica",
+               "America/Indiana/Knox", "America/North_Dakota/Beulah", "America/Monterrey", "SystemV/CST6",
+               "America/North_Dakota/Center", "America/Indiana/Tell_City", "America/Mexico_City", "America/Matamoros",
+               "CST6CDT", "America/Knox_IN", "America/Menominee", "America/Resolute", "Canada/Central",
+               "America/Bahia_Banderas", "US/Indiana-Starke", "SystemV/CST6CDT", "America/Merida",
+               "Canada/Saskatchewan", "America/North_Dakota/New_Salem", "America/Winnipeg", ],
+    "-03:30": ["America/St_Johns", "Canada/Newfoundland", ],
+    "+13:45": ["NZ-CHAT", "Pacific/Chatham", ],
+    "+10:30": ["Australia/Yancowinna", "Australia/Adelaide", "Australia/Broken_Hill", "Australia/South", ],
+    "+11:00": ["Australia/Hobart", "Australia/Tasmania", "Australia/ACT", "Pacific/Ponape", "Pacific/Bougainville",
+               "Australia/Victoria", "Antarctica/Macquarie", "Antarctica/Casey", "Australia/Canberra",
+               "Australia/Currie", "Australia/Lord_Howe", "Australia/NSW", "Pacific/Pohnpei", "Pacific/Efate",
+               "Asia/Magadan", "Pacific/Kosrae", "Australia/Sydney", "Australia/LHI", "Asia/Sakhalin", "Pacific/Noumea",
+               "Etc/GMT-11", "Asia/Srednekolymsk", "Australia/Melbourne", "Pacific/Guadalcanal", ],
+    "+13:00": ["Pacific/Fakaofo", "Antarctica/McMurdo", "Pacific/Fiji", "Pacific/Enderbury", "NZ", "Pacific/Apia",
+               "Antarctica/South_Pole", "Pacific/Kanton", "Pacific/Auckland", "Pacific/Tongatapu", "Etc/GMT-13", ],
+    "-09:30": ["Pacific/Marquesas", ],
+    "-08:00": ["Etc/GMT+8", "Canada/Pacific", "PST8PDT", "Pacific/Pitcairn", "Mexico/BajaNorte", "America/Tijuana",
+               "SystemV/PST8", "America/Santa_Isabel", "America/Vancouver", "America/Ensenada", "SystemV/PST8PDT",
+               "America/Los_Angeles", "US/Pacific", ],
+    "-02:00": ["Etc/GMT+2", "America/Noronha", "Brazil/DeNoronha", "Atlantic/South_Georgia", ],
+    "-04:00": ["America/Cuiaba", "America/Marigot", "Canada/Atlantic", "Etc/GMT+4", "America/Manaus",
+               "America/St_Thomas", "America/Anguilla", "America/Barbados", "America/Curacao", "America/Guyana",
+               "America/Martinique", "America/Puerto_Rico", "America/Port_of_Spain", "SystemV/AST4",
+               "America/Kralendijk", "America/Antigua", "America/Moncton", "America/St_Vincent", "America/Dominica",
+               "Atlantic/Bermuda", "Brazil/West", "America/Aruba", "America/Halifax", "America/La_Paz",
+               "America/Blanc-Sablon", "America/Santo_Domingo", "America/Glace_Bay", "America/St_Barthelemy",
+               "America/St_Lucia", "America/Montserrat", "America/Lower_Princes", "America/Thule", "America/Tortola",
+               "America/Porto_Velho", "America/Campo_Grande", "America/Goose_Bay", "America/Virgin",
+               "America/Boa_Vista", "America/Grenada", "America/St_Kitts", "America/Caracas", "America/Guadeloupe",
+               "SystemV/AST4ADT", ],
+    "+02:00": ["Africa/Cairo", "Africa/Mbabane", "Etc/GMT-2", "Europe/Zaporozhye", "Libya", "Africa/Kigali",
+               "Africa/Tripoli", "Israel", "Europe/Kaliningrad", "Africa/Windhoek", "Europe/Bucharest",
+               "Europe/Mariehamn", "Africa/Lubumbashi", "Europe/Tiraspol", "Europe/Chisinau", "Europe/Helsinki",
+               "Asia/Beirut", "Asia/Tel_Aviv", "Europe/Sofia", "Africa/Gaborone", "Asia/Gaza", "Europe/Riga",
+               "Africa/Maputo", "Asia/Damascus", "Europe/Uzhgorod", "Asia/Jerusalem", "Africa/Bujumbura", "Europe/Kiev",
+               "Europe/Vilnius", "Africa/Maseru", "Africa/Blantyre", "Africa/Lusaka", "Africa/Harare", "Europe/Tallinn",
+               "Africa/Khartoum", "Africa/Johannesburg", "Africa/Juba", "Asia/Nicosia", "Asia/Famagusta", "EET",
+               "Asia/Hebron", "Egypt", "Asia/Amman", "Europe/Nicosia", "Europe/Athens", ],
+    "+03:30": ["Iran", "Asia/Tehran", ],
+    "+04:00": ["Asia/Yerevan", "Etc/GMT-4", "Asia/Dubai", "Indian/Reunion", "Indian/Mauritius", "Europe/Saratov",
+               "Europe/Samara", "Indian/Mahe", "Asia/Baku", "Asia/Muscat", "Europe/Astrakhan", "Asia/Tbilisi",
+               "Europe/Ulyanovsk", ],
+    "+06:00": ["Asia/Kashgar", "Etc/GMT-6", "Asia/Almaty", "Asia/Dacca", "Asia/Omsk", "Asia/Dhaka", "Indian/Chagos",
+               "Asia/Qostanay", "Asia/Bishkek", "Antarctica/Vostok", "Asia/Urumqi", "Asia/Thimbu", "Asia/Thimphu", ],
+    "+08:45": ["Australia/Eucla", ],
+    "+08:00": ["Asia/Kuching", "Asia/Chungking", "Etc/GMT-8", "Australia/Perth", "Asia/Macao", "Asia/Macau",
+               "Asia/Choibalsan", "Asia/Shanghai", "Asia/Ulan_Bator", "Asia/Chongqing", "Asia/Ulaanbaatar",
+               "Asia/Taipei", "Asia/Manila", "PRC", "Asia/Ujung_Pandang", "Asia/Harbin", "Singapore", "Asia/Brunei",
+               "Australia/West", "Asia/Hong_Kong", "Asia/Makassar", "Hongkong", "Asia/Kuala_Lumpur", "Asia/Irkutsk",
+               "Asia/Singapore", ],
+    "-12:00": ["Etc/GMT+12", ],
+    "+05:30": ["Asia/Kolkata", "Asia/Colombo", "Asia/Calcutta", ],
+    "+09:30": ["Australia/North", "Australia/Darwin", ],
+    "-10:00": ["Pacific/Honolulu", "Pacific/Rarotonga", "Pacific/Tahiti", "Pacific/Johnston", "America/Atka",
+               "US/Hawaii", "SystemV/HST10", "America/Adak", "US/Aleutian", "Etc/GMT+10", ],
+
+}
+
+FORMATS = {
+    "yyyy": "%Y",
+    "dd": "%d",
+    "MM": "%m",
+    "HH": "%H",
+    "mm": "%M",
+    "ss": "%S"
+}
+
+
+def floor_div(x, y):
+    q = x // y
+    if x ^ y < 0 and q * y != x:
+        return q - 1
+    return q
+
+
+def floor_mod(x, y):
+    r = x % y
+    if (x ^ y) < 0 and r != 0:
+        return r + y
+    return r
+
+
+def get_format(str_format):
+    if str_format is None or len(str_format) == 0:
+        return "%Y-%m-%d %H:%M:%S"
+    return FORMATS[str_format]
+
+
+def get_zone(zone):
+    if zone is None or len(zone) == 0:
+        return "UTC"
+    return TIME_ZONES[zone][0]