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

api_logic_server_cli/add_cust/add_cust.py

@@ -25,28 +25,12 @@ Note: many require: rebuild-from-database --project_name=./ --db_url=sqlite:///d
 '''
 
 def add_genai_customizations(project: Project, do_show_messages: bool = True, do_security: bool = True):
-    """ Add customizations to genai (default creation)
+    """ Add customizations `prototypes/genai_demo` to genai (default creation)
 
     0. Initial: create_project_and_overlay_prototypes() -- minor: just creates the readme
             * When done with genai logic prompt, logic is pre-created (in logic/declare_logic.py)
     1. Deep copy prototypes/genai_demo (adds logic and security, and custom end point)
 
-    WebGenAI DX:
-
-    0. Convention: click the Blue Button
-            * Home/Create Project
-            * Home/Open App
-            * Landing
-            * Overview[Manager]/Open
-            * Overview/GitHub
-            * App Home / Develop --> GitHub
-    0. demo --> codespaces.  Where are instructions (what is CS, how do I load/run)?
-    1. Name can be any, iff created with APILOGICPROJECT_IS_GENAI_DEMO
-    2. Bypass duplicate discovery logic iff created with APILOGICPROJECT_IS_GENAI_DEMO
-    3. TODO:
-            * cd project
-            * als add-cust  # add customizations
-            * run, and use place b2b order service - end point is not activated.
 
     Args:
     """
@@ -251,7 +235,9 @@ def add_cust(project: Project, models_py_path: Path, project_name: str):
     if not models_py_path.exists():
         raise Exception("Customizations are northwind/genai-specific - models.py does not exist")
 
-    project_is_genai_demo = False  # can't use project.is_genai_demo because this is not the create command...
+    project_is_genai_demo = False
+    ''' can't use project.is_genai_demo because this is not the create command...'''
+    
     if project.project_directory_path.joinpath('docs/project_is_genai_demo.txt').exists():
         project_is_genai_demo = True
     
@@ -260,8 +246,8 @@ def add_cust(project: Project, models_py_path: Path, project_name: str):
         add_nw_customizations(project=project, do_security=False)
         log.info("\nNext step - add authentication:\n  $ ApiLogicServer add-auth --db_url=auth\n\n")
 
-    elif project_is_genai_demo and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
-        add_genai_customizations(project=project, do_security=False)
+    # elif project_is_genai_demo and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
+    #    add_genai_customizations(project=project, do_security=False)
 
     elif project_name == 'sample_ai' and create_utils.does_file_contain(search_for="CustomerName = Column(Text", in_file=models_py_path):
         cocktail_napkin_path = project.project_directory_path.joinpath('logic/cocktail-napkin.jpg')
@@ -271,7 +257,7 @@ def add_cust(project: Project, models_py_path: Path, project_name: str):
         else:
             add_sample_ai_iteration(project=project)
 
-    elif project_name == 'basic_demo' and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
+    elif (project_is_genai_demo or project_name == 'basic_demo') and create_utils.does_file_contain(search_for="Customer", in_file=models_py_path):
         cocktail_napkin_path = project.project_directory_path.joinpath('logic/cocktail-napkin.jpg')
         is_customized = cocktail_napkin_path.exists()
         if not is_customized:

api_logic_server_cli/api_logic_server.py

