arthexis 0.1.9__py3-none-any.whl → 0.1.26__py3-none-any.whl

config/__init__.py

@@ -1,5 +1,5 @@
-"""Config package initialization."""
-
-from .celery import app as celery_app
-
-__all__ = ("celery_app",)
+"""Config package initialization."""
+
+from .celery import app as celery_app
+
+__all__ = ("celery_app",)

config/active_app.py

@@ -1,15 +1,15 @@
-import threading
-import socket
-
-_active = threading.local()
-_active.name = socket.gethostname()
-
-
-def get_active_app():
-    """Return the currently active app name."""
-    return getattr(_active, "name", socket.gethostname())
-
-
-def set_active_app(name: str) -> None:
-    """Set the active app name for the current thread."""
-    _active.name = name or socket.gethostname()
+import threading
+import socket
+
+_active = threading.local()
+_active.name = socket.gethostname()
+
+
+def get_active_app():
+    """Return the currently active app name."""
+    return getattr(_active, "name", socket.gethostname())
+
+
+def set_active_app(name: str) -> None:
+    """Set the active app name for the current thread."""
+    _active.name = name or socket.gethostname()

config/asgi.py

@@ -1,29 +1,29 @@
-"""
-ASGI config for config project.
-
-It exposes the ASGI callable as a module-level variable named ``application``.
-
-For more information on this file, see
-https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
-"""
-
-import os
-from config.loadenv import loadenv
-from channels.auth import AuthMiddlewareStack
-from channels.routing import ProtocolTypeRouter, URLRouter
-from django.core.asgi import get_asgi_application
-import ocpp.routing
-
-loadenv()
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
-
-django_asgi_app = get_asgi_application()
-
-websocket_patterns = ocpp.routing.websocket_urlpatterns
-
-application = ProtocolTypeRouter(
-    {
-        "http": django_asgi_app,
-        "websocket": AuthMiddlewareStack(URLRouter(websocket_patterns)),
-    }
-)
+"""
+ASGI config for config project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
+"""
+
+import os
+from config.loadenv import loadenv
+from channels.auth import AuthMiddlewareStack
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+import ocpp.routing
+
+loadenv()
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+django_asgi_app = get_asgi_application()
+
+websocket_patterns = ocpp.routing.websocket_urlpatterns
+
+application = ProtocolTypeRouter(
+    {
+        "http": django_asgi_app,
+        "websocket": AuthMiddlewareStack(URLRouter(websocket_patterns)),
+    }
+)

config/auth_app.py

@@ -1,7 +1,7 @@
-from django.contrib.auth.apps import AuthConfig as DjangoAuthConfig
-
-
-class AuthConfig(DjangoAuthConfig):
-    """Use a shorter label for the auth section in the admin."""
-
-    verbose_name = "AUTH"
+from django.contrib.auth.apps import AuthConfig as DjangoAuthConfig
+
+
+class AuthConfig(DjangoAuthConfig):
+    """Use a shorter label for the auth section in the admin."""
+
+    verbose_name = "AUTH"

config/celery.py

@@ -1,25 +1,32 @@
-"""Celery application configuration."""
-
-import os
-
-from celery import Celery
-
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
-
-# When running on production-oriented nodes, avoid Celery debug mode.
-NODE_ROLE = os.environ.get("NODE_ROLE", "")
-if NODE_ROLE in {"Constellation", "Satellite"}:
-    for var in ["CELERY_TRACE_APP", "CELERY_DEBUG"]:
-        os.environ.pop(var, None)
-    os.environ.setdefault("CELERY_LOG_LEVEL", "INFO")
-
-app = Celery("config")
-app.config_from_object("django.conf:settings", namespace="CELERY")
-app.autodiscover_tasks()
-
-
-@app.task(bind=True)
-def debug_task(self):  # pragma: no cover - debug helper
-    """A simple debug task."""
-    print(f"Request: {self.request!r}")
+"""Celery application configuration."""
+
+import os
+
+from celery import Celery
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+# When running on production-oriented nodes, avoid Celery debug mode.
+NODE_ROLE = os.environ.get("NODE_ROLE", "")
+PRODUCTION_ROLES = {
+    "constellation",
+    "satellite",
+    "control",
+    "terminal",
+    "gateway",
+}
+if NODE_ROLE.lower() in PRODUCTION_ROLES:
+    for var in ["CELERY_TRACE_APP", "CELERY_DEBUG"]:
+        os.environ.pop(var, None)
+    os.environ.setdefault("CELERY_LOG_LEVEL", "INFO")
+
+app = Celery("config")
+app.config_from_object("django.conf:settings", namespace="CELERY")
+app.autodiscover_tasks()
+
+
+@app.task(bind=True)
+def debug_task(self):  # pragma: no cover - debug helper
+    """A simple debug task."""
+    print(f"Request: {self.request!r}")

