wwpdb.utils.wf 0.43__py3-none-any.whl

wwpdb/utils/wf/DataSelector.py

@@ -0,0 +1,106 @@
+##
+# File:    DataSelector.py
+# Date:    5-April-2010
+#
+# Updates:
+#
+##
+"""
+Container for data selection criteria.
+
+"""
+
+__docformat__ = "restructuredtext en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Creative Commons Attribution 3.0 Unported"
+__version__ = "V0.01"
+
+
+class DataSelector:
+    """A container for data selection criteria.
+
+    A selector defines the following parameters:
+
+    - targetCategoryName  name of category to which selection is applied
+    - targetAttributeNameList [attributeName, attributeName,...] the values of the
+      attributes in this list will be returned subject to the selection condition.
+
+    Selection conditions are stored as a list of tuples of name, value and operator:
+
+    - conditionList  [(attributeName,attributeValue,comparisonOp),,...]
+
+    """
+
+    def __init__(self):
+        super(DataSelector, self).__init__()
+        # self.__verbose = False
+        # sys.stderr.write("DataSelector.__init_()\n")
+        self.__selectorType = None
+        #
+        self.__targetCategoryName = None
+        self.__targetAttributeList = []
+        self.__selectConditionList = []
+
+    def getSelectorType(self):
+        """Get the type of selector type.  Currently only attribute value selections are supported."""
+        return self.__selectorType
+
+    def setSelectCategoryName(self, categoryName):
+        """Set the target category for this selection.
+
+        Returns:
+
+        True for success or False otherwise
+        """
+        try:
+            self.__targetCategoryName = categoryName
+            return True
+        except:  # noqa: E722 pylint: disable=bare-except
+            return False
+
+    def getSelectCategoryName(self):
+        """Get the taget category for this selection."""
+        return self.__targetCategoryName
+
+    def addSelectAttributeName(self, attributeName):
+        """Add an attribute to the list of attributes for this selection.
+
+        Returns:
+
+        True for success or False otherwise
+        """
+        try:
+            if attributeName not in self.__targetAttributeList:
+                self.__targetAttributeList.append(attributeName)
+                self.__selectorType = "attribute"
+            return True
+        except:  # noqa: E722 pylint: disable=bare-except
+            return False
+
+    def getSelectAttributeList(self):
+        """Get the list attributes for the current selection"""
+        return self.__targetAttributeList
+
+    def addSelectCondition(self, attributeName, attributeValue, comparisonOp="equal"):
+        """Add a selection condition to the current selection.
+
+        A selection condition contains the following:
+        - attributeName in the target category.
+        - attributeValue
+        - one of the comparison operators (equals, ...)
+
+        Returns:
+
+        True for success or False otherwise.
+
+        """
+        try:
+            self.__selectConditionList.append((attributeName, attributeValue, comparisonOp))
+            return True
+        except:  # noqa: E722 pylint: disable=bare-except
+            return False
+
+    def getSelectConditionList(self):
+        """Get the list selection conditions."""
+        return self.__selectConditionList

wwpdb/utils/wf/DataValueContainer.py

