rcdb 0.9.1__py3-none-any.whl

rcdb/__init__.py

@@ -0,0 +1,128 @@
+from .model import ConditionType
+from .provider import RCDBProvider
+from .provider import ConfigurationProvider
+from .rcdb_cli.app import rcdb_cli as run_rcdb_cli
+
+
+# This thing separates cells in data blob
+blob_delimiter = "|"
+
+# if cell of data table is a string and the string already contains blob_delimiter
+# we have to encode blob_delimiter to blob_delimiter_replace on data write and decode it bach on data read
+blob_delimiter_replacement = "&delimiter;"
+
+SQL_SCHEMA_VERSION = 2
+
+
+class UpdateReasons(object):
+    """Class holds a default values of UpdateContext.reason field
+    Attributes:
+        START -  means update goes after 'GO', beginning of the data taking
+        UPDATE - after run in started, RCDB is being update each minute. That is how it is done
+        END -    after run is ended
+        """
+    START = 'start'
+    UPDATE = 'update'
+    END = 'end'
+    UNKNOWN = ''
+
+
+# -------------------------------------------------
+# class holding a context of the update operations
+# -------------------------------------------------
+class UpdateContext(object):
+    """Updates context
+
+        Attributes:
+            self.db - RCDBProvider with connection
+            self.reason - one of UpdateReasons or empty string
+            self.run - Run object
+    """
+
+    def __init__(self, db, reason):
+        self.db = db
+        self.reason = reason  # Context in which daq is called '', 'start', 'update', 'end'
+        self.run = None       # Run object
+
+
+# -------------------------------------------------
+# function Convert list to DB text representation
+# -------------------------------------------------
+def list_to_db_text(values):
+    """
+    Converts list of values like pedestal,threshold,baseline_preset values
+    to a space separated string - that is how the values are stored in the DB
+
+    :param values: list of values
+    :type values: []
+
+    :return: string with values as it is stored in DB
+    :rtype: basestring
+    """
+    return " ".join([str(value) for value in values])
+
+
+def make_threshold_preset(db, board, values):
+    """
+    checks if values
+    :param values:
+    :return:
+    """
+
+    if isinstance(values, list):
+        text_values = list_to_db_text(values)
+
+
+class DefaultConditions(object):
+    """
+    Holds common names for conditions and can ensure database have them
+    """
+
+    EVENT_RATE = 'event_rate'
+    EVENT_COUNT = 'event_count'
+    RUN_TYPE = 'run_type'
+    RUN_CONFIG = 'run_config'
+    RUN_LENGTH = 'run_length'
+    RUN_START_TIME = 'run_start_time'
+    RUN_END_TIME = 'run_end_time'
+    DAQ_SETUP = 'daq_setup'
+    SESSION = 'session'
+    USER_COMMENT = 'user_comment'
+    COMPONENTS = 'components'
+    COMPONENT_STATS = 'component_stats'
+    RTVS = 'rtvs'
+    IS_VALID_RUN_END = 'is_valid_run_end'
+
+
+def create_default_condition_types(db):
+    """
+    Checks if condition types listed in class exist in the database and create them if not
+    :param db: RCDBProvider connected to database
+    :type db: RCDBProvider
+
+    :return: None
+    """
+    all_types_dict = {t.name: t for t in db.get_condition_types()}
+
+    def create_condition_type(name, value_type, description=""):
+        all_types_dict[name] if name in all_types_dict.keys() \
+            else db.create_condition_type(name, value_type, description)
+
+    # get or create condition type
+    create_condition_type(DefaultConditions.EVENT_RATE, ConditionType.FLOAT_FIELD, "Average event rate")
+    create_condition_type(DefaultConditions.EVENT_COUNT, ConditionType.INT_FIELD, "Number of events")
+    create_condition_type(DefaultConditions.RUN_TYPE, ConditionType.STRING_FIELD, "DAQ Run type")
+    create_condition_type(DefaultConditions.RUN_CONFIG, ConditionType.STRING_FIELD, "DAQ Run configuration")
+    create_condition_type(DefaultConditions.SESSION, ConditionType.STRING_FIELD)
+    create_condition_type(DefaultConditions.USER_COMMENT, ConditionType.STRING_FIELD)
+    create_condition_type(DefaultConditions.COMPONENTS, ConditionType.JSON_FIELD)
+    create_condition_type(DefaultConditions.RTVS, ConditionType.JSON_FIELD)
+    create_condition_type(DefaultConditions.COMPONENT_STATS, ConditionType.JSON_FIELD)
+    create_condition_type(DefaultConditions.IS_VALID_RUN_END, ConditionType.BOOL_FIELD,
+                          "True if a run has valid run-end record. "
+                          "False means the run was aborted/crashed at some point")
+    create_condition_type(DefaultConditions.RUN_LENGTH, ConditionType.INT_FIELD, "Length of the run ")
+    create_condition_type(DefaultConditions.RUN_START_TIME, ConditionType.TIME_FIELD, "Run start time ")
+    create_condition_type(DefaultConditions.RUN_END_TIME, ConditionType.TIME_FIELD, "Run end time (last CODA update)")
+
+

