flask-app-class 0.1.0__py3-none-any.whl

flask_app_class/__init__.py

@@ -0,0 +1 @@
+from flask_app_class.flask_app import FlaskApp, render_template

flask_app_class/__main__.py

@@ -0,0 +1,12 @@
+import sys
+import argparse
+from logging_handler import DEBUG, INFO, WARNING, ERROR, CRITICAL
+from flask_app_class import FlaskApp
+
+parser = argparse.ArgumentParser(description="Flask Class Based application framework.")
+parser.add_argument("--config", type=str, default=None, help='Enter a JSON configuration file to load.')
+parser.add_argument("--log_level", type=str, default='DEBUG', help='Enter a logging level ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")')
+args = parser.parse_args()
+
+app = FlaskApp(config_file=args.config, web_log_level=args.log_level, app_log_level=args.log_level)
+app.start()

flask_app_class/_radius.py

@@ -0,0 +1,655 @@
+#!/usr/bin/env python
+'''
+Basic RADIUS authentication. Minimum necessary to be able to authenticate a
+user with or without challenge/response, yet remain RFC2865 compliant (I hope).
+
+Homepage at http://github.com/btimby/py-radius/
+'''
+
+# Copyright (c) 1999, Stuart Bishop <zen@shangri-la.dropbear.id.au>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#
+#     Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the
+#     distribution.
+#
+#     The name of Stuart Bishop may not be used to endorse or promote
+#     products derived from this software without specific prior written
+#     permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import os
+import socket
+import logging
+import struct
+
+from select import select
+from random import randint
+from contextlib import closing, contextmanager
+
+try:
+    from collections import UserDict
+except ImportError:
+    from UserDict import UserDict
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import new as md5
+
+from six import PY3
+
+
+__version__ = '2.0.2'
+
+LOGGER = logging.getLogger(__name__)
+LOGGER.addHandler(logging.NullHandler())
+
+# Networking constants.
+# -------------------------------
+PACKET_MAX = 4096
+DEFAULT_PORT = 1812
+DEFAULT_RETRIES = 3
+DEFAULT_TIMEOUT = 5 
+# -------------------------------
+
+# Protocol specific constants.
+# -------------------------------
+# Codes indicating packet type.
+CODE_ACCESS_REQUEST = 1
+CODE_ACCESS_ACCEPT = 2
+CODE_ACCESS_REJECT = 3
+CODE_ACCOUNTING_REQUEST = 4
+CODE_ACCOUNTING_RESPONSE = 5
+CODE_ACCESS_CHALLENGE = 11
+CODE_STATUS_SERVER = 12
+CODE_STATUS_CLIENT = 13
+# CODE_RESERVED = 255
+
+# Map from name to id.
+CODES = {
+    CODE_ACCESS_REQUEST: 'Access-Request',
+    CODE_ACCESS_ACCEPT: 'Access-Accept',
+    CODE_ACCESS_REJECT: 'Access-Reject',
+    CODE_ACCOUNTING_REQUEST: 'Accounting-Request',
+    CODE_ACCOUNTING_RESPONSE: 'Accounting-Response',
+    CODE_ACCESS_CHALLENGE: 'Access-Challenge',
+    CODE_STATUS_SERVER: 'Status-Server',
+    CODE_STATUS_CLIENT: 'Status-Client',
+}
+
+CODE_NAMES = {v.lower(): k for k, v in CODES.items()}
+
+# Attributes that can be part of the RADIUS payload.
+ATTR_USER_NAME = 1
+ATTR_USER_PASSWORD = 2
+ATTR_CHAP_PASSWORD = 4
+ATTR_NAS_IP_ADDRESS = 4
+ATTR_NAS_PORT = 5
+ATTR_SERVICE_TYPE = 6
+ATTR_FRAMED_PROTOCOL = 7
+ATTR_FRAMED_IP_ADDRESS = 8
+ATTR_FRAMED_IP_NETMASK = 9
+ATTR_FRAMED_ROUTING = 10
+ATTR_FILTER_ID = 11
+ATTR_FRAMED_MTU = 12
+ATTR_FRAMED_COMPRESSION = 13
+ATTR_LOGIN_IP_HOST = 14
+ATTR_LOGIN_SERVICE = 15
+ATTR_LOGIN_TCP_PORT = 16
+# ATTR_UNASSIGNED = 17
+ATTR_REPLY_MESSAGE = 18
+ATTR_CALLBACK_NUMBER = 19
+ATTR_CALLBACK_ID = 20
+# ATTR_UNASSIGNED = 21
+ATTR_FRAMED_ROUTE = 22
+ATTR_FRAMED_IPX_NETWORK = 23
+ATTR_STATE = 24
+ATTR_CLASS = 25
+ATTR_VENDOR_SPECIFIC = 26
+ATTR_SESSION_TIMEOUT = 27
+ATTR_IDLE_TIMEOUT = 28
+ATTR_TERMINATION_ACTION = 29
+ATTR_CALLED_STATION_ID = 30
+ATTR_CALLING_STATION_ID = 31
+ATTR_NAS_IDENTIFIER = 32
+ATTR_PROXY_STATE = 33
+ATTR_LOGIN_LAT_SERVICE = 34
+ATTR_LOGIN_LAT_NODE = 35
+ATTR_LOGIN_LAT_GROUP = 36
+ATTR_FRAMED_APPLETALK_LINK = 37
+ATTR_FRAMED_APPLETALK_NETWORK = 38
+ATTR_FRAMED_APPLETALK_ZONE = 39
+# ATTR_RESERVED = 40-59
+ATTR_CHAP_CHALLENGE = 60
+ATTR_NAS_PORT_TYPE = 61
+ATTR_PORT_LIMIT = 62
+ATTR_LOGIN_LAT_PORT = 63
+
+# ADDED - tdunteman
+ATTR_TUNNEL_TYPE = 64
+ATTR_TUNNEL_MEDIUM_TYPE = 65
+ATTR_TUNNEL_PRIVATE_GROUP_ID = 81
+# END ADDED
+
+ATTRS = {
+    ATTR_USER_NAME: 'User-Name',
+    ATTR_USER_PASSWORD: 'User-Password',
+    ATTR_CHAP_PASSWORD: 'CHAP-Password',
+    ATTR_NAS_IP_ADDRESS: 'NAS-IP-Address',
+    ATTR_NAS_PORT: 'NAS-Port',
+    ATTR_SERVICE_TYPE: 'Service-Type',
+    ATTR_FRAMED_PROTOCOL: 'Framed-Protocol',
+    ATTR_FRAMED_IP_ADDRESS: 'Framed-IP-Address',
+    ATTR_FRAMED_IP_NETMASK: 'Framed-IP-NetMask',
+    ATTR_FRAMED_ROUTING: 'Framed-Routing',
+    ATTR_FILTER_ID: 'Filter-Id',
+    ATTR_FRAMED_MTU: 'Framed-MTU',
+    ATTR_FRAMED_COMPRESSION: 'Framed-Compression',
+    ATTR_LOGIN_IP_HOST: 'Login-IP-Host',
+    ATTR_LOGIN_SERVICE: 'Login-Service',
+    ATTR_LOGIN_TCP_PORT: 'Login-TCP-Port',
+    ATTR_REPLY_MESSAGE: 'Reply-Message',
+    ATTR_CALLBACK_NUMBER: 'Callback-Number',
+    ATTR_CALLBACK_ID: 'Callback-Id',
+    ATTR_FRAMED_ROUTE: 'Framed-Route',
+    ATTR_FRAMED_IPX_NETWORK: 'Framed-IPX-Network',
+    ATTR_STATE: 'State',
+    ATTR_CLASS: 'Class',
+    ATTR_VENDOR_SPECIFIC: 'Vendor-Specific',
+    ATTR_SESSION_TIMEOUT: 'Session-Timeout',
+    ATTR_IDLE_TIMEOUT: 'Idle-Timeout',
+    ATTR_TERMINATION_ACTION: 'Termination-Action',
+    ATTR_CALLED_STATION_ID: 'Called-Station-Id',
+    ATTR_CALLING_STATION_ID: 'Calling-Station-Id',
+    ATTR_NAS_IDENTIFIER: 'NAS-Identifier',
+    ATTR_PROXY_STATE: 'Proxy-State',
+    ATTR_LOGIN_LAT_SERVICE: 'Login-LAT-Service',
+    ATTR_LOGIN_LAT_NODE: 'Login-LAT-Node',
+    ATTR_LOGIN_LAT_GROUP: 'Login-LAT-Group',
+    ATTR_FRAMED_APPLETALK_LINK: 'Framed-AppleTalk-Link',
+    ATTR_FRAMED_APPLETALK_NETWORK: 'Framed-AppleTalk-Network',
+    ATTR_FRAMED_APPLETALK_ZONE: 'Framed-AppleTalk-Zone',
+    ATTR_CHAP_CHALLENGE: 'CHAP-Challenge',
+    ATTR_NAS_PORT_TYPE: 'NAS-Port-Type',
+    ATTR_PORT_LIMIT: 'Port-Limit',
+    ATTR_LOGIN_LAT_PORT: 'Login-LAT-Port',
+
+    # ADDED - tdunteman
+    ATTR_TUNNEL_TYPE: 'Tunnel-Type',
+    ATTR_TUNNEL_MEDIUM_TYPE: 'Tunnel-Medium-Type',
+    ATTR_TUNNEL_PRIVATE_GROUP_ID: 'Tunnel-Private-Group-ID'
+    # END ADDED
+}
+
+# Map from name to id.
+ATTR_NAMES = {v.lower(): k for k, v in ATTRS.items()}
+# -------------------------------
+
+
+class Error(Exception):
+    """
+    Base Error class.
+    """
+
+    pass
+
+
+class NoResponse(Error):
+    """
+    Indicates no valid response received.
+    """
+
+    pass
+
+
+class ChallengeResponse(Error):
+    """
+    Raised when radius replies with a challenge.
+
+    Provides the message(s) if any, as well as the state (if provided).
+
+    There can be 0+ messages. State is either defined or not.
+    """
+    def __init__(self, msg=None, state=None):
+        if msg is None:
+            self.messages = []
+        elif isinstance(msg, list):
+            self.messages = msg
+        else:
+            self.messages = [msg]
+        self.state = state
+
+
+class SocketError(NoResponse):
+    """
+    Indicates general network error.
+    """
+
+    pass
+
+
+if PY3:
+    # These functions are used to act upon strings in Python2, but bytes in
+    # Python3. Their functions are not necessary in PY3, so we NOOP them.
+    def ord(s):
+        return s
+
+    def chr(s):
+        return bytes([s])
+
+
+def bytes_safe(s, e='utf-8'):
+    try:
+        return s.encode(e)
+    except (AttributeError, UnicodeDecodeError):
+        return s
+
+
+def join(items):
+    """
+    Shortcut to join collection of strings.
+    """
+    return b''.join(items)
+
+
+def authenticate(secret, username, password, host=None, port=None, **kwargs):
+    """
+    Authenticate the user against a radius server.
+
+    Return True if the user successfully logged in and False if not.
+
+    If the server replies with a challenge, a `ChallengeResponse` exception is
+    raised with the challenge.
+
+    Can raise either NoResponse or SocketError
+    """
+    # Pass host/port to the Radius instance. But ONLY if they are defined,
+    # otherwise we allow Radius to use the defaults for the kwargs.
+    rkwargs = {}
+    if host:
+        rkwargs['host'] = host
+    if port:
+        rkwargs['port'] = port
+    # Additional kwargs (like attributes) are sent to Radius.authenticate().
+    return Radius(secret, **rkwargs).authenticate(username, password, **kwargs)
+
+
+def radcrypt(secret, authenticator, password):
+    """Encrypt a password with the secret and authenticator."""
+    # First, pad the password to multiple of 16 octets.
+    password += b'\0' * (16 - (len(password) % 16))
+
+    if len(password) > 128:
+        raise ValueError('Password exceeds maximun of 128 bytes')
+
+    result, last = b'', authenticator
+    while password:
+        # md5sum the shared secret with the authenticator,
+        # after the first iteration, the authenticator is the previous
+        # result of our encryption.
+        hash = md5(secret + last).digest()
+        for i in range(16):
+            result += chr(ord(hash[i]) ^ ord(password[i]))
+        # The next iteration will act upon the next 16 octets of the password
+        # and the result of our xor operation above. We will set last to
+        # the last 16 octets of our result (the xor we just completed). And
+        # remove the first 16 octets from the password.
+        last, password = result[-16:], password[16:]
+
+    return result
+
+
+class Attributes(UserDict):
+    """
+    Dictionary-style interface.
+
+    Can retrieve or set values by name or by code. Internally stores items by
+    their assigned code. A given attribute can be present more than once.
+    """
+    def __init__(self, initialdata={}):
+        UserDict.__init__(self, {})
+        # Set keys via update() to invoke validation.
+        self.update(initialdata)
+
+    def __getkeys(self, value):
+        """Return tuple of code, name for given code or name."""
+        if isinstance(value, int):
+            return value, ATTRS[value]
+        else:
+            id = ATTR_NAMES[value.lower()]
+            return id, ATTRS[id]
+
+    def __contains__(self, key):
+        """
+        Override in operator.
+        """
+        code = self.__getkeys(key)[0]
+        return UserDict.__contains__(self, code)
+
+    def __getitem__(self, key):
+        """
+        Retrieve an item from attributes (by name or id).
+        """
+        for k in self.__getkeys(key):
+            try:
+                return UserDict.__getitem__(self, k)
+            except KeyError:
+                continue
+        raise KeyError(key)
+
+    def __setitem__(self, key, value):
+        """
+        Add an item to attributes (by name or id)
+        """
+        try:
+            code, name = self.__getkeys(key)
+        except KeyError:
+            raise ValueError('Invalid radius attribute: %s' % key)
+        values = self.get(code, [])
+        values.append(value)
+        UserDict.__setitem__(self, code, values)
+
+    def update(self, data):
+        """
+        Sets keys via __setitem__() to invoke validation.
+        """
+        for k, v in data.items():
+            self[k] = v
+
+    def nameditems(self):
+        """
+        Yields name value pairs as names (instead of ids).
+        """
+        for k, v in self.items():
+            yield self.__getkeys(k)[1], v
+
+    def pack(self):
+        """
+        Packs Attributes instance into data buffer.
+        """
+        data = []
+        for key, values in self.items():
+            for value in values:
+                data.append(struct.pack('BB%ds' % len(value), key,
+                                        len(value) + 2, bytes_safe(value)))
+        return join(data)
+
+    @staticmethod
+    def unpack(data):
+        """
+        Unpacks data into Attributes instance.
+        """
+        pos, attrs = 0, {}
+        while pos < len(data):
+            code, l = struct.unpack('BB', data[pos:pos + 2])
+            attrs[code] = data[pos + 2:pos + l]
+            pos += l
+        return Attributes(attrs)
+
+
+class Message(object):
+    """
+    Represents a radius protocol packet.
+
+    This class can be used for requests and replies. The RFC dictates the
+    format.
+
+     0                   1                   2                   3
+     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |     Code      |  Identifier   |            Length             |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |                                                               |
+    |                     Response Authenticator                    |
+    |                                                               |
+    |                                                               |
+    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    |  Attributes ...
+    +-+-+-+-+-+-+-+-+-+-+-+-+-
+
+    Code - one octet, see CODES enum.
+    Identifier - one octet, unique value that represents request/response pair.
+                 Provided by client and echoed by server.
+    Length - two octets, the length of the packet up to the max of 4096.
+    """
+
+    def __init__(self, secret, code, id=None, authenticator=None,
+                 attributes=None):
+        self.code = code
+        self.secret = secret
+        self.id = id if id else randint(0, 255)
+        self.authenticator = authenticator if authenticator else os.urandom(16)
+        if isinstance(attributes, dict):
+            attributes = Attributes(attributes)
+        self.attributes = attributes if attributes else Attributes()
+
+    def pack(self):
+        """Pack the packet into binary form for transport."""
+        # First pack the attributes, since we need to know their length.
+        attrs = self.attributes.pack()
+        data = []
+        # Now pack the code, id, total length, authenticator
+        data.append(struct.pack('!BBH16s', self.code, self.id,
+                    len(attrs) + 20, self.authenticator))
+        # Attributes take up the remainder of the message.
+        data.append(attrs)
+        return join(data)
+
+    @staticmethod
+    def unpack(secret, data):
+        """Unpack the data into it's fields."""
+        code, id, l, authenticator = struct.unpack('!BBH16s', data[:20])
+        if l != len(data):
+            LOGGER.warning('Too much data!')
+        attrs = Attributes.unpack(data[20:l])
+        return Message(secret, code, id, authenticator, attrs)
+
+    def verify(self, data):
+        """
+        Verify and unpack a response.
+
+        Ensures that a message is a valid response to this message, then
+        unpacks it.
+        """
+        id = ord(data[1])
+        assert self.id == id, 'ID mismatch (%s != %s)' % (self.id, id)
+        signature = md5(
+            data[:4] + self.authenticator + data[20:] + self.secret).digest()
+        assert signature == data[4:20], 'Invalid authenticator'
+        return Message.unpack(self.secret, data)
+
+
+class Radius(object):
+    """
+    Radius client implementation.
+    """
+
+    def __init__(self, secret, host='radius', port=DEFAULT_PORT,
+                 retries=DEFAULT_RETRIES, timeout=DEFAULT_TIMEOUT):
+        self._secret = bytes_safe(secret)
+        self.retries = retries
+        self.timeout = timeout
+        self._host = host
+        self._port = port
+
+    @property
+    def host(self):
+        return self._host
+
+    @property
+    def port(self):
+        return self._port
+
+    @property
+    def secret(self):
+        return self._secret
+
+    @contextmanager
+    def connect(self):
+        with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as c:
+            c.connect((self.host, self.port))
+            LOGGER.debug('Connected to %s:%s', self.host, self.port)
+            yield c
+
+    def send_message(self, message):
+        send = message.pack()
+
+        try:
+            with self.connect() as c:
+                for i in range(self.retries):
+                    LOGGER.debug(
+                        'Sending (as hex): %s',
+                        ':'.join(format(ord(c), '02x') for c in send))
+
+                    c.send(send)
+
+                    r, w, x = select([c], [], [], self.timeout)
+                    if c in r:
+                        recv = c.recv(PACKET_MAX)
+                    else:
+                        # No data available on our socket. Try again.
+                        LOGGER.warning('Timeout expired on try %s', i)
+                        continue
+
+                    LOGGER.debug(
+                        'Received (as hex): %s',
+                        ':'.join(format(ord(c), '02x') for c in recv))
+
+                    try:
+                        return message.verify(recv)
+                    except AssertionError as e:
+                        LOGGER.warning('Invalid response discarded %s', e)
+                        # Silently discard invalid replies (as RFC states).
+                        continue
+
+        except socket.error as e:  # SocketError
+            LOGGER.debug('Socket error', exc_info=True)
+            raise SocketError(e)
+
+        LOGGER.error('Request timed out after %s tries', i)
+        raise NoResponse()
+
+    def access_request_message(self, username, password, **kwargs):
+        username = bytes_safe(username)
+        password = bytes_safe(password)
+
+        message = Message(self.secret, CODE_ACCESS_REQUEST, **kwargs)
+        message.attributes['User-Name'] = username
+        message.attributes['User-Password'] = \
+            radcrypt(self.secret, message.authenticator, password)
+
+        return message
+
+    def authenticate(self, username, password, **kwargs):
+        """
+        Attempt to authenticate with the given username and password.
+
+           Returns False on failure
+           Returns True on success
+           Raises a NoResponse (or its subclass SocketError) exception if no
+               responses or no valid responses are received
+        """
+        reply = self.send_message(
+            self.access_request_message(username, password, **kwargs))
+
+        if reply.code == CODE_ACCESS_ACCEPT:
+            LOGGER.info('Access accepted')
+            return True
+
+        elif reply.code == CODE_ACCESS_CHALLENGE:
+            LOGGER.info('Access challenged')
+            messages = reply.attributes.get('Reply-Message', None)
+            state = reply.attributes.get('State', [None])[0]
+            raise ChallengeResponse(messages, state)
+
+        LOGGER.info('Access rejected')
+        return False
+
+
+# Don't break code written for radius.py distributed with the ZRadius
+# Zope product
+RADIUS = Radius
+
+
+def main():
+    host = raw_input("Host [default: 'radius']: ")
+    port = raw_input('Port [default: %s]: ' % DEFAULT_PORT)
+
+    host = host if host else 'radius'
+    port = int(port) if port else DEFAULT_PORT
+
+    secret = username = password = None
+
+    while not secret:
+        secret = raw_input('Enter RADIUS Secret: ')
+
+    while not username:
+        username = raw_input('Enter your username: ')
+
+    while not password:
+        password = raw_input('Enter your password: ')
+
+    def _status(outcome):
+        if outcome:
+            print('Authentication Succeeded')
+            sys.exit(0)
+        else:
+            sys.exit('Authentication Failed')
+
+    try:
+        _status(authenticate(secret, username, password, host=host, port=port))
+    except ChallengeResponse as e:
+        pass
+    except Exception as e:
+        traceback.print_exc()
+        sys.exit('Authentication Error')
+
+    print('RADIUS server replied with a challenge.')
+
+    for m in e.messages:
+        print(' - %s' % m)
+
+    response = None
+    while not response:
+        response = raw_input('Enter your challenge response: ')
+
+    a = Attributes()
+    if e.state:
+        a['State'] = e.state
+
+    try:
+        _status(authenticate(secret, username, response, host=host, port=port,
+                attributes=a))
+    except Exception as e:
+        traceback.print_exc()
+        sys.exit('Authentication Error')
+
+
+if __name__ == '__main__':
+    import sys
+    import traceback
+
+    LOGGER.addHandler(logging.StreamHandler())
+    LOGGER.setLevel(logging.DEBUG)
+
+    main()

