ApiLogicServer 15.0.61__py3-none-any.whl → 15.1.0__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/customize_api.py

@@ -0,0 +1,63 @@
+import logging
+import api.system.api_utils as api_utils
+import safrs
+from flask import request, jsonify
+from safrs import jsonapi_rpc
+from database import models
+
+# called by api_logic_server_run.py, to customize api (new end points, services).
+# separate from expose_api_models.py, to simplify merge if project recreated
+
+app_logger = logging.getLogger(__name__)
+
+# called by api_logic_server_run.py, to customize api (new end points, services).
+# separate from expose_api_models.py, to simplify merge if project recreated
+
+def expose_services(app, api, project_dir, swagger_host: str, PORT: str):
+    """ Customize API - new end points for services 
+    
+        Brief background: see readme_customize_api.md
+
+        Your Code Goes Here
+    
+    """
+    
+    app_logger.debug("api/customize_api.py - expose custom services")
+
+    from api.api_discovery.auto_discovery import discover_services
+    discover_services(app, api, project_dir, swagger_host, PORT)
+
+    @app.route('/hello_world')
+    def hello_world():  # test it with: http://localhost::5656/hello_world?user=ApiLogicServer
+        """
+        This is inserted to illustrate that APIs not limited to database objects, but are extensible.
+
+        See: https://apilogicserver.github.io/Docs/API-Customize/
+
+        See: https://github.com/thomaxxl/safrs/wiki/Customization
+        """
+        user = request.args.get('user')
+        return jsonify({"result": f'hello, {user}'})
+
+
+    @app.route('/stop')
+    def stop():  # test it with: http://localhost:5656/stop?msg=API stop - Stop API Logic Server
+        """
+        Use this to stop the server from the Browser.
+
+        See: https://stackoverflow.com/questions/15562446/how-to-stop-flask-application-without-using-ctrl-c
+
+        See: https://github.com/thomaxxl/safrs/wiki/Customization
+        """
+
+        import os, signal
+
+        if not os.getenv('APILOGICPROJECT_STOP_OK'):
+            return jsonify({ "success": False, "message": "Shutdown not enabled" })
+
+        msg = request.args.get('msg')
+        app_logger.info(f'\nStopped server: {msg}\n')
+
+        os.kill(os.getpid(), signal.SIGINT)
+        return jsonify({ "success": True, "message": "Server is shutting down..." })
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/expose_api_models.py

@@ -0,0 +1,52 @@
+import inspect
+import safrs
+import importlib
+import pathlib
+import logging as logging
+import flask_sqlalchemy
+from config.config import Args
+from config import config
+
+# use absolute path import for easier multi-{app,model,db} support
+database = __import__('database')
+app_logger = logging.getLogger(__name__)
+app_logger.debug("api/expose_api_models.py - endpoint for each table")
+
+def add_check_sum(cls):
+    """
+    Checksum decorator for each model
+    """
+    @safrs.jsonapi_attr
+    def _check_sum_(self):
+        if isinstance(self, flask_sqlalchemy.model.DefaultMeta) or not hasattr(self, "_check_sum_property"):   # property does not exist during initialization
+            return None
+        return self._check_sum_property
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):
+        self._check_sum_property = value
+
+    cls.S_CheckSum = _check_sum_
+    return cls
+
+def expose_models(api, method_decorators = []):
+    """
+        Declare API - on existing SAFRSAPI to expose each model - API model-driven automation
+        - Including get (filtering, pagination, related data access, optimistic locking)
+        - And post/patch/update (including logic enforcement)
+
+        Invoked at server startup (api_logic_server_run -> config/server_setup)
+
+        You typically do not customize this file
+        - See https://apilogicserver.github.io/Docs/Tutorial/#customize-and-debug
+    """
+
+    debug_inspect_list = inspect.getmembers(database.models)
+
+    # Get all the subclasses of the Base class and expose them in the api
+    for name, obj in inspect.getmembers(database.models):
+        if inspect.isclass(obj) and issubclass(obj, database.models.SAFRSBaseX) and obj is not database.models.SAFRSBaseX:
+            app_logger.info(f"Exposing /{name}")
+            api.expose_object(add_check_sum(obj), method_decorators= method_decorators)
+
+    return api

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/json_encoder.py

