mimerpy 1.3.0__py3-none-any.whl

mimerpy/__init__.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2017 Mimer Information Technology
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# See license for more details.
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "0.0.0"  # fallback if not built
+
+
+#
+# Set globals in mimerpy module and version in mimerapi module
+#
+from mimerpy import mimerapi
+import re
+
+apilevel = '2.0'
+threadsafety = '1'
+paramstyle = 'qmark'
+_v = re.findall(r'^\d+\.\d+\.\d+$', __version__)
+version = _v[0] if len(_v) else ''
+version_info = tuple([int(x) for x in version.split(".")]) if len(version) else ()
+mimerapi.__version__ = mimerapi.mimerAPIVersion().rstrip()
+
+
+#
+#  Check MimerAPI required version and set function level
+#
+from mimerpy.mimPyExceptions import *
+from mimerpy.mimPyExceptionHandler import mimerpy_error
+
+(_a, _b, _c, _d) = re.findall(r'^(\d+)\.(\d+)\.(\d)+(.)',
+                              mimerapi.__version__)[0]
+mimerapi._version_tuple = (int(_a), int(_b), int(_c), _d)
+if mimerapi._version_tuple < (11, 0, 5, 'A'):
+    raise NotSupportedError((-25101, mimerpy_error[-25101]))
+elif mimerapi._version_tuple < (11, 0, 5, 'B'):
+    # First supported version
+    mimerapi._level = 1
+else:
+    # String access to DECIMAL(p,s) and FLOAT(p). Map to Python decimal
+    mimerapi._level = 2
+
+
+from mimerpy.connectionPy import Connection
+
+def connect(dsn='', user='', password='',
+            autocommit=False, errorhandler=None):
+    """
+    Create a database connection.
+
+    dsn         Data source name.
+                If empty, the environment variable MIMER_DATABASE is consulted.
+                If that variable is unavailable, the default database as
+                specified in /etc/sqlhosts (UNIX) or in the Mimer Administrator
+                (Windows) is used.
+
+    user        Name of the ident to use.
+                If empty, the database server will perform an OS_USER login
+                using the OS-level username. This does not work if the database
+                server is remote.
+
+    password    Password to chosen ident.
+                Leave this empty if performing an OS_USER login.
+
+    autocommit  Autocommit mode.
+                The default behaviour according to PEP-0249 is False, meaning
+                that all transactions have to be explicitly committed.
+                If autocommit is enabled, each statement is committed
+                automatically when executed.
+
+    errorhandler A handler for errors according to the Optional Error Handling
+                Extension described in PEP-0249.
+    """
+    return Connection(dsn, user, password, autocommit, errorhandler)
+
+#
+#  Tracing and logging
+#
+import functools
+import logging
+from mimerpy.cursorPy import _define_funcs
+
+def _tracefunc(func, prefix, logger):
+    @functools.wraps(func)
+    def tracer(*args, **kwargs):
+        r_args = [repr(a) for a in args]
+        r_kwargs = ["%s=%s" % (k, repr(v)) for k, v in kwargs.items()]
+        signature = ", ".join(r_args + r_kwargs)
+        logger.info("%sCall %s(%s)"
+                    % (prefix, func.__name__, signature))
+        try:
+            value = func(*args, **kwargs)
+            logger.info("%sRet: %s" % (prefix, repr(value)))
+            return value
+        except Exception as e:
+            logger.info("EXCEPTION: %s" % repr(e))
+            raise e
+    return tracer
+
+def _alterfuncs(d, prefix, logger):
+    for fn in dir(d):
+        f = d.__getattribute__(fn)
+        if fn[0] != '_' and fn[0] >= 'a' and callable(f):
+            setattr(d, fn, _tracefunc(f, prefix, logger))
+
+def _apitrace(prefix=''):
+    logger = logging.getLogger("MimerAPI")
+    logger.setLevel(logging.INFO)
+    _alterfuncs(mimerapi, prefix, logger)
+    _define_funcs()
+
+def _altermeths(d, prefix, logger):
+    for fn in dir(d):
+        if fn[0] != '_' and fn[0] >= 'a':
+            try:
+                f = d.__getattribute__(d, fn)
+                if callable(f):
+                    setattr(d, fn, _tracefunc(f, prefix, logger))
+            except AttributeError:
+                pass
+
+def _pytrace(prefix=''):
+    logger = logging.getLogger("MimerPy")
+    logger.setLevel(logging.INFO)
+    _alterfuncs(mimerpy, prefix, logger)
+    _altermeths(mimerpy.connectionPy.Connection, prefix, logger)
+    _altermeths(mimerpy.cursorPy.Cursor, prefix, logger)
+    _altermeths(mimerpy.cursorPy.ScrollCursor, prefix, logger)
+
+def _trace(things=255, prefix='', setLogLevel=True):
+    if setLogLevel:
+        logging.basicConfig(level=logging.INFO)
+    if things & 1:
+        _pytrace(prefix)
+    if things & 2:
+        _apitrace(prefix)