config/context_processors.py

@@ -1,68 +1,67 @@
-import socket
-
-from django.contrib.sites.models import Site
-from django.http import HttpRequest
-from django.conf import settings
-
-
-def site_and_node(request: HttpRequest):
-    """Provide current Site and Node based on request host.
-
-    Returns a dict with keys ``badge_site`` and ``badge_node``.
-    ``badge_site`` is a ``Site`` instance or ``None`` if no match.
-    ``badge_node`` is a ``Node`` instance or ``None`` if no match.
-    ``badge_site_color`` and ``badge_node_color`` provide the configured colors.
-    """
-    host = request.get_host().split(":")[0]
-    site = Site.objects.filter(domain__iexact=host).first()
-
-    node = None
-    try:
-        from nodes.models import Node
-
-        node = Node.get_local()
-        if not node:
-            hostname = socket.gethostname()
-            try:
-                addresses = socket.gethostbyname_ex(hostname)[2]
-            except socket.gaierror:
-                addresses = []
-
-            node = Node.objects.filter(hostname__iexact=hostname).first()
-            if not node:
-                for addr in addresses:
-                    node = Node.objects.filter(address=addr).first()
-                    if node:
-                        break
-            if not node:
-                node = (
-                    Node.objects.filter(hostname__iexact=host).first()
-                    or Node.objects.filter(address=host).first()
-                )
-    except Exception:
-        node = None
-
-    site_color = "#28a745"
-    if site:
-        try:
-            site_color = site.badge.badge_color
-        except Exception:
-            pass
-
-    node_color = "#28a745"
-    if node:
-        node_color = node.badge_color
-
-    site_name = site.name if site else ""
-    node_role_name = node.role.name if node and node.role else ""
-    return {
-        "badge_site": site,
-        "badge_node": node,
-        # Public views fall back to the node role when the site name is blank.
-        "badge_site_name": site_name or node_role_name,
-        # Admin site badge uses the site display name if set, otherwise the domain.
-        "badge_admin_site_name": site_name or (site.domain if site else ""),
-        "badge_site_color": site_color,
-        "badge_node_color": node_color,
-        "TIME_ZONE": settings.TIME_ZONE,
-    }
+import socket
+
+from django.contrib.sites.models import Site
+from django.http import HttpRequest
+from django.conf import settings
+
+
+DEFAULT_BADGE_COLOR = "#28a745"
+UNKNOWN_BADGE_COLOR = "#6c757d"
+
+
+def site_and_node(request: HttpRequest):
+    """Provide current Site and Node based on request host.
+
+    Returns a dict with keys ``badge_site`` and ``badge_node``.
+    ``badge_site`` is a ``Site`` instance or ``None`` if no match.
+    ``badge_node`` is a ``Node`` instance or ``None`` if no match.
+    ``badge_site_color`` and ``badge_node_color`` report the palette color used
+    for the corresponding badge. Badges always use green when the entity is
+    known and grey when the value cannot be determined.
+    """
+    host = request.get_host().split(":")[0]
+    site = Site.objects.filter(domain__iexact=host).first()
+
+    node = None
+    try:
+        from nodes.models import Node
+
+        node = Node.get_local()
+        if not node:
+            hostname = socket.gethostname()
+            try:
+                addresses = socket.gethostbyname_ex(hostname)[2]
+            except socket.gaierror:
+                addresses = []
+
+            node = Node.objects.filter(hostname__iexact=hostname).first()
+            if not node:
+                for addr in addresses:
+                    node = Node.objects.filter(address=addr).first()
+                    if node:
+                        break
+            if not node:
+                node = (
+                    Node.objects.filter(hostname__iexact=host).first()
+                    or Node.objects.filter(address=host).first()
+                )
+    except Exception:
+        node = None
+
+    site_color = DEFAULT_BADGE_COLOR if site else UNKNOWN_BADGE_COLOR
+    node_color = DEFAULT_BADGE_COLOR if node else UNKNOWN_BADGE_COLOR
+
+    site_name = site.name if site else ""
+    node_role_name = node.role.name if node and node.role else ""
+    return {
+        "badge_site": site,
+        "badge_node": node,
+        # Public views fall back to the node role when the site name is blank.
+        "badge_site_name": site_name or node_role_name,
+        # Admin site badge uses the site display name if set, otherwise the domain.
+        "badge_admin_site_name": site_name or (site.domain if site else ""),
+        "badge_site_color": site_color,
+        "badge_node_color": node_color,
+        "current_site_domain": site.domain if site else host,
+        "TIME_ZONE": settings.TIME_ZONE,
+    }