flask_app_class/flask_app.py

@@ -0,0 +1,422 @@
+from flask import Flask, render_template, send_from_directory, g, session, send_file, abort
+from flask import Flask, flash, redirect, render_template, request, session, abort, url_for, jsonify
+from flask_login import LoginManager, login_user, current_user, logout_user, login_required
+from urllib.parse import urlparse, urljoin
+import os
+import json
+import inspect
+import logging
+from datetime import datetime, timedelta
+from threading import Lock, Thread
+from time import sleep
+import uuid
+import re, glob
+from typing import Callable
+from flask_socketio import SocketIO, emit, disconnect
+from werkzeug.middleware.proxy_fix import ProxyFix
+from logging_handler import create_logger, DEBUG, INFO, WARNING, ERROR, CRITICAL, _log_level_number
+
+'''
+==================================
+Global Variables available in to all modules
+==================================
+'''
+FLASK_SECRET_LENGTH = 128
+FLASK_DEFAULT_STATIC_DIR = 'static'
+BASE_TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), 'base_templates')
+
+SOCKETIO_DEFAULT_HANDLERS = {
+    "connect": "_socket_io_connect"
+}
+
+def load_config_json(config_file:str):
+    ''' Load a json config file '''
+    global config_data
+    with open(config_file, 'r', encoding='utf-8') as input_file:
+        config_data = json.loads(input_file.read())
+    return config_data
+
+
+class FlaskLogFilter(logging.Filter):
+    ''' Class to handle filtering of web log mess '''
+    log_filter_list = []
+    
+    def filter(self, record):
+        ''' Filter out selected log messages - returns FALSE if message should be filtered '''
+        for filter in self.log_filter_list:
+            if filter in record.getMessage():
+                return False
+        return True # don't filter!
+
+class FlaskApp:
+    ''' Class to hold and manage all the general flask related data and functions '''
+    def __init__(self, config_file:str|None=None, web_log_level:str=INFO, app_log_level:str=INFO, app_path=None,
+                 templates_path=os.path.join(os.path.dirname(__file__), 'templates')):
+        # app config
+        self.config_file = config_file
+        self.config = {}
+        self._templates = None
+        self.site_data = {
+            'templates_path': os.path.abspath(templates_path),
+            'app_path': app_path,
+            }
+
+        # init objects
+        self.app = None
+        self.login_manager = None
+        self.async_mode = None
+        self.socketio = None
+        self.user_controller = None
+
+        # save log levels
+        self.web_log_level = web_log_level if web_log_level in [DEBUG, INFO, WARNING, ERROR, CRITICAL] else INFO
+        self.app_log_level = app_log_level if app_log_level in [DEBUG, INFO, WARNING, ERROR, CRITICAL] else INFO
+        self.flask_logger = create_logger(console_level=self.app_log_level)
+        self.app_logger = create_logger(console_level=self.app_log_level, name=__name__)
+
+        # create list of web pages and API url's
+        self.web_pages = {
+            'web_home': {
+                'routes': ['/', '/index.html', '/default.html'],
+                'params': {}
+            },
+            'healthz': {
+                'routes': ['/healthz']
+            }
+        }
+        self.api_pages = {}
+        self.web_log_filter = ['HEAD /healthz']
+        self._shutdown_post_uuid = str(uuid.uuid4())
+
+        # mapping of static path overrides and all static content pages
+        self.static_pages = {}
+        self.static_page_args = {}
+
+        # shutdown flags
+        self._shutdown = False
+
+        # socketio holders
+        self._socketio_background_threads = {}
+        self._socketio_clients = {}
+        self._socketio_client_lock = Lock()
+
+        self.init()
+
+    @property
+    def base_templates(self):
+        ''' Return a list of the available base templates '''
+        if self._templates is not None:
+            return self._templates
+        self._templates = []
+        for entry in os.scandir(BASE_TEMPLATE_PATH):
+            if entry.is_dir():
+                # check for a templates folder
+                for template_entry in os.scandir(entry.path):
+                    if template_entry.name == 'templates':
+                        self._templates.append(entry.name)
+        return self._templates
+
+    def init_login_manager(self):
+        ''' Configure the login manager '''
+        self.login_manager = LoginManager()
+        self.login_manager.login_view = self.site_data.get('login_page', '/login.html')
+        self.login_manager.init_app(self.app)
+        if self.config.get('auth', '').lower() == 'radius' or self.config.get('authentication', '').lower() == 'radius':
+            from .user_radius import RadiusUserController
+            self.user_controller = RadiusUserController(**self.config.get('radius'))
+            self.login_manager.user_loader(self.user_controller.get_user)
+        else:
+            from .user_generic import GenericUserController
+            self.user_controller = GenericUserController()
+            self.login_manager.user_loader(self.user_controller.get_user)
+
+    def init(self):
+        ''' Stop the running process and recreate all Flask objects.  Allows a complete reset of the Flask environment with all routes '''
+        self.stop()
+        self.config = load_config_json(self.config_file) if self.config_file is not None else {}
+
+        # flask objects
+        self.app = Flask(__name__, static_folder=self.config.get('static_dir', os.path.join(os.getcwd(), FLASK_DEFAULT_STATIC_DIR)), template_folder=self.site_data['templates_path'])
+        self.web_static_dir = self.config.get('static_dir', FLASK_DEFAULT_STATIC_DIR)
+        self.web_static_inc_subs = self.config.get('web_static_inc_subs', True)
+        self.app.wsgi_app = ProxyFix(self.app.wsgi_app, **dict(x_proto=1, x_host=1, x_for=1, x_prefix=1) if self.config.get('behind_proxy', False) else {})
+        self.socketio = SocketIO(self.app, cors_allowed_origins=self.config.get('cors_allowed_origins', '*'))
+
+        # logging filter
+        self.web_log_filter = self.config.get('web_log_filter', self.web_log_filter)
+        if not isinstance(self.web_log_filter, list):
+            raise ValueError(f"web_log_filter mus be a list of string objects to match against logs. Got: {self.web_log_filter}")
+        web_log_filter_obj = FlaskLogFilter()
+        web_log_filter_obj.log_filter_list = self.web_log_filter
+        werkzeug_logger = logging.getLogger('werkzeug')
+        werkzeug_logger.addFilter(web_log_filter_obj)
+
+        self.site_data['base_template'] = self.config.get('base_template', None) if self.config.get('base_template', None) in self.base_templates else None
+        self.site_data['debug'] = self.config.get('debug', False)
+        self.site_data['auth'] = self.config.get('auth', None)
+        if self.site_data['auth'] is not None:
+            self.site_data['login_page'] = self.config.get('login_page', '/login.html')
+            self.site_data['logout_page'] = self.config.get('login_page', '/logout.html')
+
+        # configure the site template by creating a sym-link to the base template under the Flask site templates (Flask requires all templates to be in 1 dir)
+        if self.site_data.get('base_template', None) is not None:
+            if os.path.exists(os.path.join(self.site_data['templates_path'], '_base_template')):
+                os.unlink(os.path.join(self.site_data['templates_path'], '_base_template'))
+            os.symlink(os.path.join(BASE_TEMPLATE_PATH, self.site_data.get('base_template')), os.path.join(self.site_data['templates_path'], '_base_template'))
+            # set the base_template file to a local 'base.html.j2' file if it exists, otherwise use the template base file
+            if os.path.isfile(os.path.join(self.site_data['templates_path'], 'base.html.j2')):
+                self.site_data['site_template'] = 'base.html.j2' # path is relative to the 'templates' folder
+            else:
+                # if a 'site_template' is specified, use that
+                self.site_data['site_template'] = os.path.join('_base_template', 'templates', self.site_data.get('site_template', 'base.html.j2'))
+        self.site_data.update(self.config.get('site_data', {}))
+        self.web_pages.update(self.config.get('web_pages', {}))
+        self.api_pages.update(self.config.get('api_pages', {}))
+
+        # add the shutdown endpoint
+        self._shutdown_post_uuid = str(uuid.uuid4())
+        self.web_pages.update({'shutdown_server': {'routes': [f'/shutdown_server'], 'params': {'methods': ['POST']}}})
+        self.app_logger.debug(f"Shutdown endpoint UUID: {self._shutdown_post_uuid}.  Shutdown server with POST to /shutdown_server wuth form endcoded 'UUID' parameter and value.")
+        
+        # create sym link for the app in addition to the base template
+        if self.site_data.get('app_path', None) is not None and os.path.join(self.site_data.get('app_path', None), 'templates') != self.site_data['templates_path']:
+            if os.path.exists(os.path.join(self.site_data['templates_path'], '_app')):
+                os.unlink(os.path.join(self.site_data['templates_path'], '_app'))
+            os.symlink(self.site_data.get('app_path'), os.path.join(self.site_data['templates_path'], '_app'))
+
+        # configure login manager
+        #if self.config.get('auth', None) != None or self.config.get('authentication', None) != None:
+        self.init_login_manager()
+
+        # load or generate flask secret key
+        if os.path.isfile(self.config.get('flask_secret_file', '.flask_secret')):
+            with open(self.config.get('flask_secret_file', '.flask_secret'), 'rb') as input_file:
+                self.app_logger.info(f"{self.info_str}: Reading flask secret file {self.config.get('flask_secret_file', '.flask_secret')}")
+                self.app.secret_key = input_file.read()
+        else:
+            self.app.secret_key = os.urandom(FLASK_SECRET_LENGTH)
+            with open(self.config.get('flask_secret_file', '.flask_secret'), 'wb') as output_file:
+                self.app_logger.info(f"{self.info_str}: Writing flask secret file {self.config.get('flask_secret_file', '.flask_secret')}")
+                output_file.write(self.app.secret_key)
+        self.update_flask_routes(reinit=False)
+
+        # configure dropdowns
+        for dropdown_menu in self.config.get('dropdowns', []):
+            self.add_dropdown(name=dropdown_menu.get('name', 'Menu'), items=dropdown_menu.get('items', []), replace=True)
+
+        # configure socketio handlers
+        for socketio_handler in self.config.get('socketio', []):
+            self.app_logger.info(f"{self.info_str}: Adding socketio handler: {socketio_handler}")
+            self._socketio_clients[socketio_handler.get('namespace', 'default')] = []
+            for handler, function in socketio_handler.get('handlers', {}).items():
+                self.socketio.on_event(handler, getattr(self, function), socketio_handler.get('namespace', 'default'))
+            #if socketio_handler.get('direction', 'out') == 'out':
+            #    self.socketio.on_event("connect", self._socket_io_connect, socketio_handler.get('namespace', 'default'))
+
+    def _socket_io_connect(self):
+        ''' On a connect request, start the background thread if not currently running '''
+        if self.socketio:
+            self.app_logger.info(f"{self.info_str}: client connect for namespace {request.namespace}...") # pyright: ignore[reportAttributeAccessIssue]
+            try:
+                # add client to the list of clients for the namespace
+                with self._socketio_client_lock:
+                    if request.namespace not in self._socketio_clients: # pyright: ignore[reportAttributeAccessIssue]
+                        self._socketio_clients[request.namespace] = [] # pyright: ignore[reportAttributeAccessIssue]
+                    self._socketio_clients[request.namespace].append(request.sid) # pyright: ignore[reportAttributeAccessIssue]
+                self.app_logger.info(f"{self.info_str}: client connected for namespace {request.namespace}. Total clients for namespace: {len(self._socketio_clients[request.namespace])}") # pyright: ignore[reportAttributeAccessIssue]
+
+                if isinstance(self._socketio_background_threads.get(request.namespace), Thread) and self._socketio_background_threads[request.namespace].is_alive(): # pyright: ignore[reportAttributeAccessIssue]
+                    self.app_logger.debug(f"{self.info_str}: socketio background thread already running")
+                else:
+                    socketio_config = [x for x in self.config['socketio'] if x.get('namespace') == request.namespace][0] # pyright: ignore[reportAttributeAccessIssue]
+                    self.app_logger.info(f"Starting background thread for {request.namespace}, socketio config: {socketio_config}...") # pyright: ignore[reportAttributeAccessIssue]
+                    self._socketio_background_threads[socketio_config.get('namespace')] = self.socketio.start_background_task(target=getattr(self, socketio_config.get('update_function'))) # pyright: ignore[reportAttributeAccessIssue]
+            except Exception as e:
+                self.app_logger.error(f"SocketIO Connect error occured: {e.__class__.__name__}: {e}")
+        else:
+            self.app_logger.critical("SocketIO connect received, but socketio not running!")
+
+    def _socket_io_disconnect(self):
+        ''' On disconnect, remove the client from the list of clients for the namespace '''
+        if self.socketio:
+            self.app_logger.info(f"{self.info_str}: client disconnect for namespace {request.namespace}...") # pyright: ignore[reportAttributeAccessIssue]
+            with self._socketio_client_lock:
+                if request.namespace in self._socketio_clients and request.sid in self._socketio_clients[request.namespace]: # pyright: ignore[reportAttributeAccessIssue]
+                    self._socketio_clients[request.namespace].remove(request.sid) # pyright: ignore[reportAttributeAccessIssue]
+                    self.app_logger.info(f"{self.info_str}: client disconnected for namespace {request.namespace}. Total clients for namespace: {len(self._socketio_clients[request.namespace])}") # pyright: ignore[reportAttributeAccessIssue]
+                else:
+                    self.app_logger.warning(f"{self.info_str}: disconnect received for namespace {request.namespace} but client SID not found in client list!") # pyright: ignore[reportAttributeAccessIssue]
+        else:
+            self.app_logger.critical("SocketIO disconnect received, but socketio not running!")
+
+    @property
+    def dropdown_menus(self) -> list:
+        ''' Returns a list of the dropdown menus that are currently configured '''
+        if 'dropdowns' not in self.site_data:
+            self.site_data['dropdowns'] = []
+        return self.site_data['dropdowns']
+
+    def remove_dropdown(self, name:str):
+        ''' Deletes a dropdown based on the display name '''
+        for i in range(len(self.dropdown_menus)):
+            if self.dropdown_menus[i]['name'] == name:
+                self.dropdown_menus.remove(i)
+                return
+
+    def add_dropdown(self, name:str, items:list, replace=True):
+        ''' Add a dropdown to the list of dropdown menus.  Replace will replace the existing menu definition with the provided definition
+            Items format: [
+                    {'name': '[Display name]',
+                     'url': '[URL for the link, relative should start with /]'],
+                     'newtab': true|false (default is False)}
+                ] '''
+        if replace:
+            self.remove_dropdown(name)
+        for i in range(len(self.dropdown_menus)):
+            if self.dropdown_menus[i]['name'] == name:
+                for k in range(len(items)):
+                    for j in range(len(self.dropdown_menus[i].get('items',[]))):
+                        if self.dropdown_menus[i]['items'][j].get('name') == items[k].get('name'):
+                            dict(self.dropdown_menus[i]['items'][j]).update(items[k])
+                            return
+                    # we didn't find a matching item, so add it
+                    self.dropdown_menus[i]['items'].append(items[k])
+                    return
+        # if we didn't run an update, add the menu
+        self.dropdown_menus.append({'name': name, 'items': items})
+
+    @property
+    def info_str(self):
+        ''' Returns the info string for the class (used in logging commands) '''
+        return f"{self.__class__.__name__} ({self.config.get('address', '0.0.0.0')}:{self.config.get('port', 8080)}){':DEBUG' if self.config.get('debug', False) else ''}"
+
+    def __del__(self):
+        self.stop()
+
+    def update_flask_routes(self, reinit=False):
+        ''' Update the flask routes '''
+        if reinit or self.app is None:
+            self.init()
+        # add base template static files
+        if self.site_data.get('base_template', None) is not None and os.path.isdir(os.path.join(self.site_data['templates_path'], '_base_template', 'static')):
+            self._add_flask_static_files(os.path.join(self.site_data['templates_path'], '_base_template', 'static'))
+        # add app static files
+        if self.site_data.get('app_path', None) is not None and os.path.isdir(os.path.join(self.site_data['templates_path'], '_app', 'static')):
+            self._add_flask_static_files(os.path.join(self.site_data['templates_path'], '_app', 'static'))
+        # add static files from the project
+        self._add_flask_static_files(os.path.join(os.getcwd(), self.config.get('static_dir', FLASK_DEFAULT_STATIC_DIR)))
+
+        # add dynamic pages
+        for page in self.web_pages:
+            for route in self.web_pages[page]['routes']:
+                self.app.add_url_rule(route, view_func=getattr(self, page), **self.web_pages[page].get('params', {}))
+
+        # add api pages
+        for page in self.api_pages:
+            for route in self.api_pages[page]['routes']:
+                self.app.add_url_rule(route, view_func=getattr(self, page), **self.api_pages[page].get('params', {}))
+
+    def _add_flask_static_files(self, root_path):
+        ''' Loop through all files in the path specified and add as static files.  If '_base_template', files will be added WITHOUT the '_base_template' in the route '''
+        for static_file in get_all_files(root_path, True):
+            self.static_pages[static_file.split(root_path)[1]] = static_file
+            self.app.add_url_rule(static_file.split(root_path)[1], view_func=self.web_static_file, **self.static_page_args)
+
+    def shutdown_server(self):
+        ''' Execute a shutdown of the server, must be a POST and include the UUID in the body '''
+        if request.method == 'POST' and request.form.get('UUID', None) == self._shutdown_post_uuid:
+            if isinstance(self.socketio, SocketIO):
+                self.app_logger.info(f"Received shutdown request from {request.remote_addr}. Stopping services...")
+                self.socketio.stop()
+                return 'Services shutting down...\n', 200
+            else:
+                self.app_logger.error(f"Received shutdown request from {request.remote_addr}. Services not running!")
+                return "Services not available", 500
+        self.app_logger.critical(f"Received shutdown request from {request.remote_addr}. Missing proper UUID. Verify Proper usage.")
+        return 'ACCESS DENIED', 403
+
+    def start(self):
+        ''' Start the Flask process in a thread '''
+        try:
+            self.socketio.run(self.app,
+                            host=self.config.get('address', '0.0.0.0'),
+                            port=self.config.get('port', 8080),
+                            debug=self.config.get('debug', False),
+                            use_reloader=False)
+            while True:
+                sleep(5)
+        except KeyboardInterrupt:
+            # CTRL+C will end the program
+            self.app_logger.info("CTRL+C Caught. Closing...")
+            self.stop()
+
+    def render_template(self, template:str, page=None, **kwargs):
+        ''' Render the requested template.  Automatically inserts base page data '''
+        # get function name of the calling function
+        stack = inspect.stack()
+        for x in range(len(stack)):
+            if stack[x].function == 'render_template':
+                break
+        if x + 1 < len(stack):
+            calling_func = stack[x+1].function
+        if os.path.exists(os.path.join(self.site_data['templates_path'], template)):
+            return render_template(template, site=self.site_data, page=self.web_pages[calling_func].get('data', {}) if page is None else page, **kwargs)
+        elif os.path.exists(os.path.join(self.site_data['templates_path'], '_app', 'templates', template)):
+            return render_template(os.path.join('_app', template), site=self.site_data, page=self.web_pages[calling_func].get('data', {}) if page is None else page, **kwargs)
+        return render_template(os.path.join('_base_template', 'templates', template), site=self.site_data, page=self.web_pages[calling_func].get('data', {}) if page is None else page, **kwargs)
+
+    def return_error(self, code:int=404):
+        ''' Return an error code '''
+        abort(code)
+
+    def stop(self):
+        pass
+
+    def web_home(self):
+        return "<body>test123</body>", 200
+
+    def healthz(self):
+        ''' Override if more complex healthcheck is required beyond 'the web service is operational' '''
+        return 'OK', 200
+
+    def web_static_file(self):
+        ''' Return a static file '''
+        file_name = request.url_rule.rule.rsplit('/', 1)[-1]
+        return send_file(self.static_pages[request.url_rule.rule], download_name=file_name, as_attachment=bool(safe_string(request.args.get('download', False))))
+
+    def request_args_safe(self, *args) -> bool:
+        ''' Checks that all request arguments are safe strings.  Non-alphanumeric characters that are accepted can be passed as arguments '''
+        for argument in request.args:
+            if not safe_string(request.args.get(argument), *args):
+                self._logger.error(f"{self.info_str}: Argument '{argument}' failed safe check!")
+                return False
+        return True
+
+
+def get_all_files(path:str, include_subdir:bool):
+    ''' Recursive function to return a list of all files '''
+    file_list = []
+    if os.path.isdir(path):
+        with os.scandir(path) as entries:
+            for entry in entries:
+                if entry.is_file():
+                    file_list.append(entry.path)
+                elif entry.is_dir():
+                    file_list.extend(get_all_files(entry.path, include_subdir))
+    return file_list
+
+
+def is_safe_url(target):
+    ref_url = urlparse(request.host_url)
+    test_url = urlparse(urljoin(request.host_url, target))
+    return test_url.scheme in ('http', 'https') and ref_url.netloc == test_url.netloc
+
+
+def safe_string(value, *args):
+    """ Verify that a passed string is alpha numeric plus any additional safe characters """
+    if value is not None:
+        for arg in args:
+            value = value.replace(arg, 'X')
+        if (isinstance(value, str) and str(value).isalnum()) or value == '':
+            return True
+    return False

