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

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/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/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)
+    

api_logic_server_cli/prototypes/base/logic/logic_discovery/auto_discovery.py

@@ -23,21 +23,30 @@ def discover_logic():
                     spec.loader.exec_module(each_logic_file)  # runs "bare" module code (e.g., initialization)
                     each_logic_file.declare_logic()  # invoke create function
 
-    if False and Path(__file__).parent.parent.parent.joinpath("docs/project_is_genai_demo.txt").exists():
-        return  # for genai_demo, logic is in logic/declare_logic.py (so ignore logic_discovery)
+    # if False and Path(__file__).parent.parent.parent.joinpath("docs/project_is_genai_demo.txt").exists():
+    #     return  # for genai_demo, logic is in logic/declare_logic.py (so ignore logic_discovery)
     
     wg_logic_path = Path(__file__).parent.parent.joinpath("wg_rules")
-    for root, dirs, files in os.walk(wg_logic_path):
-        for file in files:
-            if file.endswith(".py"):
-                spec = importlib.util.spec_from_file_location("module.name", wg_logic_path.joinpath(file))
-                if file.endswith("auto_discovery.py"):
-                    pass
-                else:
-                    logic.append(file)
-                    each_logic_file = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(each_logic_file)  # runs "bare" module code (e.g., initialization)
-                    each_logic_file.init_rule()  # invoke create function
+    if wg_logic_path.exists():
+        run_local = os.environ.get("WG_PROJECT") is None  # eg, running export locally
+        # run_local = False  # for debug
+        if run_local:  
+            wg_export_logic_path = Path(__file__).parent.parent.parent.joinpath("logic/wg_rules/active_rules_export.py") 
+            if wg_export_logic_path.is_file():
+                    spec = importlib.util.spec_from_file_location("module.name", wg_export_logic_path)
+                    logic.append(str(wg_export_logic_path))
+                    wg_export_logic_file = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(wg_export_logic_file)  # runs "bare" module code (e.g., initialization)  
+                    wg_export_logic_file.declare_logic()  # invoke create function
+        else:
+            for root, dirs, files in os.walk(wg_logic_path):
+                for file in files:
+                    if file.endswith(".py") and 'active_rules_export.py' != file:
+                        spec = importlib.util.spec_from_file_location("module.name", wg_logic_path.joinpath(file))
+                        logic.append(file)
+                        each_logic_file = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(each_logic_file)  # runs "bare" module code (e.g., initialization)
+                        each_logic_file.init_rule()  # invoke create function
 
     app_logger.info(f"..discovered logic: {logic}")
     return

api_logic_server_cli/prototypes/genai_demo/logic/declare_logic.py

@@ -20,19 +20,16 @@ def declare_logic():
     ''' Declarative multi-table derivations and constraints, extensible with Python.
  
     Brief background: see readme_declare_logic.md
-    
-    Your Code Goes Here - Use code completion (Rule.) to declare rules
 
-    GenAI: Paste the following into Copilot Chat, and paste the result below.
+    GenAI: the following prompt was sent to GenAI-Logic, which translated it into the code below:
         
-    Use Logic Bank to enforce these requirements:
+    Use case: Check Credit 
     
-    Enforce the Check Credit requirement (do not generate check constraints):
-    1. Customer.Balance <= CreditLimit
-    2. Customer.Balance = Sum(Order.AmountTotal where date shipped is null)
-    3. Order.AmountTotal = Sum(Items.Amount)
-    4. Items.Amount = Quantity * UnitPrice
-    5. Store the Items.UnitPrice as a copy from Product.UnitPrice
+    1. The Customer's balance is less than the credit limit
+    2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
+    3. The Order's amount_total is the sum of the Item amount
+    4. The Item amount is the quantity * unit_price
+    5. The Item unit_price is copied from the Product unit_price
     '''
 
     from logic_bank.logic_bank import Rule
@@ -40,39 +37,50 @@ def declare_logic():
     from logic.logic_discovery.auto_discovery import discover_logic
     discover_logic()
 
-    # Logic from GenAI: (or, use your IDE w/ code completion)n
+    # Logic from GenAI: (or, use your IDE w/ code completion)
+
+    # Ensures the customer's balance is less than the credit limit.
+    Rule.constraint(validate=Customer,
+                    as_condition=lambda row: row.Balance <= row.CreditLimit,
+                    error_msg="Customer balance ({row.Balance}) exceeds credit limit ({row.CreditLimit})")
+
+    # Computes the customer's balance as the sum of unshipped orders.
     Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal, where=lambda row: row.ShipDate is None)
+
+    # Computes the total amount of an order as the sum of item amounts.
     Rule.sum(derive=Order.AmountTotal, as_sum_of=Item.Amount)
+
+    # Calculates the item amount as the quantity times unit price.  (original rule, prior to iteration)
     # Rule.formula(derive=Item.amount, as_expression=lambda row: row.quantity * row.unit_price)
+
+    # Copies the unit price from the parent product to the item.
     Rule.copy(derive=Item.UnitPrice, from_parent=Product.UnitPrice)
-    Rule.constraint(validate=Customer,
-                    as_condition=lambda row: row.Balance <= row.CreditLimit,
-                    error_msg="Customer balance ({row.Balance}) exceeds credit limit ({row.CreditLimit})")
 
     # End Logic from GenAI
 
+
+    #als: Demonstrate that logic == Rules + Python (for extensibility)
+
+    # 4. Items.Amount = Quantity * UnitPrice, altered with IDE for CarbonNeutral discount
     def derive_amount(row: Item, old_row: Item, logic_row: LogicRow):
         amount = row.Quantity * row.UnitPrice
         if row.Product.CarbonNeutral == True and row.Quantity >= 10:
            amount = amount * Decimal(0.9)  # breakpoint here
         return amount
-
-    # 4. Items.Amount = Quantity * UnitPrice
-    Rule.formula(derive=Item.Amount, calling=derive_amount)
-
-    #als: Demonstrate that logic == Rules + Python (for extensibility)
+    # now register function; note logic ordering is automatic
+    Rule.formula(derive=Item.Amount, calling=derive_amount)  
 
     def send_order_to_shipping(row: Order, old_row: Order, logic_row: LogicRow):
         """ #als: Send Kafka message formatted by OrderShipping RowDictMapper
 
         Format row per shipping requirements, and send (e.g., a message)
 
-        NB: the after_flush event makes Order.Id avaible.  Contrast to congratulate_sales_rep().
+        NB: the after_flush event makes Order.Id avaible.
 
         Args:
             row (Order): inserted Order
             old_row (Order): n/a
-            logic_row (LogicRow): bundles curr/old row, with ins/upd/dlt logic
+            logic_row (LogicRow): bundles curr/old row, with ins/upd/dlt (etc) state
         """
         if logic_row.is_inserted():
             kafka_producer.send_kafka_message(logic_row=logic_row,

api_logic_server_cli/prototypes/manager/README.md

@@ -149,9 +149,22 @@ Verify it's operating properly:
 
 <details markdown>
 
-<summary> You can iterate the data model and logic</summary>
+<summary> You can iterate the logic and data model</summary>
 
-<br>You can add new columns/tables, while keeping the prior model intact:
+<br>Logic iterations are particuarly useful.  For example, here we take the basic check-credit logic, and add:
+
+> Provide a 10% discount when buying more than 10 carbon neutral products.<br><br>The Item carbon neutral is copied from the Product carbon neutral
+
+Explore [genai_demo_iteration_discount](system/genai/examples/genai_demo/genai_demo_iteration_discount).  This will add carbon_neutral to the data model, and update the logic to provide the discount:
+
+```bash title='Iterate Business Logic'
+# Iterate with data model and logic
+als genai --project-name='genai_demo_with_logic' --using=system/genai/examples/genai_demo/genai_demo_iteration
+# open Docs/db.dbml
+```
+<br>
+
+You can add new columns/tables, while keeping the prior model intact:
 
 ```bash title='Iterate Without Logic'
 # Step 1 - create without logic
@@ -164,7 +177,9 @@ als genai --project-name='genai_demo_no_logic' --using=system/genai/examples/gen
 als genai --project-name='genai_demo_with_logic' --using=system/genai/examples/genai_demo/genai_demo_iteration
 # open Docs/db.dbml
 ```
-> Explore [genai_demo_iteration](system/genai/examples/genai_demo/genai_demo_iteration) - observe the `--using` is a *directory* of prompts.  These include the prompts from the first example, plus an *iteration prompt* (`004_iteration_renames_logic.prompt`) to rename tables and add logic.
+
+Explore [genai_demo_iteration](system/genai/examples/genai_demo/genai_demo_iteration) - observe the `--using` is a *directory* of prompts.  These include the prompts from the first example, plus an *iteration prompt* (`004_iteration_renames_logic.prompt`) to rename tables and add logic.
+
 
 </details>
 </br>