ApiLogicServer 15.0.10__py3-none-any.whl → 15.0.12__py3-none-any.whl

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/dev_demo_no_logic_fixed/api/expose_api_models.py

@@ -1,50 +0,0 @@
-import inspect
-import safrs
-import importlib
-import pathlib
-import logging as logging
-import flask_sqlalchemy
-
-# 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)
-    pass  #vh
-    # 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/system/genai/examples/genai_demo/wg_dev_merge/dev_demo_no_logic_fixed/api/json_encoder.py

@@ -1,17 +0,0 @@
-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/system/genai/examples/genai_demo/wg_dev_merge/dev_demo_no_logic_fixed/api/readme_customize_api.md

@@ -1,103 +0,0 @@
-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/system/genai/examples/genai_demo/wg_dev_merge/dev_demo_no_logic_fixed/api/system/api_utils.py

@@ -1,171 +0,0 @@
-"""
-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")