flask_app_class/logging_patch.py

@@ -0,0 +1,30 @@
+from gevent.pywsgi import WSGIHandler
+from datetime import datetime
+
+def patched_format_request(self):
+    now = datetime.now().replace(microsecond=0)
+    length = self.response_length or '-'
+    if self.time_finish:
+        delta = '%.6f' % (self.time_finish - self.time_start)
+    else:
+        delta = '-'
+    if getattr(self, 'environ', None):
+        if 'HTTP_X_REAL_IP' in self.environ:
+            client_address = self.environ['HTTP_X_REAL_IP']
+        else:
+            client_address = self.client_address[0] if isinstance(self.client_address, tuple) else self.client_address
+    else:
+        client_address = self.client_address[0] if isinstance(self.client_address, tuple) else self.client_address
+    return '%s - - [%s] "%s" %s %s %s' % (
+        client_address or '-',
+        now,
+        self.requestline or '',
+        # Use the native string version of the status, saved so we don't have to
+        # decode. But fallback to the encoded 'status' in case of subclasses
+        # (Is that really necessary? At least there's no overhead.)
+        (self._orig_status or self.status or '000').split()[0],
+        length,
+        delta)
+
+def patch_wsgihandler():
+    WSGIHandler.format_request = patched_format_request

flask_app_class/user_controller.py