@@ -0,0 +1,17 @@
+from safrs import SAFRSJSONEncoder
+from sqlalchemy_utils.types.choice import Choice
+
+
+class SAFRSJSONEncoderExt(SAFRSJSONEncoder):
+    """
+        Quick example on adding additional types via CustomEncoder
+
+        see also https://gist.github.com/KodeKracker/b44dea8df6c0c90fdcdb
+        https://github.com/thomaxxl/safrs/blob/master/examples/demo_geoalchemy.py
+    """
+
+    def default(self, obj, **kwargs):
+        if isinstance(obj, Choice):
+            return obj.code
+
+        return super().default(obj, **kwargs)

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/readme_customize_api.md

@@ -0,0 +1,103 @@
+Without customization, your API supports multi-table retrieval.  For more information, [see here](https://apilogicserver.github.io/Docs/API-Multi-Table).
+
+This describes how to *add new endpoints*.  For more information, [see here](https://apilogicserver.github.io/Docs/API-Customize).
+
+ 
+
+## Examples      
+Examples from tutorial project:
+* Examples drawn from [tutorial project](https://github.com/ApiLogicServer/demo/blob/main/api/customize_api.py)
+* Use Shift + "." to view in project mode
+
+ 
+
+### New Endpoint: Standard Flask with Security, not exposed in Swagger
+
+Use standard Flask / SQLAlchemy (background [here](https://docs.sqlalchemy.org/en/20/core/connections.html)):
+
+```python
+    @app.route('/filters_cats')
+    @admin_required()
+    def filters_cats():
+        """
+        Illustrates:
+        * Explore SQLAlchemy and/or filters.
+        
+        Test (returns rows 2-5) (no auth):
+            curl -X GET "http://localhost:5656/filters_cats [no-filter | simple-filter]"
+        """
+
+        from sqlalchemy import and_, or_
+        filter_type = request.args.get('filter')
+        if filter_type is None:
+            filter_type = "multiple filters"
+        db = safrs.DB           # Use the safrs.DB, not db!
+        session = db.session    # sqlalchemy.orm.scoping.scoped_session
+        Security.set_user_sa()  # an endpoint that requires no auth header (see also @admin_required)
+
+        if filter_type.startswith("n"):
+            results = session.query(models.Category)    # .filter(models.Category.Id > 1)
+        elif filter_type.startswith("s"):               # normally coded like this
+            results = session.query(models.Category) \
+                .filter(models.Category.Id > 1) \
+                .filter(or_((models.Category.Client_id == 2), (models.Category.Id == 5)))
+        else:                                           # simulate grant logic (multiple filters)
+            client_grant = models.Category.Client_id == 2
+            id_grant = models.Category.Id == 5
+            grant_filter = or_( client_grant, id_grant)
+            results = session.query(models.Category) \
+                .filter(models.Category.Id > 1)  \
+                .filter(grant_filter)
+        return_result = []
+        for each_result in results:
+            row = { 'id': each_result.Id, 'name': each_result.CategoryName}
+            return_result.append(row)
+        return jsonify({ "success": True, "results":  return_result})
+```
+
+ 
+
+### New Endpoint: Standard Flask, exposed in Swagger
+
+```python
+class CategoriesEndPoint(safrs.JABase):
+    """
+    Illustrates
+    * Swagger-visible RPC that requires authentication (@jwt_required()).
+
+    Test in swagger (auth required)
+    * Post to endpoint auth to obtain <access_token> value - copy it to clipboard
+    * Authorize (top of swagger), using Bearer <access_token>
+    * Post to CategoriesEndPoint/get_cats, observe only row 1 returned
+
+    """
+
+    @staticmethod
+    @jwt_required()
+    @jsonapi_rpc(http_methods=['POST'], valid_jsonapi=False)
+    def get_cats():
+        db = safrs.DB
+        session = db.session
+        # Security.set_user_sa()  # use to bypass authorization (also requires @admin_required)
+
+        result = session.query(models.Category)
+        for each_row in result:
+            app_logger.debug(f'each_row: {each_row}')
+        rows = util.rows_to_dict(result)
+        response = {"result": rows}
+        return response
+```
+
+&nbsp;
+
+## Data Access
+
+The samples also illustrate several forms of data access, summarized in the table below.  Note the use of `util.py`, included with all projects.
+
+| Function | Auth required                         | Illustrates             | Util Usage  |
+|:-------------- |:------------------------------|:-----------------------------------|:--------------------------------------------------------------------------------------|
+| ```get_cats()``` |  Y  | Model query      |Util.rows_to_dict<br>..row.to_dict   |
+| ```filters_cats()``` |  Y  | Model query, filters         | No: No  - Manual {} creation   |
+| ```raw_sql_cats()``` |    | Raw sql        | Util.rows_to_dict<br>..fields iterator   |
+
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/api_utils.py

@@ -0,0 +1,171 @@
+"""
+Utilities for API Logic Server Projects (1.1)
+"""
+import sqlite3
+from os import path
+import logging
+import sys
+from typing import Any, Optional, Tuple
+from logic_bank.rule_bank.rule_bank import RuleBank
+
+app_logger = logging.getLogger(__name__)
+
+def log(msg: object) -> None:
+    app_logger.debug(msg)
+    # print("TIL==> " + msg)
+
+
+def connection() -> sqlite3.Connection:
+    ROOT: str = path.dirname(path.realpath(__file__))
+    log(ROOT)
+    _connection = sqlite3.connect(path.join(ROOT, "sqlitedata.db"))
+    return _connection
+
+
+def dbpath(dbname: str) -> str:
+    ROOT: str = path.dirname(path.realpath(__file__))
+    log('ROOT: '+ROOT)
+    PATH: str = path.join(ROOT, dbname)
+    log('DBPATH: '+PATH)
+    return PATH
+
+rule_count = 0
+from flask import request, jsonify
+
+def rules_report():
+    """
+    logs report of all rules, using rules_bank.__str__()
+    """
+    global rule_count
+    rules_bank = RuleBank()
+    logic_logger = logging.getLogger("logic_logger")
+    rule_count = 0
+    logic_logger.debug(f'\nThe following rules have been activated\n')
+    list_rules = rules_bank.__str__()
+    loaded_rules = list(list_rules.split("\n"))
+    for each_rule in loaded_rules:
+        logic_logger.info(each_rule + '\t\t##  ')
+        rule_count += 1
+    logic_logger.info(f'Logic Bank - {rule_count} rules loaded')
+
+
+def server_log(request, jsonify):
+    """
+    Used by test/*.py - enables client apps (the behave tests) to...
+    *  log msg into server, and 
+    * test/api_logic_server_behave/logs
+    """
+    import os
+    import datetime
+    from pathlib import Path
+    import logging
+    global rule_count
+
+
+    def add_file_handler(logger, name: str, log_dir):
+        """Add a file handler for this logger with the specified `name` (and
+        store the log file under `log_dir`)."""
+        # Format for file log
+        for each_handler in logger.handlers:
+            each_handler.flush()
+            handler_name = str(each_handler)
+            if "stderr" in handler_name:
+                pass
+                # print(f'do not delete stderr')
+            else:
+                logger.removeHandler(each_handler)
+        fmt = '%(asctime)s | %(levelname)8s | %(filename)s:%(lineno)d | %(message)s'
+        formatter = logging.Formatter(fmt)
+        formatter = logging.Formatter('%(message)s - %(asctime)s - %(name)s - %(levelname)s')
+
+        # Determine log path/file name; create log_dir if necessary
+        now = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        log_name = f'{str(name).replace(" ", "_")}'  # {now}'
+        if len(log_name) >= 26:
+            log_name = log_name[0:25]
+
+        if not os.path.exists(log_dir):
+            try:
+                os.makedirs(log_dir)
+            except:
+                app_logger.info(f'util.add_file_handler unable to create dir {log_dir}')
+                log_dir = '/tmp' if sys.platform.startswith('linux') else '.'
+                app_logger.info(f'Defaulting to {log_dir}.')
+
+        log_file = os.path.join(log_dir, log_name) + '.log'
+        if os.path.exists(log_file):
+            os.remove(log_file)
+        else:
+            pass  # file does not exist
+
+        # Create file handler for logging to a file (log all five levels)
+        # print(f'create file handler for logging: {log_file}')
+        logger.file_handler = logging.FileHandler(log_file)
+        logger.file_handler.setLevel(logging.DEBUG)
+        logger.file_handler.setFormatter(formatter)
+        logger.addHandler(logger.file_handler)
+
+    msg = request.args.get('msg')
+    test = request.args.get('test')
+    if "Server Log: Behave Run Successfully Completed" in msg:
+        debug_stop = 'good breakpoint'
+    if test is not None and test != "None":
+        if test == "None":
+            print(f'None for msg: {msg}')
+        logic_logger = logging.getLogger('logic_logger')  # for debugging user logic
+        # logic_logger.info("\n\nLOGIC LOGGER HERE\n")
+        use_relative = True
+        if use_relative:
+            api_utils_path = Path(__file__)
+            proj_path = api_utils_path.parent.parent.parent
+            log_path = proj_path.joinpath('test/api_logic_server_behave/logs/scenario_logic_logs')
+            print(f'Log Dir: {log_path}')
+            add_file_handler(logic_logger, test, log_path)
+        else:
+            dir = request.args.get('dir')
+            add_file_handler(logic_logger, test, Path(os.getcwd()).joinpath(dir))
+    if msg == "Rules Report":
+        rules_report()
+        logic_logger.info(f'Logic Bank - {rule_count} rules loaded')
+    else:
+        app_logger.info(f'{msg}')
+        if "Server Log: Behave Run Successfully Completed" in msg:
+            logic_logger.info(f'\n\n*** {msg}\n\n***\n\n')
+    return jsonify({"result": f'ok'})
+
+
+def sys_info(flask_app_config):  
+    """
+    Print env and path
+    """  
+    import os, socket
+    print("\n\nsys_info here")
+    print("\nEnvironment Variables...")
+    env = os.environ
+    for each_variable in os.environ:
+            print(f'.. {each_variable} = {env[each_variable]}')
+
+    print(f'\n\nflask_app.config: \n\t')
+    flask_app_config_str = str(flask_app_config)
+    flask_app_config_str = flask_app_config_str.replace(', ', ',\n\t')
+    print((flask_app_config_str))
+
+    print("\n\nPYTHONPATH..")
+    for p in sys.path:
+        print(".." + p)
+        
+    print("")
+    print(f'sys.prefix (venv): {sys.prefix}\n')
+
+    print("")
+    hostname = socket.gethostname()
+    IPAddr = 'unknown'
+    try:
+        local_ip = socket.gethostbyname(hostname)
+        IPAddr=socket.gethostbyname(hostname) 
+    except:
+        local_ip = f"Warning - Failed local_ip = socket.gethostbyname(hostname) with hostname: {hostname}"
+
+    print(f"hostname={hostname} on local_ip={local_ip}, IPAddr={IPAddr}\n\n")
+
+    print(f"os.getcwd()={os.getcwd()}\n\n")