rcdb/__main__.py

@@ -0,0 +1,3 @@
+from rcdb.rcdb_cli.app import rcdb_cli
+
+rcdb_cli()

rcdb/admin_cmd.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import posixpath
+
+import click
+
+from rcdb.app_context import RcdbApplicationContext, parse_run_range
+from rcdb import RCDBProvider
+
+pass_rcdb_context = click.make_pass_decorator(RcdbApplicationContext)
+
+
+def get_default_config_path():
+    return os.path.join(os.path.expanduser('~'), '.rcdb_user')
+
+
+@click.group()
+@click.option('--user-config', envvar='RCDB_USER_CONFIG', default=get_default_config_path, metavar='PATH', help='Changes the user config location.')
+@click.option('--connection', '-c', envvar='RCDB_CONNECTION', help='Database connection string', default=None, required=True)
+@click.option('--config', nargs=2, multiple=True, metavar='KEY VALUE', help='Overrides a config key/value pair.')
+@click.option('--verbose', '-v', is_flag=True, help='Enables verbose mode.')
+@click.version_option('1.0')
+@click.pass_context
+def cli(ctx, user_config, connection, config, verbose):
+    """'rcdb' is a RCDB (run conditions database) command line tool
+
+    This tool allows to select runs and get values as well as manage RCDB values
+    """
+
+    # Create a rcdb_app_context object and remember it as as the context object.  From
+    # this point onwards other commands can refer to it by using the
+    # @pass_rcdb_context decorator.
+    ctx.obj = RcdbApplicationContext(os.path.abspath(user_config), connection)
+    ctx.obj.verbose = verbose
+    for key, value in config:
+        ctx.obj.set_config(key, value)
+
+
+@cli.command(help="")
+@click.argument('search', required=False)
+@click.option('--long', '-l', 'is_long', is_flag=True, help='Prints condition full information')
+@pass_rcdb_context
+def walk(context, search, is_long):
+    """Lists condition
+
+
+    """
+    db = context.db
+    assert isinstance(db, RCDBProvider)
+    cnd_types = db.get_condition_types_by_name()
+    names = sorted(cnd_types.keys())
+    if search:
+        names = [n for n in names if search in n]
+
+    longest_len = len(max(names, key=len))
+    for name in names:
+        cnd_type = cnd_types[name]
+        click.echo("{0:<{1}}   {2}".format(name, longest_len, cnd_type.description))
+
+@cli.command()
+@click.argument('search', required=False)
+@click.option('--long', '-l', 'is_long', is_flag=True, help='Prints condition full information')
+@pass_rcdb_context
+def ls(context, search, is_long):
+    """Lists condition
+
+
+    """
+    db = context.db
+    assert isinstance(db, RCDBProvider)
+    cnd_types = db.get_condition_types_by_name()
+    names = sorted(cnd_types.keys())
+    if search:
+        names = [n for n in names if search in n]
+
+    longest_len = len(max(names, key=len))
+    for name in names:
+        cnd_type = cnd_types[name]
+        click.echo("{0:<{1}}   {2}".format(name, longest_len, cnd_type.description))
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    cli(prog_name="rcdb")