@@ -0,0 +1,86 @@
+from flask_login import UserMixin
+import logging
+
+class FlaskUserController:
+    ''' Parent class to handle basic user management functions.  Tasks should be overriden by an inherritting class  '''
+    def __init__(self, logger=logging):
+        self._logger = logger
+        self._inherit_info_str = ''
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        pass
+
+    @property
+    def info_str(self):
+        ''' Returns the info string for the class (used in logging commands) '''
+        return f"{self.__class__.__name__}({self._inherit_info_str})"
+
+    def authenticate_user(self, username:str, password=None, password_hash=None):
+        ''' Authenticate a user and return a FlaskUser object '''
+        return NotImplemented
+
+    def authorize_user(self, username:str, **kwargs):
+        ''' Authorize a user based on criteria that is passed '''
+        return NotImplemented
+
+    def get_user(self, username=None, user_id=None):
+        ''' Find a user from a username or user_id '''
+        return NotImplemented
+    
+    def enable_user(self, user_id):
+        ''' Mark a user as enabled '''
+        return NotImplemented
+
+    def disable_user(self, user_id):
+        ''' Mark a user as disabled '''
+        return NotImplemented
+
+    def add_user(self, username:str, password=None, enabled=True, **kwargs):
+        ''' Create a new user in the underlying system '''
+        return NotImplemented
+
+    def delete_user(user_id):
+        ''' Delete a user in the underlying system ''' 
+        return NotImplemented
+
+    def update_user(self, user_id, username=None, password=None, enabled=None, **kwargs):
+        ''' Update properties for a user in the underlying system '''
+        return NotImplemented
+        
+
+class FlaskUser(UserMixin):
+    '''
+    Represents a user that has attempted a login via the FlaskLoginController. 
+    Extends the Flask UserMixin class to represent the user. Base class includes __eq__ and __ne__ functions
+    '''
+    def __init__(self, user_id:str|int, username:str, auth_ok:bool, acct_active:bool):
+        ''' Create an instance to represent a user login ''' 
+        self._user_data = (user_id, username, auth_ok, acct_active)
+
+    @property
+    def is_active(self):
+        ''' is_active returns True if the account is active (not suspended or rejected for reasons other than auth) '''
+        return self._user_data[4]
+
+    @property
+    def username(self):
+        return self._user_data[1]
+
+    @property
+    def name(self):
+        return self.user_data[1]
+
+    @property
+    def is_authenticated(self):
+        ''' Returns True if the account is authenticated '''
+        return self._user_data[2]
+
+    def get_id(self):
+        return self._user_data[0]
+
+    def __str__(self):
+        ''' Return the username and ID as a string '''
+        return f"{self.username}({self.get_id()})"

