iris-pex-embedded-python 3.1.3__tar.gz → 3.1.4__tar.gz

{iris_pex_embedded_python-3.1.3/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-3.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iris_pex_embedded_python
-Version: 3.1.3
+Version: 3.1.4
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.1.3"
+version = "3.1.4"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/intersystems_iris/_ConnectionInformation.py

@@ -1,7 +1,7 @@
 import intersystems_iris._Constant
 
-class _ConnectionInformation(object):
 
+class _ConnectionInformation(object):
     def __init__(self):
         self.protocol_version = intersystems_iris._Constant._Constant.PROTOCOL_VERSION
         self._is_unicode = True
@@ -20,9 +20,10 @@ class _ConnectionInformation(object):
     def _parse_server_version(self, server_version):
         split_1 = server_version.split("|")
         self._server_version = split_1[0]
-        if len(split_1)>1: self._iris_install_dir = split_1[1]
+        if len(split_1) > 1:
+            self._iris_install_dir = split_1[1]
         if self._server_version.find("Version") > 0:
-            version = server_version[server_version.find("Version")+8:]
+            version = server_version[server_version.find("Version") + 8 :]
             self._server_version_major = version.split(".")[0]
             self._server_version_minor = version.split(".")[1]
         return
@@ -31,24 +32,25 @@ class _ConnectionInformation(object):
     def _map_server_locale(locale):
         # we need to map IRIS locale literals to Python locale literals
         _locales = {
-            "LATIN1": "latin_1", 
-            "LATIN2": "iso8859_2", 
-            "LATINC": "iso8859_5", 
-            "LATINA": "iso8859_6", 
-            "LATING": "iso8859_7", 
-            "LATINH": "iso8859_8", 
-            "LATINT": "iso8859_11", 
-            "LATIN9": "iso8859_15", 
-            "CP1250": "cp1250", 
-            "CP1251": "cp1251", 
-            "CP1252": "cp1252", 
-            "CP1253": "cp1253", 
-            "CP1255": "cp1255", 
-            "CP1256": "cp1256", 
-            "CP1257": "cp1257", 
-            "CP874": "cp874", 
+            "LATIN1": "latin_1",
+            "LATIN2": "iso8859_2",
+            "LATINC": "iso8859_5",
+            "LATINA": "iso8859_6",
+            "LATING": "iso8859_7",
+            "LATINH": "iso8859_8",
+            "LATINT": "iso8859_11",
+            "LATIN9": "iso8859_15",
+            "CP1250": "cp1250",
+            "CP1251": "cp1251",
+            "CP1252": "cp1252",
+            "CP1253": "cp1253",
+            "CP1255": "cp1255",
+            "CP1256": "cp1256",
+            "CP1257": "cp1257",
+            "CP874": "cp874",
             "UNICODE": "utf-8",
         }
         return _locales[locale.upper()] if locale.upper() in _locales else locale
 
-
+    def __repr__(self) -> str:
+        return f"<{self._server_version}>"

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/intersystems_iris/dbapi/_DBAPI.py

@@ -1,3 +1,4 @@
+from typing import Union
 import struct
 import copy
 import enum
@@ -25,6 +26,7 @@ from ._SQLType import SQLType
 
 from .._IRISNative import connect as native_connect
 from .._IRISEmbedded import _IRISEmbedded
+from intersystems_iris._IRISConnection import _IRISConnection
 
 
 def NotImplementedErrorDBAPI(msg=None):
@@ -42,7 +44,7 @@ def embedded_connect(*args, hostname=None, port=None, namespace=None, username=N
     return connection
 
 
-def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw):
+def connect(*args, embedded=False, hostname=None, port=None, namespace=None, username=None, password=None, **kw) -> Union[_IRISConnection, _IRISEmbedded]:
     try:
         if not embedded:
             return native_connect(
@@ -1180,6 +1182,8 @@ class Cursor(_BaseCursor):
         sets = self._parameter_sets or 1
         self.params = list(self.params).copy()
         param_types = [param.type for param in self._params._params_list]
+        if not self.params:
+            return
 
         for i in range(sets):
             params = self._params.collect(i)
@@ -2149,6 +2153,7 @@ class Cursor(_BaseCursor):
 
         if retval is None:
             return retval
+        # print('retval', retval[:])
         return retval.as_tuple()
         # return tuple(retval[:])
 

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/intersystems_iris/dbapi/_ResultSetRow.py

@@ -1,5 +1,5 @@
 import uuid
-from datetime import datetime, date, time
+from datetime import datetime, date, time, timezone
 from collections import namedtuple
 from ._SQLType import SQLType
 from .._DBList import _DBList
@@ -11,20 +11,26 @@ from ._Column import _Column
 def from_timestamp_posix(posix):
     time = int(posix)
     if time > 0:
-        time ^= 0x1000000000000000 
+        time ^= 0x1000000000000000
     else:
-        time |= 0xF000000000000000 
+        time |= 0xF000000000000000
 
     time /= 1000000
 
-    value = datetime.utcfromtimestamp(time).replace(tzinfo=None)
+    value = datetime.fromtimestamp(time, timezone.utc).replace(tzinfo=None)
     return value
 
+
 class _ResultSetRow:
     _locale = "latin-1"
     _connection = None
 
-    def __init__(self, connection, columns=None, rowcount=0, ):
+    def __init__(
+        self,
+        connection,
+        columns=None,
+        rowcount=0,
+    ):
         self._connection = connection
         # index from user-inputted columns to columns received from server
         self.col_index = []
@@ -55,7 +61,7 @@ class _ResultSetRow:
             self.colCount = len(columns) if columns != None else 0
 
         # number of columns received from server, aka number of items per row
-        #self.colCount = rowcount
+        # self.colCount = rowcount
 
         # list of _ListItems corresponding to the various entries in the row, plus the offset of next row's first _ListItem
         self.rowItems = None
@@ -126,9 +132,9 @@ class _ResultSetRow:
 
         def get(self):
             return self[:]
-        
+
         def as_tuple(self):
-            row = namedtuple('Row', [col.name for col in self._columns], rename=True)
+            row = namedtuple("Row", [col.name for col in self._columns], rename=True)
             values = self[:]
             return row(*values)
 
@@ -164,15 +170,18 @@ class _ResultSetRow:
                         HOROLOG_ORDINAL = date(1840, 12, 31).toordinal()
                         if item:
                             item = date.fromordinal(HOROLOG_ORDINAL + item)
+                    if ctype == SQLType.TIMESTAMP and item:
+                        item = item + '.000' if '.' not in item else item
+                        item = datetime.strptime(item, '%Y-%m-%d %H:%M:%S.%f')
                     if ctype == SQLType.TIME_HOROLOG:
                         if item:
                             item = time(item // 3600, item % 3600 // 60, item % 3600 % 60)
                     if ctype == SQLType.GUID:
                         item = uuid.UUID(item)
-                    if ctype == SQLType.TIMESTAMP_POSIX:
+                    if ctype == SQLType.TIMESTAMP_POSIX and item:
                         item = from_timestamp_posix(item)
 
-                    if _column.tableName == 'None' and _column.schema == 'None':
+                    if _column.tableName == "None" and _column.schema == "None":
                         # Ignore for anonymous tables
                         pass
                     elif item is None:
@@ -285,8 +294,9 @@ class _ResultSetRow:
                 rowItems[i] = curr_offset
                 prev_offset = curr_offset
             except IndexError:
-                raise IndexError("Row incomplete: " + str(self.colCount) +
-                                 " items expected, but " + str(i) + " were found")
+                raise IndexError(
+                    "Row incomplete: " + str(self.colCount) + " items expected, but " + str(i) + " were found"
+                )
         self.update(rowItems)
         return True
 
@@ -319,8 +329,9 @@ class _ResultSetRow:
                 rowItems[i] = curr_offset
                 prev_offset = curr_offset
             except IndexError:
-                raise IndexError("Row incomplete: " + str(self.colCount) +
-                                 " items expected, but " + str(i) + " were found")
+                raise IndexError(
+                    "Row incomplete: " + str(self.colCount) + " items expected, but " + str(i) + " were found"
+                )
         return self.update(rowItems)
 
     def update(self, rowItems):
@@ -330,7 +341,7 @@ class _ResultSetRow:
                 colIndexOffsets[idx] = rowItems[i]
             colIndexOffsets[-1] = self._last_list_item.next_offset
             self.rowItems = colIndexOffsets
-            return self.rowItems[:self.colCount]
+            return self.rowItems[: self.colCount]
         self.rowItems = rowItems
         self._offsets = self.DataRow(self)
         self._new_buffer = False

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/intersystems_iris/dbapi/preparser/_PreParser.py

@@ -580,7 +580,10 @@ class _PreParser(object):
                     break
                 if token.TokenType is TOKEN.CONSTANT:
                     values += '?'
-                    params += [token.Lexeme] 
+                    param = token.Lexeme
+                    if param.__len__ and param[0] == "'" and param[0] == param[-1]:
+                        param = param[1: -1]
+                    params += [param]
                 else:    
                     values += token.Lexeme
                 values += ' '

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4/src/iris_pex_embedded_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iris_pex_embedded_python
-Version: 3.1.3
+Version: 3.1.4
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/iris_pex_embedded_python.egg-info/SOURCES.txt

@@ -131,12 +131,6 @@ src/iop/cls/IOP/PrivateSession/Message/Start.cls
 src/iop/cls/IOP/PrivateSession/Message/Stop.cls
 src/iop/cls/IOP/Service/WSGI.cls
 src/iop/wsgi/handlers.py
-src/iris/__init__.py
-src/iris/__init__.pyi
-src/iris/_cli.py
-src/iris/iris_ipm.py
-src/iris/iris_ipm.pyi
-src/iris/iris_utils.py
 src/iris_pex_embedded_python.egg-info/PKG-INFO
 src/iris_pex_embedded_python.egg-info/SOURCES.txt
 src/iris_pex_embedded_python.egg-info/dependency_links.txt

{iris_pex_embedded_python-3.1.3 → iris_pex_embedded_python-3.1.4}/src/iris_pex_embedded_python.egg-info/top_level.txt

@@ -1,5 +1,4 @@
 grongier
 intersystems_iris
 iop
-iris
 irisnative

iris_pex_embedded_python-3.1.3/src/iris/__init__.py

@@ -1,60 +0,0 @@
-from sys import path as __syspath
-import os
-from .iris_ipm import ipm
-
-# check for install dir in environment
-# environment to check is IRISINSTALLDIR
-# if not found, raise exception and exit
-# ISC_PACKAGE_INSTALLDIR - defined by default in Docker images
-installdir = os.environ.get('IRISINSTALLDIR') or os.environ.get('ISC_PACKAGE_INSTALLDIR')
-if installdir is None:
-        raise Exception("""Cannot find InterSystems IRIS installation directory
-    Please set IRISINSTALLDIR environment variable to the InterSystems IRIS installation directory""")
-
-# join the install dir with the bin directory
-__syspath.append(os.path.join(installdir, 'bin'))
-# also append lib/python
-__syspath.append(os.path.join(installdir, 'lib', 'python'))
-
-# save working directory
-__ospath = os.getcwd()
-
-from pythonint import *
-
-# restore working directory
-os.chdir(__ospath)
-
-# TODO: Figure out how to hide __syspath and __ospath from anyone that
-#       imports iris.  Tried __all__ but that only applies to this:
-#           from iris import *
-
-#
-# End-of-file
-#
-
-def __getattr__(name):
-    try:
-        return globals()[name]
-    except KeyError:
-        return __get_iris_object__(name)
- 
-def __get_iris_object__(name:str):
-    try:
-        # replace '_' with '%'
-        name = name.replace('_', '%')
-        return cls(name)
-    except RuntimeError:
-        return __get_iris_package__(name)
- 
-def __get_iris_package__(name:str):
-    return IrisPackage(name)
- 
-class IrisPackage:
-    def __init__(self, name:str):
-        self.name = name
- 
-    def __getattr__(self, name):
-        try:
-            return globals()[f"{self.name}.{name}"]
-        except KeyError:
-            return __get_iris_object__(f"{self.name}.{name}")

iris_pex_embedded_python-3.1.3/src/iris/__init__.pyi

@@ -1,236 +0,0 @@
-from __future__ import annotations
-from typing import Any
-from iris.iris_ipm import ipm
-from . import iris_ipm
-__all__ = [ 'check_status', 'cls', 'execute', 'gref', 'ipm', 'iris_ipm', 'lock', 'os', 'ref', 'routine', 'sql', 'system', 'tcommit', 'tlevel', 'trollback', 'trollbackone', 'tstart', 'unlock', 'utils']
-def check_status(self, status):
-    """
-    Raises an exception on an error status, or returns None if no error condition occurs.
-    Example: iris.check_status(st) checks the status code st to see if it contains an error.
-    """
-def cls(self, class_name):
-    """
-    Returns a reference to an InterSystems IRIS class.
-    Example: iris.cls("%SYSTEM.INetInfo").LocalHostName() calls a method in the class %SYSTEM.INetInfo.
-    """
-def execute(self, statements):
-    """
-    execute IRIS statements.
-    Example: iris.execute("set x="Hello"\nw x,!\n") returns nothing.
-    """
-def gref(self, global_name) -> global_ref:
-    """
-    Returns a reference to an InterSystems IRIS global.
-    Example: g = iris.gref("^foo") sets g to a reference to global ^foo
-    """
-def lock(self, lock_list, timeout_value, locktype):
-    """
-    Sets locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
-    Example: iris.lock(["^foo","^bar"], 30, "S") sets locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
-    """
-def ref(self, value):
-    """
-    Creates an iris.ref object with a specified value.
-    Example: iris.ref("hello") creates an iris.ref object with the value "hello"
-    """
-def routine(self, routine, args):
-    """
-    Invokes an InterSystems IRIS routine, optionally at a given tag.
-    Example: iris.routine("Stop^SystemPerformance", "20211221_160620_test") calls tag Stop in routine ^SystemPerformance.
-    """
-def tcommit(self):
-    """
-    Marks a successful end of an InterSystems IRIS transaction.
-    Example: iris.commit() marks the successful end of a transaction and decrements the nesting level by 1
-    """
-def tlevel(self):
-    """
-    Detects whether a transaction is currently in progress and returns the nesting level. Zero means not in a transaction.
-    Example: iris.tlevel() returns the current transaction nesting level, or zero if not in a transaction
-    """
-def trollback(self):
-    """
-    Terminates the current transaction and restores all journaled database values to their values at the start of the transaction.
-    Example: iris.trollback() rolls back all current transactions in progress and resets the transaction nesting level to 0
-    """
-def trollbackone(self):
-    """
-    Rolls back the current level of nested transactions, that is, the one initiated by the most recent tstart().
-    Example: iris.trollbackone() rolls back the current level of nested transactions and decrements the nesting level by 1
-    """
-def tstart(self):
-    """
-    Starts an InterSystems IRIS transaction.
-    Example: iris.tstart() marks the beginning of a transaction.
-    """
-def unlock(self, lock_list, timout_value, locktype):
-    """
-    Removes locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
-    Example: iris.unlock(["^foo","^bar"], 30, "S") removes locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
-    """
-def utils(self):
-    """
-    Returns a reference to the InterSystems IRIS utilities class.
-    Example: iris.utils().$Job() returns the current job number.
-    """
-# Stubs for the gref object
-class global_ref:
-    def data(self, key):
-        """
-        Checks if a node of a global contains data and/or has descendants. The key of the node is passed as a list. Passing a key with the
-        value None (or an empty list) indicates the root node of the global.\n
-        You can use data() to inspect a node to see if it contains data before attempting to access that data and possibly encountering an error.
-        The method returns 0 if the node is undefined (contains no data), 1 if the node is defined (contains data), 10 if the node is undefined
-        but has descendants, or 11 if the node is defined and has descendants.
-        """
-    def get(self, key):
-        """
-        Gets the value stored at a node of a global. The key of the node is passed as a list. Passing a key with the value None (or an empty list)
-        indicates the root node of the global.
-        """
-    def getAsBytes(self, key):
-        """
-        Gets a string value stored at a node of a global and converts it to the Python bytes data type. The key of the node is passed as a list.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-    def keys(self, key):
-        """
-        Returns the keys of a global, starting from a given key. The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def kill(self, key):
-        """
-        Deletes the node of a global, if it exists. The key of the node is passed as a list. This also deletes any descendants of the node.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-    def order(self, key):
-        """
-        Returns the next key in that level of the global, starting from a given key. The starting key is passed as a list.
-        If no key follows the starting key, order() returns None.
-        """
-    def orderiter(self, key):
-        """
-        Returns the keys and values of a global, starting from a given key, down to the next leaf node.
-        The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def query(self, key):
-        """
-        Traverses a global starting at the specified key, returning each key and value.
-        The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def set(self, key, value):
-        """
-        Sets a node in a global to a given value. The key of the node is passed as a list, and value is the value to be stored.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-# stubs for the sql object
-class sql:
-    """
-    The sql object provides access to the InterSystems IRIS SQL API.
-    """
-    def exec(self, query: str) -> Any:
-        """
-        Execute a query
-        """
-    def prepare(self, query: str) -> PreparedQuery:
-        """
-        Prepare a query
-        """
-    class PreparedQuery:
-        def execute(self, **kwargs) -> Any:
-            """
-            Execute a prepared query, you can pass values
-            """
-# stubs for the system object
-class system:
-    """
-    The system object provides access to the InterSystems IRIS system API.
-    The following classes are available:
-    'DocDB', 'Encryption', 'Error', 'Event', 'Monitor', 'Process', 'Python', 'SQL', 'SYS', 'Security', 'Semaphore', 'Status', 'Util', 'Version'
-    """
-    class DocDB:
-        """
-        The DocDB class provides access to the InterSystems IRIS Document Database API.
-        The following methods are available:
-        'CreateDatabase', 'DropAllDatabases', 'DropDatabase', 'Exists', 'GetAllDatabases', 'GetDatabase', 'Help'
-        """
-        def CreateDatabase(self, name: str, path: str, **kwargs) -> Any:
-            """
-            Create a database
-            """
-        def DropAllDatabases(self) -> Any:
-            """
-            Drop all databases
-            """
-        def DropDatabase(self, name: str) -> Any:
-            """
-            Drop a database
-            """
-        def Exists(self, name: str) -> Any:
-            """
-            Check if a database exists
-            """
-        def GetAllDatabases(self) -> Any:
-            """
-            Get all databases
-            """
-        def GetDatabase(self, name: str) -> Any:
-            """
-            Get a database
-            """
-        def Help(self) -> Any:
-            """
-            Get help
-            """
-    def Encryption(self) -> Any:
-        """
-        The Encryption class provides access to the InterSystems IRIS Encryption API.
-        """
-    def Error(self) -> Any:
-        """
-        The Error class provides access to the InterSystems IRIS Error API.
-        """
-    def Event(self) -> Any:
-        """
-        The Event class provides access to the InterSystems IRIS Event API.
-        """
-    def Monitor(self) -> Any:
-        """
-        The Monitor class provides access to the InterSystems IRIS Monitor API.
-        """
-    def Process(self) -> Any:
-        """
-        The Process class provides access to the InterSystems IRIS Process API.
-        """
-    def Python(self) -> Any:
-        """
-        The Python class provides access to the InterSystems IRIS Python API.
-        """
-    def SQL(self) -> Any:
-        """
-        The SQL class provides access to the InterSystems IRIS SQL API.
-        """
-    def SYS(self) -> Any:
-        """
-        The SYS class provides access to the InterSystems IRIS SYS API.
-        """
-    def Security(self) -> Any:
-        """
-        The Security class provides access to the InterSystems IRIS Security API.
-        """
-    def Semaphore(self) -> Any:
-        """
-        The Semaphore class provides access to the InterSystems IRIS Semaphore API.
-        """
-    def Status(self) -> Any:
-        """
-        The Status class provides access to the InterSystems IRIS Status API.
-        """
-    def Util(self) -> Any:
-        """
-        The Util class provides access to the InterSystems IRIS Util API.
-        """
-    def Version(self) -> Any:
-        """
-        The Version class provides access to the InterSystems IRIS Version API.
-        """
-

iris_pex_embedded_python-3.1.3/src/iris/_cli.py

@@ -1,38 +0,0 @@
-import os
-import sys
-import argparse
-
-from . import iris_utils
-import iris
-
-
-def bind():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--namespace", default="")
-
-    args = parser.parse_args()
-
-    libpython = iris_utils.find_libpython()
-    if not libpython:
-        raise RuntimeError("libpython not found")
-
-    iris.system.Process.SetNamespace("%SYS")
-    config = iris.cls("Config.config").Open()
-
-    # Set the new libpython path
-    config.PythonRuntimeLibrary = libpython
-    # Set the new PythonPath to VIRTUAL_ENV + "/lib" + "/python+" + sys.version[:4] + "/site-packages
-    config.PythonPath = os.path.join(os.environ["VIRTUAL_ENV"], "lib", "python" + sys.version[:4], "site-packages")
-
-    config._Save()
-
-def unbind():
-    iris.system.Process.SetNamespace("%SYS")
-    config = iris.cls("Config.config").Open()
-
-    # Set the new libpython path
-    config.PythonRuntimeLibrary = ""
-    # Set the new PythonPath to VIRTUAL_ENV + "/lib" + "/python+" + sys.version[:4] + "/site-packages
-    config.PythonPath = ""
-
-    config._Save()

iris_pex_embedded_python-3.1.3/src/iris/iris_ipm.py

@@ -1,40 +0,0 @@
-def ipm(cmd, *args):
-    """
-    Executes shell command with IPM:
-    Parameters
-    ----------
-    cmd : str
-        The command to execute
-    Examples
-    --------
-    `ipm('help')`
-    `ipm('load /home/irisowner/dev -v')`
-    `ipm('install webterminal')`
-    """
-
-    import multiprocessing
-    import iris
-
-    def shell(cmd, status):
-        
-
-        status.put(True)
-
-        res = iris.cls("%ZPM.PackageManager").Shell(cmd)
-        print('')
-        if res != 1:
-            status.get()
-            status.put(False)
-
-    manager = multiprocessing.Manager()
-    status = manager.Queue()
-    process = multiprocessing.Process(
-        target=shell,
-        args=(
-            cmd,
-            status,
-        ),
-    )
-    process.start()
-    process.join()
-    return status.get()

iris_pex_embedded_python-3.1.3/src/iris/iris_ipm.pyi

@@ -1,17 +0,0 @@
-from __future__ import annotations
-__all__ = ['ipm']
-def ipm(cmd, *args):
-    """
-    
-        Executes shell command with IPM:
-        Parameters
-        ----------
-        cmd : str
-            The command to execute
-        Examples
-        --------
-        `ipm('help')`
-        `ipm('load /home/irisowner/dev -v')`
-        `ipm('install webterminal')`
-        
-    """