config/horologia_app.py

@@ -1,7 +1,7 @@
-from django_celery_beat.apps import BeatConfig as BaseBeatConfig
-
-
-class HorologiaConfig(BaseBeatConfig):
-    """Customize Periodic Tasks app label."""
-
-    verbose_name = "5. Horologia"
+from django_celery_beat.apps import BeatConfig as BaseBeatConfig
+
+
+class HorologiaConfig(BaseBeatConfig):
+    """Customize Periodic Tasks app label."""
+
+    verbose_name = "5. Horologia"

config/loadenv.py

@@ -1,11 +1,11 @@
-from pathlib import Path
-from dotenv import load_dotenv
-
-
-BASE_DIR = Path(__file__).resolve().parent.parent
-
-
-def loadenv() -> None:
-    """Load all .env files from the repository root."""
-    for env_file in sorted(BASE_DIR.glob("*.env")):
-        load_dotenv(env_file, override=False)
+from pathlib import Path
+from dotenv import load_dotenv
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+def loadenv() -> None:
+    """Load all .env files from the repository root."""
+    for env_file in sorted(BASE_DIR.glob("*.env")):
+        load_dotenv(env_file, override=False)

config/logging.py

@@ -1,48 +1,59 @@
-import sys
-import os
-import glob
-import logging
-from logging.handlers import TimedRotatingFileHandler
-from pathlib import Path
-from django.conf import settings
-
-from .active_app import get_active_app
-
-
-class ActiveAppFileHandler(TimedRotatingFileHandler):
-    """File handler that writes to a file named after the active app."""
-
-    def _current_file(self) -> Path:
-        log_dir = Path(settings.LOG_DIR)
-        log_dir.mkdir(parents=True, exist_ok=True)
-        if "test" in sys.argv:
-            return log_dir / "tests.log"
-        return log_dir / f"{get_active_app()}.log"
-
-    def emit(self, record: logging.LogRecord) -> None:
-        current = str(self._current_file())
-        if self.baseFilename != current:
-            self.baseFilename = current
-            Path(self.baseFilename).parent.mkdir(parents=True, exist_ok=True)
-            if self.stream:
-                self.stream.close()
-            self.stream = self._open()
-        super().emit(record)
-
-    def rotation_filename(self, default_name: str) -> str:
-        """Place rotated logs inside the old log directory."""
-        default_path = Path(default_name)
-        old_log_dir = Path(settings.OLD_LOG_DIR)
-        old_log_dir.mkdir(parents=True, exist_ok=True)
-        return str(old_log_dir / default_path.name)
-
-    def getFilesToDelete(self):
-        """Return files to delete in the old log directory respecting backupCount."""
-        if self.backupCount <= 0:
-            return []
-        _, base_name = os.path.split(self.baseFilename)
-        files = glob.glob(os.path.join(settings.OLD_LOG_DIR, base_name + ".*"))
-        files.sort()
-        if len(files) <= self.backupCount:
-            return []
-        return files[: len(files) - self.backupCount]
+import sys
+import os
+import glob
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+from django.conf import settings
+
+from .active_app import get_active_app
+
+
+class ActiveAppFileHandler(TimedRotatingFileHandler):
+    """File handler that writes to a file named after the active app."""
+
+    def _current_file(self) -> Path:
+        log_dir = Path(settings.LOG_DIR)
+        log_dir.mkdir(parents=True, exist_ok=True)
+        if "test" in sys.argv:
+            return log_dir / "tests.log"
+        return log_dir / f"{get_active_app()}.log"
+
+    def emit(self, record: logging.LogRecord) -> None:
+        current = str(self._current_file())
+        if self.baseFilename != current:
+            self.baseFilename = current
+            Path(self.baseFilename).parent.mkdir(parents=True, exist_ok=True)
+            if self.stream:
+                self.stream.close()
+            self.stream = self._open()
+        super().emit(record)
+
+    def rotation_filename(self, default_name: str) -> str:
+        """Place rotated logs inside the old log directory."""
+        default_path = Path(default_name)
+        old_log_dir = Path(settings.OLD_LOG_DIR)
+        old_log_dir.mkdir(parents=True, exist_ok=True)
+        return str(old_log_dir / default_path.name)
+
+    def getFilesToDelete(self):
+        """Return files to delete in the old log directory respecting backupCount."""
+        if self.backupCount <= 0:
+            return []
+        _, base_name = os.path.split(self.baseFilename)
+        files = glob.glob(os.path.join(settings.OLD_LOG_DIR, base_name + ".*"))
+        files.sort()
+        if len(files) <= self.backupCount:
+            return []
+        return files[: len(files) - self.backupCount]
+
+
+class ErrorFileHandler(ActiveAppFileHandler):
+    """File handler dedicated to capturing application errors."""
+
+    def _current_file(self) -> Path:
+        log_dir = Path(settings.LOG_DIR)
+        log_dir.mkdir(parents=True, exist_ok=True)
+        if "test" in sys.argv:
+            return log_dir / "tests-error.log"
+        return log_dir / "error.log"