flask_app_class/user_generic.py

@@ -0,0 +1,20 @@
+'''
+Generic user controller for when no other user controller is used.  Returns 'admin' as the user and always logged in
+'''
+
+import logging
+from .user_controller import FlaskUserController, FlaskUser
+
+
+class GenericUserController(FlaskUserController):
+    ''' Extends the base FlaskUserController to always return a logged in user of 'admin' '''
+    def __init__(self, logger=logging):
+        super().__init__(logger=logger)
+
+    def authenticate_user(self, *args, **kwargs):
+        ''' Authenticate a user and return a FlaskUser object '''
+        return FlaskUser(user_id='admin', username='admin', auth_ok=True, acct_active=True)
+
+    def get_user(self, user_id=None):
+        ''' Find a user from a user_id - Currently requires the user list '''
+        return FlaskUser(user_id='admin', username='admin', auth_ok=True, acct_active=True)

flask_app_class/user_radius.py

@@ -0,0 +1,40 @@
+import logging
+from .user_controller import FlaskUserController, FlaskUser
+from ._radius import Radius, DEFAULT_RETRIES, DEFAULT_TIMEOUT
+
+
+class RadiusUserController(FlaskUserController):
+    ''' Extends the base FlaskUserController to utilize a RADIUS backend for authentication and authorization
+        NOTES: 
+            - Radius user controller only supports read methods, 
+            - user_id is the username
+            - user_table is a list of user id's that should be permitted (can be used to filter users): [1, 55, 132]
+        '''
+    def __init__(self, host:str, shared_secret:str, port=1812, user_table=None, logger=logging, retries=DEFAULT_RETRIES, timeout=DEFAULT_TIMEOUT):
+        super().__init__(logger=logger)
+        self._inherit_info_str = f'{host}:{port}'
+        self._logger.info(f"{self.info_str}: Connecting to RADIUS Server")
+        self.radius = Radius(secret=shared_secret, host=host, port=port, retries=retries, timeout=timeout)
+        self.user_table = user_table if user_table is not None else []
+
+    def authenticate_user(self, username:str, password=None, password_hash=None, strip_username=True, lcase_username=True):
+        ''' Authenticate a user and return a FlaskUser object '''
+        if strip_username:
+            username = username.strip() # Remove spaces that might be before or after the username
+        if lcase_username:
+            username = username.lcase() # Easier for mobile devices that might capitalize the first letter
+        if len(self.user_table) == 0 or username in self.user_table:
+            if self.radius.authenticate(username=username, password=password):
+                self._logger.info(f"{self.info_str}: {username}: Auth Successful")
+                return FlaskUser(user_id=username, username=username, auth_ok=True, acct_active=True)
+        return None
+
+    def authorize_user(self, username: str, **kwargs):
+        ''' Need to setup the radius package to return extended attributes to use authorization '''
+        return NotImplemented
+
+    def get_user(self, user_id=None):
+        ''' Find a user from a user_id - Currently requires the user list '''
+        if user_id in self.user_table:
+            return FlaskUser(user_id, user_id, False, False)
+        return None

flask_app_class-0.1.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: flask_app_class
+Version: 0.1.0
+Summary: Class based tool to build Flask applications that include socketio and authentication
+Author-email: Thomas Dunteman <git@learningtopi.com>
+Project-URL: homepage, https://github.com/LearningToPi/flask_app_class
+Project-URL: bug tracker, https://github.com/LearningToPi/flask_app_class/issues
+Project-URL: source code, https://github.com/LearningToPi/flask_app_class
+Keywords: flask,socketio
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Flask
+Classifier: Environment :: Web Environment
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiosmtpd==1.4.6
+Requires-Dist: atpublic==7.0.0
+Requires-Dist: attrs==25.4.0
+Requires-Dist: azure-communication-email==1.1.0
+Requires-Dist: azure-core==1.38.0
+Requires-Dist: azure-identity==1.25.1
+Requires-Dist: certifi==2026.1.4
+Requires-Dist: cffi==2.0.0
+Requires-Dist: charset-normalizer==3.4.4
+Requires-Dist: cryptography==46.0.3
+Requires-Dist: idna==3.11
+Requires-Dist: ipcalc==1.99.0
+Requires-Dist: isodate==0.7.2
+Requires-Dist: logging-handler==1.0.7
+Requires-Dist: msal==1.34.0
+Requires-Dist: msal-extensions==1.3.1
+Requires-Dist: parameter-verification==0.1.1
+Requires-Dist: pycparser==3.0
+Requires-Dist: PyJWT==2.10.1
+Requires-Dist: queue_processor==1.1.2
+Requires-Dist: requests==2.32.5
+Requires-Dist: six==1.17.0
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: urllib3==2.6.3
+Requires-Dist: validators==0.35.0