mimerpy/__main__.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2017 Mimer Information Technology
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# See license for more details.
+
+import mimerpy
+from mimerpy import mimerapi
+import argparse
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(prog = "mimerpy", description="""
+A simple command line program for the MimerPy library. It can
+display the version number of the MimerPy library (-v switch) or
+connect to a Mimer SQL database server and execute a singe SQL
+statement (provide database, user, and password arguments and a
+SQL statement).
+""")
+    parser.add_argument("-d", "--database",
+                        help="Database to connect to")
+    parser.add_argument("-u", "--user",
+                        help="User name to use in connection")
+    parser.add_argument("-p", "--password",
+                        help="Password for the user")
+    parser.add_argument("-v", "--version",
+                        help="Display MimerPy and MimerAPI version numbers",
+                        action="store_true")
+    parser.add_argument("-t", "--tag",
+                        help=argparse.SUPPRESS, action="store_true")
+    parser.add_argument("--trace",
+                        help=argparse.SUPPRESS, action="store_true")
+    parser.add_argument("sql", default=None, nargs='?',
+                        help="A SQL command to execute")
+    args = parser.parse_args()
+
+    something = False
+
+    if args.tag:
+        something = True
+        print(mimerpy.version)
+
+    if args.version:
+        something = True
+        print("MimerPy   version %s" % mimerpy.__version__)
+        print("Mimer API version %s" % mimerapi.__version__)
+
+    if args.sql:
+        something = True
+        try:
+            if args.trace:
+                mimerpy._trace()
+            with mimerpy.connect(dsn = args.database,
+                                 user = args.user,
+                                 password = args.password,
+                                 autocommit = True) as con:
+                with con.cursor() as cur:
+                    cur.execute(args.sql)
+                    if cur.description is not None:
+                        for r in cur:
+                            print(r)
+        except Exception as e:
+            print(e)
+
+    if not something:
+        print("Use option -h to get help")

mimerpy/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)
+
+__commit_id__ = commit_id = None

mimerpy/connectionPy.py

