rcdb 2.2.9__tar.gz → 2.2.10__tar.gz

{rcdb-2.2.9/rcdb.egg-info → rcdb-2.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.2.9
+Version: 2.2.10
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT

rcdb-2.2.10/rcdb/cli/add.py

@@ -0,0 +1,141 @@
+import click
+from rcdb.provider import RCDBProvider
+from rcdb.model import ConditionType, ConfigurationFile
+from rcdb.cli.context import pass_rcdb_context
+from rcdb import ConditionType as CT
+
+# A helper mapping from short strings like 'bool','int','float' -> ConditionType.<XYZ>_FIELD
+TYPE_MAP = {
+    "bool": CT.BOOL_FIELD,
+    "int": CT.INT_FIELD,
+    "float": CT.FLOAT_FIELD,
+    "string": CT.STRING_FIELD,
+    "json": CT.JSON_FIELD,
+    "time": CT.TIME_FIELD,
+    "blob": CT.BLOB_FIELD
+}
+
+
+@click.group("add", help="Add data to the RCDB (types, conditions, files).")
+@pass_rcdb_context
+def add_command(context):
+    """
+    The 'add' group command. See subcommands like:
+      rcdb add type - adds Condition Type
+      rcdb add condition - adds Condition to a run
+      rcdb add file - adds File and associate it to a run
+    """
+    pass
+
+
+@add_command.command(name="type", help="Add a new condition type to the DB.")
+@click.argument("name", required=True)
+@click.option("--type", "value_type",
+              type=click.Choice(TYPE_MAP.keys(), case_sensitive=False),
+              default="float", show_default=True,
+              help="Data type of the condition (bool, int, float, string, json, time, blob).")
+@click.option("--description", "-d",
+              default="",
+              help="Optional description.")
+@pass_rcdb_context
+def add_type(context, name, value_type, description):
+    """
+    Adds a new condition type with given NAME and --type/--description.
+
+    Example:
+      rcdb add type beam_current --type=float --description "Beam current in nA"
+    """
+    db = context.db
+    actual_type = TYPE_MAP[value_type.lower()]
+
+    # Create or verify
+    click.echo(f"Creating condition type '{name}' of type '{value_type}'")
+    ct = db.create_condition_type(name, actual_type, description)
+    click.echo("Done.")
+
+
+@add_command.command(name="condition", help="Add or update a condition for a run.")
+@click.argument("run_number", type=int)
+@click.argument("condition_name", type=str)
+@click.argument("value", required=True)
+@click.option("--replace", "-r", is_flag=True,
+              help="If present, replace existing value if it already exists.")
+@pass_rcdb_context
+def add_condition(context, run_number, condition_name, value, replace):
+    """
+    Adds a condition to RUN_NUMBER called CONDITION_NAME with given VALUE.
+
+    Example:
+      rcdb add condition 1000 my_value 123.4
+      rcdb add condition 1000 event_count 10000 --replace
+    """
+    db = context.db
+
+    # 1) Ensure run exists
+    run = db.get_run(run_number)
+    if not run:
+        run = db.create_run(run_number)
+        click.echo(f"Created new run #{run_number}")
+
+    # 2) Look up condition type
+    try:
+        condition_type = db.get_condition_type(condition_name)
+    except:
+        click.echo(f"ERROR: No condition type '{condition_name}' found in DB. Create it first with:\n"
+                   f"  rcdb add type {condition_name} --type=<type>\n", err=True)
+        raise click.Abort()
+
+    # 3) Convert value if needed
+    #    (If 'value' is obviously numeric, you can do more advanced type conversion here if you like)
+    #    For now we store the raw string and rely on ConditionType conversion in RCDB:
+    #    db.add_condition will do the right thing (if you pass an int for an INT_FIELD, float for FLOAT_FIELD, etc.)
+    #    You might do a quick parse though, e.g. if condition_type.value_type is CT.FLOAT_FIELD => float(value), etc.
+
+    # 4) Add condition
+    db.add_condition(run, condition_type, value, replace=replace)
+    db.session.commit()
+    click.echo(f"Added condition '{condition_name}' = '{value}' to run {run_number}")
+
+
+@add_command.command(name="file", help="Attach or add a file to a run in the DB.")
+@click.argument("run_number", type=int)
+@click.argument("file_path", type=str)
+@click.option("--importance", "-i", default=0, type=int,
+              help="Importance level, default=0 (lowest).")
+@click.option("--overwrite", is_flag=True, default=False,
+              help="Overwrite existing content for the same path & run.")
+@click.option("--content", default=None,
+              help="Optional raw content to store. If not specified, reads from file_path on disk.")
+@pass_rcdb_context
+def add_file(context, run_number, file_path, importance, overwrite, content):
+    """
+    Adds or attaches a configuration file to RUN_NUMBER using FILE_PATH.
+
+    Example:
+      rcdb add file 1000 /path/to/coda_run.log
+      rcdb add file 1000 /path/to/config.txt --importance=2 --overwrite
+    """
+    db = context.db
+    run = db.get_run(run_number)
+    if not run:
+        run = db.create_run(run_number)
+        click.echo(f"Created new run #{run_number}")
+
+    if content:
+        # If user provides --content, we do not read from the file path.
+        # We'll just store the provided content under that path.
+        the_content = content
+        click.echo("Using the provided --content instead of reading from disk.")
+    else:
+        # Otherwise read from disk
+        try:
+            with open(file_path, "r") as f:
+                the_content = f.read()
+        except Exception as ex:
+            click.echo(f"ERROR: Cannot open/read file '{file_path}': {ex}", err=True)
+            raise click.Abort()
+
+    # Now add
+    db.add_configuration_file(run, file_path, content=the_content, overwrite=overwrite, importance=importance)
+    db.session.commit()
+    click.echo(f"File '{file_path}' attached to run {run_number}.")

{rcdb-2.2.9 → rcdb-2.2.10}/rcdb/cli/app.py

@@ -15,6 +15,7 @@ from .db import db_command
 from .rp import rp_command
 from .web import web_command
 from .info import info_command
+from .add import add_command
 
 
 pass_rcdb_context = click.make_pass_decorator(RcdbApplicationContext)
@@ -69,4 +70,5 @@ rcdb_cli.add_command(db_command)
 rcdb_cli.add_command(rp_command)
 rcdb_cli.add_command(web_command)
 rcdb_cli.add_command(info_command)
+rcdb_cli.add_command(add_command)
 

{rcdb-2.2.9 → rcdb-2.2.10}/rcdb/provider.py

@@ -711,8 +711,142 @@ class RCDBProvider(object):
 
         return query.first()
 
+    """
+    RCDB data provider that uses SQLAlchemy for accessing databases
+    """
+
+    # ------------------------------------------------
+    # Adds start time
+    # ------------------------------------------------
+    def add_run_start_time(self, run, dtm):
+        """
+            Sets staring time of run
+        """
+        assert (isinstance(dtm, datetime.datetime))
+
+        if not isinstance(run, Run):  # run is given as run number not Run object
+            run = self.create_run(int(run))
+
+        if run.start_time == dtm:
+            return
+
+        log.debug(Lf("Setting start time '{}' to run '{}'", dtm, run.number))
+
+        run.start_time = dtm
+        self.session.commit()
+
+    # ------------------------------------------------
+    # Adds end time
+    # ------------------------------------------------
+    def add_run_end_time(self, run, dtm):
+        """Adds time of run"""
+        assert (isinstance(dtm, datetime.datetime))
+
+        if not isinstance(run, Run):  # run is given as run number not Run object
+            run = self.create_run(int(run))
+
+        if run.end_time == dtm:
+            return
+
+        log.debug(Lf("Setting end time '{}' to run '{}'", dtm, run.number))
+        run.end_time = dtm
+        self.session.commit()
+
+    # ------------------------------------------------
+    #
+    # ------------------------------------------------
+    def add_configuration_file(self, run, path, content=None, overwrite=False, importance=0):
+        """Adds configuration file to run configuration. If such file exists
+        :param importance: 0 - HIGH importance, 1 - LOWER importance. Is used to show in WEB interface
+        :param overwrite: If this flag is true, such file for this run exists but checksumm is different,
+                          file content will be overwritten
+        :param content: Content of a file. If not given, func tryes to open file by path.
+        :param path: Path of the file
+        :param run: Run number
+        """
+
+        def get_content():
+            if content:
+                return content
+            with open(path) as io_file:
+                return io_file.read()
+
+        log.debug("Processing configuration file")
+
+        if content is None:
+            log.debug(Lf("|- Content is not provided as func param, reading from FS '{}'", path))
+            check_sum = rcdb.file_archiver.get_file_sha256(path)
+        else:
+            log.debug(Lf("|- Content is NOT none, using it to put to DB", path))
+            check_sum = rcdb.file_archiver.get_string_sha256(content)
+
+        if not isinstance(run, Run):  # run is given as run number not Run object
+            run = self.create_run(run)
+
+        if overwrite:
+            # If we have to potentially overwrite the file, we have to apply another logic
+            # First, we look at file with this name in this run
+            query = self.session.query(ConfigurationFile) \
+                .filter(ConfigurationFile.runs.contains(run)) \
+                .filter(ConfigurationFile.path == path) \
+                .order_by(desc(ConfigurationFile.id))  # we want latest
+            if query.count():
+                # There are file to overwrite!
+                conf_file = query.first()
+                conf_file.sha256 = check_sum
+                conf_file.path = path
+                conf_file.content = get_content()
+                conf_file.importance = importance
+                log.debug(Lf("|- File '{}' is getting overwritten", path))
+
+                self.session.commit()
+                return conf_file
+
+        # Overwrite = false or is not possible
+        # Look, do we have a file with such name and checksumm?
+        file_query = self.session.query(ConfigurationFile) \
+            .filter(ConfigurationFile.sha256 == check_sum, ConfigurationFile.path == path)
+
+        if not file_query.count():
+            # no such file found!
+            log.debug(Lf("|- File '{}' not found in DB", path))
+
+            # create file.
+            conf_file = ConfigurationFile()
+            conf_file.sha256 = check_sum
+            conf_file.path = path
+            conf_file.content = get_content()
+            conf_file.importance = importance
+
+            # put it to DB and associate with run
+            self.session.add(conf_file)
+            self.session.commit()
+
+            conf_file.runs.append(run)
+
+            # save and exit
+            self.session.commit()
+            self.add_log_record(conf_file, "File added to DB. Path: '{}'. Run: '{}'".format(path, run), run.number)
+            return conf_file
+
+        # such file already exists! Get it from database
+        conf_file = file_query.first()
+        log.debug(Lf("|- File '{}' found in DB by id: '{}'", path, conf_file.id))
+
+        # maybe... we even have this file in run conf?
+        if conf_file not in run.files:
+            conf_file.runs.append(run)
+            # run_conf.files.append(conf_file)
+            self.session.commit()  # save and exit
+            self.add_log_record(conf_file, "File associated. Path: '{}'. Run: '{}'".format(path, run), run.number)
+        else:
+            log.debug(Lf("|- File already associated with run'{}'", run))
+
+        return conf_file
+
+
     def select_runs(self, search_str="", run_min=0, run_max=sys.maxsize, sort_desc=False):
-        """ Searches RCDB for runs with e
+        """ Obsolete. Searches RCDB for runs with e
 
         :param sort_desc: if True result runs will by sorted descendant by run_number, ascendant if False
         :param run_min: minimum run to search
@@ -1283,138 +1417,8 @@ class RunSelectionResult(RcdbSelectionResult):
 
 
 class ConfigurationProvider(RCDBProvider):
-    """
-    RCDB data provider that uses SQLAlchemy for accessing databases
-    """
-
-    # ------------------------------------------------
-    #
-    # ------------------------------------------------
-    def add_run_start_time(self, run, dtm):
-        """
-            Sets staring time of run
-        """
-        assert (isinstance(dtm, datetime.datetime))
-
-        if not isinstance(run, Run):  # run is given as run number not Run object
-            run = self.create_run(int(run))
-
-        if run.start_time == dtm:
-            return
-
-        log.debug(Lf("Setting start time '{}' to run '{}'", dtm, run.number))
-
-        run.start_time = dtm
-        self.session.commit()
-
-    # ------------------------------------------------
-    #
-    # ------------------------------------------------
-    def add_run_end_time(self, run, dtm):
-        """Adds time of run"""
-        assert (isinstance(dtm, datetime.datetime))
-
-        if not isinstance(run, Run):  # run is given as run number not Run object
-            run = self.create_run(int(run))
-
-        if run.end_time == dtm:
-            return
-
-        log.debug(Lf("Setting end time '{}' to run '{}'", dtm, run.number))
-        run.end_time = dtm
-        self.session.commit()
-
-    # ------------------------------------------------
-    #
-    # ------------------------------------------------
-    def add_configuration_file(self, run, path, content=None, overwrite=False, importance=0):
-        """Adds configuration file to run configuration. If such file exists
-        :param importance: 0 - HIGH importance, 1 - LOWER importance. Is used to show in WEB interface
-        :param overwrite: If this flag is true, such file for this run exists but checksumm is different,
-                          file content will be overwritten
-        :param content: Content of a file. If not given, func tryes to open file by path.
-        :param path: Path of the file
-        :param run: Run number
-        """
-
-        def get_content():
-            if content:
-                return content
-            with open(path) as io_file:
-                return io_file.read()
-
-        log.debug("Processing configuration file")
-
-        if content is None:
-            log.debug(Lf("|- Content is not provided as func param, reading from FS '{}'", path))
-            check_sum = rcdb.file_archiver.get_file_sha256(path)
-        else:
-            log.debug(Lf("|- Content is NOT none, using it to put to DB", path))
-            check_sum = rcdb.file_archiver.get_string_sha256(content)
-
-        if not isinstance(run, Run):  # run is given as run number not Run object
-            run = self.create_run(run)
-
-        if overwrite:
-            # If we have to potentially overwrite the file, we have to apply another logic
-            # First, we look at file with this name in this run
-            query = self.session.query(ConfigurationFile) \
-                .filter(ConfigurationFile.runs.contains(run)) \
-                .filter(ConfigurationFile.path == path) \
-                .order_by(desc(ConfigurationFile.id))  # we want latest
-            if query.count():
-                # There are file to overwrite!
-                conf_file = query.first()
-                conf_file.sha256 = check_sum
-                conf_file.path = path
-                conf_file.content = get_content()
-                conf_file.importance = importance
-                log.debug(Lf("|- File '{}' is getting overwritten", path))
-
-                self.session.commit()
-                return conf_file
-
-        # Overwrite = false or is not possible
-        # Look, do we have a file with such name and checksumm?
-        file_query = self.session.query(ConfigurationFile) \
-            .filter(ConfigurationFile.sha256 == check_sum, ConfigurationFile.path == path)
-
-        if not file_query.count():
-            # no such file found!
-            log.debug(Lf("|- File '{}' not found in DB", path))
-
-            # create file.
-            conf_file = ConfigurationFile()
-            conf_file.sha256 = check_sum
-            conf_file.path = path
-            conf_file.content = get_content()
-            conf_file.importance = importance
-
-            # put it to DB and associate with run
-            self.session.add(conf_file)
-            self.session.commit()
-
-            conf_file.runs.append(run)
-
-            # save and exit
-            self.session.commit()
-            self.add_log_record(conf_file, "File added to DB. Path: '{}'. Run: '{}'".format(path, run), run.number)
-            return conf_file
-
-        # such file already exists! Get it from database
-        conf_file = file_query.first()
-        log.debug(Lf("|- File '{}' found in DB by id: '{}'", path, conf_file.id))
-
-        # maybe... we even have this file in run conf?
-        if conf_file not in run.files:
-            conf_file.runs.append(run)
-            # run_conf.files.append(conf_file)
-            self.session.commit()  # save and exit
-            self.add_log_record(conf_file, "File associated. Path: '{}'. Run: '{}'".format(path, run), run.number)
-        else:
-            log.debug(Lf("|- File already associated with run'{}'", run))
-
-        return conf_file
+    """Obsolete. Still exists for backward compatibility. All methods moved to RCDBProvider"""
+    pass
 
 
 def destroy_schema(db):

{rcdb-2.2.9 → rcdb-2.2.10}/rcdb/version.py

@@ -1,5 +1,5 @@
 # String version. Used both for setup.py and for internal code
-version = '2.2.9'
+version = '2.2.10'
 
 # version as the tuple of ints
 version_tuple = tuple(int(val) for val in version.split('.'))

{rcdb-2.2.9 → rcdb-2.2.10/rcdb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rcdb
-Version: 2.2.9
+Version: 2.2.10
 Summary: RCDB - Run Conditions DataBase
 Author-email: Dmitry Romanov <romanov@jlab.org>
 License-Expression: MIT

{rcdb-2.2.9 → rcdb-2.2.10}/rcdb.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ rcdb.egg-info/requires.txt
 rcdb.egg-info/top_level.txt
 rcdb/cli/__init__.py
 rcdb/cli/__main__.py
+rcdb/cli/add.py
 rcdb/cli/app.py
 rcdb/cli/context.py
 rcdb/cli/db.py
@@ -199,6 +200,9 @@ rcdb/web/templates/settings/profile.html
 rcdb/web/templates/statistics/index.html
 rcdb/web/templates/user/index.html
 rcdb/web/templates/user/profile.html
+tests/test_cli_add_condition.py
+tests/test_cli_add_file.py
+tests/test_cli_add_type.py
 tests/test_coda_parser.py
 tests/test_conditions.py
 tests/test_config_parser.py

rcdb-2.2.10/tests/test_cli_add_condition.py

@@ -0,0 +1,139 @@
+import os
+import tempfile
+import unittest
+from click.testing import CliRunner
+
+from rcdb.cli.app import rcdb_cli
+from rcdb.provider import RCDBProvider, destroy_all_create_schema
+from rcdb.model import ConditionType
+
+
+class TestAddCondition(unittest.TestCase):
+    def setUp(self):
+        """
+        Creates a temporary SQLite file and initializes a fresh RCDB schema.
+        Then we disconnect so the file is not locked on Windows.
+        """
+        tmp_file = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
+        self.db_file_name = tmp_file.name
+        tmp_file.close()  # we only need the path
+
+        self.connection_str = "sqlite:///" + self.db_file_name
+
+        # Create the schema
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        destroy_all_create_schema(self.db)
+        self.db.session.commit()  # Important: commit the new schema
+        self.db.disconnect()
+
+    def tearDown(self):
+        """
+        Disconnect if needed and remove the temporary .db file
+        """
+        try:
+            self.db.disconnect()
+        except:
+            pass
+        if os.path.exists(self.db_file_name):
+            try:
+                os.remove(self.db_file_name)
+            except:
+                pass
+
+    def test_add_condition_new_run(self):
+        """
+        Test adding a condition to a run that doesn't exist yet
+        => should create run #10 automatically.
+        """
+        # Reconnect, create the "beam_current" condition type, commit, then disconnect
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        self.db.create_condition_type("beam_current", ConditionType.FLOAT_FIELD, "Beam current")
+        self.db.session.commit()
+        self.db.disconnect()
+
+        runner = CliRunner()
+        result = runner.invoke(rcdb_cli, [
+            "--connection", self.connection_str,
+            "add", "condition", "10", "beam_current", "123.4"
+        ])
+
+        print("Output:\n", result.output)
+        if result.exception:
+            print("Exception:", result.exception)
+
+        self.assertEqual(result.exit_code, 0, msg=result.output)
+
+        # Check DB by reconnecting
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        run_10 = self.db.get_run(10)
+        self.assertIsNotNone(run_10, "Run #10 should be created automatically by 'add condition'")
+        val = run_10.get_condition_value("beam_current")
+        self.assertEqual(float(val), 123.4)
+
+    def test_add_condition_existing_run(self):
+        """
+        If run #5 exists, adding condition to it should just attach to the existing run.
+        Must also create the 'is_production' condition type so the CLI won't error.
+        """
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        # 1) Create run #5
+        self.db.create_run(5)
+        # 2) Also create 'is_production' condition type
+        self.db.create_condition_type("is_production", ConditionType.BOOL_FIELD, "Production run?")
+        self.db.session.commit()
+        self.db.disconnect()
+
+        runner = CliRunner()
+        result = runner.invoke(rcdb_cli, [
+            "--connection", self.connection_str,
+            "add", "condition", "5", "is_production", "True"
+        ])
+        self.assertEqual(result.exit_code, 0, msg=result.output)
+
+        # Check results
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        run_5 = self.db.get_run(5)
+        self.assertIsNotNone(run_5)
+
+        val = run_5.get_condition_value("is_production")
+        self.assertEqual(val, True)
+
+    def test_add_condition_replace(self):
+        """
+        If we already have a condition, test the --replace functionality
+        to overwrite it with a new value.
+        """
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        # Make sure the condition type exists
+        self.db.create_condition_type("beam_current", ConditionType.FLOAT_FIELD, "Beam current")
+
+        # Create run #1 and add beam_current=999.9
+        self.db.create_run(1)
+        self.db.add_condition(1, "beam_current", 999.9)
+        self.db.session.commit()
+        self.db.disconnect()
+
+        runner = CliRunner()
+        result = runner.invoke(rcdb_cli, [
+            "--connection", self.connection_str,
+            "add", "condition", "1", "beam_current", "100.1", "--replace"
+        ])
+        self.assertEqual(result.exit_code, 0, msg=result.output)
+
+        # Check
+        self.db = RCDBProvider(self.connection_str, check_version=False)
+        run_1 = self.db.get_run(1)
+        self.assertIsNotNone(run_1)
+        self.assertEqual(float(run_1.get_condition_value("beam_current")), 100.1)
+
+    def test_add_condition_missing_type(self):
+        """
+        If the condition type isn't in DB, the CLI should fail with an error.
+        """
+        runner = CliRunner()
+        result = runner.invoke(rcdb_cli, [
+            "--connection", self.connection_str,
+            "add", "condition", "2", "non_existent_type", "X"
+        ])
+        self.assertNotEqual(result.exit_code, 0)  # Should fail
+        self.assertIn("ERROR: No condition type 'non_existent_type' found", result.output)