@@ -12,9 +12,10 @@ ApiLogicServer CLI: given a database url, create [and run] customizable ApiLogic
 Called from api_logic_server_cli.py, by instantiating the ProjectRun object.
 '''
 
-__version__ = "14.05.00"  # last public release: 14.04.00
+__version__ = "14.05.03"  # last public release: 14.04.00
 recent_changes = \
     f'\n\nRecent Changes:\n' +\
+    "\t05/19/2024 - 14.05.03: mcp filters with working date range (AND), email stub, use basic_demo custs for genai_demo \n"\
     "\t05/16/2024 - 14.05.00: safrs 3.1.7, running mcp preview \n"\
     "\t04/27/2024 - 14.04.00: Graphics preview, Vibe install fix, Improved IDE Chat Logic, MCP Exploration \n"\
     "\t03/30/2024 - 14.03.25: WebGenAI fixes for Kafka and Keycloak \n"\
@@ -417,7 +418,8 @@ def create_project_and_overlay_prototypes(project: 'ProjectRun', msg: str) -> st
             # readme now opens automatically, so use that...
             shutil.move(project.project_directory_path.joinpath('readme.md'), 
                         project.project_directory_path.joinpath('readme_standard.md'))   
-            create_utils.copy_md(project = project, from_doc_file = "Sample-Genai.md", to_project_file='readme.md')
+            # create_utils.copy_md(project = project, from_doc_file = "Sample-Genai.md", to_project_file='readme.md')
+            create_utils.copy_md(project = project, from_doc_file = "Sample-Basic-Demo.md", to_project_file='readme.md')
 
         if "postgres" or "mysql" in project.db_url:
             fixup_devops_for_postgres_mysql(project)

api_logic_server_cli/api_logic_server_info.yaml

@@ -1,3 +1,3 @@
-last_created_date: May 15, 2025 12:52:13
+last_created_date: May 18, 2025 16:45:45
 last_created_project_name: ../../../servers/basic_demo
-last_created_version: 14.04.08
+last_created_version: 14.05.02

api_logic_server_cli/prototypes/basic_demo/customizations/api/api_discovery/{mcp_server_executor.py → mcp_discovery.py}

@@ -111,6 +111,7 @@ def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_deco
         ```
         {
             "tool_type": "json-api",
+            "schema_version": "1.0",
             "base_url": "https://crm.company.com",
             "resources": [
                 {

api_logic_server_cli/prototypes/basic_demo/customizations/config/server_setup.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+
+###############################################################################
+#
+#    Initalization functions used by api_logic_server_run.py
+#
+#    You typically do not customize this file,
+#        except to override Creation Defaults and Logging, below.
+#
+###############################################################################
+
+"""
+Operation:
+    1. api_logic_server_run.py - imports config
+        1. captures args
+    2. api_logic_server_run.py - imports server_setup
+        1. server_setup#logging_setup()
+    3. api_logic_server_run.py - server_setup.api_logic_server_setup
+On error, NOT CALLED: constraint_handler or ValidationErrorExt (!)
+
++ Operation:
+    1. api_logic_server_run.py - imports config
+        1. captures args
+        1. config#logging_setup()
+    2. api_logic_server_run.py - imports server_setup
+    3. api_logic_server_run.py - server_setup.api_logic_server_setup
+
+"""
+
+start_up_message = "normal start"
+
+import traceback
+try:
+    import os, logging, logging.config, sys, yaml  # failure here means venv probably not set
+except:
+    track = traceback.format_exc()
+    print(" ")
+    print(track)
+    print("venv probably not set")
+    print("Please see https://apilogicserver.github.io/Docs/Project-Env/ \n")
+    exit(1)
+
+from flask_sqlalchemy import SQLAlchemy
+import json
+from pathlib import Path
+if os.getenv("EXPERIMENT") == '+':
+    import config
+from config.config import Args
+
+
+setup_path = Path(os.path.abspath(os.path.dirname(__file__)))
+project_path = setup_path.parent
+
+
+def is_docker() -> bool:
+    """ running docker?  dir exists: /home/api_logic_server """
+    path = '/home/api_logic_server'
+    path_result = os.path.isdir(path)  # this *should* exist only on docker
+    env_result = "DOCKER" == os.getenv('APILOGICSERVER_RUNNING')
+    # assert path_result == env_result
+    return path_result
+
+
+if is_docker():
+    sys.path.append(os.path.abspath('/home/api_logic_server'))
+
+logic_alerts = True
+""" Set False to silence startup message """
+declare_logic_message = ""
+declare_security_message = "ALERT:  *** Security Not Enabled ***"
+
+project_dir = str(project_path)
+os.chdir(project_dir)  # so admin app can find images, code
+import api.system.api_utils as api_utils
+logic_logger_activate_debug = False
+""" True prints all rules on startup """
+
+args = ""
+arg_num = 0
+for each_arg in sys.argv:
+    args += each_arg
+    arg_num += 1
+    if arg_num < len(sys.argv):
+        args += ", "
+project_name = os.path.basename(os.path.normpath(project_path))
+
+from typing import TypedDict
+import safrs  # fails without venv - see https://apilogicserver.github.io/Docs/Project-Env/
+from database.system.SAFRSBaseX import SAFRSBase
+from safrs import ValidationError, SAFRSAPI as _SAFRSAPI
+#from safrs import ValidationError, SAFRSBase, SAFRSAPI as _SAFRSAPI
+from logic_bank.logic_bank import LogicBank
+from logic_bank.exceptions import LBActivateException
+from logic_bank.exec_row_logic.logic_row import LogicRow
+from logic_bank.rule_type.constraint import Constraint
+from .activate_logicbank import activate_logicbank
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session
+import socket
+import warnings
+from flask import Flask, redirect, send_from_directory, send_file
+from flask_cors import CORS
+from safrs import ValidationError, SAFRSAPI
+import ui.admin.admin_loader as AdminLoader
+from security.system.authentication import configure_auth
+import database.bind_dbs as bind_dbs
+import oracledb
+import integration.kafka.kafka_producer as kafka_producer
+import integration.kafka.kafka_consumer as kafka_consumer
+import integration.n8n.n8n_producer as n8n_producer
+
+
+if os.getenv("EXPERIMENT") == '+':
+    app_logger = logging.getLogger("api_logic_server_app")
+
+
+class SAFRSAPI(_SAFRSAPI):
+    """
+    Extends SAFRSAPI to handle client_uri
+
+    Args:
+        _SAFRSAPI (_type_): _description_
+    """
+
+    def __init__(self, *args, **kwargs):
+        client_uri = kwargs.pop('client_uri', None)
+        if client_uri:
+            kwargs['port'] = None
+            kwargs['host'] = client_uri
+        super().__init__(*args, **kwargs)
+
+
+
+# ==================================
+#       Set
+# ================================== 
+
+def get_args(flask_app: Flask) -> Args:
+    """
+    Get Args, update logging
+
+    Returns:
+        Args: typed access to flask_app.config
+    """
+    args = Args(flask_app=flask_app)                                # creation defaults
+
+    import config.config as config
+    flask_app.config.from_object(config.Config)
+    app_logger.debug(f"\nserver_setup - get_args: Config args: \n{args}")  #                 # config file (e.g., db uri's)
+
+    args.get_cli_args(dunder_name=__name__, args=args)
+    app_logger.debug(f"\nserver_setup - get_args: CLI args: \n{args}")                       # api_logic_server_run cl args
+
+    flask_app.config.from_prefixed_env(prefix="APILOGICPROJECT")    # env overrides (e.g., docker)
+    app_logger.debug(f"\nserver_setup - get_args: ENV args: \n{args}\n\n")
+
+    if args.verbose:  # export APILOGICPROJECT_VERBOSE=True
+        app_logger.setLevel(logging.DEBUG)
+        safrs.log.setLevel(logging.DEBUG)  # notset 0, debug 10, info 20, warn 30, error 40, critical 50
+        authentication_logger = logging.getLogger('security.system.authentication')
+        authentication_logger.setLevel(logging.DEBUG)
+        authorization_logger = logging.getLogger('security.system.authorization')
+        authorization_logger.setLevel(logging.DEBUG)
+        auth_provider_logger = logging.getLogger('security.authentication_provider.sql.auth_provider')
+        auth_provider_logger.setLevel(logging.DEBUG)
+        # sqlachemy_logger = logging.getLogger('sqlalchemy.engine')
+        # sqlachemy_logger.setLevel(logging.DEBUG)
+
+    if app_logger.getEffectiveLevel() <= logging.DEBUG:
+        api_utils.sys_info(flask_app.config)
+    app_logger.debug(f"\nserver_setup - get_args: ENV args: \n{args}\n\n")
+    return args
+
+
+# ==================================
+#       LOGGING SETUP
+# ================================== 
+
+def logging_setup() -> logging.Logger:
+    """
+    Setup Logging
+    """
+    global app_logger, debug_value, project_path
+    logging_config = f'{project_path}/config/logging.yml'
+    if os.getenv('APILOGICPROJECT_LOGGING_CONFIG'):
+        logging_config = project_path.joinpath(os.getenv("APILOGICPROJECT_LOGGING_CONFIG"))
+    with open(logging_config,'rt') as f:  # see also logic/declare_logic.py
+            config=yaml.safe_load(f.read())
+            f.close()
+    logging.config.dictConfig(config)  # log levels: notset 0, debug 10, info 20, warn 30, error 40, critical 50
+    app_logger = logging.getLogger("api_logic_server_app")
+    debug_value = os.getenv('APILOGICPROJECT_DEBUG')
+    if debug_value is not None:  # > export APILOGICPROJECT_DEBUG=True
+        debug_value = debug_value.upper()
+        if debug_value.startswith("F") or debug_value.startswith("N"):
+            app_logger.setLevel(logging.INFO)
+        else:
+            app_logger.setLevel(logging.DEBUG)
+            app_logger.debug(f'\nDEBUG level set from env\n')
+    app_logger.info(f'\nAPI Logic Project Server Setup ({project_name}) Starting with CLI args: \n.. {args}\n')
+    app_logger.info(f'Created August 03, 2024 09:34:01 at {str(project_path)}\n') 
+    return app_logger  
+
+
+class ValidationErrorExt(ValidationError):
+    """
+    This exception is raised when invalid input has been detected (client side input)
+    Always send back the message to the client in the response
+    """
+
+    def __init__(self, message="", status_code=400, api_code=2001, detail=None, error_attributes=None):
+        Exception.__init__(self)
+        self.error_attributes = error_attributes
+        self.status_code = status_code
+        self.message = message
+        self.api_code = api_code
+        self.detail: TypedDict = detail
+
+
+def validate_db_uri(flask_app):
+    """
+
+    For sqlite, verify the SQLALCHEMY_DATABASE_URI file exists
+
+        * Since the name is not reported by SQLAlchemy
+
+    Args:
+        flask_app (_type_): initialize flask app
+    """
+
+    db_uri = flask_app.config['SQLALCHEMY_DATABASE_URI']
+    app_logger.debug(f'sqlite_db_path validity check with db_uri: {db_uri}')
+    if 'sqlite' not in db_uri:
+        return
+    sqlite_db_path = ""
+    if db_uri.startswith('sqlite:////'):  # eg, sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/servers/ai_customer_orders/database/db.sqlite
+        sqlite_db_path = Path(db_uri[9:])
+        app_logger.debug(f'\t.. Absolute: {str(sqlite_db_path)}')
+    else:                                # eg, sqlite:///../database/db.sqlite
+        db_relative_path = db_uri[10:]
+        db_relative_path = db_relative_path.replace('../', '') # relative
+        sqlite_db_path = Path(os.getcwd()).joinpath(db_relative_path)
+        app_logger.debug(f'\t.. Relative: {str(sqlite_db_path)}')
+        if db_uri == 'sqlite:///database/db.sqlite':
+            raise ValueError(f'This fails, please use; sqlite:///../database/db.sqlite')
+    if sqlite_db_path.is_file():
+        app_logger.debug(f'\t.. sqlite_db_path is a valid file\n')
+    else:  # remove this if you wish
+        raise ValueError(f'sqlite database does not exist: {str(sqlite_db_path)}')
+
+
+
+# ==========================================================
+# API Logic Server Setup
+#   - Opens Database(s)
+#   - Setup API, Logic, Security, Optimistic Locking 
+# ==========================================================
+
+def api_logic_server_setup(flask_app: Flask, args: Args):
+    """
+    API Logic Server Setup
+
+    1. Opens Database(s)
+    2. Setup API, Logic, Security, Optimistic Locking
+
+
+    Args:
+        flask_app (_type_): configured flask_app (servers, ports, db uri's)
+        args (_type_): typed access to flask_app.config
+
+    Raises:
+        ValidationErrorExt: rebadge LogicBank errors for SAFRS API
+    """
+
+    from sqlalchemy import exc as sa_exc
+
+    global logic_logger_activate_debug, declare_logic_message, declare_security_message
+
+    with warnings.catch_warnings():
+
+        safrs_log_level = safrs.log.getEffectiveLevel()
+        db_logger = logging.getLogger('sqlalchemy')
+        db_log_level = db_logger.getEffectiveLevel()
+        safrs_init_logger = logging.getLogger("safrs.safrs_init")
+        authorization_logger = logging.getLogger('security.system.authorization')
+        authorization_log_level = authorization_logger.getEffectiveLevel()
+        do_hide_chatty_logging = True and not args.verbose
+        # eg, system startup health check: read on API and relationship - hide many log entries
+        if do_hide_chatty_logging and app_logger.getEffectiveLevel() <= logging.INFO:
+            safrs.log.setLevel(logging.WARN)  # notset 0, debug 10, info 20, warn 30, error 40, critical 50
+            db_logger.setLevel(logging.WARN)
+            safrs_init_logger.setLevel(logging.WARN)
+            authorization_logger.setLevel(logging.WARN)
+
+        bind_dbs.bind_dbs(flask_app)
+
+        # https://stackoverflow.com/questions/34674029/sqlalchemy-query-raises-unnecessary-warning-about-sqlite-and-decimal-how-to-spe
+        warnings.simplefilter("ignore", category=sa_exc.SAWarning)  # alert - disable for safety msgs
+
+        def constraint_handler(message: str, constraint: Constraint, logic_row: LogicRow):
+            """ format LogicBank constraint exception for SAFRS """
+            if constraint is not None and hasattr(constraint, 'error_attributes'):
+
+                detail = {"model": logic_row.name, "error_attributes": constraint.error_attributes}
+            else:
+                detail = {"model": logic_row.name}
+            raise ValidationErrorExt(message=message, detail=detail)
+
+        admin_enabled = os.name != "nt"
+        admin_enabled = False
+        """ internal use, for future enhancements """
+        if admin_enabled:
+            flask_app.config.update(SQLALCHEMY_BINDS={'admin': 'sqlite:////tmp/4LSBE.sqlite.4'})
+
+        db = SQLAlchemy()
+        db.init_app(flask_app)
+        flask_app.db = db
+        with flask_app.app_context():
+
+            with open(Path(project_path).joinpath('security/system/custom_swagger.json')) as json_file:
+                custom_swagger = json.load(json_file)
+            safrs_api = SAFRSAPI(flask_app, app_db= db, host=args.swagger_host, port=args.swagger_port, client_uri=args.client_uri,
+                                 prefix = args.api_prefix, custom_swagger=custom_swagger)
+
+            if os.getenv('APILOGICSERVER_ORACLE_THICK'):
+                oracledb.init_oracle_client(lib_dir=os.getenv('APILOGICSERVER_ORACLE_THICK'))
+
+            db = safrs.DB  # valid only after is initialized, above
+            session: Session = db.session
+
+            if admin_enabled:  # unused (internal dev use)
+                db.create_all()
+                db.create_all(bind='admin')
+                session.commit()
+
+            from api import expose_api_models, customize_api
+
+            import database.models
+            app_logger.info("Data Model Loaded, customizing...")
+            from database import customize_models
+
+            activate_logicbank(session, constraint_handler)
+            
+            method_decorators : list = []
+            safrs_init_logger.setLevel(logging.WARN)
+            expose_api_models.expose_models(safrs_api, method_decorators)
+            app_logger.info(f'Declare   API - api/expose_api_models, endpoint for each table on {args.swagger_host}:{args.swagger_port}, customizing...')
+            customize_api.expose_services(flask_app, safrs_api, project_dir, swagger_host=args.swagger_host, PORT=args.port)  # custom services
+
+            if args.security_enabled:
+                configure_auth(flask_app, database, method_decorators)
+
+            if args.security_enabled:
+                from security import declare_security  # activate security
+                app_logger.info("..declare security - security/declare_security.py"
+                    # not accurate: + f' -- {len(database.database_discovery.authentication_models.metadata.tables)}'
+                    + ' authentication tables loaded')
+                declare_security_message = declare_security.declare_security_message
+
+            from api.system.opt_locking import opt_locking
+            from config.config import OptLocking
+            if args.opt_locking == OptLocking.IGNORED.value:
+                app_logger.info("\nOptimistic Locking: ignored")
+            else:
+                opt_locking.opt_locking_setup(session)
+
+            kafka_producer.kafka_producer()
+            kafka_consumer.kafka_consumer(safrs_api = safrs_api)
+
+            n8n_producer.n8n_producer()
+
+            SAFRSBase._s_auto_commit = False
+            session.close()
+        
+        safrs.log.setLevel(safrs_log_level)
+        db_logger.setLevel(db_log_level)
+        authorization_logger.setLevel(authorization_log_level)
+
+        if os.getenv('APILOGICPROJECT_DEBUG'):  # temp debug since logging in config is not happening
+            KAFKA_SERVER = os.getenv('KAFKA_SERVER')
+            is_empty = False
+            if KAFKA_SERVER is not None:
+                is_empty = KAFKA_SERVER == ""
+            is_none = KAFKA_SERVER is None
+            app_logger.debug(f'\nDEBUG KAFKA_SERVER: [{KAFKA_SERVER}] (is_empty: {is_empty}) (is_none: {is_none}) \n')
+            app_logger.debug(f'... Args.instance.kafka_producer: {Args.instance.kafka_producer}\n')
+
+

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

@@ -0,0 +1,136 @@
+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))
+
+        return query.filter(operator.and_(*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`.