@@ -0,0 +1,273 @@
+# Copyright (c) 2017 Mimer Information Technology
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# See license for more details.
+
+from mimerpy import mimerapi
+import weakref
+from mimerpy.cursorPy import *
+from mimerpy.mimPyExceptionHandler import *
+import sys
+
+def defaulterrorhandler(connection, cursor, errorclass, errorvalue):
+    """
+    If cursor is not None, (errorclass, errorvalue) is appended to
+    cursor.messages; otherwise it is appended to
+    connection.messages. Then errorclass is raised with errorvalue as
+    the value.
+    You can override this with your own error handler by assigning it
+    to the instance.
+    """
+#    sys.tracebacklimit = 1
+    error = errorclass, errorvalue
+    if cursor:
+        cursor.messages.append(error)
+    else:
+        connection.messages.append(error)
+
+    raise errorclass(errorvalue)
+
+
+class Connection:
+
+    """
+
+        MimerSQL database connection
+
+        The class Connection is used to establish
+        a connection with a Mimer database.
+
+    """
+
+    def __init__(self, dsn='', user='', password='',
+                 autocommit=False, errorhandler=None):
+        """
+        Creates a database connection.
+
+        Use the mimerpy.connect() function to create a connection rather than
+        calling this function.
+        """
+        self.autocommitmode = autocommit
+        self.errorhandler = (errorhandler if errorhandler
+                             else defaulterrorhandler)
+        self.messages = []
+        self._session = None
+        self.__cursors = weakref.WeakSet()
+        self._transaction = False
+
+        dsn = dsn if dsn else ""
+        user = user if user else ""
+        password = password if password else ""
+
+        (self._session, rc) = mimerapi.mimerBeginSession8(dsn, user, password)
+        if rc:
+            if rc == 90:
+                rc = -25031     # Login failure
+            (ec, ev) = get_mimerapi_exception(rc, self._session)
+            mimerapi.mimerEndSession(self._session)
+            self._session = None
+            self.errorhandler(self, None, ec, ev)
+
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self,type, value, traceback):
+        self.__check_if_open()
+        self.close()
+
+    def __del__(self):
+        if (not self._session == None):
+            self.close()
+
+    def close(self):
+        """
+
+            Closes the database connection.
+
+            Method is used for closing a connection.
+            When using close() all cursors that are
+            using the connection are also closed.
+
+            If the auto-commit feature is turned off
+            and a connection is closed before committing
+            any changes, an implicit rollback is executed.
+            Thus, before evoking close(), commit() should
+            be used to prevent any changes being lost. However,
+            if auto-commit is turned on, an implicit rollback
+            is not performed.
+
+            When a connection has been closed using close(),
+            it is unusable and a ProgrammingError() is raised
+            if any operations are attempted on the connection.
+
+        """
+        if (not self._session == None):
+            for cur in self.__cursors:
+                cur.close()
+
+            if (self._transaction):
+                rc_value = mimerapi.mimerEndTransaction(self._session, 1)
+                if (rc_value != -24101):
+                    self.__check_mimerapi_error(rc_value, self._session)
+                self._transaction = False
+            rc_value = mimerapi.mimerEndSession(self._session)
+            self.__check_mimerapi_error(rc_value, self._session)
+            self._session = None
+
+    def rollback(self):
+        """
+
+            Rolls back any pending transaction. Causes the database
+            to roll back to the start of any pending transaction.
+            If a connection is closed without committing any changes
+            made during the transaction, a rollback is implicitly performed.
+
+        """
+        self.__check_if_open()
+        if (self._transaction):
+            rc_value = mimerapi.mimerEndTransaction(self._session, 1)
+            self.__check_mimerapi_error(rc_value, self._session)
+        self._transaction = False
+
+    def commit(self):
+        """Commits any pending transaction."""
+        self.__check_if_open()
+        if (self._transaction):
+            rc_value = mimerapi.mimerEndTransaction(self._session, 0)
+            self.__check_mimerapi_error(rc_value, self._session)
+        self._transaction = False
+
+    def cursor(self, **kwargs):
+        """
+
+            Returns a new Cursor Object using the connection.
+            If scrollable is unspecified, the default cursor class
+            will be returned. If scrollable = True a scrollable
+            cursor will be returned.
+
+        """
+        self.__check_if_open()
+        kwargs2 = kwargs.copy()
+        mode = kwargs2.pop('scrollable', False)
+        if (mode):
+             curs = ScrollCursor(self, self._session)
+        else:
+             curs = Cursor(self, self._session)
+
+        self.__cursors.add(curs)
+        return curs
+
+    def execute(self, *arg):
+        """
+            Creates a cursor and executes a database operation.
+
+            arg
+                query to execute
+
+            Returns a new Cursor object using the connection and executes
+            a database operation.
+
+        """
+        self.__check_if_open()
+        curs = Cursor(self, self._session)
+        self.__cursors.add(curs)
+        curs.execute(*arg)
+        return curs
+
+    def executemany(self, *arg):
+        """
+            Creates a cursor and executes a database operation.
+
+            arg
+                query to execute and parameter sequences.
+
+            Returns a new Cursor object using the connection and executes
+            a database operation against all parameter sequences or mappings
+            found in args.
+
+        """
+        self.__check_if_open()
+        curs = Cursor(self, self._session)
+        self.__cursors.add(curs)
+        curs.executemany(*arg)
+        return curs
+
+    def autocommit(self, mode):
+        """
+
+        Turns autocommit mode on or off. Defualt is false.
+        By using this method, from this point onward changes are autocommitted.
+
+        arg
+            Boolean
+
+        """
+        if (mode):
+            self.autocommitmode = True
+            if (self._transaction):
+                self.rollback()
+        else:
+            self.autocommitmode = False
+
+    def reset(self):
+        """
+        Reset the connection. Close all cursors and do rollback if a transaction
+        is running. Reset auto commit to default.
+        """
+        if self.__cursors:
+            for cur in self.__cursors:
+                cur.close()
+        
+        if self._transaction:
+            self.rollback()
+        
+        self.autocommit(False)
+
+    def __raise_exception(self, rc):
+        self.errorhandler(self, None, get_error_class(rc),
+                          (rc, mimerpy_error[rc]))
+
+    def __check_if_open(self):
+        if (self._session == None):
+            self.__raise_exception(-25010)
+
+    def __check_mimerapi_error(self, rc, handle):
+        if rc < 0:
+            (ec, ev) = get_mimerapi_exception(rc, handle)
+            self.errorhandler(self, None, ec, ev)
+
+    def xid(self):
+        self.__raise_exception(-25001)
+
+    def tpc_begin(self):
+        self.__raise_exception(-25001)
+
+    def tpc_prepare(self):
+        self.__raise_exception(-25001)
+
+    def tpc_commit(self):
+        self.__raise_exception(-25001)
+
+    def tpc_rollback(self):
+        self.__raise_exception(-25001)
+
+    def tpc_recover(self):
+        self.__raise_exception(-25001)