ApiLogicServer 14.2.2__py3-none-any.whl → 14.3.0__py3-none-any.whl

api_logic_server_cli/genai/genai_svcs.py

@@ -21,6 +21,8 @@ import ast
 import astor
 import yaml
 
+from genai.client import get_ai_client
+
 K_LogicBankOff = "LBX"
 ''' LBX Disable Logic (for demos) '''
 K_LogicBankTraining = "Here is the simplified API for LogicBank"
@@ -65,20 +67,103 @@ try:  # this is just for WebGenAI
     # Add the file handler to the logger
     log.addHandler(file_handler)
     log.setLevel(logging.DEBUG)
-    log.info(f"Svcs log file: /tmp/genai_svcs.log")
+    
 except Exception as exc:
     pass # this is just for WebGenAI, ok to ignore error
 
-def get_code(rule_list: List[DotMap]) -> str:
-    """returns code snippet for rules from rule
+def get_code_update_logic_file(rule_list: List[DotMap], logic_file_path: Path = None) -> str:
+    """returns code snippet for rules from rule, updates rules if logic_file_path provided
+
+        * see avoid_collisions_on_rule
 
     Args:
         rule_list (List[DotMap]): list of rules from ChatGPT in DotMap format
+        logic_file_path (Path): if provided, update default rule file, with provisions for model named `Rule`
 
     Returns:
         str: the rule code
     """    
 
+    import re
+
+    patterns = [ re.compile(r"derive=(\w+).*$"),
+                 re.compile(r"from_parent=(\w+).*$"),
+                 re.compile(r"Rule\.constraint\(validate=(\w+).*$"),
+                 re.compile(r"as_sum_of=(\w+).*$"),
+                 re.compile(r"as_count_of=(\w+).*$")
+               ]
+
+    def get_imports(each_line: str, imports: set):
+        """updates imports by extracting the class names to import
+        
+        eg, Rule.constraint(validate=Customer) -> Customer
+
+        Args:
+            each_line (str): the ChatGPT code
+            imports (set): the set of imported classes (updated in place)
+        """
+
+        for each_pattern in patterns:
+            match = each_pattern.search(each_line)
+            if match:
+                the_class_name = match.group(1)
+                log.debug(f'.. found class: {the_class_name} in: {each_line}')
+                imports.add(the_class_name)
+            else:
+                pass
+                # log.debug(f'.. no classes found in: {each_line}')
+        return
+
+    def insert_logic_into_file_and_avoid_collisions_on_rule(translated_logic: str, imports: set, logic_file_path: Path = None) -> None:
+        """ Update logic file with rule code (if provided), with collision avoidance on models named Rule
+        
+        If there's a model named `Rule`, that collides with LogicBank.Rule.  So, change LogicBank.Rule refs:
+
+        1. `from logic_bank.logic_bank import Rule`
+                * to: from logic_bank.logic_bank import Rule as LogicBankRule
+        2. `Rule.early_row_event_all_classes(early_row_event_all_classes=handle_all)`
+                * to: LogicBankRule.early_row_event_all_classes
+                * not used in logic_files, so project is None
+        3. Users' logic (e.g, Rule.constraint) --> LogicBank.Rule.constraint
+
+        Beware of these cases:
+        1. als create - this is not used (but logic/declare_logic.py must exist)
+        2. als genai - uses this, with discovery stuff & Rule.early_event at the end
+        3. als genai-logic - logic/logic_discovery files, no discovery stuff at end
+        4. webG logic - operates differently, to create logic/wg_rules files (for diagnostics)
+
+        Args:
+            rule_list (List[DotMap]): list of rules from ChatGPT in DotMap format
+            project (Project): a Project object (unless creating a logic file)
+            imports (set): the set of imported classes
+        """        
+        insert_logic = "\n    # Logic from GenAI: (or, use your IDE w/ code completion)\n"
+        insert_logic += translated_logic
+        insert_logic += "\n    # End Logic from GenAI\n\n"
+
+        utils.insert_lines_at(lines=insert_logic, 
+                            file_name=logic_file_path, 
+                            at='discover_logic()', 
+                            after=True)
+        
+        if 'Rule' not in imports:
+            return
+        if logic_file_path is None:  # this needs review for WebGenAI
+            log.debug(f'.. .. WebGenAI - avoid_collisions_on_rule: {logic_file_path}')
+            return
+        # find and replace `Rule` in declare_logic.py:
+        utils.replace_string_in_file(search_for='from logic_bank.logic_bank import Rule', 
+                                     replace_with='from logic_bank.logic_bank import Rule as LogicBankRule', 
+                                     in_file=logic_file_path)
+        utils.replace_string_in_file(search_for='Rule.early_row_event_all_classes', 
+                                     replace_with='LogicBankRule.early_row_event_all_classes', 
+                                     in_file=logic_file_path)
+        utils.replace_string_in_file(search_for='    Rule.', 
+                                     replace_with='    LogicBankRule.', 
+                                     in_file=logic_file_path)
+
+
+
     def remove_logic_halluncinations(each_line: str) -> str:
         """remove hallucinations from logic
 
@@ -117,7 +202,9 @@ def get_code(rule_list: List[DotMap]) -> str:
                 log.debug(f'.. removed hallucination: {each_line}')
         return return_line
 
+
     translated_logic = ""
+    imports = set()
     for each_rule in rule_list:
         comment_line = each_rule.description
         translated_logic += f'\n    # {comment_line}\n'
@@ -127,11 +214,19 @@ def get_code(rule_list: List[DotMap]) -> str:
         for each_line in code_lines:
             if 'declare_logic.py' not in each_line:
                 each_repaired_line = remove_logic_halluncinations(each_line=each_line)
+                get_imports(each_line = each_repaired_line, imports=imports)
                 if not each_repaired_line.startswith('    '):  # sometimes in indents, sometimes not
                     each_repaired_line = '    ' + each_repaired_line
                 if 'def declare_logic' not in each_repaired_line:
-                    translated_logic += each_repaired_line + '\n'    
-    return translated_logic
+                    translated_logic += each_repaired_line + '\n' 
+
+    # from database.models import Customer, Order, Item, Product 
+    return_translated_logic = '    from database.models import ' + ', '.join(imports) + '\n' + translated_logic
+    insert_logic_into_file_and_avoid_collisions_on_rule(
+        imports=imports, 
+        translated_logic=return_translated_logic, 
+        logic_file_path=logic_file_path)
+    return return_translated_logic
 
 def rebuild_test_data_for_project(response: str = 'docs/response.json',
                                   project: Project = None,
@@ -166,7 +261,6 @@ def rebuild_test_data_for_project(response: str = 'docs/response.json',
         existing_models = rebuild_project
         del existing_models['rules']
         del existing_models['test_data']
-        del existing_models['test_data_rows']
         del existing_models['test_data_sqlite']
         rebuild_request.append({"role": "user", "content": json.dumps(existing_models)})
         with open(get_manager_path().joinpath('system/genai/prompt_inserts/rebuild_test_data.prompt'), 'r') as file:
@@ -434,6 +528,8 @@ def fix_and_write_model_file(response_dict: DotMap,  save_dir: str, post_error:
                 check_for_row_name = False
             if 'Base.metadata.create_all(engine)' in each_fixed_line:
                 each_fixed_line = each_fixed_line.replace('Base.metadata.create_all(engine)', '# Base.metadata.create_all(engine)')
+            if ',00' in each_fixed_line:
+                each_fixed_line = each_fixed_line.replace(',00', ',0')
             return each_fixed_line
 
         row_names = list()
@@ -759,22 +855,22 @@ def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str) -
         using (str): str to save response.json (relative to cwd)
     Returns:
         str: response from ChatGPT
-    """    
+    """
     try:
         start_time = time.time()
-        db_key = os.getenv("APILOGICSERVER_CHATGPT_APIKEY")
-        client = OpenAI(api_key=os.getenv("APILOGICSERVER_CHATGPT_APIKEY"))
         model = api_version
         if model == "":  # default from CLI is '', meaning fall back to env variable or system default...
             model = os.getenv("APILOGICSERVER_CHATGPT_MODEL")
-            if model is None or model == "*":  # system default chatgpt model
-                model = "gpt-4o-2024-08-06"
+            if model is None or model == "*":   # system default chatgpt model
+                model = "gpt-4o-2024-08-06"     #  33 sec
+                # model = "o3-mini"               # 130 sec
         with open(Path(using).joinpath('request.json'), "w") as request_file:  # save for debug
             json.dump(messages, request_file, indent=4)
         log.info(f'.. saved request: {using}/request.json')
-
+        client = get_ai_client()
         completion = client.beta.chat.completions.parse(
-            messages=messages, response_format=WGResult,
+            messages=messages,
+            response_format=WGResult,
             # temperature=self.project.genai_temperature,  values .1 and .7 made students / charges fail
             model=model  # for own model, use "ft:gpt-4o-2024-08-06:personal:logicbank:ARY904vS" 
         )

api_logic_server_cli/genai/genai_utils.py

@@ -98,7 +98,6 @@ class GenAIUtils:
         api_version = f"{self.genai_version}"
         start_time = time.time()
         db_key = os.getenv("APILOGICSERVER_CHATGPT_APIKEY", "")
-        client = OpenAI(api_key=db_key)
         model = api_version if api_version else os.getenv("APILOGICSERVER_CHATGPT_MODEL", "gpt-4o-2024-08-06")
         self.resolved_model = model
 

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/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/config/config.py

@@ -46,6 +46,7 @@ class OptLocking(ExtendedEnum):
 
 basedir = path.abspath(path.dirname(__file__))
 load_dotenv(path.join(basedir, "default.env"))
+project_path = Path(__file__).parent.parent
 app_logger = logging.getLogger('api_logic_server_app')
 
 def is_docker() -> bool:
@@ -89,11 +90,10 @@ class Config:
     FLASK_APP = environ.get("FLASK_APP")
     FLASK_ENV = environ.get("FLASK_ENV")
     DEBUG = environ.get("DEBUG")
-            
-    running_at = Path(__file__)
-    project_abs_dir = running_at.parent.absolute()
+
 
     # Database
+    db_path = str(project_path.joinpath('database/db.sqlite'))
     SQLALCHEMY_DATABASE_URI : typing.Optional[str] = f"replace_db_url"
     # override SQLALCHEMY_DATABASE_URI here as required
 
@@ -143,9 +143,8 @@ class Config:
         app_logger.info(f'config.py - security disabled')
 
     # Begin Multi-Database URLs (from ApiLogicServer add-db...)
-
-
-    SQLALCHEMY_DATABASE_URI_AUTHENTICATION = 'sqlite:///../database/authentication_db.sqlite'
+    auth_db_path = str(project_path.joinpath('database/authentication_db.sqlite'))
+    SQLALCHEMY_DATABASE_URI_AUTHENTICATION = f'sqlite:///{auth_db_path}'
     app_logger.info(f'config.py - SQLALCHEMY_DATABASE_URI_AUTHENTICATION: {SQLALCHEMY_DATABASE_URI_AUTHENTICATION}\n')
 
     # as desired, use env variable: export SQLALCHEMY_DATABASE_URI='sqlite:////Users/val/dev/servers/docker_api_logic_project/database/db.sqliteXX'
@@ -153,6 +152,11 @@ class Config:
         SQLALCHEMY_DATABASE_URI_AUTHENTICATION = os.getenv('SQLALCHEMY_DATABASE_URI_AUTHENTICATION')  # type: ignore # type: str
         app_logger.debug(f'.. overridden from env variable: SQLALCHEMY_DATABASE_URI_AUTHENTICATION')
 
+    # Single Page App (SPA) Landing Page Database
+    landing_db_path = project_path.joinpath('database/db_spa.sqlite')
+    SQLALCHEMY_DATABASE_URI_LANDING = f'sqlite:///{landing_db_path}'
+    if landing_db_path.exists():
+        app_logger.info(f'config.py - SQLALCHEMY_DATABASE_URI_LANDING: {SQLALCHEMY_DATABASE_URI_LANDING}\n')
 
     # End Multi-Database URLs (from ApiLogicServer add-db...)
 

api_logic_server_cli/prototypes/base/database/bind_dbs.py

@@ -14,7 +14,8 @@ def bind_dbs(flask_app):
     """ called by api_logic_server_run to open/bind each additional database"""
 
     flask_app.config.update(SQLALCHEMY_BINDS = {
-		'authentication': flask_app.config['SQLALCHEMY_DATABASE_URI_AUTHENTICATION']
+      'authentication': flask_app.config['SQLALCHEMY_DATABASE_URI_AUTHENTICATION'],
+      '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/logic/declare_logic.py

@@ -5,9 +5,9 @@ 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 logging
 
 app_logger = logging.getLogger(__name__)
@@ -22,8 +22,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,216 @@
+#
+# 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 *
+
+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)
+