flask_app_class-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+flask_app_class/__init__.py,sha256=7Lvx93yptZlySx3QRFv3vvjk7_o92vGazUywdNZKEnY,64
+flask_app_class/__main__.py,sha256=Qkgk89cSulYr2lFe1eDP__JiNJ_bVoncxfPg3jL-Rss,606
+flask_app_class/_radius.py,sha256=2Pu150fskWhcZ_QN3uzYrx8fv8TF_OPpQ5oGuwIOc_0,20255
+flask_app_class/flask_app.py,sha256=WC16ZGvrrn47jOarppFAYMHooGuMNuqBqFaSOHo7L_Y,23222
+flask_app_class/logging_patch.py,sha256=dlTpCJGBIwI0oDJ_9mV56X80J9rci3mn_lECzXRh8Fc,1233
+flask_app_class/user_controller.py,sha256=ALrDt-7M5Ner8Fpz-FZtXdZ1ZbsrSuW4rHfRJcslgLg,2859
+flask_app_class/user_generic.py,sha256=DKmCQCjV9INrgF_7oA0ZXeyafAjG4yWsdY2REuHBuu0,845
+flask_app_class/user_radius.py,sha256=s9qphsBHkaneVo0Z9Lx2fj1SgVU4orM4enHJ3fQD7Oo,2264
+flask_app_class-0.1.0.dist-info/METADATA,sha256=MNC6zTCE8EAgLpTfdQqE91768YpJu2M_lmUpNPyzB08,1539
+flask_app_class-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flask_app_class-0.1.0.dist-info/top_level.txt,sha256=X0NAW5bsPKXKoEPGHKPi_Mn5ry3bXY7L1_ccTBrrZ2w,16
+flask_app_class-0.1.0.dist-info/RECORD,,

flask_app_class-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flask_app_class-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flask_app_class