rcdb/alias.py

@@ -0,0 +1,90 @@
+class ConditionSearchAlias(object):
+    def __init__(self, name, expression, comment):
+        self.name = name
+        self.expression = expression
+        self.comment = comment
+
+
+default_aliases = [
+    ConditionSearchAlias('is_production', """run_type in ['hd_all.tsg', 'hd_all.tsg_ps', 'hd_all.bcal_fcal_st.tsg'] and
+                                             beam_current and beam_current > 2 and
+                                             event_count > 500000 and
+                                             solenoid_current and solenoid_current > 100 and
+                                             collimator_diameter != 'Blocking'""",
+                         "Is production run"),
+
+    ConditionSearchAlias('is_2018production', """daq_run == 'PHYSICS' and
+                                             beam_current > 2 and
+                                             event_count > 10000000 and
+                                             solenoid_current > 100 and
+                                             collimator_diameter != 'Blocking'""",
+                         "Is production run"),
+
+    ConditionSearchAlias('is_primex_production', """daq_run == 'PHYSICS_PRIMEX' and
+                                             event_count > 1000000 and
+                                             collimator_diameter != 'Blocking'""",
+                         "Is PrimEx production run"),
+
+    ConditionSearchAlias('is_dirc_production', """daq_run == 'PHYSICS_DIRC' and 
+                                                  beam_current > 2 and 
+                                                  event_count > 5000000 and 
+                                                  solenoid_current > 100 and 
+                                                  collimator_diameter != 'Blocking'""",
+                         "Is DIRC production run"),
+
+    ConditionSearchAlias('is_src_production', """daq_run == 'PHYSICS_SRC' and 
+                                                  beam_current > 2 and 
+                                                  event_count > 5000000 and 
+                                                  solenoid_current > 100 and 
+                                                  collimator_diameter != 'Blocking'""",
+                         "Is SRC production run"),
+
+    ConditionSearchAlias('is_cpp_production', """daq_run == 'PHYSICS_CPP' and 
+                                                  beam_current > 2 and 
+                                                  event_count > 5000000 and 
+                                                  solenoid_current > 100 and 
+                                                  collimator_diameter != 'Blocking'""",
+                         "Is CPP production run"),
+
+    ConditionSearchAlias('is_production_long', """daq_run == 'PHYSICS_raw'
+                                             beam_current > 2 and
+                                             event_count > 5000000 and
+                                             solenoid_current > 100 and
+                                             collimator_diameter != 'Blocking'""",
+                         "Is production run with long mode data"),
+
+    ConditionSearchAlias('is_cosmic', '"cosmic" in run_config and beam_current < 1 and event_count > 5000',
+                         "Is cosmic run"),
+
+    ConditionSearchAlias('is_empty_target', "target_type == 'EMPTY & Ready'", "Target is empty"),
+
+    # These should be true starting in 2017.  Need to check to make sure that 2016 data is accurate...
+    ConditionSearchAlias('is_amorph_radiator', "polarization_angle < 0.",  "Amorphous Radiator"),                         
+    ConditionSearchAlias('is_coherent_beam', "polarization_angle >= 0.", "Coherent Beam"),
+    #ConditionSearchAlias('is_amorph_radiator', "radiator_index == -1 and radiator_type != 'None' and target_type == 'FULL & Ready'",
+    #                     "Amorphous Radiator"),
+    #ConditionSearchAlias('is_coherent_beam', "(radiator_id != 5  and radiator_id > 0) and target_type == 'FULL & Ready'", "Coherent Beam"),
+
+    ConditionSearchAlias('is_field_off', "solenoid_current < 100", " Field Off"),
+
+    ConditionSearchAlias('is_field_on', "solenoid_current >= 100", " Field On"),
+
+    ConditionSearchAlias('status_calibration', "status == 3", "Run status = calibration"),
+
+    ConditionSearchAlias('status_approved_long', "status == 2", "Run status = approved (long)"),
+
+    ConditionSearchAlias('status_approved', "status == 1", "Run status = approved"),
+
+    ConditionSearchAlias('status_unchecked', "status == -1", "Run status = unchecked"),
+
+    ConditionSearchAlias('status_reject', " status == 0", "Run status = reject"),
+]
+
+_def_al_by_name = None
+
+
+def get_default_aliases_by_name():
+    global _def_al_by_name
+    if _def_al_by_name is None:
+        _def_al_by_name = {al.name:al for al in default_aliases }
+    return _def_al_by_name

rcdb/app_context.py

@@ -0,0 +1,100 @@
+import click
+from rcdb import RCDBProvider
+import sys
+
+
+class RcdbApplicationContext(object):
+
+    def __init__(self, home, connection_str):
+        self.home = home
+        self._db_instance = None
+
+        self.config = {}
+        self.verbose = False
+        self.connection_str = connection_str
+
+    @property
+    def db(self):
+        if not self._db_instance:
+            self._db_instance = RCDBProvider(self.connection_str)
+        return self._db_instance
+
+    def set_config(self, key, value):
+        self.config[key] = value
+        if self.verbose:
+            click.echo('  config[%s] = %s' % (key, value), file=sys.stderr)
+
+    def __repr__(self):
+        return '<Repo %r>' % self.home
+
+
+class RcdbAdminApplicationContext(RcdbApplicationContext):
+
+    def __init__(self, home, connection_str):
+        super(RcdbAdminApplicationContext).__init__(home, connection_str)
+
+
+def parse_run_range(run_range_str, run_periods=None):
+    """ Parses run range, returning a pair (run_from, run_to) or (run_from, None) or (None, None)
+
+    Function doesn't raise FormatError
+    :exception ValueError: if run_range_str is not str
+
+    :param run_range_str: string to parse
+    :return: (run_from, run_to). Function always return lower run number as run_from
+    """
+
+    if run_range_str is None:
+        return None, None
+
+    run_range_str = str(run_range_str).strip()
+    if not run_range_str:
+        return None, None
+
+    assert isinstance(run_range_str, str)
+
+    # Is it run period?
+    if run_periods:
+        if run_range_str in run_periods:
+            run_min, run_max, descr = run_periods[run_range_str]
+            return run_min, run_max
+
+    # Have run-range?
+    if '-' in run_range_str:
+        tokens = [t.strip() for t in run_range_str.split("-")]
+        try:
+            run_from = int(tokens[0])
+        except (ValueError, KeyError):
+            return None, None
+
+        try:
+            run_to = int(tokens[1])
+        except (ValueError, KeyError):
+            return run_from, None
+
+        return (run_from, run_to) if run_from <= run_to else (run_to, run_from)
+
+    # Have run number?
+    if run_range_str.isdigit():
+        return int(run_range_str), None
+
+    # Default return is index
+    return None, None
+
+
+def minmax_run_range(run_range: tuple):
+    """If one or both values of run_range tuple is None, replaces it to 0 or sys.maxsize
+
+    > minmax_run_range((None, None)) 
+    (0, sys.maxsize)
+    > minmax_run_range((None, value2)) 
+    (0, value2)
+    > minmax_run_range((value1, None)) 
+    (value1, sys.maxsize)
+    > minmax_run_range((value1, value2)) 
+    (value1, value2)
+    """
+
+    min_run = 0 if run_range[0] is None else run_range[0]
+    max_run = sys.maxsize if run_range[1] is None else run_range[1]
+    return min_run, max_run