@@ -0,0 +1,158 @@
+##
+# File:    DataValueContainer.py
+# Date:    28-Mar-2010
+#
+# Updates:
+#
+##
+"""
+Container for data values.
+
+"""
+
+__docformat__ = "restructuredtext en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Creative Commons Attribution 3.0 Unported"
+__version__ = "V0.01"
+
+# For python 2/3 compatible comparison with isinstace
+from builtins import str  # noqa: UP029,A004
+from datetime import date, datetime
+
+
+class DataValueContainer:
+    """Container for data values.
+
+    Supported container types include:
+    - individual bool, int, float, string, date, or datetime values
+    - lists of bool, int, float, string,  date, datetime values
+
+    """
+
+    def __init__(self):
+        super(DataValueContainer, self).__init__()
+        # sys.stderr.write("DataValueContainer.__init_()\n")
+        #
+        self.__valueTypeName = None
+        """ A supported data type name such:
+            - boolean
+            - int or integer
+            - float or double
+            - string
+            - date
+            - datetime
+            """
+        #
+        self.__valueType = type(None)
+        """ Intrinsic Python type corresponding to the valueTypeName.
+
+            Types are defined in the Python class `types`.
+        """
+        #
+        self.__containerTypeName = None
+        """ Container type setting:
+            - value, a single value
+            - list,  a list/vector of values
+            - dict,  a dictionary of key/values pairs
+
+        """
+        #
+        self.__value = None
+
+    def isValueValid(self):
+        """Performs a sanity type check on the current value and container types.
+
+        Returns:
+
+        True if value and container types correspond to the current type settings or False otherwise.
+        """
+        if self.__containerTypeName == "list":
+            if isinstance(self.__value, list):
+                for v in self.__value:  # noqa: SIM110
+                    if not isinstance(v, self.__valueType):
+                        return False
+                return True
+            return False
+        if self.__containerTypeName == "dict":
+            if isinstance(self.__value, dict):
+                return True
+            return False
+
+        if isinstance(self.__value, self.__valueType):
+            return True
+        return False
+
+    def isValueSet(self):
+        """Performs a check if the current data value has been set.
+
+        Returns:
+
+        True if the value has been set or False otherwise.
+
+        """
+        return self.__value is not None
+
+    def setValue(self, value):
+        self.__value = value
+
+    def getValue(self):
+        return self.__value
+
+    def setValueTypeName(self, typeName):
+        """Set the data type name for the container.
+
+        Supported types include:
+        - boolean
+        - int or integer
+        - float or double
+        - string
+        - date
+        - datetime -- no TZ aware form -- might need an update
+
+        Returns:
+
+        True if the input typeName is a supported type or False otherwise.
+        """
+        if str(typeName) in ["boolean", "int", "integer", "float", "double", "string", "date", "datetime"]:
+            self.__valueTypeName = str(typeName)
+            if typeName in ("bool", "boolean"):
+                self.__valueType = bool
+            elif typeName in ("integer", "int", "float", "double"):
+                self.__valueType = int
+            elif typeName == "string":
+                self.__valueType = str
+            elif typeName == "date":
+                tt = date(2010, 1, 1)
+                self.__valueType = tt.__class__
+            elif typeName == "datetime":
+                tt = datetime(2010, 1, 1)  # noqa: DTZ001
+                self.__valueType = tt.__class__
+            else:
+                return False
+            return True
+        return False
+
+    def setContainerTypeName(self, containerName):
+        """Set the container type name.
+
+        Supported container types include:
+        - value,  a individual value
+        - list,   list or vector of values
+        - dict,   dictionary of key,value pairs
+
+        Returns:
+
+        True for supported container types or False otherwise.
+
+        """
+        if containerName in ["value", "list", "dict"]:
+            self.__containerTypeName = containerName
+            return True
+        return False
+
+    def getContainerTypeName(self):
+        return self.__containerTypeName
+
+    def getValueTypeName(self):
+        return self.__valueTypeName

wwpdb/utils/wf/WfDataObject.py

@@ -0,0 +1,89 @@
+##
+# File:    WfDataObject.py
+# Date:    5-April-2010
+#
+# Updates:
+#    1-May-2015  jdw   add common output method
+#    7-Sep-2015  jdw   add __str__ and __repl__
+#
+##
+"""
+Mixin container the workflow data object.
+
+"""
+
+__docformat__ = "restructuredtext en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Creative Commons Attribution 3.0 Unported"
+__version__ = "V0.01"
+
+try:
+    import cStringIO as StringIO  # type: ignore[import-not-found]
+except ImportError:
+    import io as StringIO  # noqa: N812
+
+from wwpdb.io.locator.DataReference import DataFileReference
+
+from wwpdb.utils.wf.DataSelector import DataSelector
+from wwpdb.utils.wf.DataValueContainer import DataValueContainer
+
+
+class WfDataObject(DataSelector, DataValueContainer, DataFileReference):
+    """Top-level container for workflow data object.
+
+    This container includes some combination of the following:
+    - A data file reference (`DataFileReference`)
+    - A data value container (`DataValueContainer`)
+    - A data selector (`DataSelector`)
+
+    """
+
+    # Inherit base __init__
+    # def __init__(self):
+    #    super(WfDataObject, self).__init__()
+    # self.__verbose = False
+    # sys.stderr.write("WfDataObject.__init_()\n")
+
+    def printMe(self, ofh):
+        if self.getReferenceType() in ["file"]:
+            ofh.write("+WfDataObject.printMe() reference type    %s\n" % self.getReferenceType())
+            ofh.write("+WfDataObject.printMe() version ID        %s\n" % self.getVersionId())
+            ofh.write("+WfDataObject.printMe() data set ID       %s\n" % self.getDepositionDataSetId())
+            ofh.write("+WfDataObject.printMe() partition number  %s\n" % self.getPartitionNumber())
+            ofh.write("+WfDataObject.printMe() content type      %s\n" % self.getContentType())
+            ofh.write("+WfDataObject.printMe() file format       %s\n" % self.getFileFormat())
+            ofh.write("+WfDataObject.printMe() storage type      %s\n" % self.getStorageType())
+            ofh.write("+WfDataObject.printMe() directory path    %s\n" % self.getDirPathReference())
+            ofh.write("+WfDataObject.printMe() file path         %s\n" % self.getFilePathReference())
+            if self.getSelectorType() is not None:
+                ofh.write("+WfDataObject.printMe() selector type     %s\n" % self.getSelectorType())
+                ofh.write("+WfDataObject.printMe() select category   %s\n" % self.getSelectCategoryName())
+                ofh.write("+WfDataObject.printMe() select attributes %r\n" % self.getSelectAttributeList())
+                ofh.write("+WfDataObject.printMe() select conditions %r\n" % self.getSelectConditionList())
+        elif self.getContainerTypeName() in ["value", "list", "dict"]:
+            ofh.write("+WfDataObject.printMe() container type %s\n" % self.getContainerTypeName())
+            ofh.write("+WfDataObject.printMe() value type     %s\n" % self.getValueTypeName())
+            ofh.write("+WfDataObject.printMe() is value set   %r\n" % self.isValueSet())
+            ofh.write("+WfDataObject.printMe() is value valid %r\n" % self.isValueValid())
+            ofh.write("+WfDataObject.printMe() data value     %r\n" % self.getValue())
+        else:
+            ofh.write("+WfDataObject.printMe() undefined data object\n")
+
+    def __str__(self):
+        output = StringIO.StringIO()
+        self.printMe(ofh=output)
+        contents = output.getvalue()
+        output.close()
+        return contents
+
+    def __repr__(self):
+        output = StringIO.StringIO()
+        self.printMe(ofh=output)
+        contents = output.getvalue()
+        output.close()
+        return contents
+
+
+if __name__ == "__main__":
+    wfd = WfDataObject()