config/middleware.py

@@ -1,25 +1,71 @@
-from utils.sites import get_site
-import socket
-from nodes.models import Node
-
-from .active_app import set_active_app
-
-
-class ActiveAppMiddleware:
-    """Store the current app based on the request's site."""
-
-    def __init__(self, get_response):
-        self.get_response = get_response
-
-    def __call__(self, request):
-        site = get_site(request)
-        node = Node.get_local()
-        role_name = node.role.name if node and node.role else "Terminal"
-        active = site.name or role_name
-        set_active_app(active)
-        request.active_app = active
-        try:
-            response = self.get_response(request)
-        finally:
-            set_active_app(socket.gethostname())
-        return response
+import socket
+from django.core.exceptions import DisallowedHost
+from django.http import HttpResponsePermanentRedirect
+from nodes.models import Node
+from utils.sites import get_site
+
+from .active_app import set_active_app
+
+
+class ActiveAppMiddleware:
+    """Store the current app based on the request's site."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = get_site(request)
+        node = Node.get_local()
+        role_name = node.role.name if node and node.role else "Terminal"
+        active = site.name or role_name
+        set_active_app(active)
+        request.site = site
+        request.active_app = active
+        try:
+            response = self.get_response(request)
+        finally:
+            set_active_app(socket.gethostname())
+        return response
+
+
+def _is_https_request(request) -> bool:
+    if request.is_secure():
+        return True
+
+    forwarded_proto = request.META.get("HTTP_X_FORWARDED_PROTO", "")
+    if forwarded_proto:
+        candidate = forwarded_proto.split(",")[0].strip().lower()
+        if candidate == "https":
+            return True
+
+    forwarded_header = request.META.get("HTTP_FORWARDED", "")
+    for forwarded_part in forwarded_header.split(","):
+        for element in forwarded_part.split(";"):
+            key, _, value = element.partition("=")
+            if key.strip().lower() == "proto" and value.strip().strip('"').lower() == "https":
+                return True
+
+    return False
+
+
+class SiteHttpsRedirectMiddleware:
+    """Redirect HTTP traffic to HTTPS for sites that require it."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = getattr(request, "site", None)
+        if site is None:
+            site = get_site(request)
+            request.site = site
+
+        if getattr(site, "require_https", False) and not _is_https_request(request):
+            try:
+                host = request.get_host()
+            except DisallowedHost:  # pragma: no cover - defensive guard
+                host = request.META.get("HTTP_HOST", "")
+            redirect_url = f"https://{host}{request.get_full_path()}"
+            return HttpResponsePermanentRedirect(redirect_url)
+
+        return self.get_response(request)

config/offline.py

@@ -1,49 +1,49 @@
-import os
-import functools
-import asyncio
-
-
-class OfflineError(RuntimeError):
-    """Raised when a network operation is attempted in offline mode."""
-
-
-def _is_offline() -> bool:
-    flag = os.environ.get("ARTHEXIS_OFFLINE", "").lower()
-    return flag not in ("", "0", "false", "no")
-
-
-def requires_network(func):
-    """Decorator that blocks execution when offline mode is enabled.
-
-    When the environment variable ``ARTHEXIS_OFFLINE`` is set to a truthy value,
-    any function decorated with ``@requires_network`` will raise
-    :class:`OfflineError` before executing. Works with both synchronous and
-    asynchronous callables.
-    """
-
-    if asyncio.iscoroutinefunction(func):
-
-        @functools.wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            if _is_offline():
-                raise OfflineError(f"{func.__name__} requires network access")
-            return await func(*args, **kwargs)
-
-        return async_wrapper
-
-    @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
-        if _is_offline():
-            raise OfflineError(f"{func.__name__} requires network access")
-        return func(*args, **kwargs)
-
-    return sync_wrapper
-
-
-def network_available() -> bool:
-    """Return ``True`` if network operations are permitted."""
-
-    return not _is_offline()
-
-
-__all__ = ["OfflineError", "requires_network", "network_available"]
+import os
+import functools
+import asyncio
+
+
+class OfflineError(RuntimeError):
+    """Raised when a network operation is attempted in offline mode."""
+
+
+def _is_offline() -> bool:
+    flag = os.environ.get("ARTHEXIS_OFFLINE", "").lower()
+    return flag not in ("", "0", "false", "no")
+
+
+def requires_network(func):
+    """Decorator that blocks execution when offline mode is enabled.
+
+    When the environment variable ``ARTHEXIS_OFFLINE`` is set to a truthy value,
+    any function decorated with ``@requires_network`` will raise
+    :class:`OfflineError` before executing. Works with both synchronous and
+    asynchronous callables.
+    """
+
+    if asyncio.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            if _is_offline():
+                raise OfflineError(f"{func.__name__} requires network access")
+            return await func(*args, **kwargs)
+
+        return async_wrapper
+
+    @functools.wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        if _is_offline():
+            raise OfflineError(f"{func.__name__} requires network access")
+        return func(*args, **kwargs)
+
+    return sync_wrapper
+
+
+def network_available() -> bool:
+    """Return ``True`` if network operations are permitted."""
+
+    return not _is_offline()
+
+
+__all__ = ["OfflineError", "requires_network", "network_available"]