ApiLogicServer 14.2.20__py3-none-any.whl → 14.3.7__py3-none-any.whl

api_logic_server_cli/manager.py

@@ -11,14 +11,14 @@ from pathlib import Path
 import api_logic_server_cli.api_logic_server as PR
 
 def create_manager(clean: bool, open_with: str, api_logic_server_path: Path, 
-                   volume: str = "", open_manager: bool = True):
+                   volume: str = "", open_manager: bool = True, samples: bool = True):
     """Implements als start to create manager - called from api_logic_server_cli/cli.py
 
     create Manager at os.getcwd(), including:
 
     1. .vscode, readme
     2. System folder (GenAI sample prompts / responses, others TBD)
-    3. pre-created samples
+    3. pre-created samples (optional)
 
     Example, from CLI in directory containing a `venv` (see https://apilogicserver.github.io/Docs/Manager/):
         als start
@@ -122,21 +122,25 @@ def create_manager(clean: bool, open_with: str, api_logic_server_path: Path,
         except:     # do NOT fail 
             pass    # just fall back to using the pip-installed version
 
-        if project.is_docker:
-            log.debug(f"    tutorial not created for docker\n\n")
+        if not samples:
+            shutil.rmtree(to_dir.joinpath(f'{docker_volume}system/app_model_editor'))
+            shutil.rmtree(to_dir.joinpath(f'{docker_volume}system/genai/examples/genai_demo/wg_dev_merge'))
         else:
-            tutorial_project = PR.ProjectRun(command="tutorial", 
-                    project_name='./samples', 
-                    db_url="",
-                    execute=False,
-                    open_with="NO_AUTO_OPEN"
-                    )
-            tutorial_project = tutorial_project.tutorial(msg="Creating:") ##, create='tutorial')
-
-        samples_project = PR.ProjectRun(command= "create", project_name=f'{docker_volume}samples/nw_sample', db_url='nw+', open_with="NO_AUTO_OPEN")
-        log.setLevel(mgr_save_level)
-        log.disabled = False  # todo why was it reset?
-        samples_project = PR.ProjectRun(command= "create", project_name=f'{docker_volume}samples/nw_sample_nocust', db_url='nw', open_with="NO_AUTO_OPEN")
+            if project.is_docker:
+                log.debug(f"    tutorial not created for docker\n\n")
+            else:
+                tutorial_project = PR.ProjectRun(command="tutorial", 
+                        project_name='./samples', 
+                        db_url="",
+                        execute=False,
+                        open_with="NO_AUTO_OPEN"
+                        )
+                tutorial_project = tutorial_project.tutorial(msg="Creating:") ##, create='tutorial')
+
+            samples_project = PR.ProjectRun(command= "create", project_name=f'{docker_volume}samples/nw_sample', db_url='nw+', open_with="NO_AUTO_OPEN")
+            log.setLevel(mgr_save_level)
+            log.disabled = False  # todo why was it reset?
+            samples_project = PR.ProjectRun(command= "create", project_name=f'{docker_volume}samples/nw_sample_nocust', db_url='nw', open_with="NO_AUTO_OPEN")
         log.info('')
         log.setLevel(mgr_save_level)
         log.disabled = False

api_logic_server_cli/model_migrator/model_migrator_start.py

@@ -56,7 +56,7 @@ class ModelMigrator(object):
             # need repos location and project api name (teamspaces/api/{lac_project_name})
             running_at = Path(__file__)
             repos_location = f"{running_at.parent}{os.sep}CALiveAPICreator.repository"
-            lac_project_name = "fedex" # pass as args.lac_project_name TODO
+            lac_project_name = "repos" # pass as args.lac_project_name TODO
             repo_reader.start(repos_location, self.project_directory, lac_project_name, table_to_class ) 
             log.debug('.. ModelMigrator.run() - done')
 

api_logic_server_cli/model_migrator/reposreader.py

@@ -404,7 +404,7 @@ class ModelMigrationService(object):
                         j = json.loads(d)
                         isActive = j["isActive"]
                         if isActive:
-                            func_type = j["functionType"]
+                            func_type = j.get("functionType","Java")
                             if func_type == "rowLevel":
                                 comments = j["comments"]
                                 if comments != "":
@@ -427,6 +427,14 @@ class ModelMigrationService(object):
                                 self.add_content("'''")
                                 self.add_content("")
                                 lac_func.append(name)
+                            elif func_type == "Java":
+                                name = j["name"]
+                                self.add_content("'''")
+                                self.add_content(f"#Java Function: {j['methodName']}") 
+                                self.add_content(f"#Java Function: {j['className']}") 
+                                self.add_content("'''")
+                                self.add_content("")
+                                lac_func.append(name)
         return lac_func
 
     def functionList(self, thisPath: str):

api_logic_server_cli/model_migrator/rule_obj.py

@@ -102,25 +102,43 @@ class RuleObj:
         title =""
         if j.title is not None:
             title = j.title
-        funName = "fn_" + name.split(".")[0]
+        #funName = "fn_" + name.split(".")[0]
+        entityLower = entity.lower()
+        funName =  f"fn_{entityLower}_{ruleType}_{name}"
         comments = j.comments
         appliesTo = ""
         if j.appliesTo is not None:
             appliesTo = j.appliesTo
         
         # Define a function to use in the rule 
-        ruleJSObj = None if self.jsObj is None else fixup(self.jsObj)
+        ruleJSObj = None if self.jsObj is None else fixup(self.jsObj) if self.jsObj is None else ""
         tab = "\t\t"
         self.add_content(f"\t# RuleType: {ruleType}")
         self.add_content(f"\t# Title: {title}")
         self.add_content(f"\t# Name: {name}")
         self.add_content(f"\t# Entity: {entity}")
+        
+        codeType = j.get("codeType", None)
+        if codeType == "Java":
+            className = j.get("className", None)
+            methodName = j.get("methodName", None)
+            self.add_content(f"\t# CodeType: {codeType}")
+            self.add_content(f"\t# ClassName: {className}")
+            self.add_content(f"\t# MethodName: {methodName}")
+            if name == "cache":
+                funName =  f"fn_{methodName}"
+
+            
         self.add_content(f"\t# Comments: {comments}")
         self.add_content("")
+        if codeType == "Java":
+            self.add_content(f"\tdef {funName}(row: models.{entity}, old_row: models.{entity}, logic_row: LogicRow):")
+            self.add_content(f"\t\t# Call Java Code: {className}.{methodName}(row, old_row, logic_row)")
+            self.add_content("\t\tpass")
+            
+    
         if ruleJSObj is not None:
-            entityLower = entity.lower()
-            funName =  f"\tfn_{entityLower}_{ruleType}_{name}"
-            if len(ruleJSObj) < 80 and ruleType == "formula":
+            if len(ruleJSObj) < 80 and ruleType == "formula" and codeType == "JavaScript":
                 pass
             else:
                 self.add_content(f"\tdef {funName}(row: models.{entity}, old_row: models.{entity}, logic_row: LogicRow):")
@@ -149,7 +167,7 @@ class RuleObj:
                 if ruleJSObj is not None and len(ruleJSObj) > 80:
                     self.add_content(f"{tab}calling={funName})")
                 else:
-                    ruleJSObj = ruleJSObj.replace("return","lambda row: ")
+                    ruleJSObj = ruleJSObj.replace("return","lambda row: ") if ruleJSObj is not None else ""
                     self.add_content(f"{tab}as_expression={ruleJSObj})")
             case "count":
                 attr = j.attribute

api_logic_server_cli/prototypes/base/api/api_discovery/ontimize_api.py

@@ -231,7 +231,10 @@ def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_deco
             session.flush()
         except Exception as ex:
             session.rollback()
-            return jsonify({"code":1,"message":f"{ex}","data":[],"sqlTypes":None}) 
+            msg = f"{ex.message if hasattr(ex, 'message') else ex}"
+            return jsonify(
+                {"code": 1, "message": f"{msg}", "data": [], "sqlTypes": None}
+            ) 
             
         return jsonify({"code":0,"message":f"{method}:True","data":result,"sqlTypes":None})   #{f"{method}":True})
     

api_logic_server_cli/prototypes/base/api/system/expression_parser.py

@@ -153,18 +153,24 @@ def fixup_sort(clz, data):
                     continue
     return sort
 def fixup_data(data, sqltypes):
+    new_data = None
     if data:
+        new_data = {}
         for key, value in data.items():
+            new_data[key] = value
             if sqltypes and key in sqltypes and isinstance(value, str):
                 if sqltypes[key] in [-5,2,4,5,-6]: #BIGINT, TINYINT, INT, SMALLINT, INTEGER
-                    data[key] = int(value)
+                    if new_data[key].isdigit():
+                        new_data[key] = int(value)
+                    else:
+                        del new_data[key]
                 elif  sqltypes[key] in [6]: #DECIMAL
-                    data[key] = Decimal(value)
+                    new_data[key] = Decimal(value)
             if sqltypes and key in sqltypes and sqltypes[key] in [91,93] and isinstance(value, int): #DATE, TIMESTAMP 
                 from datetime import datetime  
                 fmt = "%Y-%m-%d" if sqltypes[key] == 91 else "%Y-%m-%d %H:%M:%S"
-                data[key] = datetime.fromtimestamp(value / 1000) #.strftime(fmt)  
-    return data
+                new_data[key] = datetime.fromtimestamp(value / 1000) #.strftime(fmt)  
+    return new_data
 
 def _parseFilter(filter: dict, sqltypes: any):
     # {filter":{"@basic_expression":{"lop":"BALANCE","op":"<=","rop":35000}}

api_logic_server_cli/prototypes/base/config/activate_logicbank.py

@@ -19,23 +19,27 @@ def activate_logicbank(session, constraint_handler):
 
     app_logger.info("LogicBank Activation - declare_logic.py")
     aggregate_defaults = os.environ.get("AGGREGATE_DEFAULTS") == "True"
+    all_defaults = os.environ.get("ALL_DEFAULTS") == "True"
     try:          # hover activate for info
         LogicBank.activate(session=session, 
                            activator=declare_logic.declare_logic, 
                            constraint_event=constraint_handler,
-                           aggregate_defaults=aggregate_defaults)
+                           aggregate_defaults=aggregate_defaults,
+                           all_defaults=all_defaults)
     except LBActivateException as e:
         app_logger.error("\nLogic Bank Activation Error -- see https://apilogicserver.github.io/Docs/WebGenAI-CLI/#recovery-options")
         if e.invalid_rules: logic_logger.error(f"Invalid Rules:  {e.invalid_rules}")
         if e.missing_attributes: logic_logger.error(f"Missing Attrs (try als genai-utils --fixup): {e.missing_attributes}")
         app_logger.error("\n")
-        if not os.environ.get("VERIFY_RULES") == "True":
-            # WG Rule Verification, continue if VERIFY_RULES is True
+        if not os.environ.get("VERIFY_RULES") == "True" and not os.environ.get("WG_PROJECT") == "True":
+            # WG Rule Verification, continue if VERIFY_RULES is True or inside WebGenAI
             raise e
         
     except Exception as e:
         app_logger.error(f"Logic Bank Activation Error: {e}")
         app_logger.exception(e)
-        raise e
+        if not os.environ.get("WG_PROJECT") == "True":
+            # Continue if inside WebGenAI
+            raise e
     logic_logger.setLevel(logic_logger_level)
     

api_logic_server_cli/prototypes/base/database/bind_dbs.py

@@ -15,7 +15,7 @@ def bind_dbs(flask_app):
 
     flask_app.config.update(SQLALCHEMY_BINDS = {
       'authentication': flask_app.config['SQLALCHEMY_DATABASE_URI_AUTHENTICATION'],
-      'landing_page' : flask_app.config['SQLALCHEMY_DATABASE_URI_LANDING'],
+      'landing_page' : flask_app.config['SQLALCHEMY_DATABASE_URI_LANDING']
     })  # make multiple databases available to SQLAlchemy
 
     return

api_logic_server_cli/prototypes/base/database/test_data/readme.md

@@ -1,10 +1,10 @@
-GenAI often fails to build proper test data that matches the derivation rules.
+ChatGPT sometimes fails to build proper test data that matches the derivation rules.
 
-You can rebuild the test data, using Logic Bank rules for proper derivations.
+You can rebuild the test data, using Logic Bank rules for proper derivations, to rebuild your `database/db.sqlite` (make a copy first to preserve your existing data).
 
-Envisioned support will create a new db.sqlite, with test data that reflects derivations.  
-Review, and copy to your database/db.sqlite.
 
 ```
 als genai-utils --rebuild-test-data 
-```
+```
+
+You can explore the generated `database/test_data/test_data_code.py` to control test data generation.

api_logic_server_cli/prototypes/base/integration/kafka/kafka_producer.py

@@ -1,6 +1,6 @@
 """
 
-Version 1.1
+Version 2.0
 
 Invoked at server start (api_logic_server_run.py -> config/setup.py)
 
@@ -47,8 +47,23 @@ def kafka_producer():
         producer = Producer(conf)
         logger.debug(f'\nKafka producer connected')
 
+from sqlalchemy.inspection import inspect
 
-def send_kafka_message(kafka_topic: str, kafka_key: str, msg: str="", json_root_name: str = "", 
+def get_primary_key(logic_row: LogicRow):
+    """ Return primary key for row, if it exists
+
+    Args:
+        logic_row (LogicRow): The SQLAlchemy row object
+
+    Returns:
+        dict: A dictionary with primary key column names and their values
+    """
+    primary_key_columns = inspect(logic_row.row).mapper.primary_key
+    primary_key = {column.name: getattr(logic_row.row, column.name) for column in primary_key_columns}
+    return primary_key
+
+
+def send_kafka_message(kafka_topic: str, kafka_key: str = None, msg: str="", json_root_name: str = "", 
                        logic_row: LogicRow = None, row_dict_mapper: RowDictMapper = None, payload: dict = None):
     """ Send Kafka message regarding logic_row, mapped by row_dict_mapper
 
@@ -80,18 +95,27 @@ def send_kafka_message(kafka_topic: str, kafka_key: str, msg: str="", json_root_
         else:
             root_name = logic_row.name
 
+    if kafka_key is None:
+        kafka_key = get_primary_key(logic_row) 
+
+    log_msg = msg if msg != "" else f"Sending {root_name} to Kafka topic '{kafka_topic}'" 
+
     json_string = jsonify({f'{root_name}': row_obj_dict}).data.decode('utf-8')
-    log_msg = msg + ' sends:'
+    log_msg = log_msg
     if producer:  # enabled in config/config.py?
         try:
             producer.produce(value=json_string, topic="order_shipping", key=kafka_key)
             if logic_row:
-                logic_row.log(msg)
+                logic_row.log(log_msg)
         except KafkaException as ke:
             logger.error("kafka_producer#send_kafka_message error: {ke}") 
     else:
-        log_msg += "    [Note: **Kafka not enabled** ]"
+        log_msg += " [Note: **Kafka not enabled** ]"
     if logic_row is not None:
-        logic_row.log(f'\n\n{log_msg}\n{json_string}')
-    else:
-        logger.debug(f'\n\n{log_msg}\n{json_string}')
+        logic_row.log(f'{log_msg}')
+    logger.debug(f'\n\n{log_msg}\n{json_string}')
+
+
+def send_row_to_kafka(row: object, old_row: object, logic_row: LogicRow, with_args: dict):
+    if logic_row.row.date_shipped is not None:
+        send_kafka_message(logic_row=logic_row, kafka_topic=with_args["topic"])

api_logic_server_cli/prototypes/base/integration/system/RowDictMapper.py

@@ -1,7 +1,7 @@
 from database import models
 from flask import request, jsonify
 import sqlalchemy as sqlalchemy
-from sqlalchemy import Column
+from sqlalchemy import Column, inspect
 from sqlalchemy.ext.declarative import declarative_base
 from flask_sqlalchemy.model import DefaultMeta
 from sqlalchemy.ext.hybrid import hybrid_property
@@ -276,8 +276,7 @@ class RowDictMapper():
                 parent_lookup_list.append(self.parent_lookups)
             for each_parent_lookup in parent_lookup_list:
                 self._parent_lookup_from_child(child_row_dict = row_dict, 
-                                            lookup_fields = each_parent_lookup[1],
-                                            parent_class = each_parent_lookup[0],
+                                            parent_lookup = each_parent_lookup,
                                             child_row = sql_alchemy_row,
                                             session = session)
         
@@ -354,27 +353,31 @@ class RowDictMapper():
 
     def _parent_lookup_from_child(self, child_row_dict: dict, child_row: object,
                       session: object, 
-                      parent_class: DefaultMeta,
-                      lookup_fields: list[object]):
-        """ Used from child -- parent_lookups
+                      parent_lookup: tuple[DefaultMeta, list[tuple[Column, str]]]):
+        """ Used from child -- parent_lookups (e,g, B2B Product)
 
         Args:
-            child_row_dict (dict): _description_
-            child_row (object): _description_
-            session (object): _description_
-            lookup_parent_endpoint (RowDictMapper, optional): _description_. Defaults to None.
+            child_row_dict (dict): the incoming payload
+            child_row (object): row
+            parent_lookup (tuple[DefaultMeta, list[tuple[Column, str]]]): parent class, list of attrs/json keys
+            session (object): SqlAlchemy session
+
+        Example lookup_fields (genai_demo/OrderB2B.py):
+            parent_lookup = ( models.Customer, [(models.Customer.name, 'Account')] )
+            parent_class: parent_lookups[0] Customer)
+            lookup_fields: parent_lookups[1] [(models.Customer.name, 'Account')]
 
         Raises:
-            ValueError: _description_
-            ValueError: _description_
+            ValueError: eg, missing parent
         """
-
+        parent_class = parent_lookup[0]
+        lookup_fields = parent_lookup[1]
         query = session.query(parent_class)
 
         if parent_class.__name__ in ['Product', 'Customer']:
             logging.debug(f'_parent_lookup_from_child {parent_class.__name__}' )
-        for each_lookup_param_field in lookup_fields:
-            attr_name = each_lookup_param_field
+        for each_lookup_param_field in lookup_fields:   # e.g, (models.Customer.name, 'Account')
+            attr_name = each_lookup_param_field         #       <col_def>             <filter-val>
             if isinstance(each_lookup_param_field, tuple):
                 col_def = each_lookup_param_field[0]
                 attr_name = each_lookup_param_field[1]
@@ -394,6 +397,20 @@ class RowDictMapper():
                 raise ValueError('Lookup failed: missing parent', child_row, parent_class.__name__, str(child_row_dict)) 
             
             parent_row = parent_rows[0]
-            setattr(child_row, parent_class.__name__, parent_row)
+
+            # find parent accessor - usually parent_class.__name__, unless fk is lower case (B2bOrders)
+            mapper = inspect(child_row).mapper
+            parent_accessor = None
+            for each_attribute in mapper.attrs:  # find parent accessors
+                if isinstance(each_attribute, sqlalchemy.orm.relationships.RelationshipProperty):
+                    if each_attribute.argument == parent_class.__name__:
+                        if parent_accessor is None:
+                            parent_accessor = each_attribute.key
+                        else:
+                            raise ValueError(f'Parent accessor not unique: {parent_accessor}')  # TODO - multiple parents
+            if parent_accessor is None:
+                raise ValueError(f'Parent accessor not found: {parent_class.__name__}')
+
+            setattr(child_row, parent_accessor, parent_row)
 
         return

api_logic_server_cli/prototypes/base/logic/declare_logic.py

@@ -5,9 +5,10 @@ from logic_bank.extensions.rule_extensions import RuleExtension
 from logic_bank.logic_bank import Rule
 from logic_bank.logic_bank import DeclareRule
 import database.models as models
-from database.models import *
 import api.system.opt_locking.opt_locking as opt_locking
 from security.system.authorization import Grant, Security
+from logic.load_verify_rules import load_verify_rules
+import integration.kafka.kafka_producer as kafka_producer
 import logging
 
 app_logger = logging.getLogger(__name__)
@@ -22,8 +23,13 @@ def declare_logic():
     Your Code Goes Here - Use code completion (Rule.) to declare rules
     '''
 
-    from logic.logic_discovery.auto_discovery import discover_logic
-    discover_logic()
+    if os.environ.get("WG_PROJECT"):
+        # Inside WG: Load rules from docs/expprt/export.json
+        load_verify_rules()
+    else:
+        # Outside WG: load declare_logic function
+        from logic.logic_discovery.auto_discovery import discover_logic
+        discover_logic()
 
     def handle_all(logic_row: LogicRow):  # #als: TIME / DATE STAMPING, OPTIMISTIC LOCKING
         """

api_logic_server_cli/prototypes/base/logic/load_verify_rules.py

@@ -0,0 +1,217 @@
+#
+# This code loads and verifies rules from export.json and activates them if they pass verification
+# It is WebGenAI specific, used only when env var WG_PROJECT is set
+#
+import ast
+import json
+import logging
+import os
+import sys
+import safrs
+import subprocess
+from importlib import import_module
+from pathlib import Path
+from werkzeug.utils import secure_filename
+from database.models import *
+from logic_bank.logic_bank import DeclareRule, Rule, LogicBank
+from colorama import Fore, Style, init
+from logic_bank.logic_bank import RuleBank
+from logic_bank.rule_bank.rule_bank_setup import find_referenced_attributes
+import tempfile
+
+
+app_logger = logging.getLogger(__name__)
+declare_logic_message = "ALERT:  *** No Rules Yet ***"  # printed in api_logic_server.py
+
+rule_import_template = """
+from logic_bank.logic_bank import Rule
+from database.models import *
+import integration.kafka.kafka_producer as kafka_producer
+
+def init_rule():
+{rule_code}
+"""
+
+MANAGER_PATH = "/opt/webgenai/database/manager.py"
+EXPORT_JSON_PATH = os.environ.get("EXPORT_JSON_PATH", "./docs/export/export.json")
+
+
+def set_rule_status(rule_id, status):
+    """
+    Call the manager.py script to set the status of a rule 
+    
+    (if the status is "active", the manager will remove the rule error)
+    """
+    if not Path(MANAGER_PATH).exists():
+        app_logger.info(f"No manager, can't set rule {rule_id} status {status}")
+        return
+    subprocess.run([
+            "python", MANAGER_PATH, 
+            "-R", rule_id,
+            "--rule-status", status],
+            cwd="/opt/webgenai")
+
+
+def set_rule_error(rule_id, error):
+    """
+    Call the manager.py script to set the error of a rule
+    """
+    if not Path(MANAGER_PATH).exists():
+        app_logger.warning(f"No manager, can't set rule {rule_id} error {error}")
+        return
+    subprocess.check_output([
+                "python", MANAGER_PATH, 
+                "-R", rule_id,
+                "--rule-error", error],
+                cwd="/opt/webgenai")
+
+
+def check_rule_code_syntax(rule_code):
+    """
+    Check the syntax of the rule code
+    """
+    try:
+        ast.parse(rule_code)
+        return rule_code
+    except Exception as exc:
+        log.warning(f"Syntax error in rule code '{rule_code}': {exc}")
+    
+    rule_code = rule_code.replace("\\\\", "\\")
+    try:
+        ast.parse(rule_code)
+        return rule_code
+    except Exception as exc:
+        log.warning(f"Syntax error in rule code '{rule_code}': {exc}")
+        return None
+
+
+def get_exported_rules(rule_code_dir):
+    """
+    Read the exported rules from export.json and write the code to the 
+    rule_code_dir
+    """
+    export_file = Path(EXPORT_JSON_PATH)
+    if not export_file.exists():
+        app_logger.info(f"{export_file.resolve()} does not exist")
+        return []
+
+    try:
+        with open(export_file) as f:
+            export = json.load(f)
+        rules = export.get("rules", [])
+    except Exception as exc:
+        app_logger.warning(f"Failed to load rules from {export_file}: {exc}")
+        return []
+
+    for rule in rules:
+        if rule["status"] == "rejected":
+            continue
+        rule_file = rule_code_dir / f"{secure_filename(rule['name']).replace('.','_')}.py"
+        try:
+            # write current rule to rule_file
+            # (we can't use eval, because logicbank uses inspect)
+            rule_code_str = check_rule_code_syntax(rule["code"])
+            if not rule_code_str:
+                continue
+            with open(rule_file, "w") as temp_file:
+                rule_code = "\n".join([f"  {code}" for code in rule_code_str.split("\n")])
+                temp_file.write(rule_import_template.format(rule_code=rule_code))
+                temp_file_path = temp_file.name
+            # module_name used to import current rule
+            module_name = Path(temp_file_path).stem
+            rule["module_name"] = module_name
+            app_logger.info(f"{rule['id']} rule file: {rule_file}")
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"Failed to write rule code to {rule_file}: {exc}")
+            
+    return rules
+
+
+def verify_rules(rule_code_dir, rule_type="accepted"):
+    """
+    Verify the rules from export.json and activate them if they pass verification
+    
+    Write the rule code to a temporary file and import it as a module
+    """
+    rules = get_exported_rules(rule_code_dir)
+    
+    for rule in rules:
+        if not rule["status"] == rule_type:
+            continue
+        module_name = rule["module_name"]
+        app_logger.info(f"\n{Fore.BLUE}Verifying rule: {module_name} - {rule['id']}{Style.RESET_ALL}")
+        try:
+            rule_module = import_module(module_name)
+            rule_module.init_rule()
+            LogicBank.activate(session=safrs.DB.session, activator=rule_module.init_rule)
+            if rule["status"] != "active":
+                set_rule_status(rule["id"], "active")
+            app_logger.info(f"\n{Fore.GREEN}Activated rule {rule['id']}{Style.RESET_ALL}")
+            
+        except Exception as exc:
+            app_logger.exception(exc)
+            set_rule_error(rule["id"], f"{type(exc).__name__}: {exc}")
+            app_logger.warning(f"{Fore.RED}Failed to verify {rule_type} rule code\n{rule['code']}\n{Fore.YELLOW}{type(exc).__name__}: {exc}{Style.RESET_ALL}")
+            app_logger.debug(f"{rule}")
+            rule["status"] = "accepted"
+            rule["error"] = f"{type(exc).__name__}: {exc}"
+        
+    return rules
+   
+      
+def load_active_rules(rule_code_dir, rules=None):
+    """
+    Load the active rules from export.json
+    """
+    if not rules:
+        rules = get_exported_rules(rule_code_dir)
+    for rule in rules:
+        module_name = rule.get("module_name", None)
+        if not rule["status"] == "active" or module_name is None:
+            continue
+        app_logger.info(f"{Fore.GREEN}Loading Rule Module {module_name} {rule['id']} {Style.RESET_ALL}")
+        rule_module = import_module(module_name)
+        try:
+            rule_module.init_rule()
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"{Fore.RED}Failed to load active rule {rule['id']} {rule['code']} {Style.RESET_ALL}")
+            set_rule_error(rule["id"], f"{type(exc).__name__}: {exc}")
+            
+
+def get_project_id():
+    if os.environ.get("PROJECT_ID"):
+        return os.environ.get("PROJECT_ID")
+    
+    return Path(os.getcwd()).name
+
+
+def load_verify_rules():
+    
+    # Add FileHandler to root_logger
+    log_file = Path(os.getenv("LOG_DIR",tempfile.mkdtemp())) / "load_verify_rules.log"
+    file_handler = logging.FileHandler(log_file)
+    root_logger = logging.getLogger()
+    root_logger.addHandler(file_handler)
+    
+    rule_code_dir = Path("./logic/wg_rules") # in the project root
+    rule_code_dir.mkdir(parents=True, exist_ok=True)
+    sys.path.append(f"{rule_code_dir}")
+    
+    app_logger.info(f"Loading rules from {rule_code_dir.resolve()}")
+    
+    rules = []
+    
+    if os.environ.get("VERIFY_RULES") == "True":
+        rules = verify_rules(rule_code_dir, rule_type="active")
+        verify_rules(rule_code_dir, rule_type="accepted")
+    else:
+        try:
+            load_active_rules(rule_code_dir, rules)
+        except Exception as exc:
+            app_logger.exception(exc)
+            app_logger.warning(f"{Fore.RED}Failed to load active exported rules: {exc}{Style.RESET_ALL}")
+            
+    root_logger.removeHandler(file_handler)
+