lex-app 2.2.2__tar.gz → 2.3.0__tar.gz

{lex_app-2.2.2/lex_app.egg-info → lex_app-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lex-app
-Version: 2.2.2
+Version: 2.3.0
 Summary: A Python / Django library to create business applications easily with complex logic
 Author-email: Melih Sünbül <m.sunbul@excellence-cloud.com>
 License-Expression: MIT
@@ -36,6 +36,8 @@ Requires-Dist: nest_asyncio
 Requires-Dist: Office365-REST-Python-Client
 Requires-Dist: streamlit<1.62,>=1.61
 Requires-Dist: streamlit-keycloak-lex
+Requires-Dist: reflex<0.10,>=0.9.12
+Requires-Dist: reflex-enterprise<0.10,>=0.9.6
 Requires-Dist: sqlalchemy
 Requires-Dist: django_redis
 Requires-Dist: django-storages[google]

{lex_app-2.2.2 → lex_app-2.3.0}/generate_pycharm_configs.py

@@ -75,6 +75,11 @@ RUN_CONFIGS = (
         "name": "Streamlit",
         "args": ("streamlit", "run", "streamlit_app.py"),
     },
+    {
+        "pycharm_filename": "Reflex.run.xml",
+        "name": "Reflex",
+        "args": ("reflex", "run"),
+    },
     {
         "pycharm_filename": "Create_DB.run.xml",
         "name": "Create DB",

lex_app-2.3.0/lex/_version.py

@@ -0,0 +1 @@
+__version__ = "2.3.0"

{lex_app-2.2.2 → lex_app-2.3.0}/lex/api/views/global_search_for_models/Search.py

@@ -7,7 +7,7 @@ from rest_framework.views import APIView
 from rest_framework_api_key.permissions import HasAPIKey
 
 EXCLUDED_MODELS = {'calculationdashboard', 'user', 'group', 'permission', 'contenttype', 'userchangelog',
-                   'calculationlog', 'log', 'streamlit'}
+                   'calculationlog', 'log', 'streamlit', 'reflex'}
 EXCLUDED_TYPES = {'FloatField', 'BooleanField', 'IntegerField', "FileField", "ForeignKey", "XLSXField", "PDFField", "ImageField"}
 
 

{lex_app-2.2.2 → lex_app-2.3.0}/lex/bin/lex.py

@@ -14,7 +14,11 @@ import shutil
 
 import click
 import uvicorn
-from lex.tools.project_root import find_project_root, resolve_llm_working_directory
+from lex.tools.project_root import (
+    find_project_root,
+    load_project_env_file,
+    resolve_llm_working_directory,
+)
 from lex.tools.setup_with_ai import (
     DEFAULT_LEX_MCP_MODE,
     DEFAULT_REMOTE_MCP_URL,
@@ -83,23 +87,9 @@ PROJECT_ROOT_DIR = Path(find_project_root(os.getcwd())).resolve()
 sys.path.append(LEX_APP_PACKAGE_ROOT)
 
 
-def _load_project_env_file(project_root: Path) -> None:
-    env_path = project_root / ".env"
-    if not env_path.exists():
-        return
-
-    for raw_line in env_path.read_text(encoding="utf-8").splitlines():
-        line = raw_line.strip()
-        if not line or line.startswith("#") or "=" not in line:
-            continue
-        key, value = line.split("=", 1)
-        key = key.strip()
-        value = value.strip()
-        if not key:
-            continue
-        if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
-            value = value[1:-1]
-        os.environ.setdefault(key, value)
+# Lives in lex/tools/project_root.py so that a process not started through this
+# CLI -- the Reflex backend worker -- loads the same file the same way.
+_load_project_env_file = load_project_env_file
 
 
 _load_project_env_file(PROJECT_ROOT_DIR)
@@ -706,6 +696,187 @@ def streamlit(ctx):
         t.join(timeout=float(os.getenv("LEX_PROXY_SHUTDOWN_TIMEOUT", "5")))
 
 
+# ---------- Reflex ----------
+
+#: What `lex reflex` writes to a project with no ``rxconfig.py`` yet. Reflex reads
+#: its configuration from that file in the directory it runs in, so a project that
+#: serves Reflex dashboards has one; everything lex-app needs is in `lex_config()`.
+REFLEX_CONFIG_TEMPLATE = '''"""Reflex configuration for this Lex App project.
+
+`lex reflex` created this file, because Reflex reads its configuration from
+rxconfig.py in the project root. lex_config() is wired for Lex App: the Reflex
+app lex-app serves, and Keycloak sign-in. Pass it any rx.Config / rxe.Config
+option to override a default, e.g.
+
+    config = lex_config(show_built_with_reflex=False)
+
+Leave the ports to `lex reflex`, which gives each run mode the ones it accepts.
+"""
+
+from lex.tools.django_bootstrap import prepare_environment
+
+# The project's .env, loaded before anything reads Django's settings -- which
+# importing lex_config does. `lex reflex` has loaded it already; this is what
+# lets a bare `reflex run` see the same environment.
+prepare_environment()
+
+from lex.lex_app.reflex.config import lex_config  # noqa: E402
+
+config = lex_config()
+'''
+
+#: Reflex subcommands that do not act on a project, and so need no rxconfig.py.
+_REFLEX_PROJECTLESS_ARGS = frozenset({"login", "logout", "--help", "-h", "--version"})
+
+# Defaults for the two Reflex ports. Reflex's own, 3000 and 8000, are where the
+# React frontend and the Django server run in development; these sit beside
+# Streamlit's 8501 instead. Fixed rather than auto-incremented, because Keycloak
+# has to know the callback URL in advance: http://localhost:8502/callback.
+_DEFAULT_REFLEX_FRONTEND_PORT = "8502"
+_DEFAULT_REFLEX_BACKEND_PORT = "8503"
+
+
+def _env_flag_set(name: str) -> bool:
+    return (os.getenv(name) or "").strip().lower() in ("1", "true", "yes", "y", "on")
+
+
+def _resolve_reflex_port_flags(reflex_args, configured_frontend=None, configured_backend=None):
+    """The port flags to append to a `lex reflex run`, honouring the caller.
+
+    A port the caller chose wins, wherever they chose it -- ``--frontend-port`` /
+    ``--backend-port``, ``REFLEX_FRONTEND_PORT`` / ``REFLEX_BACKEND_PORT``, or
+    ``rxconfig.py`` (``configured_*``) -- and only the missing ones are supplied,
+    the way `lex streamlit` resolves its ports.
+
+    Which ones a run may take depends on its mode, and Reflex refuses a run
+    handed one it cannot use: a frontend port with ``--backend-only``, a backend
+    port with ``--frontend-only``, and two different ports in ``--env prod`` or
+    ``preview``, which serve the frontend and backend on one. So in those modes a
+    single port is supplied, and none at all once the caller has chosen one.
+    """
+    if not reflex_args or reflex_args[0] != "run":
+        return []
+    args = reflex_args[1:]
+
+    env_mode = (_cli_option(args, "env") or "dev").strip().lower()
+    backend_only = "--backend-only" in args or _env_flag_set("REFLEX_BACKEND_ONLY")
+    frontend_only = "--frontend-only" in args or _env_flag_set("REFLEX_FRONTEND_ONLY")
+    given_frontend = (
+        _cli_option(args, "frontend-port") or os.getenv("REFLEX_FRONTEND_PORT") or configured_frontend
+    )
+    given_backend = (
+        _cli_option(args, "backend-port") or os.getenv("REFLEX_BACKEND_PORT") or configured_backend
+    )
+
+    if env_mode in ("prod", "preview"):
+        if given_frontend or given_backend:
+            return []
+        if backend_only:
+            return ["--backend-port", _DEFAULT_REFLEX_BACKEND_PORT]
+        return ["--frontend-port", _DEFAULT_REFLEX_FRONTEND_PORT]
+
+    flags = []
+    if not backend_only and not given_frontend:
+        flags += ["--frontend-port", _DEFAULT_REFLEX_FRONTEND_PORT]
+    if not frontend_only and not given_backend:
+        flags += ["--backend-port", _DEFAULT_REFLEX_BACKEND_PORT]
+    return flags
+
+#: Top-level entries of a project that Reflex's hot reload must not watch: they
+#: are generated, vendored, or change without the app changing.
+_REFLEX_RELOAD_SKIP = frozenset({
+    "build", "dist", "env", "htmlcov", "media", "migrations", "node_modules",
+    "reflex.lock", "reports", "static", "uploaded_files", "venv",
+})
+
+
+def _ensure_reflex_config(project_root: Path) -> tuple[Path, bool]:
+    """Return ``(path, created)`` for the project's ``rxconfig.py``, writing it if absent.
+
+    An existing file is never touched -- it is the project's to edit.
+    """
+    path = project_root / "rxconfig.py"
+    if path.exists():
+        return path, False
+    path.write_text(REFLEX_CONFIG_TEMPLATE, encoding="utf-8")
+    return path, True
+
+
+def _reflex_hot_reload_paths(project_root: Path) -> str:
+    """``REFLEX_HOT_RELOAD_OVERRIDE_PATHS`` for the project: what to watch in dev.
+
+    Reflex watches the tree its *app module* sits in. The app module is
+    ``lex.reflex_app``, inside the installed lex package, so left alone it would
+    watch site-packages -- tens of thousands of files -- and never the project's
+    own models and ``_reflex_structure.py``, which are what change.
+
+    Its top-level entries, then, minus hidden and generated ones: ``.web/`` is
+    rewritten by every compile, so watching it would reload the backend in a
+    loop. Names are relative, and resolve against the project root Reflex runs
+    in, because Reflex splits the variable on ``:`` -- which an absolute Windows
+    path contains.
+    """
+    names = []
+    for entry in sorted(project_root.iterdir(), key=lambda item: item.name):
+        name = entry.name
+        if name.startswith((".", "__")) or name in _REFLEX_RELOAD_SKIP or ":" in name:
+            continue
+        if entry.is_dir() and (entry / "pyvenv.cfg").exists():
+            continue  # a virtualenv under whatever name it was given
+        names.append(name)
+    return ":".join(names) or "rxconfig.py"
+
+
+@lex.command(
+    name="reflex",
+    short_help="Run the project's Reflex dashboards.",
+    context_settings=dict(ignore_unknown_options=True, allow_extra_args=True),
+    add_help_option=False,
+)
+@click.pass_context
+def reflex_cmd(ctx):
+    """Run the project's Reflex dashboards (arguments go to the Reflex CLI).
+
+    \b
+    lex reflex                    # reflex run: dev server with hot reload
+    lex reflex run --env prod     # production, as a deployment runs it
+    lex reflex login              # sign in to Reflex, for reflex-enterprise
+    lex reflex --help             # Reflex's own help
+    """
+    # The Reflex counterpart of `lex streamlit`, with one difference that shapes
+    # the rest: Streamlit runs in THIS process, after Django is set up, so this
+    # command set Django up for it. Reflex compiles and serves the app from worker
+    # processes that never see this one's bootstrap, so the app module they import
+    # (`lex.reflex_app`) sets Django up itself -- and this command, which is in
+    # `_SKIP_BOOTSTRAP_COMMANDS`, does not do it a second time.
+    reflex_args = list(ctx.args) or ["run"]
+
+    if reflex_args[0] not in _REFLEX_PROJECTLESS_ARGS:
+        # Reflex reads rxconfig.py from, and writes .web/ into, the directory it
+        # runs in -- the project root, wherever `lex` was invoked from.
+        os.chdir(PROJECT_ROOT_DIR.as_posix())
+        config_path, created = _ensure_reflex_config(PROJECT_ROOT_DIR)
+        if created:
+            click.echo(f"rxconfig.py: {config_path} (created)")
+        os.environ.setdefault(
+            "REFLEX_HOT_RELOAD_OVERRIDE_PATHS", _reflex_hot_reload_paths(PROJECT_ROOT_DIR)
+        )
+
+        if reflex_args[0] == "run":
+            # Loaded here only to learn whether rxconfig.py chose the ports. It is
+            # the load Reflex would make next anyway, and Reflex reuses it.
+            from reflex.config import get_config
+
+            config = get_config()
+            reflex_args += _resolve_reflex_port_flags(
+                reflex_args, config.frontend_port, config.backend_port
+            )
+
+    from reflex.reflex import cli as reflex_cli
+
+    reflex_cli.main(args=reflex_args, prog_name="lex reflex")
+
+
 @lex.command(name="pytest", context_settings=dict(ignore_unknown_options=True, allow_extra_args=True))
 @click.pass_context
 def pytest_cmd(ctx):
@@ -1500,8 +1671,13 @@ def _collect_setup_with_ai_credentials(
 #: It is lex-app's own command and must stay skipped whatever happens to that
 #: rule -- it is the recovery path when the installed lex-mcp-local is too old
 #: for anything else here to work.
+#: reflex is here because its server processes are not this one: the app module
+#: Reflex imports sets Django up where the app actually runs.
 _SKIP_BOOTSTRAP_COMMANDS = frozenset(
-    {"start", "celery", "celery-workers", "flower", "pytest", "pytest-groups", "setup", "setup-with-ai", "ai-update"}
+    {
+        "start", "celery", "celery-workers", "flower", "pytest", "pytest-groups",
+        "setup", "setup-with-ai", "ai-update", "reflex",
+    }
 )
 
 

{lex_app-2.2.2 → lex_app-2.3.0}/lex/core/models/LexModel.py

@@ -1253,6 +1253,33 @@ class LexModel(LifecycleModel):
         """
         st.info("No class-level visualization available for this model.")
 
+    @classmethod
+    def reflex_main(cls):
+        """
+        Instance-level Reflex dashboard -- the Reflex counterpart of ``streamlit_main``.
+        Override in subclasses to return the component ``lex reflex`` shows for
+        ``?model=<name>&pk=<pk>``.
+
+        A classmethod, not an instance method: Reflex compiles the page once,
+        ahead of any request, so there is no record to call it on. The
+        component's own state reads the record in an event handler with
+        ``lex.lex_app.reflex.current_record``.
+        """
+        import reflex as rx
+
+        return rx.callout("No instance-level visualization available for this model.", icon="info")
+
+    @classmethod
+    def reflex_class_main(cls):
+        """
+        Class-level Reflex dashboard -- the Reflex counterpart of ``streamlit_class_main``.
+        Override in subclasses to return the component ``lex reflex`` shows for
+        ``?model=<name>``: aggregate visualizations, statistics, etc.
+        """
+        import reflex as rx
+
+        return rx.callout("No class-level visualization available for this model.", icon="info")
+
 
 # -- Aware-datetime invariant ---------------------------------------------
 # Under USE_TZ=True, Django only normalizes datetimes at the DB boundary:

{lex_app-2.2.2 → lex_app-2.3.0}/lex/lex_app/apps.py

@@ -95,6 +95,23 @@ def _create_audit_logger_for_task(audit_logging_enabled=None):
 
 
 
+def _apply_nest_asyncio():
+    """``nest_asyncio.apply()``, unless this process's event loop cannot be patched.
+
+    nest_asyncio patches asyncio's own pure-Python loop and refuses any other. A
+    server running on uvloop -- granian, which serves `lex reflex`, picks uvloop
+    whenever it is installed -- has already installed a uvloop policy when Django
+    is set up, so ``apply()`` raises ``ValueError`` inside ``ready()`` and takes
+    ``django.setup()`` down with it. Such a process does not need the patch: lex's
+    synchronous code reaches the database from worker threads there, and a worker
+    thread has no running loop to nest into.
+    """
+    try:
+        nest_asyncio.apply()
+    except ValueError as exc:
+        logger.info("nest_asyncio not applied (%s); this process's loop runs as it is.", exc)
+
+
 def should_load_data(auth_settings):
     """
     Check whether the initial data should be loaded.
@@ -116,7 +133,7 @@ class LexAppConfig(GenericAppConfig):
             generic_app_models = {f"{model.__name__}": model for model in
                                   set(list(apps.get_app_config(repo_name).models.values())
                                       + list(apps.get_app_config(repo_name).models.values())) if model.__name__.count("Historical") != 1}
-            nest_asyncio.apply()
+            _apply_nest_asyncio()
 
             # Run the initial-data check (config load + are_all_models_empty()
             # DB query) OFF the ready() critical path so django.setup() returns
@@ -143,6 +160,7 @@ class LexAppConfig(GenericAppConfig):
         from django.contrib import admin
         from django.contrib.auth import get_user_model
         from lex.process_admin.utils.model_registration import ModelRegistration
+        from lex.lex_app.reflex.Reflex import Reflex, reflex_enabled
         from lex.lex_app.streamlit.Streamlit import Streamlit
 
         # Models to explicitly exclude (shouldn't show in frontend)
@@ -198,7 +216,7 @@ class LexAppConfig(GenericAppConfig):
         if self.model_structure_builder.widget_structure:
             ModelRegistration.register_widget_structure(self.model_structure_builder.widget_structure)
         ModelRegistration.register_models(
-            [Streamlit],
+            [Streamlit, Reflex] if reflex_enabled() else [Streamlit],
             self.untracked_models,
             self.model_structure_builder.history_tracking_enabled,
         )

lex_app-2.3.0/lex/lex_app/reflex/Reflex.py

@@ -0,0 +1,27 @@
+import os
+
+from lex.core.models.HTMLReport import HTMLReport
+
+
+class Reflex(HTMLReport):
+    """The project's Reflex dashboards, as a page of the lex-app frontend.
+
+    Registered -- and placed in the sidebar -- only when ``IS_REFLEX_ENABLED``
+    is ``true``: a project that never runs ``lex reflex`` should not show an
+    entry that frames nothing.
+    """
+
+    def get_html(self, user):
+        # 8502 is `lex reflex`'s default frontend port (lex/bin/lex.py). `lex_embed=1`
+        # is how lex-app says it is framing a dashboard in its own chrome: the page
+        # then leaves out the signed-in user and sign-out that chrome already shows.
+        base = os.getenv("REFLEX_URL", "http://localhost:8502").rstrip("/")
+        return f"""<iframe
+              src="{base}/?lex_embed=1"
+              style="width:100%;border:none;height:100%"
+            ></iframe>"""
+
+
+def reflex_enabled() -> bool:
+    """``IS_REFLEX_ENABLED``, read the way ``IS_STREAMLIT_ENABLED`` is."""
+    return os.getenv("IS_REFLEX_ENABLED") == "true"

lex_app-2.3.0/lex/lex_app/reflex/__init__.py

@@ -0,0 +1,82 @@
+"""The Reflex surface of lex-app.
+
+Everything a dashboard author needs is importable from here::
+
+    from lex.lex_app.reflex import current_record, run_orm, has_permission
+
+========================  ====================================================
+``current_record``        the record ``?model=&pk=`` names, from any state
+``run_orm`` / ``orm``     synchronous Django code, from an async event handler
+``current_permissions``   the user's Keycloak UMA permissions
+``has_permission``        an ``auth=`` check built from one of them
+``current_access_token``  the user's Keycloak access token, for the lex-app API
+``LexUser``               the signed-in user's names, as frontend vars
+``lex_config``            the ``rxe.Config`` a project's ``rxconfig.py`` returns
+========================  ====================================================
+
+Nothing is imported until it is used. ``rxconfig.py`` imports
+:mod:`lex.lex_app.reflex.config` through this package before Django or any
+Reflex state exists, and an eager import here would create the states -- the
+auth provider among them -- inside the config that configures them.
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from lex.lex_app.reflex.auth import (
+        LexKeycloakAuthState,
+        LexUser,
+        current_access_token,
+        current_permissions,
+        has_permission,
+    )
+    from lex.lex_app.reflex.config import lex_auth_plugin, lex_config
+    from lex.lex_app.reflex.dashboards import LexDashboardState, current_record
+    from lex.lex_app.reflex.django_orm import orm, run_orm
+
+_EXPORTS = {
+    "LexKeycloakAuthState": "lex.lex_app.reflex.auth",
+    "LexUser": "lex.lex_app.reflex.auth",
+    "current_access_token": "lex.lex_app.reflex.auth",
+    "current_permissions": "lex.lex_app.reflex.auth",
+    "has_permission": "lex.lex_app.reflex.auth",
+    "lex_auth_plugin": "lex.lex_app.reflex.config",
+    "lex_config": "lex.lex_app.reflex.config",
+    "LexDashboardState": "lex.lex_app.reflex.dashboards",
+    "current_record": "lex.lex_app.reflex.dashboards",
+    "orm": "lex.lex_app.reflex.django_orm",
+    "run_orm": "lex.lex_app.reflex.django_orm",
+}
+
+#: The same names, spelled out: tools that read the package without importing it
+#: -- the docs gate among them -- see a module ``__getattr__`` plus ``__all__`` as
+#: its exports (PEP 562). 1.357c keeps the two lists equal.
+__all__ = [
+    "LexDashboardState",
+    "LexKeycloakAuthState",
+    "LexUser",
+    "current_access_token",
+    "current_permissions",
+    "current_record",
+    "has_permission",
+    "lex_auth_plugin",
+    "lex_config",
+    "orm",
+    "run_orm",
+]
+
+
+def __getattr__(name: str) -> Any:
+    module = _EXPORTS.get(name)
+    if module is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(importlib.import_module(module), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *_EXPORTS})

lex_app-2.3.0/lex/lex_app/reflex/app.py

@@ -0,0 +1,40 @@
+"""The Reflex app ``lex reflex`` serves.
+
+Built in one place so that the entry module Reflex imports
+(``lex/reflex_app.py``) is nothing but the order things must happen in: Django
+first, then this.
+"""
+
+from __future__ import annotations
+
+
+def create_app():
+    """The project's Reflex app: sign-in, Django connections, and its dashboards.
+
+    * ``rxe.App`` rather than ``rx.App`` -- the auth plugin refuses anything else,
+      and it is what puts every page, handler and var behind sign-in.
+    * :class:`DjangoConnectionMiddleware`, so each event gets the connection
+      handling a Django request gets.
+    * ``/``, which shows whichever dashboard the query string asks for.
+
+    Further pages come from the project itself: any ``@rxe.page`` in
+    ``_reflex_structure.py``, or in a module it imports, is added when the app
+    compiles.
+    """
+    import reflex_enterprise as rxe
+
+    from lex.lex_app.reflex.dashboards import (
+        LexDashboardState,
+        dashboard_page,
+        load_structure,
+    )
+    from lex.lex_app.reflex.django_orm import DjangoConnectionMiddleware
+
+    app = rxe.App()
+    app.add_middleware(DjangoConnectionMiddleware())
+    app.add_page(
+        dashboard_page(load_structure()),
+        route="/",
+        on_load=LexDashboardState.resolve,
+    )
+    return app