wwpdb/utils/wf/__init__.py

@@ -0,0 +1,5 @@
+__docformat__ = "restructuredtext en"
+__author__ = "Ezra Peisach"
+__email__ = "ezra.peisach@rcsb.org"
+__license__ = "Apache 2.0"
+__version__ = "0.43"

wwpdb/utils/wf/dbapi/DbApiUtil.py

@@ -0,0 +1,237 @@
+##
+# File:  DbApiUtil.py
+# Date:  04-May-2015
+# Updates:
+##
+"""
+Providing general APIs for database access
+
+This software was developed as part of the World Wide Protein Data Bank
+Common Deposition and Annotation System Project
+
+Copyright (c) 2015 wwPDB
+
+This software is provided under a Creative Commons Attribution 3.0 Unported
+License described at http://creativecommons.org/licenses/by/3.0/.
+
+"""
+
+__docformat__ = "restructuredtext en"
+__author__ = "Zukang Feng"
+__email__ = "zfeng@rcsb.rutgers.edu"
+__license__ = "Creative Commons Attribution 3.0 Unported"
+__version__ = "V0.07"
+
+import datetime
+import os
+import sys
+import time
+
+import MySQLdb
+
+#
+from wwpdb.utils.wf.dbapi.DbConnection import DbConnection
+
+
+class DbApiUtil:
+    def __init__(
+        self,
+        dbServer=None,
+        dbHost=None,
+        dbName=None,
+        dbUser=None,
+        dbPw=None,
+        dbSocket=None,
+        dbPort=None,
+        verbose=False,
+        log=sys.stderr,
+    ):
+        """ """
+        self.__debug = False
+        self.__Nretry = 5
+        self.__dbServer = dbServer
+        self.__dbHost = dbHost
+        self.__dbName = dbName
+        self.__dbUser = dbUser
+        self.__dbPw = dbPw
+        self.__dbSocket = dbSocket
+        self.__dbPort = dbPort
+        self.__verbose = verbose  # pylint: disable=unused-private-member
+        self.__lfh = log
+        self.__schemaMap = {}
+        self.__dbState = 0
+
+        if self.__debug:
+            self.__lfh.write("\n+DbApiUtil.__init__() using socket %r\n" % self.__dbSocket)
+            self.__lfh.write("+DbApiUtil.__init__() using socket environment reference %r\n" % os.getenv("SITE_DB_SOCKET", None))
+
+        self.__myDb = DbConnection(
+            dbServer=self.__dbServer,
+            dbHost=self.__dbHost,
+            dbName=self.__dbName,
+            dbUser=self.__dbUser,
+            dbPw=self.__dbPw,
+            dbPort=self.__dbPort,
+            dbSocket=self.__dbSocket,
+        )
+
+        self.__dbcon = self.__myDb.connect()
+
+    def __reConnect(self):
+        """ """
+        try:
+            self.__myDb.close(self.__dbcon)
+        except MySQLdb.Error:
+            self.__lfh.write("+DbApiUtil.reConnect() DB connection lost - cannot close\n")
+            self.__lfh.write("+DbApiUtil.reConnect() Re-connecting to the database ..\n")
+            self.__lfh.write("+DbApiUtil.reConnect() UTC time = %s\n" % datetime.datetime.utcnow())  # noqa: DTZ003
+
+        for i in range(1, self.__Nretry):
+            try:
+                self.__dbcon = self.__myDb.connect()
+                self.__dbState = 0
+                return True
+            except MySQLdb.Error:
+                self.__lfh.write("+DbApiUtil.reConnect() Cannot get re-connection : trying again\n")
+                time.sleep(2 * i)
+
+        return False
+
+    def __runSelectSQL(self, query):
+        """ """
+        rows = ()
+        try:
+            self.__dbcon.commit()
+            curs = self.__dbcon.cursor(MySQLdb.cursors.DictCursor)
+            curs.execute(query)
+            rows = curs.fetchall()
+        except MySQLdb.Error as e:
+            self.__dbState = e.args[0]
+            self.__lfh.write("Database error %s: %s\n" % (e.args[0], e.args[1]))
+
+        return rows
+
+    def __runUpdateSQL(self, query):
+        """ """
+        try:
+            curs = self.__dbcon.cursor()
+            curs.execute("set autocommit=0")
+            _nrows = curs.execute(query)  # noqa: F841
+            self.__dbcon.commit()
+            curs.execute("set autocommit=1")
+            curs.close()
+            return "OK"
+        except MySQLdb.Error as e:
+            self.__dbcon.rollback()
+            self.__dbState = e.args[0]
+            self.__lfh.write("Database error %s: %s\n" % (e.args[0], e.args[1]))
+        #
+        return None
+
+    def setSchemaMap(self, schemaMap):
+        """ """
+        self.__schemaMap = schemaMap
+
+    def runSelectSQL(self, sql):
+        """method to run a query"""
+        for retry in range(1, self.__Nretry):
+            ret = self.__runSelectSQL(sql)
+            if ret is None:
+                if self.__dbState > 0:
+                    time.sleep(retry * 2)
+                    if not self.__reConnect():
+                        return None
+                else:
+                    return None
+                #
+            else:
+                return ret
+            #
+        #
+        return None
+
+    def runUpdateSQL(self, sql):
+        """method to run a query"""
+        for retry in range(1, self.__Nretry):
+            ret = self.__runUpdateSQL(sql)
+            if ret is None:
+                if self.__dbState > 0:
+                    time.sleep(retry * 2)
+                    if not self.__reConnect():
+                        return None
+                else:
+                    return None
+                #
+            else:
+                return ret
+            #
+        #
+        return None
+
+    def runUpdate(self, table=None, where=None, data=None):
+        if not table:
+            return None
+        #
+        if (not where) and (not data):
+            return None
+        #
+        rowExists = False
+        if where:
+            sql = (
+                "select * from "  # noqa: S608
+                + str(table)
+                + " where "
+                + " and ".join(["%s = '%s'" % (k, v.replace("'", "\\'")) for k, v in where.items()])
+            )  # noqa: S608
+            rows = self.runSelectSQL(sql)
+            if rows and len(rows) > 0:
+                rowExists = True
+            #
+        #
+        if rowExists and (not data):
+            return "OK"
+        #
+        if rowExists:
+            sql = (
+                "update "  # noqa: S608
+                + str(table)
+                + " set "
+                + ",".join(["%s = '%s'" % (k, v.replace("'", "\\'")) for k, v in data.items()])
+            )  # noqa: S608
+            if where:
+                sql += " where " + " and ".join(["%s = '%s'" % (k, v.replace("'", "\\'")) for k, v in where.items()])
+            #
+        else:
+            sql = "insert into " + str(table) + " (" + ",".join(["%s" % (k) for k, v in where.items()])
+            if data:
+                sql += "," + ",".join(["%s" % (k) for k, v in data.items()])
+            #
+            sql += ") values (" + ",".join(["'%s'" % (v.replace("'", "\\'")) for k, v in where.items()])
+            if data:
+                sql += "," + ",".join(["'%s'" % (v.replace("'", "\\'")) for k, v in data.items()])
+            #
+            sql += ")"
+        #
+        return self.runUpdateSQL(sql)
+
+    def runUpdateSQLwithKey(self, key=None, parameter=()):
+        """ """
+        if not key or not self.__schemaMap or (key not in self.__schemaMap):
+            return None
+        #
+        sql = self.__schemaMap[key]
+        if parameter:
+            sql = self.__schemaMap[key] % parameter
+        #
+        return self.runUpdateSQL(sql)
+
+    def selectData(self, key=None, parameter=()):
+        """ """
+        if key is None or not self.__schemaMap or (key not in self.__schemaMap):
+            return None
+        #
+        sql = self.__schemaMap[key]
+        if parameter:
+            sql = self.__schemaMap[key] % parameter
+        #
+        return self.runSelectSQL(sql)