django-components-lite 0.1.0__tar.gz

django_components_lite-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+
+# Unit test / coverage reports
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+.pytest_cache/
+
+# Django
+*.log
+*.sqlite3
+
+# Python environment
+.venv/
+.mypy_cache/
+.ruff_cache/
+
+# Build artifacts
+site/
+.DS_Store
+.claude/worktrees/

django_components_lite-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2019 Emil Stenström
+Copyright (c) 2026 Oliver Haas
+
+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.

django_components_lite-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: django-components-lite
+Version: 0.1.0
+Summary: Lightweight reusable template components for Django. An exploratory fork of django-components.
+Project-URL: Homepage, https://github.com/oliverhaas/django-components-lite
+Project-URL: Documentation, https://oliverhaas.github.io/django-components-lite/
+Project-URL: Issues, https://github.com/oliverhaas/django-components-lite/issues
+Author-email: Oliver Haas <ohaas@e1plus.de>
+License: MIT
+License-File: LICENSE
+Keywords: components,css,django,html,js
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: django<7,>=5.2
+Description-Content-Type: text/markdown
+
+# django-components-lite
+
+**An exploratory, lightweight fork of [django-components](https://github.com/django-components/django-components).**
+
+This package strips django-components down to its core: simple, reusable template components for Django, just templates with some optional python logic. The goal is to see how a minimal django-components feels in practice.
+
+## Attribution
+
+This project is built on the excellent work of the **[django-components](https://github.com/django-components/django-components)** project by **[Emil Stenström](https://github.com/EmilStenstrom)**, **[Juro Oravec](https://github.com/JuroOravec)**, and [all contributors](https://github.com/django-components/django-components/graphs/contributors). Their years of work made this possible.
+
+**If you're looking for a mature, full-featured, and battle-tested component library for Django, use [django-components](https://github.com/django-components/django-components).** It has an active community, extensive documentation, and a rich feature set.
+
+
+## Features
+
+What django-components-lite keeps from django-components:
+
+- Component classes with Python logic and Django templates
+- `{% component %}` / `{% endcomponent %}` template tags
+- Slots and fills (`{% slot %}`, `{% fill %}`)
+- Component autodiscovery
+- Component registry
+- Static file handling (JS/CSS)
+- Isolated component context
+- HTML attribute rendering utilities
+
+## What's removed?
+
+Compared to django-components, the following have been stripped out:
+
+- Extension system
+- Built-in components (DynamicComponent, ErrorFallback)
+- Component caching
+- Provide/Inject system
+- Template expressions
+- Management commands
+- JS/CSS data methods and dependency management
+- Type validation (Args/Kwargs/Slots/TemplateData)
+- `on_render()` generator system and deferred rendering
+- `context_behavior` setting (always isolated, like Django's `inclusion_tag`)
+- Tag formatters
+- Component views and URLs
+- `libraries` setting and `import_libraries()`
+- `reload_on_file_change` setting
+- All deprecated setting aliases
+
+## Installation
+
+```bash
+pip install django-components-lite
+```
+
+Add to your Django settings:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_components_lite",
+]
+```
+
+## Quick example
+
+```python
+# myapp/components/greeting/greeting.py
+from django_components_lite import Component
+
+class Greeting(Component):
+    template_name = "greeting/greeting.html"
+
+    def get_context_data(self, name):
+        return {"name": name}
+```
+
+```html
+<!-- myapp/components/greeting/greeting.html -->
+<div class="greeting">
+  Hello, {{ name }}!
+  {% slot "extra" %}{% endslot %}
+</div>
+```
+
+```html
+<!-- In any template -->
+{% load component_tags %}
+{% component "greeting" name="World" %}
+  {% fill "extra" %}
+    <p>Welcome!</p>
+  {% endfill %}
+{% endcomponent %}
+```
+
+## Links
+
+- [django-components (original)](https://github.com/django-components/django-components)  -  the full-featured upstream project
+- [Documentation](https://oliverhaas.github.io/django-components-lite/)
+- [Issues](https://github.com/oliverhaas/django-components-lite/issues)
+
+## License
+
+MIT  -  see [LICENSE](LICENSE).

django_components_lite-0.1.0/README.md

@@ -0,0 +1,101 @@
+# django-components-lite
+
+**An exploratory, lightweight fork of [django-components](https://github.com/django-components/django-components).**
+
+This package strips django-components down to its core: simple, reusable template components for Django, just templates with some optional python logic. The goal is to see how a minimal django-components feels in practice.
+
+## Attribution
+
+This project is built on the excellent work of the **[django-components](https://github.com/django-components/django-components)** project by **[Emil Stenström](https://github.com/EmilStenstrom)**, **[Juro Oravec](https://github.com/JuroOravec)**, and [all contributors](https://github.com/django-components/django-components/graphs/contributors). Their years of work made this possible.
+
+**If you're looking for a mature, full-featured, and battle-tested component library for Django, use [django-components](https://github.com/django-components/django-components).** It has an active community, extensive documentation, and a rich feature set.
+
+
+## Features
+
+What django-components-lite keeps from django-components:
+
+- Component classes with Python logic and Django templates
+- `{% component %}` / `{% endcomponent %}` template tags
+- Slots and fills (`{% slot %}`, `{% fill %}`)
+- Component autodiscovery
+- Component registry
+- Static file handling (JS/CSS)
+- Isolated component context
+- HTML attribute rendering utilities
+
+## What's removed?
+
+Compared to django-components, the following have been stripped out:
+
+- Extension system
+- Built-in components (DynamicComponent, ErrorFallback)
+- Component caching
+- Provide/Inject system
+- Template expressions
+- Management commands
+- JS/CSS data methods and dependency management
+- Type validation (Args/Kwargs/Slots/TemplateData)
+- `on_render()` generator system and deferred rendering
+- `context_behavior` setting (always isolated, like Django's `inclusion_tag`)
+- Tag formatters
+- Component views and URLs
+- `libraries` setting and `import_libraries()`
+- `reload_on_file_change` setting
+- All deprecated setting aliases
+
+## Installation
+
+```bash
+pip install django-components-lite
+```
+
+Add to your Django settings:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "django_components_lite",
+]
+```
+
+## Quick example
+
+```python
+# myapp/components/greeting/greeting.py
+from django_components_lite import Component
+
+class Greeting(Component):
+    template_name = "greeting/greeting.html"
+
+    def get_context_data(self, name):
+        return {"name": name}
+```
+
+```html
+<!-- myapp/components/greeting/greeting.html -->
+<div class="greeting">
+  Hello, {{ name }}!
+  {% slot "extra" %}{% endslot %}
+</div>
+```
+
+```html
+<!-- In any template -->
+{% load component_tags %}
+{% component "greeting" name="World" %}
+  {% fill "extra" %}
+    <p>Welcome!</p>
+  {% endfill %}
+{% endcomponent %}
+```
+
+## Links
+
+- [django-components (original)](https://github.com/django-components/django-components)  -  the full-featured upstream project
+- [Documentation](https://oliverhaas.github.io/django-components-lite/)
+- [Issues](https://github.com/oliverhaas/django-components-lite/issues)
+
+## License
+
+MIT  -  see [LICENSE](LICENSE).

django_components_lite-0.1.0/django_components_lite/__init__.py

@@ -0,0 +1,72 @@
+"""Main package for Django Components."""
+
+# Public API
+# isort: off
+from django_components_lite.app_settings import ComponentsSettings
+from django_components_lite.attributes import format_attributes, merge_attributes
+from django_components_lite.autodiscovery import autodiscover
+from django_components_lite.component import (
+    Component,
+    ComponentNode,
+    ComponentVars,
+    all_components,
+    get_component_by_class_id,
+)
+from django_components_lite.component_registry import (
+    AlreadyRegisteredError,
+    ComponentRegistry,
+    NotRegisteredError,
+    RegistrySettings,
+    register,
+    registry,
+    all_registries,
+)
+
+from django_components_lite.library import TagProtectedError
+from django_components_lite.slots import (
+    FillNode,
+    Slot,
+    SlotContext,
+    SlotFallback,
+    SlotFunc,
+    SlotInput,
+    SlotNode,
+    SlotResult,
+)
+from django_components_lite.util.loader import ComponentFileEntry, get_component_dirs, get_component_files
+from django_components_lite.util.types import Empty
+
+# isort: on
+
+
+__all__ = [
+    "AlreadyRegisteredError",
+    "Component",
+    "ComponentFileEntry",
+    "ComponentNode",
+    "ComponentRegistry",
+    "ComponentVars",
+    "ComponentsSettings",
+    "Empty",
+    "FillNode",
+    "NotRegisteredError",
+    "RegistrySettings",
+    "Slot",
+    "SlotContext",
+    "SlotFallback",
+    "SlotFunc",
+    "SlotInput",
+    "SlotNode",
+    "SlotResult",
+    "TagProtectedError",
+    "all_components",
+    "all_registries",
+    "autodiscover",
+    "format_attributes",
+    "get_component_by_class_id",
+    "get_component_dirs",
+    "get_component_files",
+    "merge_attributes",
+    "register",
+    "registry",
+]

django_components_lite-0.1.0/django_components_lite/app_settings.py

@@ -0,0 +1,316 @@
+# ruff: noqa: N802
+import re
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from os import PathLike
+from pathlib import Path
+from typing import (
+    NamedTuple,
+    TypeVar,
+    cast,
+)
+
+from django.conf import settings
+
+from django_components_lite.util.misc import default
+
+T = TypeVar("T")
+
+
+# This is the source of truth for the settings that are available. If the documentation
+# or the defaults do NOT match this, they should be updated.
+class ComponentsSettings(NamedTuple):
+    """
+    Settings available for django_components_lite.
+
+    **Example:**
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        autodiscover=False,
+        dirs = [BASE_DIR / "components"],
+    )
+    ```
+    """
+
+    autodiscover: bool | None = None
+    """
+    Toggle whether to run [autodiscovery](../concepts/fundamentals/autodiscovery.md) at the Django server startup.
+
+    Defaults to `True`
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        autodiscover=False,
+    )
+    ```
+    """
+
+    dirs: Sequence[str | PathLike | tuple[str, str] | tuple[str, PathLike]] | None = None
+    """
+    Specify the directories that contain your components.
+
+    Defaults to `[Path(settings.BASE_DIR) / "components"]`. That is, the root `components/` app.
+
+    Directories must be full paths, same as with
+    [STATICFILES_DIRS](https://docs.djangoproject.com/en/5.2/ref/settings/#std-setting-STATICFILES_DIRS).
+
+    These locations are searched during [autodiscovery](../concepts/fundamentals/autodiscovery.md),
+    or when you [define HTML, JS, or CSS as separate files](../concepts/fundamentals/html_js_css_files.md).
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        dirs=[BASE_DIR / "components"],
+    )
+    ```
+
+    Set to empty list to disable global components directories:
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        dirs=[],
+    )
+    ```
+    """
+
+    app_dirs: Sequence[str] | None = None
+    """
+    Specify the app-level directories that contain your components.
+
+    Defaults to `["components"]`. That is, for each Django app, we search `<app>/components/` for components.
+
+    The paths must be relative to app, e.g.:
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        app_dirs=["my_comps"],
+    )
+    ```
+
+    To search for `<app>/my_comps/`.
+
+    These locations are searched during [autodiscovery](../concepts/fundamentals/autodiscovery.md),
+    or when you [define HTML, JS, or CSS as separate files](../concepts/fundamentals/html_js_css_files.md).
+
+    Set to empty list to disable app-level components:
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        app_dirs=[],
+    )
+    ```
+    """
+
+    multiline_tags: bool | None = None
+    """
+    Enable / disable
+    [multiline support for template tags](../concepts/fundamentals/template_tag_syntax.md#multiline-tags).
+    If `True`, template tags like `{% component %}` or `{{ my_var }}` can span multiple lines.
+
+    Defaults to `True`.
+
+    Disable this setting if you are making custom modifications to Django's
+    regular expression for parsing templates at `django.template.base.tag_re`.
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        multiline_tags=False,
+    )
+    ```
+    """
+
+    static_files_allowed: list[str | re.Pattern] | None = None
+    """
+    A list of file extensions (including the leading dot) that define which files within
+    [`COMPONENTS.dirs`](./settings.md#django_components_lite.app_settings.ComponentsSettings.dirs)
+    or
+    [`COMPONENTS.app_dirs`](./settings.md#django_components_lite.app_settings.ComponentsSettings.app_dirs)
+    are treated as [static files](https://docs.djangoproject.com/en/5.2/howto/static-files/).
+
+    If a file is matched against any of the patterns, it's considered a static file. Such files are collected
+    when running [`collectstatic`](https://docs.djangoproject.com/en/5.2/ref/contrib/staticfiles/#collectstatic),
+    and can be accessed under the
+    [static file endpoint](https://docs.djangoproject.com/en/5.2/ref/settings/#static-url).
+
+    You can also pass in compiled regexes ([`re.Pattern`](https://docs.python.org/3/library/re.html#re.Pattern))
+    for more advanced patterns.
+
+    By default, JS, CSS, and common image and font file formats are considered static files:
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        static_files_allowed=[
+            ".css",
+            ".js", ".jsx", ".ts", ".tsx",
+            # Images
+            ".apng", ".png", ".avif", ".gif", ".jpg",
+            ".jpeg",  ".jfif", ".pjpeg", ".pjp", ".svg",
+            ".webp", ".bmp", ".ico", ".cur", ".tif", ".tiff",
+            # Fonts
+            ".eot", ".ttf", ".woff", ".otf", ".svg",
+        ],
+    )
+    ```
+
+    !!! warning
+
+        Exposing your Python files can be a security vulnerability.
+        See [Security notes](../overview/security_notes.md).
+    """
+
+    static_files_forbidden: list[str | re.Pattern] | None = None
+    """
+    A list of file extensions (including the leading dot) that define which files within
+    [`COMPONENTS.dirs`](./settings.md#django_components_lite.app_settings.ComponentsSettings.dirs)
+    or
+    [`COMPONENTS.app_dirs`](./settings.md#django_components_lite.app_settings.ComponentsSettings.app_dirs)
+    will NEVER be treated as [static files](https://docs.djangoproject.com/en/5.2/howto/static-files/).
+
+    If a file is matched against any of the patterns, it will never be considered a static file,
+    even if the file matches a pattern in
+    [`static_files_allowed`](./settings.md#django_components_lite.app_settings.ComponentsSettings.static_files_allowed).
+
+    Use this setting together with
+    [`static_files_allowed`](./settings.md#django_components_lite.app_settings.ComponentsSettings.static_files_allowed)
+    for a fine control over what file types will be exposed.
+
+    You can also pass in compiled regexes ([`re.Pattern`](https://docs.python.org/3/library/re.html#re.Pattern))
+    for more advanced patterns.
+
+    By default, any HTML and Python are considered NOT static files:
+
+    ```python
+    COMPONENTS = ComponentsSettings(
+        static_files_forbidden=[
+            ".html", ".django", ".dj", ".tpl",
+            # Python files
+            ".py", ".pyc",
+        ],
+    )
+    ```
+
+    !!! warning
+
+        Exposing your Python files can be a security vulnerability.
+        See [Security notes](../overview/security_notes.md).
+    """
+
+
+# NOTE: Some defaults depend on the Django settings, which may not yet be
+# initialized at the time that these settings are generated. For such cases
+# we define the defaults as a factory function, and use the `Dynamic` class to
+# mark such fields.
+@dataclass(frozen=True)
+class Dynamic[T]:
+    getter: Callable[[], T]
+
+
+# This is the source of truth for the settings defaults. If the documentation
+# does NOT match it, the documentation should be updated.
+#
+# NOTE: Because we need to access Django settings to generate default dirs
+#       for `COMPONENTS.dirs`, we do it lazily.
+# NOTE 2: We show the defaults in the documentation, together with the comments
+#        (except for the `Dynamic` instances and comments like `type: ignore`).
+#        So `fmt: off` turns off Black/Ruff formatting and `snippet:defaults` allows
+#        us to extract the snippet from the file.
+#
+# fmt: off
+# --snippet:defaults--
+defaults = ComponentsSettings(
+    autodiscover=True,
+    # Root-level "components" dirs, e.g. `/path/to/proj/components/`
+    dirs=Dynamic(lambda: [Path(settings.BASE_DIR) / "components"]),  # type: ignore[arg-type]
+    # App-level "components" dirs, e.g. `[app]/components/`
+    app_dirs=["components"],
+    multiline_tags=True,
+    static_files_allowed=[
+        ".css",
+        ".js", ".jsx", ".ts", ".tsx",
+        # Images
+        ".apng", ".png", ".avif", ".gif", ".jpg",
+        ".jpeg", ".jfif", ".pjpeg", ".pjp", ".svg",
+        ".webp", ".bmp", ".ico", ".cur", ".tif", ".tiff",
+        # Fonts
+        ".eot", ".ttf", ".woff", ".otf", ".svg",
+    ],
+    static_files_forbidden=[
+        # See https://marketplace.visualstudio.com/items?itemName=junstyle.vscode-django-support
+        ".html", ".django", ".dj", ".tpl",
+        # Python files
+        ".py", ".pyc",
+    ],
+)
+# --endsnippet:defaults--
+# fmt: on
+
+
+# Interface through which we access the settings.
+#
+# This is the only place where we actually access the settings.
+# The settings are merged with defaults, and then validated.
+#
+# The settings are then available through the `app_settings` object.
+#
+# Settings are loaded from Django settings only once, at `apps.py` in `ready()`.
+class InternalSettings:
+    def __init__(self) -> None:
+        self._settings: ComponentsSettings | None = None
+
+    def _load_settings(self) -> None:
+        data = getattr(settings, "COMPONENTS", {})
+        components_settings = ComponentsSettings(**data) if not isinstance(data, ComponentsSettings) else data
+
+        # Merge we defaults and otherwise initialize if necessary
+
+        # For DIRS setting, we use a getter for the default value, because the default value
+        # uses Django settings, which may not yet be initialized at the time these settings are generated.
+        dirs_default_fn = cast("Dynamic[Sequence[str | tuple[str, str]]]", defaults.dirs)
+        dirs_default = dirs_default_fn.getter()
+
+        self._settings = ComponentsSettings(
+            autodiscover=default(components_settings.autodiscover, defaults.autodiscover),
+            dirs=default(components_settings.dirs, dirs_default),
+            app_dirs=default(components_settings.app_dirs, defaults.app_dirs),
+            multiline_tags=default(components_settings.multiline_tags, defaults.multiline_tags),
+            static_files_allowed=default(components_settings.static_files_allowed, defaults.static_files_allowed),
+            static_files_forbidden=self._prepare_static_files_forbidden(components_settings),
+        )
+
+    def _get_settings(self) -> ComponentsSettings:
+        if self._settings is None:
+            self._load_settings()
+        return cast("ComponentsSettings", self._settings)
+
+    def _prepare_static_files_forbidden(self, new_settings: ComponentsSettings) -> list[str | re.Pattern]:
+        return default(
+            new_settings.static_files_forbidden,
+            cast("list[str | re.Pattern]", defaults.static_files_forbidden),
+        )
+
+    @property
+    def AUTODISCOVER(self) -> bool:
+        return self._get_settings().autodiscover  # type: ignore[return-value]
+
+    @property
+    def DIRS(self) -> Sequence[str | PathLike | tuple[str, str] | tuple[str, PathLike]]:
+        return self._get_settings().dirs  # type: ignore[return-value]
+
+    @property
+    def APP_DIRS(self) -> Sequence[str]:
+        return self._get_settings().app_dirs  # type: ignore[return-value]
+
+    @property
+    def MULTILINE_TAGS(self) -> bool:
+        return self._get_settings().multiline_tags  # type: ignore[return-value]
+
+    @property
+    def STATIC_FILES_ALLOWED(self) -> Sequence[str | re.Pattern]:
+        return self._get_settings().static_files_allowed  # type: ignore[return-value]
+
+    @property
+    def STATIC_FILES_FORBIDDEN(self) -> Sequence[str | re.Pattern]:
+        return self._get_settings().static_files_forbidden  # type: ignore[return-value]
+
+
+app_settings = InternalSettings()