simpledomcontrol 0.158.8__tar.gz → 0.159.0__tar.gz

simpledomcontrol-0.159.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Martin Starman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/PKG-INFO

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: SimpleDomControl
-Version: 0.158.8
+Version: 0.159.0
 Summary: Simple DOM control -> a django MVC framework
-License: Apache-2.0
+License-Expression: MIT
+License-File: LICENSE
 Keywords: django,MVC
 Author: Martin Starman
 Author-email: private@martin-starman.com
 Requires-Python: >=3.13,<4.0
-Classifier: Environment :: Web Environment
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Framework :: Django
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Environment :: Web Environment
+Classifier: Operating System :: OS Independent
+Provides-Extra: postgres
 Requires-Dist: attrs (>=25.4.0,<26.0.0)
 Requires-Dist: channels (>=4.3.2,<5.0.0)
 Requires-Dist: channels-redis (>=4.3.0,<5.0.0)
@@ -22,12 +22,14 @@ Requires-Dist: click (>=8.1.0)
 Requires-Dist: daphne (>=4.2.1,<5.0.0)
 Requires-Dist: django (>=6.0.2,<7.0.0)
 Requires-Dist: inquirerpy (>=0.3.4,<0.4.0)
-Requires-Dist: poetry-core (>=2.3.1,<3.0.0)
-Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0) ; extra == "postgres"
 Requires-Dist: pyjwt (>=2.11.0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
 Requires-Dist: regex (>=2026.1.15,<2027.0.0)
-Project-URL: Homepage, https://github.com/StarmanMartin/sdc
+Project-URL: Documentation, https://simpledomcontrol.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/StarmanMartin/SimpleDomControl
+Project-URL: Repository, https://github.com/StarmanMartin/SimpleDomControl
+Project-URL: changelog, https://github.com/StarmanMartin/SimpleDomControl/blob/master/CHANGELOG.md
 Description-Content-Type: text/markdown
 
 # Simple Dom Control (SDC)

simpledomcontrol-0.159.0/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "SimpleDomControl"
+version = "0.159.0"
+description = "Simple DOM control -> a django MVC framework"
+authors = [{ name = "Martin Starman", email = "private@martin-starman.com" }]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.13,<4.0"
+keywords = ["django", "MVC"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Framework :: Django",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Environment :: Web Environment",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "daphne (>=4.2.1,<5.0.0)",
+    "channels (>=4.3.2,<5.0.0)",
+    "channels-redis (>=4.3.0,<5.0.0)",
+    "django (>=6.0.2,<7.0.0)",
+    "attrs (>=25.4.0,<26.0.0)",
+    "regex (>=2026.1.15,<2027.0.0)",
+    "click (>=8.1.0)",
+    "pyjwt (>=2.11.0,<3.0.0)",
+    "inquirerpy (>=0.3.4,<0.4.0)",
+    "pyyaml (>=6.0.3,<7.0.0)",
+]
+
+[project.optional-dependencies]
+# PostgreSQL driver: pip install "simpledomcontrol[postgres]"
+postgres = ["psycopg2-binary (>=2.9.11,<3.0.0)"]
+
+[project.urls]
+homepage = "https://github.com/StarmanMartin/SimpleDomControl"
+repository = "https://github.com/StarmanMartin/SimpleDomControl"
+documentation = "https://simpledomcontrol.readthedocs.io/en/latest/"
+changelog = "https://github.com/StarmanMartin/SimpleDomControl/blob/master/CHANGELOG.md"
+
+[project.scripts]
+sdc = "sdc.__main__:cli"
+
+[tool.poetry]
+packages = [{include = "sdc_core"}, {include = "sdc_user"}, {include = "sdc_tools"}, {include = "sdc"}]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^9.0.2"
+pillow = "^12.1.0"
+sphinx = "^9.1.0"
+sphinx-toolbox = "^4.1.2"
+sphinx-markdown-builder = "^0.6.9"
+sphinx-rtd-theme = "^3.1.0"
+
+[tool.pytest.ini_options]
+pythonpath = [
+    "."
+]
+testpaths = [
+    "pytests",
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

simpledomcontrol-0.159.0/sdc/__main__.py

@@ -0,0 +1,92 @@
+"""
+Command line tool of SDC: ``sdc new --name <project>`` creates a new Django project with SDC.
+
+Installed as the console script ``sdc`` (also ``python -m sdc``).
+"""
+import os
+import re
+import shutil
+import subprocess
+import sys
+import venv
+from importlib import metadata
+from pathlib import Path
+
+import click
+
+
+def _default_package():
+    """The simpledomcontrol version of this installation, so the new project uses the same one."""
+    try:
+        return f"simpledomcontrol=={metadata.version('SimpleDomControl')}"
+    except metadata.PackageNotFoundError:
+        return "simpledomcontrol"
+
+
+def _run(cmd, cwd):
+    click.echo(f"$ {' '.join(str(c) for c in cmd)}")
+    result = subprocess.run(cmd, cwd=cwd)
+    if result.returncode != 0:
+        raise click.ClickException(f"Command failed with exit code {result.returncode}: {' '.join(map(str, cmd))}")
+
+
+def _venv_python(venv_dir: Path) -> Path:
+    if os.name == "nt":
+        return venv_dir / "Scripts" / "python.exe"
+    return venv_dir / "bin" / "python"
+
+
+def _add_sdc_core(settings_path: Path):
+    text = settings_path.read_text()
+    if "'sdc_core'" in text or '"sdc_core"' in text:
+        return
+    new_text, count = re.subn(r"INSTALLED_APPS\s*=\s*\[", "INSTALLED_APPS = [\n    'sdc_core',", text, count=1)
+    if count != 1:
+        raise click.ClickException(f"INSTALLED_APPS not found in {settings_path}")
+    settings_path.write_text(new_text)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command(help="Creates a new SDC project in the subdirectory NAME of the current directory.")
+@click.option("--name", prompt="Project name", help="Name of the new project (a valid Python identifier).")
+@click.option("--package", default=None,
+              help="pip requirement used to install SDC into the project's virtualenv "
+                   "(default: the installed version, e.g. simpledomcontrol==0.159.0).")
+@click.option("--skip-npm", is_flag=True, help="Do not run 'npm install'.")
+def new(name, package, skip_npm):
+    if not name.isidentifier():
+        raise click.BadParameter("The project name must be a valid Python identifier.", param_hint="--name")
+    target = Path.cwd() / name
+    if target.exists() and any(target.iterdir()):
+        raise click.ClickException(f"{target} already exists and is not empty.")
+    target.mkdir(parents=True, exist_ok=True)
+
+    # The virtualenv is created in its final location; moving a virtualenv breaks it.
+    venv_dir = target / "venv"
+    click.echo(f"Creating virtualenv in {venv_dir}")
+    venv.EnvBuilder(with_pip=True).create(venv_dir)
+    python = _venv_python(venv_dir)
+
+    _run([python, "-m", "pip", "install", "--upgrade", "pip"], target)
+    _run([python, "-m", "pip", "install", package or _default_package()], target)
+    _run([python, "-m", "django", "startproject", name, "."], target)
+    _add_sdc_core(target / name / "settings.py")
+    _run([python, "manage.py", "sdc_init", "-y"], target)
+
+    if skip_npm:
+        click.echo("Skipped 'npm install'.")
+    elif shutil.which("npm"):
+        _run(["npm", "install"], target)
+    else:
+        click.echo("npm was not found; run 'npm install' in the project directory to install the client.")
+
+    click.echo(f"\nDone. Next steps:\n  cd {name}\n  source venv/bin/activate\n"
+               f"  python manage.py migrate\n  npm run develop   # in a second terminal: python manage.py runserver")
+
+
+if __name__ == '__main__':
+    cli()

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/sdc_core/apps.py

@@ -8,7 +8,7 @@ class SdcCoreConfig(AppConfig):
     def ready(self):
         import sys
         from django.conf import settings
-        from sdc_core.signals import set_winner
+        import sdc_core.signals  # noqa: F401 (registers the signal receivers)
 
         if settings.DEBUG and os.path.exists('./Assets'):
             env_vars = {}

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/sdc_core/consumers.py

@@ -6,6 +6,7 @@ import traceback
 from django.apps import apps
 from django.conf import settings
 from django.core.exceptions import PermissionDenied
+from django.core.serializers.json import DjangoJSONEncoder
 from django.core.files.uploadhandler import TemporaryFileUploadHandler
 
 from django.utils.datastructures import MultiValueDict
@@ -14,11 +15,10 @@ from django.utils.translation import gettext as _f
 from django.contrib.auth import get_user_model
 from channels.generic.websocket import WebsocketConsumer, AsyncWebsocketConsumer
 
-from asgiref.sync import async_to_sync
-import importlib
+from asgiref.sync import async_to_sync, sync_to_async
 import json
 
-from sdc_core.sdc_extentions.models import SdcModel, SDCSerializer, all_models, sanitize_filter_query
+from sdc_core.sdc_extentions.models import SdcModel, SDCSerializer, all_models, sanitize_filter_query, resolve_form
 from sdc_core.sdc_extentions.response import sdc_link_factory, sdc_link_obj_factory
 from sdc_core.sdc_extentions.import_manager import import_function
 from sdc_core.sdc_extentions.search import handle_search_form
@@ -68,7 +68,7 @@ class MsgManager:
         return {'save': {'header': f'{model} saved', 'msg': '{0} was successfully saved'},
                 'on_change': {'header': f'{model} was changed', 'msg': '{0} was changed'},
                 'create': {'header': f'{model} created', 'msg': '{0} was successfully created'},
-                'delete': {'header': f'{model} was deleted', 'msg': '{0} was changed'}}
+                'delete': {'header': f'{model} was deleted', 'msg': '{0} was deleted'}}
 
 
 class SDCConsumer(AsyncWebsocketConsumer):
@@ -115,7 +115,7 @@ class SDCConsumer(AsyncWebsocketConsumer):
             'is_error': True,
             'msg': event.get('msg', ''),
             'header': event.get('header', ''),
-        }))
+        }, cls=DjangoJSONEncoder))
 
     @staticmethod
     def to_camel_case(snake_str):
