rda-python-common 2.0.10__tar.gz → 2.0.14__tar.gz

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rda_python_common
-Version: 2.0.10
+Version: 2.0.14
 Summary: RDA Python common library codes shared by other RDA python packages
 Author-email: Zaihua Ji <zji@ucar.edu>
 Project-URL: Homepage, https://github.com/NCAR/rda-python-common

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rda_python_common"
-version = "2.0.10"
+version = "2.0.14"
 authors = [
   { name="Zaihua Ji", email="zji@ucar.edu" },
 ]

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/src/rda_python_common/PgDBI.py

@@ -468,6 +468,8 @@ def check_dberror(pgerr, pgcnt, sqlstr, ary, logact = PGDBI['ERRLOG']):
 
    if logact&PgLOG.DOLOCK and pgcode and re.match(r'^55\w\w\w$', pgcode):
       logact &= ~PgLOG.EXITLG   # no exit for lock error
+   elif pgcnt > PgLOG.PGLOG['DBRETRY']:
+      logact |= PgLOG.EXITLG   # exit for error count exceeds limit
    return qelog(dberror, 0, sqlstr, ary, pgcnt, logact)
 
 #

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/src/rda_python_common/pg_cmd.py

@@ -1,18 +1,13 @@
-#
 ###############################################################################
-#
-#     Title : pg_cmd.py
-#    Author : Zaihua Ji,  zji@ucar.edu
-#      Date : 08/25/2020
+#     Title: pg_cmd.py
+#    Author: Zaihua Ji,  zji@ucar.edu
+#      Date: 08/25/2020
 #             2025-01-10 transferred to package rda_python_common from
 #             https://github.com/NCAR/rda-shared-libraries.git
-#   Purpose : python library module for functions to record commands for delayed
+#   Purpose: python library module for functions to record commands for delayed
 #             mode or command recovery
-#
-#    Github : https://github.com/NCAR/rda-python-common.git
-#
+#    Github: https://github.com/NCAR/rda-python-common.git
 ###############################################################################
-#
 import os
 import re
 import sys
@@ -25,18 +20,18 @@ class PgCMD(PgLock):
       super().__init__()  # initialize parent class
       # cached dscheck info
       self.DSCHK = {}
-      self.BOPTIONS = {"hostname" : None, "qoptions" : None, "modules" : None, "environments" : None}
+      self.BOPTIONS = {"hostname": None, "qoptions": None, "modules": None, "environments": None}
       self.BFIELDS = ', '.join(self.BOPTIONS)
       self.TRYLMTS = {
-         'dsquasar'  : 3,
-         'dsarch'  : 2,
-         'default' : 1
+         'dsquasar': 3,
+         'dsarch': 2,
+         'default': 1
       }
       self.DLYPTN = r'(^|\s)-(d|BP|BatchProcess|DelayedMode)(\s|$)'
       self.DLYOPT = {
-         'dsarch' : ' -d',
-         'dsupdt' : ' -d',
-         'dsrqst' : ' -d'
+         'dsarch': ' -d',
+         'dsupdt': ' -d',
+         'dsrqst': ' -d'
       }
 
    #  params: dict array holding option values
@@ -381,7 +376,7 @@ class PgCMD(PgLock):
          fcnt = pgrec['fcount']
       else:
          fcnt = 0
-         pgrec = {'fcount' : 0}
+         pgrec = {'fcount': 0}
       if not fcnt: fcnt = self.pgget("wfrqst", "", cnd, logact)
       if fcnt and fcount != fcnt: fcount = fcnt
       if fcount:
@@ -402,14 +397,14 @@ class PgCMD(PgLock):
 
    # set dscheck fcount
    def set_dscheck_fcount(self, count, logact = 0):
-      record = {'fcount' : count, 'chktime' : int(time.time())}
+      record = {'fcount': count, 'chktime': int(time.time())}
       self.pgupdt("dscheck", record, self.DSCHK['chkcnd'], logact)
       self.DSCHK['fcount'] = count
       return self.DSCHK['dcount']     # return Done count
 
    # set dscheck dcount
    def set_dscheck_dcount(self, count, size, logact = 0):
-      record = {'dcount' : count, 'size' : size, 'chktime' : int(time.time())}
+      record = {'dcount': count, 'size': size, 'chktime': int(time.time())}
       self.pgupdt("dscheck", record, self.DSCHK['chkcnd'], logact)
       self.DSCHK['dcount'] = count
       self.DSCHK['size'] = size
@@ -444,7 +439,7 @@ class PgCMD(PgLock):
       if pgrec['pid'] != cpid or pgrec['lockhost'] != chost: return 0
    
       # update dscheck status only if it is still locked by the current process
-      record = {'status' : stat, 'chktime' : int(time.time()), 'pid' : 0}
+      record = {'status': stat, 'chktime': int(time.time()), 'pid': 0}
       return self.pgupdt("dscheck", record, self.DSCHK['chkcnd'], logact)
 
    # get the number of tries to execute for a given cmd under dscheck control

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/src/rda_python_common/pg_dbi.py

@@ -1,18 +1,13 @@
-#
 ###############################################################################
-#
-#     Title : pg_dbi.py  -- PostgreSQL DataBase Interface
-#    Author : Zaihua Ji,  zji@ucar.edu
-#      Date : 06/07/2022
+#     Title: pg_dbi.py  -- PostgreSQL DataBase Interface
+#    Author: Zaihua Ji,  zji@ucar.edu
+#      Date: 06/07/2022
 #             2025-01-10 transferred to package rda_python_common from
 #             https://github.com/NCAR/rda-shared-libraries.git
 #             2025-11-24 convert to class PgDBI
-#   Purpose : Python library module to handle query and manipulate PostgreSQL database
-#
-#    Github : https://github.com/NCAR/rda-python-common.git
-#
+#   Purpose: Python library module to handle query and manipulate PostgreSQL database
+#    Github: https://github.com/NCAR/rda-python-common.git
 ###############################################################################
-
 import os
 import re
 import time
@@ -49,22 +44,22 @@ class PgDBI(PgLOG):
       self.PGSIGNS = ['!', '<', '>', '<>']
       self.CHCODE = 1042
       # hard coded db ports for dbnames
-      self.DBPORTS = {'default' : 0}
+      self.DBPORTS = {'default': 0}
       self.DBPASS = {}
       self.DBBAOS = {}
       # hard coded db names for given schema names
       self.DBNAMES = {
-         'ivaddb' : 'ivaddb',
-         'cntldb' : 'ivaddb',
-         'cdmsdb' : 'ivaddb',
-         'ispddb' : 'ispddb',
-          'obsua' : 'upadb',
-        'default' : 'rdadb',
+         'ivaddb': 'ivaddb',
+         'cntldb': 'ivaddb',
+         'cdmsdb': 'ivaddb',
+         'ispddb': 'ispddb',
+          'obsua': 'upadb',
+        'default': 'rdadb',
       }
       # hard coded socket paths for machine_dbnames
-      self.DBSOCKS = {'default' : ''}
+      self.DBSOCKS = {'default': ''}
       # home path for check db on alter host
-      self.VIEWHOMES = {'default' : self.PGLOG['DSSDBHM']}
+      self.VIEWHOMES = {'default': self.PGLOG['DSSDBHM']}
       # add more to the list if used for names
       self.PGRES = ['end', 'window']
       self.SETPGDBI('DEFDB', 'rdadb')
@@ -366,6 +361,8 @@ class PgDBI(PgLOG):
             return self.SUCCESS
       if logact&self.DOLOCK and pgcode and re.match(r'^55\w\w\w$', pgcode):
          logact &= ~self.EXITLG   # no exit for lock error
+      elif pgcnt > self.PGLOG['DBRETRY']:
+         logact |= self.EXITLG   # exit for error count exceeds limit
       return self.qelog(dberror, 0, sqlstr, ary, pgcnt, logact)
 
    # return hash reference to postgresql batch mode command and output file name
@@ -395,8 +392,8 @@ class PgDBI(PgLOG):
       elif reconnect:
          reconnect = 0   # initial connection
       while True:
-         config = {'database' : self.PGDBI['DBNAME'],
-                       'user' : self.PGDBI['LNNAME']}
+         config = {'database': self.PGDBI['DBNAME'],
+                       'user': self.PGDBI['LNNAME']}
          if self.PGDBI['DBSHOST'] == self.PGLOG['HOSTNAME']:
             config['host'] = 'localhost'
          else:
@@ -746,8 +743,8 @@ class PgDBI(PgLOG):
 
    # tablenames: comma deliminated string of one or more tables
    #     fields: comma deliminated string of one or more field names,
-   #    cnddict: condition dict with field names : values
-   # return a dict(field names : values) upon success
+   #    cnddict: condition dict with field names: values
+   # return a dict(field names: values) upon success
    # retrieve one records from tablenames condition dict
    def pghget(self, tablenames, fields, cnddict, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -792,8 +789,8 @@ class PgDBI(PgLOG):
 
    # tablenames: comma deliminated string of one or more tables
    #     fields: comma deliminated string of one or more field names,
-   #   cnddicts: condition dict with field names : value lists
-   # return a dict(field names : value lists) upon success
+   #   cnddicts: condition dict with field names: value lists
+   # return a dict(field names: value lists) upon success
    # retrieve multiple records from tablenames for condition dict
    def pgmhget(self, tablenames, fields, cnddicts, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -868,7 +865,7 @@ class PgDBI(PgLOG):
 
    # update one or multiple rows in tablename
    # tablename: update for one table name each call
-   #    record: dict with field names : values
+   #    record: dict with field names: values
    # condition: update conditions for where clause)
    # return number of rows undated upon success
    def pgupdt(self, tablename, record, condition, logact = None):
@@ -902,8 +899,8 @@ class PgDBI(PgLOG):
 
    # update one or multiple records in tablename
    # tablename: update for one table name each call
-   #    record: update values, dict with field names : values
-   #   cnddict: condition dict with field names : values
+   #    record: update values, dict with field names: values
+   #   cnddict: condition dict with field names: values
    # return number of records updated upon success
    def pghupdt(self, tablename, record, cnddict, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -937,8 +934,8 @@ class PgDBI(PgLOG):
 
    # update multiple records in tablename
    # tablename: update for one table name each call
-   #   records: update values, dict with field names : value lists
-   #   cnddicts: condition dict with field names : value lists
+   #   records: update values, dict with field names: value lists
+   #   cnddicts: condition dict with field names: value lists
    # return number of records updated upon success
    def pgmupdt(self, tablename, records, cnddicts, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -1019,7 +1016,7 @@ class PgDBI(PgLOG):
 
    # delete one or mutiple records in tablename according condition
    # tablename: delete for one table name each call
-   #    cndict: delete condition dict for names : values
+   #    cndict: delete condition dict for names: values
    # return number of records deleted upon success
    def pghdel(self, tablename, cnddict, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -1050,7 +1047,7 @@ class PgDBI(PgLOG):
 
    # delete mutiple records in tablename according condition
    # tablename: delete for one table name each call
-   #   cndicts: delete condition dict for names : value lists
+   #   cndicts: delete condition dict for names: value lists
    # return number of records deleted upon success
    def pgmdel(self, tablename, cnddicts, logact = None):
       if logact is None: logact = self.PGDBI['ERRLOG']
@@ -1155,7 +1152,7 @@ class PgDBI(PgLOG):
       pgrec = self.pgget("dssdb.user", "uid", "userno = {}".format(userno), self.PGDBI['ERRLOG'])
       if pgrec: return pgrec['uid']
       pgrec = self.ucar_user_info(userno)
-      if not pgrec: pgrec = {'userno' : userno, 'stat_flag' : 'M'}
+      if not pgrec: pgrec = {'userno': userno, 'stat_flag': 'M'}
       uid = self.pgadd("dssdb.user", pgrec, (self.PGDBI['EXITLG']|self.AUTOID))
       if uid: self.pglog("{}: Scientist ID Added as user.uid = {}".format(userno, uid), self.LGWNEM)
       return uid
@@ -1177,7 +1174,7 @@ class PgDBI(PgLOG):
       pgrec = self.pgget("dssdb.user", "uid", "logname = '{}'".format(logname), self.PGDBI['ERRLOG'])
       if pgrec: return pgrec['uid']
       pgrec = self.ucar_user_info(0, logname)
-      if not pgrec: pgrec = {'logname' : logname, 'stat_flag' : 'M'}
+      if not pgrec: pgrec = {'logname': logname, 'stat_flag': 'M'}
       uid = self.pgadd("dssdb.user", pgrec, (self.PGDBI['EXITLG']|self.AUTOID))
       if uid: self.pglog("{}: UCAR Login Name Added as user.uid = {}".format(logname, uid), self.LGWNEM)
       return uid
@@ -1185,18 +1182,18 @@ class PgDBI(PgLOG):
    # get ucar user info for given userno (scientist number) or logname (Ucar login)
    def ucar_user_info(self, userno, logname = None):
       matches = {
-         'upid' : "upid",
-         'uid'  : "userno",
-         'username' : "logname",
-         'lastName' : "lstname",
-         'firstName' : "fstname",
-         'active' : "stat_flag",
-         'internalOrg' : "division",
-         'externalOrg' : "org_name",
-         'country' : "country",
-         'forwardEmail' : "email",
-         'email' : "ucaremail",
-         'phone' : "phoneno"
+         'upid': "upid",
+         'uid': "userno",
+         'username': "logname",
+         'lastName': "lstname",
+         'firstName': "fstname",
+         'active': "stat_flag",
+         'internalOrg': "division",
+         'externalOrg': "org_name",
+         'country': "country",
+         'forwardEmail': "email",
+         'email': "ucaremail",
+         'phone': "phoneno"
       }
       buf = self.pgsystem("pgperson " + ("-uid {}".format(userno) if userno else "-username {}".format(logname)), self.LOGWRN, 20)
       if not buf: return None
@@ -1248,13 +1245,13 @@ class PgDBI(PgLOG):
    #  set country code for given coutry name or email address
    def set_country_code(self, email, country = None):
       codes = {
-         'CHINA'   : "P.R.CHINA",
-         'ENGLAND' : "UNITED.KINGDOM",
-         'FR'      : "FRANCE",
-         'KOREA'   : "SOUTH.KOREA",
-         'USSR'    : "RUSSIA",
-         'US'      : "UNITED.STATES",
-         'U.S.A.'  : "UNITED.STATES"
+         'CHINA': "P.R.CHINA",
+         'ENGLAND': "UNITED.KINGDOM",
+         'FR': "FRANCE",
+         'KOREA': "SOUTH.KOREA",
+         'USSR': "RUSSIA",
+         'US': "UNITED.STATES",
+         'U.S.A.': "UNITED.STATES"
       }
       if country:
          country = country.upper()
@@ -1282,7 +1279,7 @@ class PgDBI(PgLOG):
       pgrec = self.pgget("wuser", "wuid", emcond, self.LOGERR)
       if pgrec: return pgrec['wuid']
       # now add one in
-      record = {'email' : email}
+      record = {'email': email}
       # check again if a ruser is on file
       pgrec = self.pgget("ruser", "*", emcond + " AND end_date IS NULL", self.PGDBI['ERRLOG'])
       if not pgrec: pgrec = self.pgget("ruser", "*", emcond, self.PGDBI['ERRLOG'])
@@ -1528,11 +1525,11 @@ class PgDBI(PgLOG):
 
    # email: full user email address
    # get user real name from table ruser for a given email address
-   # opts == 1 : include email
-   # opts == 2 : include org_type
-   # opts == 4 : include country
-   # opts == 8 : include valid_email
-   # opts == 16 : include org
+   # opts == 1: include email
+   # opts == 2: include org_type
+   # opts == 4: include country
+   # opts == 8: include valid_email
+   # opts == 16: include org
    def get_ruser_names(self, email, opts = 0, date = None):
       fields = "lname lstname, fname fstname"
       if opts&1: fields += ", email"
@@ -1857,9 +1854,9 @@ class PgDBI(PgLOG):
       self.DBBAOS[dbname] = {}
       url = 'https://bao.k8s.ucar.edu/'
       baopath = {
-         'ivaddb' : 'gdex/pgdb03',
-         'ispddb' : 'gdex/pgdb03',
-         'default' : 'gdex/pgdb01'
+         'ivaddb': 'gdex/pgdb03',
+         'ispddb': 'gdex/pgdb03',
+         'default': 'gdex/pgdb01'
       }
       dbpath = baopath[dbname] if dbname in baopath else baopath['default']
       client = hvac.Client(url=self.PGDBI.get('BAOURL'))

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/src/rda_python_common/pg_file.py

@@ -1,19 +1,14 @@
-#
 ###############################################################################
-#
-#     Title : self.py
-#    Author : Zaihua Ji,  zji@ucar.edu
-#      Date : 08/05/2020
+#     Title: pg_file.py
+#    Author: Zaihua Ji,  zji@ucar.edu
+#      Date: 08/05/2020
 #             2025-01-10 transferred to package rda_python_common from
 #             https://github.com/NCAR/rda-shared-libraries.git
 #             2025-12-01 convert to class PgFile
-#   Purpose : python library module to copy, move and delete data files locally
+#   Purpose: python library module to copy, move and delete data files locally
 #             and remotely
-#
-#    Github : https://github.com/NCAR/rda-python-common.git
-#
+#    Github: https://github.com/NCAR/rda-python-common.git
 ###############################################################################
-#
 import sys
 import os
 from os import path as op
@@ -39,24 +34,24 @@ class PgFile(PgUtil, PgSIG):
       super().__init__()  # initialize parent class
       self.PGCMPS = {
       #  extension Compress       Uncompress       ArchiveFormat
-         'Z'   :  ['compress -f', 'uncompress -f', 'Z'],
-         'zip' :  ['zip',         'unzip',         'ZIP'],
-         'gz'  :  ['gzip',        'gunzip',        'GZ'],
-         'xz'  :  ['xz',          'unxz',          'XZ'],
-         'bz2' :  ['bzip2',       'bunzip2',       'BZ2']
+         'Z':  ['compress -f', 'uncompress -f', 'Z'],
+         'zip':  ['zip',         'unzip',         'ZIP'],
+         'gz':  ['gzip',        'gunzip',        'GZ'],
+         'xz':  ['xz',          'unxz',          'XZ'],
+         'bz2':  ['bzip2',       'bunzip2',       'BZ2']
       }
       self.CMPSTR = '|'.join(self.PGCMPS)
       self.PGTARS = {
       #  extension   Packing      Unpacking   ArchiveFormat
-         'tar'     : ['tar -cvf',  'tar -xvf', 'TAR'],
-         'tar.Z'   : ['tar -Zcvf', 'tar -xvf', 'TAR.Z'],
-         'zip'     : ['zip -v',    'unzip -v', 'ZIP'],
-         'tgz'     : ['tar -zcvf', 'tar -xvf', 'TGZ'],
-         'tar.gz'  : ['tar -zcvf', 'tar -xvf', 'TAR.GZ'],
-         'txz'     : ['tar -cvJf', 'tar -xvf', 'TXZ'],
-         'tar.xz'  : ['tar -cvJf', 'tar -xvf', 'TAR.XZ'],
-         'tbz2'    : ['tar -cvjf', 'tar -xvf', 'TBZ2'],
-         'tar.bz2' : ['tar -cvjf', 'tar -xvf', 'TAR.BZ2']
+         'tar': ['tar -cvf',  'tar -xvf', 'TAR'],
+         'tar.Z': ['tar -Zcvf', 'tar -xvf', 'TAR.Z'],
+         'zip': ['zip -v',    'unzip -v', 'ZIP'],
+         'tgz': ['tar -zcvf', 'tar -xvf', 'TGZ'],
+         'tar.gz': ['tar -zcvf', 'tar -xvf', 'TAR.GZ'],
+         'txz': ['tar -cvJf', 'tar -xvf', 'TXZ'],
+         'tar.xz': ['tar -cvJf', 'tar -xvf', 'TAR.XZ'],
+         'tbz2': ['tar -cvjf', 'tar -xvf', 'TBZ2'],
+         'tar.bz2': ['tar -cvjf', 'tar -xvf', 'TAR.BZ2']
       }
       self.TARSTR = '|'.join(self.PGTARS)
       self.DELDIRS = {}
@@ -70,42 +65,42 @@ class PgFile(PgUtil, PgSIG):
       self.DIRLVLS = 0
       self.BFILES = {}  # cache backup file names and dates for each bid
       # record how many errors happen for working with HPSS, local or remote machines
-      self.ECNTS = {'D' : 0, 'H' : 0, 'L' : 0, 'R' : 0, 'O' : 0, 'B' : 0}
+      self.ECNTS = {'D': 0, 'H': 0, 'L': 0, 'R': 0, 'O': 0, 'B': 0}
       # up limits for how many continuing errors allowed
-      self.ELMTS = {'D' : 20, 'H' : 20, 'L' : 20, 'R' : 20, 'O' : 10, 'B' : 10}
+      self.ELMTS = {'D': 20, 'H': 20, 'L': 20, 'R': 20, 'O': 10, 'B': 10}
       # down storage hostnames & paths
       self.DHOSTS = {
-         'G' : self.PGLOG['GPFSNAME'],
-         'O' : self.OHOST,
-         'B' : self.BHOST,
-         'D' : self.DHOST
+         'G': self.PGLOG['GPFSNAME'],
+         'O': self.OHOST,
+         'B': self.BHOST,
+         'D': self.DHOST
       }
       self.DPATHS = {
-         'G' : self.PGLOG['DSSDATA'],
-         'O' : self.PGLOG['OBJCTBKT'],
-         'B' : '/' + self.PGLOG['DEFDSID'],   # backup globus endpoint
-         'D' : '/' + self.PGLOG['DEFDSID']    # disaster recovery globus endpoint
+         'G': self.PGLOG['DSSDATA'],
+         'O': self.PGLOG['OBJCTBKT'],
+         'B': '/' + self.PGLOG['DEFDSID'],   # backup globus endpoint
+         'D': '/' + self.PGLOG['DEFDSID']    # disaster recovery globus endpoint
       }
       self.QSTATS = {
-         'A' : 'ACTIVE',
-         'I' : 'INACTIVE',
-         'S' : 'SUCCEEDED',
-         'F' : 'FAILED',
+         'A': 'ACTIVE',
+         'I': 'INACTIVE',
+         'S': 'SUCCEEDED',
+         'F': 'FAILED',
       }
       self.QPOINTS = {
-         'L' : 'gdex-glade',
-         'B' : 'gdex-quasar',
-         'D' : 'gdex-quasar-drdata'
+         'L': 'gdex-glade',
+         'B': 'gdex-quasar',
+         'D': 'gdex-quasar-drdata'
       }
       self.QHOSTS = {
-         'gdex-glade' : self.LHOST,
-         'gdex-quasar' : self.BHOST,
-         'gdex-quasar-drdata' : self.DHOST
+         'gdex-glade': self.LHOST,
+         'gdex-quasar': self.BHOST,
+         'gdex-quasar-drdata': self.DHOST
       }
       self.ENDPOINTS = {
-         'gdex-glade' : "NCAR GDEX GLADE",
-         'gdex-quasar' : "NCAR GDEX Quasar",
-         'gdex-quasar-drdata' : "NCAR GDEX Quasar DRDATA"
+         'gdex-glade': "NCAR GDEX GLADE",
+         'gdex-quasar': "NCAR GDEX Quasar",
+         'gdex-quasar-drdata': "NCAR GDEX Quasar DRDATA"
       }
 
    # reset the up limit for a specified error type
@@ -339,7 +334,7 @@ class PgFile(PgUtil, PgSIG):
 
    # submit a globus task and return a task id
    def submit_globus_task(self, cmd, endpoint, logact = 0, qstr = None):
-      task = {'id' : None, 'stat' : 'U'}
+      task = {'id': None, 'stat': 'U'}
       loop = reset = 0
       while (loop-reset) < 2:
          buf = self.pgsystem(cmd, logact, self.CMDGLB, qstr)
@@ -1465,7 +1460,7 @@ class PgFile(PgUtil, PgSIG):
 
    # object store function to get file stat
    def object_file_stat(self, hash, uhash, opt):
-      info = {'isfile' : 1, 'data_size' : int(hash['Size']), 'fname' : op.basename(hash['Key'])}
+      info = {'isfile': 1, 'data_size': int(hash['Size']), 'fname': op.basename(hash['Key'])}
       if not opt: return info   
       if opt&17:
          ms = re.match(r'^(\d+-\d+-\d+)\s+(\d+:\d+:\d+)', hash['LastModified'])

{rda_python_common-2.0.10 → rda_python_common-2.0.14}/src/rda_python_common/pg_lock.py

@@ -1,18 +1,13 @@
-#
 ###############################################################################
-#
-#     Title : pg_lock.py
-#    Author : Zaihua Ji,  zji@ucar.edu
-#      Date : 08/118/2020
+#     Title: pg_lock.py
+#    Author: Zaihua Ji,  zji@ucar.edu
+#      Date: 08/118/2020
 #             2025-01-10 transferred to package rda_python_common from
 #             https://github.com/NCAR/rda-shared-libraries.git
 #             2025-12-01 convert to class PgLock
-#   Purpose : python library module for functions to lock RDADB records
-#
-#    Github : https://github.com/NCAR/rda-python-common.git
-#
+#   Purpose: python library module for functions to lock RDADB records
+#    Github: https://github.com/NCAR/rda-python-common.git
 ###############################################################################
-#
 import re
 import time
 from .pg_file import PgFile
@@ -20,9 +15,8 @@ from .pg_file import PgFile
 class PgLock(PgFile):
 
    def __init__(self):
-
       super().__init__()  # initialize parent class
-      self.DOLOCKS = {-2 : 'Force Unlock', -1 : 'Unlock', 0 : 'Unlock', 1 : 'Relock', 2 : 'Force Relock'}
+      self.DOLOCKS = {-2: 'Force Unlock', -1: 'Unlock', 0: 'Unlock', 1: 'Relock', 2: 'Force Relock'}
    
    def end_db_transaction(self, idx):
       if idx > 0: