rda-python-metrics 2.0.5__py3-none-any.whl → 3.0.2__py3-none-any.whl

rda_python_metrics/PgView.py

@@ -6,7 +6,7 @@
 #      Date : 09/24/2020
 #             2025-03-27 transferred to package rda_python_metrics from
 #             https://github.com/NCAR/rda-database.git
-#   Purpose : python library module to help rountinely updates of new data 
+#   Purpose : python library module to help routinely updates of new data 
 #             for one or multiple datasets
 #
 #    Github : https://github.com/NCAR/rda-python-metrics.git
@@ -32,7 +32,7 @@ def simple_output(params, flds, records, totals = None):
    sep = params['L'][0] if 'L' in params else '  '
    slen = len(sep)
 
-   # get total line length, dynamically evaluating column lengthes if column 4 in %FLDS is zero
+   # get total line length, dynamically evaluating column lengths if column 4 in %FLDS is zero
    rcnt = linelen = 0
    if 'A' in params: rcnt = int(params['A'][0])
    for i in range(ccnt):
@@ -390,7 +390,7 @@ def join_query_tables(tblname, tablenames = '', joins = '', tbljoin = ''):
    return (tablenames, joins)
 
 #
-# expand reocrds via query action
+# expand records via query action
 #
 def expand_query(expid, records, params, expand, vusg = None, sns = None, flds = None):
    

rda_python_metrics/__init__.py

@@ -1 +1,29 @@
+"""rda_python_metrics: RDA metrics, usage, and accounting utility package.
 
+This package exposes two parallel APIs:
+
+1. Legacy module-based API (back-compat). Import the capitalized
+   submodules and call their module-level functions, e.g.::
+
+       from rda_python_metrics import PgIPInfo, PgView
+
+2. Class-based API (preferred for new code). Import the class from the
+   lower-case module and either instantiate or subclass it, e.g.::
+
+       from rda_python_metrics.pg_ipinfo import PgIPInfo
+       from rda_python_metrics.pg_view import PgView
+
+The legacy submodules are eagerly imported below so that
+``from rda_python_metrics import PgIPInfo`` continues to return the
+module object that existing callers expect.
+"""
+
+from . import PgIPInfo, PgView
+
+__version__ = "2.0.6"
+
+__all__ = [
+   "PgIPInfo",
+   "PgView",
+   "__version__",
+]

rda_python_metrics/fill_awsusage.py

@@ -10,7 +10,7 @@
 #   Purpose : python program to retrieve info from AWS logs 
 #             and fill table wusages in PgSQL database dssdb.
 # 
-#    Github : https://github.com/NCAR/rda-pythn-metrics.git
+#    Github : https://github.com/NCAR/rda-python-metrics.git
 #
 ###############################################################################
 #

rda_python_metrics/fill_cdgusage.py

@@ -6,7 +6,7 @@
 #    Author : Zaihua Ji,  zji@ucar.edu
 #      Date : 2025-04-14
 #   Purpose : python program to retrieve info from GDEX Postgres database for GDS 
-#             file accesses and backup fill table tdsusage in PostgreSQL database dssdb.
+#             file accesses and backup fill table tdsusage in PostgreSQL database rdadb.
 # 
 #    Github : https://github.com/NCAR/rda-python-metrics.git
 #
@@ -173,7 +173,7 @@ def get_dataset_ids(dsnames):
    return dsids
 
 #
-# get cdgids recursivley
+# get cdgids recursively
 #
 def recursive_dataset_ids(pcdgid, cdgids):
 

rda_python_metrics/fill_globususage.py

@@ -10,7 +10,7 @@
 #   Purpose : python program to retrieve info from Globus logs 
 #             and fill table wusages in PgSQL database dssdb.
 # 
-#    Github : https://github.com/NCAR/rda-pythn-metrics.git
+#    Github : https://github.com/NCAR/rda-python-metrics.git
 #
 ###############################################################################
 #

rda_python_metrics/fill_osdfusage.py

@@ -8,7 +8,7 @@
 #   Purpose : python program to retrieve info from weekly OSDF logs 
 #             and fill table wusages in PgSQL database dssdb.
 # 
-#    Github : https://github.com/NCAR/rda-pythn-metrics.git
+#    Github : https://github.com/NCAR/rda-python-metrics.git
 #
 ###############################################################################
 #

rda_python_metrics/fill_rdadb.py

@@ -10,7 +10,7 @@
 #   Purpose : python program to retrieve info from data logs, and fill tables
 #             in PostgreSQL database.schema rdadb.dssdb
 #
-#    Github : https://github.com/NCAR/rda-pythn-metrics.git
+#    Github : https://github.com/NCAR/rda-python-metrics.git
 #
 ###############################################################################
 #

rda_python_metrics/fill_tdsusage.py

@@ -8,7 +8,7 @@
 #             2025-03-26 transferred to package rda_python_metrics from
 #             https://github.com/NCAR/rda-database.git
 #   Purpose : python program to retrieve info from TDS logs 
-#             and fill table tdsusage in PostgreSQL database dssdb.
+#             and fill table tdsusage in PostgreSQL database rdadb.
 # 
 #    Github : https://github.com/NCAR/rda-python-metrics.git
 #

rda_python_metrics/fillawsusage.py

@@ -8,7 +8,7 @@
 #             2025-12-16 converted to class FillAWSUsage
 #   Purpose : python program to retrieve info from AWS logs 
 #             and fill table wusages in PgSQL database dssdb.
-#    Github : https://github.com/NCAR/rda-pythn-metrics.git
+#    Github : https://github.com/NCAR/rda-python-metrics.git
 ###############################################################################
 import sys
 import re
@@ -19,6 +19,8 @@ from .pg_ipinfo import PgIPInfo
 
 class FillAWSUsage(PgIPInfo, PgFile):
 
+   """Retrieve info from AWS logs and fill table wusage in PostgreSQL database rdadb."""
+
    def __init__(self):
       super().__init__()
       self.USAGE = {
@@ -31,8 +33,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
       self.option = self.cmdstr = None
       self.params = []  # array of input values
 
-   # function to read parameters
    def read_parameters(self):
+      """Function to read parameters."""
       argv = sys.argv[1:]
       for arg in argv:
          ms = re.match(r'^-(b|d|p|N)$', arg)
@@ -55,8 +57,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
       self.cmdstr = "fillawsusage {}".format(' '.join(argv))
       self.cmdlog(self.cmdstr)
 
-   # function to start actions
    def start_actions(self):
+      """Function to start actions."""
       self.change_local_directory(self.USAGE['AWSDIR'])
       filenames = self.get_log_file_names()
       if filenames:
@@ -65,8 +67,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
         self.pglog("No log file found for given command: " + self.cmdstr, self.LOGWRN)
       self.pglog(None, self.LOGWRN)
 
-   # get the log file dates 
    def get_log_file_names(self):
+      """Get the log file dates."""
       filenames = {}
       if self.option == 'd':
          for dt in self.params:
@@ -93,8 +95,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
             pdate = self.adddate(pdate, 0, 0, 1)
       return filenames
 
-   # Fill AWS usages into table dssdb.awsusage of DSS PgSQL database from aws access logs
    def fill_aws_usages(self, filenames):
+      """Fill AWS usages into table dssdb.awsusage of DSS PgSQL database from aws access logs."""
       year = cntall = addall = 0
       for pdate in filenames:
          fnames = filenames[pdate]
@@ -147,8 +149,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
             if addall > cntadd:
                self.pglog("{} AWS usage records added for {} entries at {}".format(addall, cntall, self.current_datetime()), self.LOGWRN)
 
-   # get date and time from record
    def get_record_date_time(self, ctime):
+      """Get date and time from record."""
       ms = re.search(r'^(\d+)/(\w+)/(\d+):(\d+:\d+:\d+)$', ctime)
       if ms:
          d = int(ms.group(1))
@@ -160,8 +162,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
       else:
          self.pglog(ctime + ": Invalid date/time format", self.LGEREX)
 
-   # add usage records for year
    def add_usage_records(self, records, year):
+      """Add usage records for year."""
       cnt = 0
       for key in records:
          record = records[key]
@@ -171,8 +173,8 @@ class FillAWSUsage(PgIPInfo, PgFile):
             cnt += self.pgadd(self.USAGE['PGTBL'], record, self.LOGWRN)
       return cnt
 
-   # add record to allusage tables
    def add_to_allusage(self, year, pgrec):
+      """Add record to allusage tables."""
       record = {'source' : 'A'}
       flds = ['ip', 'dsid', 'date', 'time', 'quarter', 'size', 'method',
               'org_type', 'country', 'region', 'email']
@@ -180,7 +182,7 @@ class FillAWSUsage(PgIPInfo, PgFile):
          record[fld] = pgrec[fld]
       return self.add_yearly_allusage(year, record)
 
-# main function to excecute this script
+# main function to execute this script
 def main():
    object = FillAWSUsage()
    object.read_parameters()

rda_python_metrics/fillawsusage.usg

@@ -1,16 +1,27 @@
 
- Retrieves usage information from AWS Server logs under directory
-   ../rda/transer/AWSera5log/ to fill table 'awsusage' in database 'rdadb'.
+ fillawsusage - Fill table 'awsusage' from AWS Server log files.
 
- Usage: fillawsusage [-b] [-d LogFileDates] [-N NumberDay] [-p BeginDate [Enddate]]
+ Reads AWS access logs from /gpfs/fs1/collections/rda/transer/AWSera5log/
+ and inserts usage records into the 'awsusage' table in PostgreSQL
+ database 'rdadb'.
 
-      select option, -d, -N or -p to run this application.
+ USAGE:
+   fillawsusage [-b] (-d LogFileDates | -N NumberDays | -p BeginDate [EndDate])
 
-      - Option -b, log process information into logfile only;
+ OPTIONS (choose exactly one of -d, -N, or -p):
 
-      - Option -d, retrieve usage info from given log file dates; 
+   -d LogFileDates
+        Process log files for the given dates.
+        Date format: YYYY-MM-DD (e.g. 2024-01-15).
 
-      - Option -N, retrieve usage info in recent NumberDay days;
+   -N NumberDays
+        Process log files covering the most recent NumberDays days.
 
-      - Option -p, retrieve usage info between given period. For missing EndDate,
-          it defaults to the current date.
+   -p BeginDate [EndDate]
+        Process log files between BeginDate and EndDate, inclusive.
+        EndDate defaults to today if omitted.
+
+   -b   Run in background mode (log to file only, no terminal output).
+
+ EXAMPLE:
+   fillawsusage -p 2024-01-01 2024-01-31

rda_python_metrics/fillcdgusage.py

@@ -5,7 +5,7 @@
 #      Date : 2025-04-14
 #             2025-12-16 convert to class FillCDGUsage
 #   Purpose : python program to retrieve info from GDEX Postgres database for GDS 
-#             file accesses and backup fill table tdsusage in PostgreSQL database dssdb.
+#             file accesses and backup fill table tdsusage in PostgreSQL database rdadb.
 #    Github : https://github.com/NCAR/rda-python-metrics.git
 ###############################################################################
 import sys
@@ -18,6 +18,8 @@ from .pg_ipinfo import PgIPInfo
 
 class FillCDGUsage(PgSplit, PgIPInfo):
 
+   """Retrieve info from GDEX Postgres database for CDG file accesses and fill tables tdsusage and wusage in PostgreSQL database rdadb."""
+
    def __init__(self):
       super().__init__()
       self.USAGE = {
@@ -92,8 +94,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       self.WFILES = {}
       self.params = {}  # array of input values
 
-   # function to run this program
    def read_parameters(self):
+      """Function to run this program."""
       argv = sys.argv[1:]
       opt = None
       for arg in argv:
@@ -116,19 +118,19 @@ class FillCDGUsage(PgSplit, PgIPInfo):
          self.pglog("-(m|N|y): Missing Month, NumberDays or Year to gather CDG metrics", self.LGWNEX)   
       self.cmdlog("fillcdgusage {}".format(' '.join(argv)))
 
-   # function to start actions
    def start_actions(self):
+      """Function to start actions."""
       dranges = self.get_date_ranges(self.params)
       dsids = self.get_dataset_ids(self.params['s'])
       if dranges and dsids: self.fill_cdg_usages(dsids, dranges)
       self.pglog(None, self.LOGWRN|self.SNDEML)  # send email out if any
 
-   # connect to the gdex database esg-production
    def gdex_dbname(self):
+      """Connect to the gdex database esg-production."""
       self.set_scname('esg-production', 'metrics', 'gateway-reader', None, 'sagedbprodalma.ucar.edu')
 
-   # get datasets
    def get_dataset_ids(self, dsnames):
+      """Get datasets."""
       self.gdex_dbname()
       dsids = []
       tbname = 'metadata.dataset'
@@ -152,8 +154,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       if not dsids: self.pglog("No Dataset Id identified to gather CDG metrics", self.LOGWRN)
       return dsids
 
-   # get cdgids recursivley
    def recursive_dataset_ids(self, pcdgid, cdgids):
+      """Get cdgids recursively."""
       tbname = 'metadata.dataset'
       pgrecs = self.pgmget(tbname, 'id', "parent_dataset_id = '{}'".format(pcdgid))
       if not pgrecs: return 0
@@ -165,8 +167,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
          ccnt += self.recursive_dataset_ids(cdgid, cdgids)
       return ccnt
 
-   # get the date ranges for given condition
    def get_date_ranges(self, inputs):
+      """Get the date ranges for given condition."""
       dranges = []
       for opt in inputs:
          for input in inputs[opt]:
@@ -185,8 +187,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
             if dates: dranges.append(dates)
       return dranges
 
-   # get file download records for given dsid
    def get_dsid_records(self, cdgids, dates, strids):
+      """Get file download records for given dsid."""
       self.gdex_dbname()
       tbname = 'metrics.file_download'
       fields = ('date_completed, remote_address, logical_file_size, logical_file_name, file_access_point_uri, user_agent_name, bytes_sent, '
@@ -204,8 +206,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       self.dssdb_dbname()
       return pgrecs
 
-   # Fill TDS usages into table dssdb.tdsusage from cdg access records
    def fill_cdg_usages(self, dsids, dranges):
+      """Fill TDS usages into table dssdb.tdsusage from cdg access records."""
       allcnt = awcnt = atcnt = lcnt = 0
       for dates in dranges:
          for adsid in dsids:
@@ -305,8 +307,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
             rmsg = self.seconds_to_string_time(tm() - bt)
             self.pglog("{}: {}/{} TDS/WEB usage records added for {} CDG entries in {}".format(strids, atcnt, awcnt, allcnt, rmsg), self.LOGWRN)
 
-   # get date and time from log record
    def get_record_date_time(self, ctime):
+      """Get date and time from log record."""
       ms = re.search(r'^(\d+)-(\d+)-(\d+) (\d\d:\d\d:\d\d)', str(ctime))
       if ms:
          y = ms.group(1)
@@ -318,8 +320,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       else:
          self.pglog(str(ctime) + ": Invalid time format", self.LGEREX)
 
-   # add to tds usage records
    def add_tdsusage_records(self, year, records, date):
+      """Add to tds usage records."""
       cnt = 0
       for key in records:
          record = records[key]
@@ -345,8 +347,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       pgrec['ip'] = logrec['ip']
       return self.add_yearly_allusage(year, pgrec)
 
-   # Fill usage of a single online data file into table dssdb.wusage of DSS PgSQL database
    def add_webfile_usage(self, year, logrec):
+      """Fill usage of a single online data file into table dssdb.wusage of DSS PgSQL database."""
       table = "{}_{}".format(self.USAGE['WEBTBL'], year)
       cdate = logrec['date']
       ip = logrec['ip']
@@ -368,8 +370,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       else:
          return 0
 
-   # add web record to allusage
    def add_web_allusage(self, year, logrec, wurec):
+      """Add web record to allusage."""
       pgrec = {'source' : 'C'}
       pgrec['email'] = wurec['email']
       pgrec['org_type'] = wurec['org_type']
@@ -384,8 +386,8 @@ class FillCDGUsage(PgSplit, PgIPInfo):
       pgrec['ip'] = logrec['ip']
       return self.add_yearly_allusage(year, pgrec)
 
-   # return wfile.wid upon success, 0 otherwise
    def get_wfile_record(self, dsids, wfile):
+      """Return wfile.wid upon success, 0 otherwise."""
       for dsid in dsids:
          wkey = "{}{}".format(dsid, wfile)
          if wkey in self.WFILES: return self.WFILES[wkey]
@@ -410,7 +412,7 @@ class FillCDGUsage(PgSplit, PgIPInfo):
          self.WFILES[wkey] = pgrec
       return pgrec
 
-# main function to excecute this script
+# main function to execute this script
 def main():
    object = FillCDGUsage()
    object.read_parameters()

rda_python_metrics/fillcdgusage.usg

@@ -1,18 +1,33 @@
 
- Retrieves CDG usage information from GDEX metrics database to
-   fill table 'tdsusage' and 'webusage' in PostgreSQL database 'rdadb'.
+ fillcdgusage - Fill table 'tdsusage' and 'webusage' from CDG GDEX metrics.
 
- Usage: fillcdgusage [-b] -s DatasetShortNames [-m MonthList] [-N NumberDays] [-y YearList]
+ Retrieves CDG (Climate Data Gateway) usage info from the GDEX metrics
+ database and inserts records into the 'tdsusage' and 'webusage' tables
+ in PostgreSQL database 'rdadb'.
 
-      select option -s and one of the options, -m, -N or -y each time to run
-        this application. 
+ USAGE:
+   fillcdgusage [-b] -s DatasetShortNames
+                (-m MonthList | -N NumberDays | -y YearList)
 
-      - Option -b, log process information into logfile only;
+ OPTIONS:
 
-      - Option -s, retrieve usage info for given dataset short names; 
+   -s DatasetShortNames   (required)
+        Gather usage info for the given dataset short names.
 
-      - Option -m, retrieve usage info in given months (YYYY-MM); 
+   One of the following time-range options is required:
 
-      - Option -N, retrieve usage info in recent Number of days;
+   -m MonthList
+        Gather usage info for the given months.
+        Month format: YYYY-MM (e.g. 2024-01).
 
-      - Option -y, retrieve usage info in given years (YYYY). 
+   -N NumberDays
+        Gather usage info for the most recent NumberDays days.
+
+   -y YearList
+        Gather usage info for the given years.
+        Year format: YYYY (e.g. 2024).
+
+   -b   Run in background mode (log to file only, no terminal output).
+
+ EXAMPLE:
+   fillcdgusage -s ds083.2 -y 2024

rda_python_metrics/fillcodusage.py

@@ -7,7 +7,7 @@
 #             https://github.com/NCAR/rda-database.git
 #             2025-12-17 convert to class FillCODEUsage
 #   Purpose : python program to retrieve info from web logs 
-#             and fill table codusage in PostgreSQL database dssdb.
+#             and fill table codusage in PostgreSQL database rdadb.
 #    Github : https://github.com/NCAR/rda-python-metrics.git
 ###############################################################################
 import sys
@@ -18,6 +18,8 @@ from .pg_ipinfo import PgIPInfo
 
 class FillCODUsage(PgIPInfo):
 
+   """Retrieve info from web logs and fill table codusage in PostgreSQL database rdadb."""
+
    def __init__(self):
       super().__init__()
       # the define options for gathering COD data usage, one at a time
@@ -36,8 +38,8 @@ class FillCODUsage(PgIPInfo):
       self.datelimit = ''
       self.params = []  # array of input values
 
-   # function to readparameters
    def read_parameters(self):
+      """Function to readparameters."""
       argv = sys.argv[1:]
       for arg in argv:
          if arg == "-b":
@@ -64,8 +66,8 @@ class FillCODUsage(PgIPInfo):
       self.dssdb_dbname()
       self.cmdlog("fillcodusage {}".format(' '.join(argv)))
 
-   # function to start actions
    def start_actions(self):   
+      """Function to start actions."""
       if self.USAGE['OPTION']&self.NDAYS:
          curdate = self.curdate()
          self.datelimit = self.adddate(curdate, 0, 0, -int(self.params[0]))
@@ -78,8 +80,8 @@ class FillCODUsage(PgIPInfo):
       self.fill_cod_usages(self.USAGE['OPTION'], self.params)
       self.pglog(None, self.LOGWRN|self.SNDEML)  # send email out if any
 
-   # Fill COD usages into table dssdb.codusage of DSS PostgreSQL database from cod access logs
    def fill_cod_usages(self, option, inputs):
+      """Fill COD usages into table dssdb.codusage of DSS PostgreSQL database from cod access logs."""
       cntall = cntadd = 0
       for input in inputs:
          # get log file names
@@ -144,8 +146,8 @@ class FillCODUsage(PgIPInfo):
       s = 's' if cntadd > 1 else ''
       self.pglog("{} COD usage records added for {} entries at {}".format(cntadd, cntall, self.current_datetime()), self.LOGWRN)
 
-   # add usage to codusage table
    def add_usage_records(self, records, date):
+      """Add usage to codusage table."""
       ms = re.match(r'(\d+)-(\d+)-', date)
       if not ms: return 0
       year = ms.group(1)
@@ -178,8 +180,8 @@ class FillCODUsage(PgIPInfo):
             cnt += self.pgadd(self.USAGE['PGTBL'], record, self.LOGWRN)
       return cnt
 
-   # add usage to allusage tables
    def add_to_allusage(self, pgrec, year):
+      """Add usage to allusage tables."""
       record = {'method' : 'COD', 'source' : 'C'}
       for fld in pgrec:
          ms = re.match(r'^(engine|count)$', fld)
@@ -187,8 +189,8 @@ class FillCODUsage(PgIPInfo):
          record[fld] = pgrec[fld]
       return self.add_yearly_allusage(year, record)   # change 1 to 0 to stop checking
 
-   # cashe user info for reuse
    def cache_users(self, aid):
+      """Cashe user info for reuse."""
       pgrec = self.pgget("metautil.custom_dap_history", "*", "ID = '{}'".format(aid), self.LGEREX)
       if pgrec:
          ms = re.search(r'dsnum=(\d+\.\d|[a-z]\d{6});', pgrec['rinfo'])
@@ -198,8 +200,8 @@ class FillCODUsage(PgIPInfo):
             return 1
       return 0
 
-   # get period
    def access_period(self, etime, btime):
+      """Get period."""
       period = 86400
       ms = re.search(r'(\d+):(\d+):(\d+)', etime)
       if ms:
@@ -209,7 +211,7 @@ class FillCODUsage(PgIPInfo):
          period -= int(ms.group(1))*3600+int(ms.group(2))*60+int(ms.group(3))
       return period
 
-# main function to excecute this script
+# main function to execute this script
 def main():
    object = FillCODUsage()
    object.read_parameters()

rda_python_metrics/fillcodusage.usg

@@ -1,21 +1,32 @@
 
- Retrieves usage information from RDA Web logs under /var/log to
-   fill table 'codusage' in database 'rdadb'.
+ fillcodusage - Fill table 'codusage' from custom OPeNDAP (COD) access logs.
 
- Usage: fillcodusage [-a] [-b] [-f LogFileNames] [-m MonthList] [-N NumberDay] [-y YearList]
+ Reads RDA Web/COD access logs under /var/log and inserts usage records
+ into the 'codusage' table in PostgreSQL database 'rdadb'.
 
-      select one of the options, -a, -f, -m, -N or -y each time to run
-        this application. 
+ USAGE:
+   fillcodusage [-b] (-a | -f LogFileNames | -m MonthList |
+                      -N NumberDays | -y YearList)
 
-      - Option -b, log process information into logfile only;
+ OPTIONS (choose exactly one of -a, -f, -m, -N, or -y):
 
-      - Option -a, retrieve usages for all available logs;
+   -a   Process all available log files.
 
-      - Option -f, retrieve usage info from given log file names; 
+   -f LogFileNames
+        Process the given log file names directly.
 
-      - Option -m, retrieve usage info in given months; 
+   -m MonthList
+        Process log files for the given months.
+        Month format: YYYY-MM (e.g. 2024-01).
 
-      - Option -N, retrieve usage info in recent NumberDay days;
+   -N NumberDays
+        Process log files covering the most recent NumberDays days.
 
-      - Option -y, retrieve usage info in given years. 
+   -y YearList
+        Process log files for the given years.
+        Year format: YYYY (e.g. 2024).
 
+   -b   Run in background mode (log to file only, no terminal output).
+
+ EXAMPLE:
+   fillcodusage -m 2024-01 2024-02

rda_python_metrics/fillcountry.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3/
+#!/usr/bin/env python3
 ###############################################################################
 #     Title : fillcountry
 #    Author : Zaihua Ji,  zji@ucar.edu
@@ -15,13 +15,15 @@ import re
 from rda_python_common.pg_dbi import PgDBI
 
 class FillCountry(PgDBI):
+   """Fill missing country field from email info for a given table name."""
+
    def __init__(self):
       super().__init__()
       self.tables = ['allusage', 'user', 'wuser']
       self.table = None
 
-   # function to read paramters
-   def read_parameter(self):
+   def read_parameters(self):
+      """Function to read parameters."""
       argv = sys.argv[1:]
       # check command line
       for arg in argv:
@@ -40,13 +42,13 @@ class FillCountry(PgDBI):
          self.pglog("{}: table name must be ({})".format(self.table, '|'.join(self.tables)), self.LGEREX)
       self.cmdlog("fillcountry {}".format(' '.join(argv)))
 
-   # function to start actions
    def start_actions(self):
+      """Function to start actions."""
       self.dssdb_dbname()
       self.process_countries()
 
-   # fill country info
    def process_countries(self):
+      """Fill country info."""
       pgrecs = self.pgmget(self.table, "email", "country IS NULL", self.LOGWRN)
       cntall = len(pgrecs['email']) if pgrecs else 0
       self.pglog("Set {} record(s) for missing country in table {}".format(cntall, self.table), self.LOGWRN)
@@ -60,7 +62,7 @@ class FillCountry(PgDBI):
          cntmod += self.pgupdt(self.table, record, "email = '{}' AND country IS NULL".format(email), self.LOGWRN)
       self.pglog("{} Record(s) modified in table '{}'".format(cntmod, self.table), self.LOGWRN)
 
-# main function to excecute this script
+# main function to execute this script
 def main():
    object = FillCountry()
    object.read_parameters()