@@ -147,19 +147,25 @@ class SDCConsumer(AsyncWebsocketConsumer):
                 if asyncio.iscoroutinefunction(method):
                     return_vals = await method(self, **json_data.get('args', {}))
                 else:
-                    return_vals = method(self, **json_data.get('args', {}))
+                    # Sync methods run in a worker thread, so they may use the Django ORM.
+                    return_vals = await sync_to_async(method)(self, **json_data.get('args', {}))
 
                 return_vals_generator = []
                 if isinstance(return_vals, types.GeneratorType):
                     return_vals_generator = return_vals
                     return_vals = next(return_vals, None)
 
+                # {'is_error': True, 'msg': ..., 'header': ...} rejects the serverCall promise.
+                if isinstance(return_vals, dict) and return_vals.get('is_error'):
+                    await self.state_error(return_vals, json_data['id'])
+                    return
+
                 await self.send(text_data=json.dumps({
                     'id': json_data['id'],
                     'type': 'sdc_recall',
                     'data': return_vals,
                     'is_error': False
-                }))
+                }, cls=DjangoJSONEncoder))
                 for x in return_vals_generator: pass
             else:
                 raise ValueError("event must be sdc_call")
@@ -190,12 +196,21 @@ class SDCModelConsumer(WebsocketConsumer):
         self.model_name = None
         self.model = None
         self.queryset = {}
-        self.model_id_list = []
+        # Filter of the last full load (connect, load, list_view, named_view). Live updates
+        # (on_create) are checked against it, independent of later form or detail requests.
+        self.live_query = {}
+        # Primary keys of the rows the client has received; on_update/on_delete are only
+        # forwarded for these.
+        self.ids = []
+        self.model_id = None
         self._upload_handler = {}
         self._group_names = []
 
     def connect(self):
         self.model_name = self.scope['url_route']['kwargs']['model_name']
+        # sdc_ws/model/<model_name>/<model_id> restricts the connection to one object.
+        model_id = self.scope['url_route']['kwargs'].get('model_id')
+        self.model_id = int(model_id) if model_id else None
         self.model = ALL_MODELS.get(self.model_name)
         if self.model is None or not hasattr(self.model, '__is_sdc_model__'):
             raise ValueError(f'{self.model_name} is not a SDC model')
@@ -204,22 +219,40 @@ class SDCModelConsumer(WebsocketConsumer):
         self.accept()
 
     def websocket_disconnect(self, close_code):
-        for group in self._group_names:
-            async_to_sync(self.channel_layer.group_discard(group, self.channel_name))
-        hasattr(self.model.SdcMeta, 'on_disconnected') and self.model.SdcMeta.on_disconnected(self._load_model('disconnect'))
-        super().websocket_disconnect(close_code)
+        try:
+            for group in self._group_names:
+                async_to_sync(self.channel_layer.group_discard)(group, self.channel_name)
+            on_disconnected = getattr(self.model.SdcMeta, 'on_disconnected', None) if self.model else None
+            if callable(on_disconnected):
+                on_disconnected(self._load_model('disconnect', self.live_query))
+        except Exception:
+            logger.exception("Error while closing the SDC model connection")
+        finally:
+            super().websocket_disconnect(close_code)
 
     def on_update(self, data):
         if data['pk'] in self.ids:
             self.send(text_data=json.dumps(data))
 
+    def on_delete(self, data):
+        if data['pk'] in self.ids:
+            self.ids.remove(data['pk'])
+            self.send(text_data=json.dumps(data))
+
     def on_create(self, data):
-        instance = data['pk']
+        # Forward only rows the user may see and that match the filter of the last full load.
         try:
-            self._load_model().get(pk=instance)
+            rows = self._load_model('load', self.live_query)
+            if hasattr(rows, 'filter'):
+                visible = rows.filter(pk=data['pk']).exists()
+            else:
+                visible = data['pk'] in self._pks(rows)
+        except Exception:
+            logger.exception("Error while checking a created %s for live updates", self.model_name)
+            visible = False
+        if visible:
+            self._track_ids([data['pk']])
             self.send(text_data=json.dumps(data))
-        except:
-            pass
 
     def state_error(self, event):
         self.send(text_data=json.dumps({
@@ -266,12 +299,7 @@ class SDCModelConsumer(WebsocketConsumer):
             elif event_type == 'model_delete':
                 self._delete_element(json_data)
             elif event_type == 'model_load':
-                self.send(text_data=json.dumps({
-                    'type': json_data['event_type'],
-                    'event_id': json_data['event_id'],
-                    'args': self._prepare_loaded_data(),
-                    'is_error': False
-                }))
+                self._load(json_data)
             else:
                 raise ValueError(
                     f"{json_data['event']} must be 'model' and {json_data['event_type']} must be in [load, delete, upload, create, save, detail_view, 'connect', 'edit_form', 'create_form', 'list_view']")
@@ -287,7 +315,9 @@ class SDCModelConsumer(WebsocketConsumer):
         except Exception as e:
             extracted_list = traceback.extract_tb(e.__traceback__)
             e_text = [e.__str__()] + [item for item in traceback.StackSummary.from_list(extracted_list).format()]
+
             if settings.DEBUG:
+                logger.error(e_text[0])
                 traceback.print_tb(e.__traceback__)
             else:
                 logger.error(e_text)
@@ -317,21 +347,63 @@ class SDCModelConsumer(WebsocketConsumer):
             self.channel_name
         )
 
-    def _load_model(self, event_type=None):
+    def _load_model(self, event_type=None, query=None):
+        """
+        Returns the rows for ``query`` (default: the filter of the current message):
+        ``get_queryset()`` of the model, filtered with the sanitised query, or the
+        result of the model's ``data_load()`` hook if it returns one.
+        """
         if event_type is None:
             event_type = self.scope['event_type']
-        queryset = self.model.get_queryset(self.scope['user'], event_type, self.queryset)
-
-        data_load_result = self.model.data_load(self.scope['user'], queryset, self.queryset)
+        if query is None:
+            query = self.queryset
+        clean_query = sanitize_filter_query(self.model, query)
+        if self.model_id is not None:
+            clean_query['pk'] = self.model_id
+        queryset = self.model.get_queryset(self.scope['user'], event_type, query)
+
+        data_load_result = self.model.data_load(self.scope['user'], queryset, clean_query)
         if data_load_result is not None:
             return data_load_result
-        res = queryset.filter(**sanitize_filter_query(self.model, self.queryset))
-        self.ids = list(res.values_list('id', flat=True))
+        return queryset.filter(**clean_query)
 
-        return res
+    @staticmethod
+    def _pks(rows):
+        if hasattr(rows, 'values_list'):
+            return list(rows.values_list('pk', flat=True))
+        return [row.pk for row in rows]
+
+    def _track_ids(self, pks, replace=False):
+        """Remembers which rows the client has received (for on_update/on_delete)."""
+        if replace:
+            self.ids = list(pks)
+        else:
+            self.ids += [pk for pk in pks if pk not in self.ids]
+
+    def _full_load(self):
+        """Loads with the current filter and makes it the filter for live updates."""
+        self.live_query = dict(self.queryset)
+        rows = self._load_model()
+        self._track_ids(self._pks(rows), replace=True)
+        return rows
+
+    def _load(self, json_data):
+        # queryset.update({item}) loads a single row with {"id": <pk>}: that row is added to
+        # the known rows; any other load replaces them and the live filter.
+        if set(self.queryset.keys()) in ({'id'}, {'pk'}):
+            rows = self._load_model()
+            self._track_ids(self._pks(rows))
+        else:
+            rows = self._full_load()
+        self.send(text_data=json.dumps({
+            'type': json_data['event_type'],
+            'event_id': json_data['event_id'],
+            'args': self._prepare_loaded_data(rows),
+            'is_error': False
+        }))
 
     def _init_connection(self, json_data):
-        self._load_model()
+        self._full_load()
         self._add_to_class()
         # self.model_description =  {field.name: field.__class__.__name__ for field in self.model._meta.fields}
         self.send(text_data=json.dumps({
@@ -360,15 +432,7 @@ class SDCModelConsumer(WebsocketConsumer):
         return self._load_form(json_data, getattr(self.model.SdcMeta, form_name), instance)
 
     def _load_form(self, json_data, form_attr, instance=None):
-        if callable(form_attr):
-            form_attr = form_attr({})
-        if form_attr is None:
-            raise NotImplementedError()
-        elif isinstance(form_attr, str):
-            edit_form_path = form_attr.split('.')
-            form = getattr(importlib.import_module('.'.join(edit_form_path[0:-1])), edit_form_path[-1])
-        else:
-            form = form_attr
+        form = resolve_form(form_attr)
 
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
@@ -422,13 +486,7 @@ class SDCModelConsumer(WebsocketConsumer):
     def _submit_element(self, json_data, form_attr, instance=None):
         data = json_data['args']['data']
         files = json_data['args'].get('files')
-        if form_attr is None:
-            raise NotImplementedError()
-        elif isinstance(form_attr, str):
-            edit_form_path = form_attr.split('.')
-            form = getattr(importlib.import_module('.'.join(edit_form_path[0:-1])), edit_form_path[-1])
-        else:
-            form = form_attr
+        form = resolve_form(form_attr)
         uploads = MultiValueDict()
         if files is not None:
             for (key, val) in files.items():
@@ -442,6 +500,7 @@ class SDCModelConsumer(WebsocketConsumer):
         if is_valid:
             form_instance.save()
             new_instance = SDCSerializer().serialize(self._load_model().filter(pk=form_instance.instance.pk))
+            self._track_ids([form_instance.instance.pk])
             msg = self.msg_manager.get_msg(form_instance.instance, json_data['event_type'])
         else:
             msg = {'header': 'Upss!',
@@ -463,7 +522,7 @@ class SDCModelConsumer(WebsocketConsumer):
         if self.model.SdcMeta.html_list_template is None:
             raise NotImplementedError()
         filter = self.queryset.pop('__search_values', {})
-        loaded_data = self._load_model()
+        loaded_data = self._full_load()
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
@@ -473,10 +532,11 @@ class SDCModelConsumer(WebsocketConsumer):
         }))
 
     def _load_named_view(self, json_data):
-        loaded_data = self._load_model()
+        loaded_data = self._full_load()
         view_name = json_data['args']['view_name']
         if not hasattr(self.model.SdcMeta, view_name):
-            raise NotImplementedError()
+            text = f'"{view_name}" is not implemented in "{loaded_data.__class__.__name__}.SdcMeta".'
+            raise Exception(text)
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
@@ -490,6 +550,7 @@ class SDCModelConsumer(WebsocketConsumer):
             raise NotImplementedError()
         instance = self._load_model().get(pk=json_data['args']['pk'])
         instance.scope = self.scope
+        self._track_ids([instance.pk])
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/sdc_core/jwt_utils.py

@@ -60,6 +60,9 @@ def verify_jwt(token, type):
 
         user = User.objects.get(id=payload["user_id"])
 
+        if not user.is_active:
+            raise jwt.InvalidTokenError
+
         if type == 'refresh' and abs(payload['iat'] - user.last_login.timestamp()) > 10:
             raise jwt.InvalidTokenError
 

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/sdc_core/management/commands/init_add/sdc_core_manager.py

@@ -21,9 +21,10 @@ def add_sdc_to_main_urls(main_urls_path):
             new_apps = "%sre_path('sdc_view/sdc_tools/', include('sdc_tools.sdc_urls')),\n" % options.SEP
             new_apps += "%sre_path('sdc_view/sdc_user/', include('sdc_user.sdc_urls')),\n" % options.SEP
 
+            # The login route must come before sdc_api/<str:model>/, which would match "login" as well.
+            new_apps += f"{options.SEP}path('sdc_api/login/', get_api_token),\n"
             new_apps += f"{options.SEP}path('sdc_api/<str:model>/<int:id>/', AdcApi.as_view()),\n"
             new_apps += f"{options.SEP}path('sdc_api/<str:model>/', AdcApi.as_view()),\n"
-            new_apps += f"{options.SEP}path('sdc_api/login/', get_api_token),\n"
 
             line = re.sub(r'urlpatterns = \[',
                           "urlpatterns = [\n%s%s# scd view below\n" % (new_apps, options.SEP), line)

{simpledomcontrol-0.158.8 → simpledomcontrol-0.159.0}/sdc_core/management/commands/sdc_cc.py

@@ -57,7 +57,6 @@ class Command(BaseCommand):
         if not self.check_snake_name(controller_name):
             exit(1)
         mixin_apps = ops.get('mixin_apps')
-        print(mixin_apps)
         if mixin_apps is True:
             mixin_apps = []
         else: