Remove pseudo-interface for master.py + small fixes + cleanup

Author: GJFR

bci/analysis/plot_factory.py

@@ -5,14 +5,14 @@
 class PlotFactory:
 
     @staticmethod
-    def get_plot_revision_data(params: PlotParameters, db: MongoDB) -> dict:
-        revision_docs = db.get_documents_for_plotting(params)
+    def get_plot_revision_data(params: PlotParameters) -> dict:
+        revision_docs = MongoDB().get_documents_for_plotting(params)
         revision_results = PlotFactory.__add_outcome_info(params, revision_docs)
         return revision_results
 
     @staticmethod
-    def get_plot_version_data(params: PlotParameters, db: MongoDB) -> dict:
-        version_docs = db.get_documents_for_plotting(params, releases=True)
+    def get_plot_version_data(params: PlotParameters) -> dict:
+        version_docs = MongoDB().get_documents_for_plotting(params, releases=True)
         version_results = PlotFactory.__add_outcome_info(params, version_docs)
         return version_results
 

bci/app.py

@@ -3,28 +3,37 @@
 from flask import Flask
 from flask_sock import Sock
 
-from bci.main import Main as bci_api
+from bci.configuration import Global, Loggers
+from bci.main import Main
 
 sock = Sock()
 
+
 def create_app():
-    bci_api.initialize()
+    Loggers.configure_loggers()
+
+    if not Global.check_required_env_parameters():
+        raise Exception('Not all required environment variables are available')
+
+    # Instantiate main object and add to global flask context
+    main = Main()
 
     # Blueprint modules are only imported after loggers are configured
     from bci.web.blueprints.api import api
     from bci.web.blueprints.experiments import exp
 
     app = Flask(__name__)
     # We don't store anything sensitive in the session, so we can use a simple secret key
+    app.config['main'] = main
     app.secret_key = 'secret_key'
 
     app.register_blueprint(api)
     app.register_blueprint(exp)
     sock.init_app(app)
 
     # Configure signal handlers
-    signal.signal(signal.SIGTERM, bci_api.sigint_handler)
-    signal.signal(signal.SIGINT, bci_api.sigint_handler)
+    signal.signal(signal.SIGTERM, main.sigint_handler)
+    signal.signal(signal.SIGINT, main.sigint_handler)
 
     return app
 

bci/configuration.py

@@ -170,5 +170,14 @@ def handle_exception(exc_type, exc_value, exc_traceback):
         bci_logger.debug('Loggers initialized')
 
     @staticmethod
-    def get_formatted_buffer_logs() -> list[str]:
-        return [Loggers.formatter.format(record) for record in Loggers.memory_handler.buffer]
+    def get_logs() -> list[str]:
+        return list(
+            map(
+                lambda x: Loggers.format_to_user_log(x.__dict__),
+                Loggers.memory_handler.buffer,
+            )
+        )
+
+    @staticmethod
+    def format_to_user_log(log: dict) -> str:
+        return f'[{log["asctime"]}] [{log["levelname"]}] {log["name"]}: {log["msg"]}'

bci/database/mongo/mongodb.py

@@ -18,7 +18,6 @@
     StateResult,
     TestParameters,
     TestResult,
-    WorkerParameters,
 )
 from bci.evaluations.outcome_checker import OutcomeChecker
 from bci.version_control.states.state import State, StateCondition

bci/evaluations/logic.py

@@ -228,6 +228,35 @@ class PlotParameters:
     dirty_allowed: bool = True
     target_cookie_name: Optional[str] = None
 
+    @staticmethod
+    def from_dict(data: dict) -> PlotParameters:
+        if data.get("lower_version", None) and data.get("upper_version", None):
+            major_version_range = (data["lower_version"], data["upper_version"])
+        else:
+            major_version_range = None
+        if data.get("lower_revision_nb", None) and data.get("upper_revision_nb", None):
+            revision_number_range = (
+                data["lower_revision_nb"],
+                data["upper_revision_nb"],
+            )
+        else:
+            revision_number_range = None
+        return PlotParameters(
+            data.get("plot_mech_group"),
+            data.get("target_mech_id"),
+            data.get("browser_name"),
+            data.get("db_collection"),
+            major_version_range=major_version_range,
+            revision_number_range=revision_number_range,
+            browser_config=data.get("browser_setting", "default"),
+            extensions=data.get("extensions", []),
+            cli_options=data.get("cli_options", []),
+            dirty_allowed=data.get("dirty_allowed", True),
+            target_cookie_name=None
+            if data.get("check_for") == "request"
+            else data.get("target_cookie_name", "generic"),
+        )
+
 
 @staticmethod
 def evaluation_factory(kwargs: ImmutableMultiDict) -> list[EvaluationParameters]: