ApiLogicServer 14.5.0__py3-none-any.whl → 14.5.4__py3-none-any.whl

api_logic_server_cli/prototypes/basic_demo/customizations/database/system/SAFRSBaseX.py

@@ -0,0 +1,139 @@
+import json
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, DECIMAL, Date, ForeignKey, Integer, String
+from safrs import SAFRSBase
+from flask_login import UserMixin
+import safrs, flask_sqlalchemy
+from safrs import jsonapi_attr
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+import operator
+import json
+
+
+Base = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
+#vh new x
+@classmethod
+def jsonapi_filter(cls):
+    """
+    Use this to override SAFRS JSON:API filtering
+
+    Returns:
+        _type_: SQLAlchemy query filter
+    """
+    from sqlalchemy import text, or_, and_
+    from flask import request
+    expressions = []
+    sqlWhere = ""
+    query = cls._s_query
+    if args := request.args:
+        from api.system.expression_parser import advancedFilter
+        expressions, sqlWhere = advancedFilter(cls, args)
+    if sqlWhere != "":    
+        return query.filter(text(sqlWhere))
+    else:
+        return query.filter(and_(*expressions))   
+
+class SAFRSBaseX(SAFRSBase, safrs.DB.Model):
+    __abstract__ = True
+    if do_enable_ont_advanced_filters := False:
+        jsonapi_filter = jsonapi_filter
+        
+    def _s_parse_attr_value(self, attr_name: str, attr_val: any):
+        """
+        Parse the given jsonapi attribute value so it can be stored in the db
+        :param attr_name: attribute name
+        :param attr_val: attribute value
+        :return: parsed value
+        """
+        attr = self.__class__._s_jsonapi_attrs.get(attr_name, None)
+        if hasattr(attr, "type"):  # pragma: no cover
+            
+            if str(attr.type) in ["DATE", "DATETIME"] and attr_val:
+                try:
+                    attr_val = attr_val.replace("T", " ")
+                    datetime.strptime(attr_val, '%Y-%m-%d %H:%M')
+                    attr_val += ":00"
+                except ValueError:
+                    pass
+                except Exception as exc:
+                    safrs.log.warning(exc)
+        
+        
+        return super()._s_parse_attr_value(attr_name, attr_val)
+
+
+    @classmethod
+    def _s_filter(cls, *filter_args, **filter_kwargs):
+        """
+        Apply a filter to this model
+        :param filter_args: A list of filters information to apply, passed as a request URL parameter.
+        Each filter object has the following fields:
+        - name: The name of the field you want to filter on.
+        - op: The operation you want to use (all sqlalchemy operations are available). The valid values are:
+            - like: Invoke SQL like (or "ilike", "match", "notilike")
+            - eq: check if field is equal to something
+            - ge: check if field is greater than or equal to something
+            - gt: check if field is greater than to something
+            - ne: check if field is not equal to something
+            - is_: check if field is a value
+            - is_not: check if field is not a value
+            - le: check if field is less than or equal to something
+            - lt: check if field is less than to something
+        - val: The value that you want to compare.
+        :return: sqla query object
+        """
+        try:
+            filters = json.loads(filter_args[0])
+        except json.decoder.JSONDecodeError:
+            raise ValidationError("Invalid filter format (see https://github.com/thomaxxl/safrs/wiki)")
+
+        if not isinstance(filters, list):
+            filters = [filters]
+
+        expressions = []
+        query = cls._s_query
+
+        for filt in filters:
+            if not isinstance(filt, dict):
+                safrs.log.warning(f"Invalid filter '{filt}'")
+                continue
+            attr_name = filt.get("name")
+            attr_val = filt.get("val")
+            if attr_name != "id" and attr_name not in cls._s_jsonapi_attrs:
+                raise ValidationError(f'Invalid filter "{filt}", unknown attribute "{attr_name}"')
+
+            op_name = filt.get("op", "").strip("_")
+            attr = cls._s_jsonapi_attrs[attr_name] if attr_name != "id" else cls.id
+            if op_name in ["in", "notin"]:
+                op = getattr(attr, op_name + "_")
+                query = query.filter(op(attr_val))
+            elif op_name in ["like", "ilike", "match", "notilike"] and hasattr(attr, "like"):
+                # => attr is Column or InstrumentedAttribute
+                like = getattr(attr, op_name)
+                expressions.append(like(attr_val))
+            elif not hasattr(operator, op_name):
+                raise ValidationError(f'Invalid filter "{filt}", unknown operator "{op_name}"')
+            else:
+                op = getattr(operator, op_name)
+                expressions.append(op(attr, attr_val))
+
+        if len(filters) > 1:
+            return query.filter(operator.and_(*expressions))
+        else:
+            return query.filter(*expressions)
+
+
+class TestBase(Base):
+    __abstract__ = True
+    def __init__(self, *args, **kwargs):
+        for name, val in kwargs.items():
+            col = getattr(self.__class__, name)
+            if 'amount_total' == name:
+                debug_stop = 'stop'
+            if val is not None:
+                if str(col.type) in ["DATE", "DATETIME"]:
+                    pass
+                else:
+                    kwargs[name] = col.type.python_type(val)
+        return super().__init__(*args, **kwargs)

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/README_mcp.md

@@ -10,4 +10,6 @@ Model Context Protocol is a way for:
 
     * ***Corporate database participation*** in such flows, by making key functions available as MCP calls.
 
-This example is [explained here](https://apilogicserver.github.io/Docs/Integration-MCP/).
+This example is [explained here](https://apilogicserver.github.io/Docs/Integration-MCP/).
+
+> Note: this sample uses multi-term filters.  These are usually OR'd together, but this example requires AND.  This is provided by `database/system/SAFRSBaseX.py` (see `return query.filter(operator.and_(*expressions)`) in `_s_filter()`), activated in `config/server_setup.py`.

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/mcp_client_executor.py

@@ -10,16 +10,11 @@ Notes:
 * See: integration/mcp/README_mcp.md
 * python api_logic_server_run.py
 
-ToDo - email example is incomplete:
-1. Add email event handler (ala nw_sample/logic/declare_logic.py#send_n8n_message())
-2. And, respect the customer email_opt_out
-3. Needs to use date range
-4. Data incomplete
-
 """
 
 import json
 import os
+import re
 import openai
 import requests
 
@@ -83,30 +78,20 @@ def discover_mcp_servers():
 
 
 def get_user_nl_query():
-    """ Get the natural language query from the user. """
+    """ Get the natural language query from the user. 
+    Add instructions for the LLM to generate a tool context block.
+    
+    """
 
     global test_type
-        # this doesn't work -- missing commands for mcp_server_executor....
-    default_request = "List the orders created more than 30 days ago, and post an email message to the order's customer offering a discount"
-
-    default_request = "List the orders created more than 30 days ago, and send a discount email to the customer for each one."
-    # date range?  curl -X GET "http://localhost:5656/api/Order?filter=[{\’name\'}: {\’CreatedOn\’}, {\’op\’}: {\’gt\’}, {\’val\’}: {\’2022-05-14\’}]”
-
-    default_request = "List the orders for customer 5, and send a discount email to the customer for each one."
 
-    if test_type != 'orchestration':
-        default_request = "List customers with credit over 1000"
-
-    query = sys.argv[1] if len(sys.argv) > 1 else default_request
-
-    query += """
-Respond with a JSON array of tool context blocks using:
-- tool: 'json-api'
-- JSON:API-compliant filtering (e.g., filter[CreatedOn][lt])
-- Use {{ order.customer_id }} as a placeholder in the second step.
-- Include method, url, query_params or body, headers, expected_output.
-"""
-    return query
+    if len(sys.argv) > 1 and sys.argv[1] != 'go':
+        request = sys.argv[1]
+    else:
+        request = "List the unshipped orders created before 2023-07-14, and send a discount email to the customer for each one."
+        if test_type != 'orchestration':
+            request = "List customers with credit over 1000"
+    return request
 
 
 def query_llm_with_nl(nl_query):
@@ -131,53 +116,63 @@ def query_llm_with_nl(nl_query):
 
     # setup default tool_context to bypass LLM call and save 2-3 secs in testing
     if test_type == 'orchestration':     # orchestration: emails to pending orders
+
         tool_context = \
-            [
-                {
-                    "tool": "json-api",
-                    "method": "GET",
-                    "url": "http://localhost:5656/api/Order",
-                    "query_params": {
-                        "filter[customer_id]": 5
-                    },
-                    "headers": {
-                        "Content-Type": "application/vnd.api+json"
-                    },
-                    "expected_output": "JSON array of orders for customer 5"
-                },
-                {
-                    "tool": "email",
-                    "method": "POST",
-                    "url": "http://localhost:5656/api/Email",
-                    "body": {
-                        "to": "{{ order.customer_id }}",
-                        "subject": "Discount Offer",
-                        "message": "Dear Customer, We are offering a discount on your recent orders. Please check your account for more details."
+            {
+                "tool_type": "json-api",
+                "schema_version": "1.0",
+                "base_url": "http://localhost:5656/api",
+                "resources": [
+                    {
+                        "path": "/Order",
+                        "method": "GET",
+                        "query_params": [
+                            {
+                                "name": "date_shipped",
+                                "op": "eq",
+                                "val": None
+                            },
+                            {
+                                "name": "date_created",
+                                "op": "lt",
+                                "val": "2023-07-14"
+                            }
+                        ],
+                        "headers": [],
+                        "expected_output": []
                     },
-                    "headers": {
-                        "Content-Type": "application/json"
-                    },
-                    "expected_output": "Email sent confirmation"
-                }
-            ]
-    else:                                   # simple get request - list customers with credit over 4000 
+                    {
+                        "path": "/Email",
+                        "method": "POST",
+                        "body": {
+                            "customer_id": "{{ order.customer_id }}",
+                            "message": "You have a discount on your unshipped order."
+                        },
+                        "headers": [],
+                        "expected_output": []
+                    }
+                ]
+            }
+    else:                                   # simple get request - list customers with credit over 1000 
         tool_context = \
-            [
-                {
-                    "tool": "json-api",
-                    "method": "GET",
-                    "url": "http://localhost:5656/api/Customer",
-                    "query_params": {
-                        "filter[credit_limit][gt]": 1000
-                    },
-                    "headers": {
-                        "Content-Type": "application/vnd.api+json"
-                    },
-                    "expected_output": "JSON array of customers with credit limit over 1000"
-                }
-            ]
-
-    # Call the OpenAI API to generate the tool context        
+            {
+                "tool_type": "json-api",
+                "schema_version": "1.0",
+                "base_url": "http://localhost:5656/api",
+                "resources": [
+                    {
+                        "path": "/Customer",
+                        "method": "GET",
+                        "query_params": [
+                            {
+                                "name": "credit_limit",
+                                "op": "gt",
+                                "val": "1000"
+                            }
+                        ]
+                    }
+                ]
+            }    # Call the OpenAI API to generate the tool context        
     if create_tool_context_from_llm:  # saves 2-3 seconds...
       response = openai.chat.completions.create(
           model="gpt-4",
@@ -186,13 +181,17 @@ def query_llm_with_nl(nl_query):
       )
 
       tool_context_str = response.choices[0].message.content
+      tool_context_str_no_cr = tool_context_str.replace("\n", '')  # convert single quotes to double quotes
       try:
-          tool_context = json.loads(tool_context_str)
+          tool_context = json.loads(tool_context_str_no_cr)
       except json.JSONDecodeError:
           print("Failed to decode JSON from response:", tool_context_str)
           return None
 
-    print("\n2. generated tool context from LLM:\n", json.dumps(tool_context, indent=4))
+    print("\n\n2a. LLM request:\n", json.dumps(messages, indent=4))
+    print("\n2b. NL Query:\n", nl_query)
+    print("\n2c. schema_text: \n", json.dumps(json.loads(schema_text), indent=4))  #schema_text[0:100])
+    print("\n2d. generated tool context from LLM:\n", json.dumps(tool_context, indent=4))
     return tool_context
 
 
@@ -213,71 +212,85 @@ def process_tool_context(tool_context):
 
     def get_query_param_filter(query_params):
         """ return json:api filter
+
+        eg
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"eq","val":null},{"name":"CreatedOn","op":"lt","val":"2023-07-14"}]'
+
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"gt","val":"2023-07-14"}]'
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"eq","val":null}]'
+            curl -qg 'http://localhost:5656/api/Customer?filter=[{"name":"credit_limit","op":"gt","val":"1000"}]'
         
-        query_params might be:
-            "query_params": {
-                "filter[credit_limit][gt]": 1000 }
-        or:
-            "query_params": {
-                "filter[customer_id]": 5},
+        query_params might be simple:
+            "query_params": [ {"name": "credit_limit", "op": "gt", "val": "1000"} ]
+            ==> ?filter=[{"name":"credit_limit","op":"gt","val":"1000"}]
+
+        or a list:
+            "query_params": [
+                {
+                    "name": "date_shipped",
+                    "op": "eq",
+                    "val": None
+                },
+                {
+                    "name": "date_created",
+                    "op": "lt",
+                    "val": "2023-07-14"
+                }
+            ],
 
         """
-        query_param_filter = ''
-        if isinstance(query_params, dict):
-            for each_key, each_value in query_params.items():
-                if isinstance(each_value, dict):
-                    for sub_key, sub_value in each_value.items():
-                        query_param_filter += f"&{each_key}[{sub_key}]={sub_value}"
-                else:
-                    query_param_filter += f"&{each_key}={each_value}"
-            # query_params = ''
-        elif isinstance(query_params, dict):
-            assert False, "Query Params dict tbd"
-        return query_param_filter
-
-
-    if isinstance(tool_context, dict):
-        query_params = tool_context["query_params"]
-        query_param_filter = get_query_param_filter(query_params) 
-        mcp_response = requests.get(
-            tool_context["url"],
-            headers=tool_context["headers"],
-            params=query_param_filter
-        )
-    elif isinstance(tool_context, list):
-        context_data = {}
+
         added_rows = 0
 
-        for each_block in tool_context:
-            if each_block["tool"] in ["json-api", "email"]:
-                if each_block["method"] == "GET":
-                        query_param_filter = get_query_param_filter(each_block["query_params"])
-                        mcp_response = requests.get(
-                            url = each_block["url"],
-                            headers=each_block["headers"],
-                            params=query_param_filter
+        query_param_filter = ''
+        assert isinstance(query_params, list), "Query Params filter expected to be a list"
+        query_param_filter = 'filter=' + str(query_params)
+        # use urlencode to convert to JSON:API format...
+        # val urllib.parse.quote() or urllib.parse.urlencode()
+        # tool instructions... filtering, email etc
+        query_param_filter = query_param_filter.replace("'", '"')  # convert single quotes to double quotes
+        query_param_filter = query_param_filter.replace("None", 'null')
+        query_param_filter = query_param_filter.replace("date_created", 'CreatedOn')  # TODO - why this name?
+        return query_param_filter  # end get_query_param_filter
+
+    assert isinstance(tool_context, (dict, list)), "Tool context expected to be a dictionary"
+    context_data = {}
+    added_rows = 0
+
+    for each_block in tool_context["resources"]:
+        if True:  # TODO - add check for "tool": "json-api"
+            if each_block["method"] == "GET":
+                    query_param_filter = get_query_param_filter(each_block["query_params"])
+                    headers = {"Content-Type": "application/vnd.api+json"}
+                    if "headers" in each_block:
+                        headers.update(each_block["headers"])
+                    mcp_response = requests.get(
+                        url = tool_context["base_url"] + each_block["path"],
+                        headers=headers,
+                        params=query_param_filter
+                    )
+                    context_data = mcp_response.json()['data']  # result rows...
+            elif each_block["method"] in ["POST"]:
+                    for each_order in context_data:
+                        url = tool_context["base_url"] + each_block["path"]
+                        json_update_data =  { 'data': {"type": "Email", 'attributes': {} } }  
+                        json_update_data_attributes = json_update_data["data"]["attributes"]
+                        json_update_data_attributes["customer_id"] = context_data[0]['attributes']["customer_id"]  # TODO - fix
+                        json_update_data_attributes["message"] = each_block["body"]["message"] 
+                        # eg: POST http://localhost:5656/api/Email {'data': {'type': 'Email', 'attributes': {'customer_id': 5, 'message': {'to': '{{ order.customer_id }}', 'subject': 'Discount for your order', 'body': 'Dear customer, you have a discount for your recent order. Thank you for shopping with us.'}}}}
+                        headers = {"Content-Type": "application/vnd.api+json"}
+                        if "headers" in each_block:
+                            headers.update(each_block["headers"])
+                        mcp_response = requests.post(  
+                            url=url,
+                            headers=headers,
+                            json=json_update_data
                         )
-                        context_data = mcp_response.json()['data']  # result rows...
-                elif each_block["method"] in ["POST"]:
-                        add_rows = 0
-                        for each_order in context_data:
-                            url = each_block["url"]
-                            json_update_data =  { 'data': {"type": "Email", 'attributes': {} } }  
-                            json_update_data_attributes = json_update_data["data"]["attributes"]
-                            json_update_data_attributes["customer_id"] = context_data[0]['attributes']["customer_id"]
-                            json_update_data_attributes["message"] = each_block["body"]["message"] 
-                            # eg: POST http://localhost:5656/api/Email {'data': {'type': 'Email', 'attributes': {'customer_id': 5, 'message': {'to': '{{ order.customer_id }}', 'subject': 'Discount for your order', 'body': 'Dear customer, you have a discount for your recent order. Thank you for shopping with us.'}}}}
-                            mcp_response = requests.post(  
-                                url=url,
-                                headers=each_block["headers"],
-                                json=json_update_data
-                            )
-                            add_rows += 1
-            pass
-    else:
-        print("Invalid tool context format. Expected a dictionary or a list.")
-        return None
+                        added_rows += 1
+        pass
     print("\n3. MCP Server (als) Response:\n", mcp_response.text)
+    if added_rows > 0:
+        print(f"...Added {added_rows} rows to the database; last row (only) shown above.")
     return mcp_response 
 
 

api_logic_server_cli/prototypes/basic_demo/customizations/logic/declare_logic.py

@@ -9,6 +9,7 @@ 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
+from integration.n8n.n8n_producer import send_n8n_message
 import logging
 
 app_logger = logging.getLogger(__name__)
@@ -32,7 +33,7 @@ def declare_logic():
         discover_logic()
 
     # Logic from GenAI: (or, use your IDE w/ code completion)
-    from database.models import Product, Order, Item, Customer
+    from database.models import Product, Order, Item, Customer, Email
 
     # Ensure the customer's balance is less than their credit limit
     Rule.constraint(validate=Customer, as_condition=lambda row: row.balance <= row.credit_limit, error_msg="Customer balance ({row.balance}) exceeds credit limit ({row.credit_limit})")
@@ -54,6 +55,25 @@ def declare_logic():
 
     # End Logic from GenAI
 
+    def send_mail(row: Email, old_row: Email, logic_row: LogicRow):
+        """ 
+
+        #als: Send N8N email message (also see discovery/integration.py)
+
+        Args:
+            row (Email): inserted Email
+            old_row (Email): n/a
+            logic_row (LogicRow): bundles curr/old row, with ins/upd/dlt logic
+        """
+        if logic_row.is_inserted(): 
+            customer = row.customer  # parent accessor
+            if customer.email_opt_out:
+                logic_row.log("customer opted out of email")
+                return
+            logic_row.log(f"send email {row.message} to {customer.email} (stub, eg use N8N")  # see in log  
+
+    Rule.after_flush_row_event(on_class=Email, calling=send_mail)  # see above
+    
 
     def handle_all(logic_row: LogicRow):  # #als: TIME / DATE STAMPING, OPTIMISTIC LOCKING
         """
@@ -77,7 +97,7 @@ def declare_logic():
         Grant.process_updates(logic_row=logic_row)
 
         did_stamping = False
-        if enable_stamping := False:  # #als:  DATE / USER STAMPING
+        if enable_stamping := True:  # #als:  DATE / USER STAMPING
             row = logic_row.row
             if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedOn"):
                 row.CreatedOn = datetime.datetime.now()

api_logic_server_cli/prototypes/basic_demo/iteration/logic/declare_logic.py

@@ -119,7 +119,7 @@ def declare_logic():
         Grant.process_updates(logic_row=logic_row)
 
         did_stamping = False
-        if enable_stamping := False:  # #als:  DATE / USER STAMPING
+        if enable_stamping := True:  # #als:  DATE / USER STAMPING
             row = logic_row.row
             if logic_row.ins_upd_dlt == "ins" and hasattr(row, "CreatedOn"):
                 row.CreatedOn = datetime.datetime.now()

api_logic_server_cli/prototypes/nw/logic/declare_logic.py

@@ -148,8 +148,8 @@ def declare_logic():
                                     "Order Date": row.OrderDate,
                                     #"items": [row.OrderDetailList]
                                 },
-                ins_upd_dlt="upd", wh_entity="Order",
-                msg="1. /Webhook integration.py: n8n, sending ready Order payload")  
+                                ins_upd_dlt="upd", wh_entity="Order",
+                                msg="1. /Webhook integration.py: n8n, sending ready Order payload")  
             
         logic_row.log("send_order_to_shipping - sent order to shipping and N8N/sendgrid")  # see in log      
 

api_logic_server_cli/prototypes/nw_no_cust/.obsidian/app.json

@@ -0,0 +1 @@
+{}

api_logic_server_cli/prototypes/nw_no_cust/.obsidian/appearance.json

@@ -0,0 +1 @@
+{}

api_logic_server_cli/prototypes/nw_no_cust/.obsidian/core-plugins.json

@@ -0,0 +1,31 @@
+{
+  "file-explorer": true,
+  "global-search": true,
+  "switcher": true,
+  "graph": true,
+  "backlink": true,
+  "canvas": true,
+  "outgoing-link": true,
+  "tag-pane": true,
+  "properties": false,
+  "page-preview": true,
+  "daily-notes": true,
+  "templates": true,
+  "note-composer": true,
+  "command-palette": true,
+  "slash-command": false,
+  "editor-status": true,
+  "bookmarks": true,
+  "markdown-importer": false,
+  "zk-prefixer": false,
+  "random-note": false,
+  "outline": true,
+  "word-count": true,
+  "slides": false,
+  "audio-recorder": false,
+  "workspaces": false,
+  "file-recovery": true,
+  "publish": false,
+  "sync": true,
+  "webviewer": false
+}