django-grep 0.1.0__tar.gz

django_grep-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: django-grep
+Version: 0.1.0
+Summary: Core CTC website components, pipelines, and utilities for Wagtail/Django
+Project-URL: Homepage, https://example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Django
+Classifier: Framework :: Wagtail
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: Django
+Requires-Dist: wagtail
+
+# Django GREP
+
+The complete core library for the CTC website (formerly wagtail-ctc), including:
+- **Components**: Block framework for Wagtail.
+- **Pipelines**: Enhanced model workflows and utilities.
+- **Utils**: Shared core utilities.
+
+## Installation
+
+```bash
+pip install django-grep
+```

django_grep-0.1.0/README.md

@@ -0,0 +1,12 @@
+# Django GREP
+
+The complete core library for the CTC website (formerly wagtail-ctc), including:
+- **Components**: Block framework for Wagtail.
+- **Pipelines**: Enhanced model workflows and utilities.
+- **Utils**: Shared core utilities.
+
+## Installation
+
+```bash
+pip install django-grep
+```

django_grep-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-grep"
+version = "0.1.0"
+description = "Core CTC website components, pipelines, and utilities for Wagtail/Django"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Framework :: Django",
+    "Framework :: Wagtail",
+]
+dependencies = [
+    "Django",
+    "wagtail",
+]
+
+[project.urls]
+"Homepage" = "https://example.com"

django_grep-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_grep-0.1.0/src/django_grep/__init__.py

@@ -0,0 +1,2 @@
+from .contrib import *
+from .pipelines.routes.base import Viewset, menu_path, route

django_grep-0.1.0/src/django_grep/components/__init__.py

@@ -0,0 +1,3 @@
+from pluggy import HookimplMarker
+
+hookimpl = HookimplMarker("django_grep.components")

django_grep-0.1.0/src/django_grep/components/_init.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import itertools
+from collections import defaultdict
+from collections.abc import Generator, Iterable
+from dataclasses import dataclass, field
+from hashlib import md5
+from pathlib import Path
+from threading import Lock
+from typing import Any
+
+from django.conf import settings
+from django.template.backends.django import Template as DjangoTemplate
+from django.template.base import Node, NodeList, TextNode
+from django.template.context import Context
+from django.template.loader import select_template
+
+from django_grep.components.conf import _settings
+
+from .params import Param, Params, Value
+from .plugins import pm
+from .staticfiles import Asset, AssetType
+from .templates import (
+    find_components_in_template,
+    get_component_directories,
+    get_template_names,
+)
+from .templatetags.tags.block import BlockNode
+from .templatetags.tags.slot import DEFAULT_SLOT, SlotNode
+
+
+@dataclass(frozen=True, slots=True)
+class Component:
+    name: str
+    template: DjangoTemplate
+    assets: frozenset[Asset] = field(default_factory=frozenset)
+
+    def get_asset(self, asset_filename: str) -> Asset | None:
+        for asset in self.assets:
+            if asset.path.name == asset_filename:
+                return asset
+        return None
+
+    def get_bound_component(self, node: BlockNode):
+        params = Params.from_node(node)
+        return BoundComponent(component=self, params=params, nodelist=node.nodelist)
+
+    @property
+    def data_attribute_name(self):
+        return self.name.replace(".", "-")
+
+    @property
+    def id(self):
+        normalized_source = "".join(self.source.split())
+        hashed = md5(f"{self.name}:{self.path}:{normalized_source}".encode()).hexdigest()
+        return hashed[:7]
+
+    @property
+    def nodelist(self):
+        return self.template.template.nodelist
+
+    @property
+    def path(self):
+        return self.template.template.origin.name
+
+    @property
+    def source(self):
+        return self.template.template.source
+
+    @classmethod
+    def from_abs_path(cls, path: Path) -> Component:
+        template = select_template([str(path)])
+        return cls.from_template(template)
+
+    @classmethod
+    def from_name(cls, name: str) -> Component:
+        template_names = get_template_names(name)
+        template = select_template(template_names)
+        return cls.from_template(template)
+
+    @classmethod
+    def from_template(cls, template: DjangoTemplate) -> Component:
+        template_path = Path(template.template.origin.name)
+
+        for component_dir in get_component_directories():
+            try:
+                relative_path = template_path.relative_to(component_dir)
+                name = str(relative_path.with_suffix("")).replace("/", ".")
+                break
+            except ValueError:
+                continue
+        else:
+            name = template_path.stem
+
+        assets: list[Iterable[Asset]] = pm.hook.collect_component_assets(
+            template_path=Path(template.template.origin.name)
+        )
+
+        return cls(name=name, template=template, assets=frozenset(itertools.chain(*assets)))
+
+
+class SequenceGenerator:
+    _instance: SequenceGenerator | None = None
+    _lock: Lock = Lock()
+    _counters: dict[str, int]
+
+    def __init__(self) -> None:
+        if not hasattr(self, "_counters"):
+            self._counters = {}
+
+    def __new__(cls) -> SequenceGenerator:
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def next(self, component: Component) -> int:
+        with self._lock:
+            current = self._counters.get(component.id, 0) + 1
+            self._counters[component.id] = current
+        return current
+
+
+@dataclass
+class BoundComponent:
+    component: Component
+    params: Params
+    nodelist: NodeList | None
+    _sequence: SequenceGenerator = field(default_factory=SequenceGenerator)
+
+    def render(self, context: Context):
+        if _settings.ENABLE_BLOCK_ATTRS:
+            data_attrs = [
+                Param(
+                    f"data-block-{self.component.data_attribute_name}",
+                    Value(True),
+                ),
+                Param("data-block-id", Value(f'"{self.component.id}-{self.id}"')),
+            ]
+            self.params.attrs.extend(data_attrs)
+
+        props = self.params.render_props(self.component, context)
+        attrs = self.params.render_attrs(context)
+        slots = self.fill_slots(context)
+
+        with context.push(
+            **{
+                "attrs": attrs,
+                "props": props,
+                "slot": slots.get(DEFAULT_SLOT),
+                "slots": slots,
+                "vars": {},
+            }
+        ):
+            return self.component.template.template.render(context)
+
+    def fill_slots(self, context: Context):
+        if self.nodelist is None:
+            return {
+                DEFAULT_SLOT: None,
+            }
+
+        slot_nodes = {node.name: node for node in self.nodelist if isinstance(node, SlotNode)}
+        default_nodes = NodeList([node for node in self.nodelist if not isinstance(node, SlotNode)])
+
+        slots: dict[str, Node | NodeList] = {
+            DEFAULT_SLOT: default_nodes,
+            **slot_nodes,
+        }
+
+        if not slots[DEFAULT_SLOT] and "slot" in context:
+            slots[DEFAULT_SLOT] = TextNode(context["slot"])
+
+        return {name: node.render(context) for name, node in slots.items() if node}
+
+    @property
+    def id(self):
+        return str(self._sequence.next(self.component))
+
+
+class ComponentRegistry:
+    def __init__(self):
+        self._component_usage: dict[str, set[Path]] = defaultdict(set)
+        self._components: dict[str, Component] = {}
+        self._template_usage: dict[Path, set[str]] = defaultdict(set)
+
+    def reset(self) -> None:
+        """Reset the registry, used for testing."""
+        self._component_usage = defaultdict(set)
+        self._components = {}
+        self._template_usage = defaultdict(set)
+
+    def get_assets(self, asset_type: AssetType | None = None) -> frozenset[Asset]:
+        return frozenset(
+            asset
+            for component in self._components.values()
+            for asset in component.assets
+            if asset_type is None or asset.type == asset_type
+        )
+
+    def get_component(self, name: str) -> Component:
+        if name in self._components and not settings.DEBUG:
+            return self._components[name]
+
+        self._components[name] = Component.from_name(name)
+        if name not in self._component_usage:
+            self._component_usage[name] = set()
+        return self._components[name]
+
+    def get_component_names_used_in_template(self, template_path: str | Path) -> set[str]:
+        """Get names of components used in a template."""
+
+        path = Path(template_path)
+
+        if path in self._template_usage:
+            return self._template_usage[path]
+
+        components = find_components_in_template(template_path)
+
+        self._template_usage[path] = components
+        for component_name in components:
+            self._component_usage[component_name].add(path)
+
+        return components
+
+    def get_component_usage(self, template_path: str | Path) -> Generator[Component, Any, None]:
+        """Get components used in a template."""
+        for component_name in self.get_component_names_used_in_template(template_path):
+            yield Component.from_name(component_name)
+
+
+components = ComponentRegistry()

django_grep-0.1.0/src/django_grep/components/adapters/__init__.py

@@ -0,0 +1,2 @@
+from .base import BaseAdapter  # noqa
+from .main import DjangoAdapter  # noqa

django_grep-0.1.0/src/django_grep/components/adapters/base.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+UP_METHOD_COOKIE = "_up_method"
+
+
+class BaseAdapter:
+	"""
+	Provides the entrypoint for other frameworks to use this library.
+
+	Implements common functionality that is not often overriden as well
+	as framework specific hooks.
+	"""
+
+	def request_headers(self) -> Mapping[str, str]:
+		"""Reads the request headers from the current request.
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def request_params(self) -> Mapping[str, str]:
+		"""Reads the GET params from the current request.
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def redirect_uri(self, response: Any) -> str | None:
+		"""Returns the redirect target of a response or None if the response
+		is not a redirection (ie if it's status code is not in the range 300-400).
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def set_redirect_uri(self, response: Any, uri: str) -> None:
+		"""Set a new redirect target for the current response. This is used to
+		pass unpoly parameters via GET params through redirects.
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def set_headers(self, response: Any, headers: Mapping[str, str]) -> None:
+		"""Set headers like `X-Up-Location` on the current response.
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def set_cookie(self, response: Any, needs_cookie: bool = False) -> None:
+		"""Set or delete the `_up_method <https://unpoly.com/_up_method>`_ cookie.
+
+		The implementation should set the cookie if `needs_cookie` is `True` and
+		otherwise remove it if set.
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	@property
+	def method(self) -> str:
+		"""Exposes the current request's method (GET/POST etc)
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	@property
+	def location(self) -> str:
+		"""Exposes the current request's location (path including query params)
+
+		Needs to be implemented."""
+		raise NotImplementedError  # pragma: no cover
+
+	def deserialize_data(self, data: str) -> object:
+		"""Deserializes data passed in by Unpoly.
+
+		By default it simply reads it as JSON, but can be overriden if custom
+		decoders are needed.
+		"""
+		try:
+			return json.loads(data)
+		except json.JSONDecodeError:
+			return None
+
+	def serialize_data(self, data: object) -> str:
+		"""Serializes the data for passing it to Unpoly.
+
+		By default it simply serializes it as JSON, but can be overriden if custom
+		encoders are needed.
+		"""
+		return json.dumps(data, separators=(",", ":"), ensure_ascii=True)

django_grep-0.1.0/src/django_grep/components/adapters/main.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+from django.http import HttpRequest, HttpResponse
+
+from .base import BaseAdapter
+
+UP_METHOD_COOKIE = "_up_method"
+
+class DjangoAdapter(BaseAdapter):
+	def __init__(self, request: HttpRequest):
+		self.request = request
+
+	def request_headers(self) -> Mapping[str, str]:
+		return cast(Mapping[str, str], self.request.headers)
+
+	def request_params(self) -> Mapping[str, str]:
+		return self.request.GET
+
+	def redirect_uri(self, response: HttpResponse) -> str | None:
+		return (
+			cast(Mapping[str, str], response.headers).get("Location")
+			if 300 <= response.status_code < 400
+			else None
+		)
+
+	def set_redirect_uri(self, response: HttpResponse, uri: str) -> None:
+		response.headers["Location"] = uri
+
+	def set_headers(self, response: HttpResponse, headers: Mapping[str, str]) -> None:
+		for k, v in headers.items():
+			response.headers[k] = v
+
+	def set_cookie(self, response: HttpResponse, needs_cookie: bool = False) -> None:
+		if needs_cookie:
+			response.set_cookie(UP_METHOD_COOKIE, self.method)
+		elif UP_METHOD_COOKIE in self.request.COOKIES:
+			response.delete_cookie(UP_METHOD_COOKIE)
+
+	@property
+	def method(self) -> str:
+		return cast(str, self.request.method)
+
+	@property
+	def location(self) -> str:
+		return self.request.get_full_path_info()

django_grep-0.1.0/src/django_grep/components/adapters/test.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from contrib.setup.ext.adapter import BaseAdapter
+
+UP_METHOD_COOKIE = "_up_method"
+
+
+if TYPE_CHECKING:  # pragma: no cover
+	from collections.abc import Mapping
+
+
+
+class SimpleAdapter(BaseAdapter):
+	def __init__(
+		self,
+		method: str = "GET",
+		location: str = "/",
+		headers: dict[str, str] | None = None,
+		params: dict[str, str] | None = None,
+		redirect_uri: str | None = None,
+	):
+		self._method = method
+		self._location = location
+		self.headers = headers or {}
+		self.params = params or {}
+		self._redirect_uri = redirect_uri
+		self.response_redirect_uri: str | None = None
+		self.response_headers: Mapping[str, str] | None = None
+		self.cookie: bool | None = None
+
+	def request_headers(self) -> Mapping[str, str]:
+		return self.headers
+
+	def request_params(self) -> Mapping[str, str]:
+		return self.params
+
+	def redirect_uri(self, response: object) -> str | None:
+		return self._redirect_uri
+
+	def set_redirect_uri(self, response: object, uri: str) -> None:
+		self.response_redirect_uri = uri
+
+	def set_headers(self, response: object, headers: Mapping[str, str]) -> None:
+		self.response_headers = headers
+
+	def set_cookie(self, response: object, needs_cookie: bool = False) -> None:
+		self.cookie = needs_cookie
+
+	@property
+	def method(self) -> str:
+		return self._method
+
+	@property
+	def location(self) -> str:
+		return self._location

django_grep-0.1.0/src/django_grep/components/apps.py

@@ -0,0 +1,20 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class CoreExtAppConfig(AppConfig):
+    label = "components"
+    name = "django_grep.components"
+    verbose_name = _("Core Extensions")
+
+    def ready(self):
+        from .plugins import pm
+        from .staticfiles import asset_types
+
+        for pre_ready in pm.hook.pre_ready():
+            pre_ready()
+
+        pm.hook.register_asset_types(register_type=asset_types.register_type)
+
+        for ready in pm.hook.ready():
+            ready()

django_grep-0.1.0/src/django_grep/components/blocks/__init__.py

@@ -0,0 +1,9 @@
+from .base import *
+from .contact import *
+from .content import *
+from .media import *
+from .mixins import *
+from .pages import *
+from .partials import *
+from .profile import *
+from .streamBlocks import *

django_grep-0.1.0/src/django_grep/components/blocks/base.py

@@ -0,0 +1,143 @@
+import logging
+import uuid
+
+from django.utils.translation import gettext_lazy as _
+from wagtail import blocks
+
+from .mixins import ResponsiveBlockMixin, StyledBlockMixin
+
+logger = logging.getLogger(__name__)
+
+
+class BaseBlock(StyledBlockMixin, ResponsiveBlockMixin, blocks.StructBlock):
+    """
+    Enhanced base block class with built-in styling and responsive support.
+    Provides common functionality for all blocks.
+    """
+
+    # Common fields for all blocks
+    custom_css_id = blocks.CharBlock(
+        required=False,
+        max_length=50,
+        label=_("Custom CSS ID"),
+        help_text=_("Custom HTML ID for CSS targeting and JavaScript."),
+    )
+
+    custom_css_class = blocks.CharBlock(
+        required=False,
+        max_length=100,
+        label=_("Custom CSS Class"),
+        help_text=_("Additional CSS classes for custom styling."),
+    )
+
+    data_attributes = blocks.RawHTMLBlock(
+        required=False,
+        label=_("Data Attributes"),
+        help_text=_("Custom data attributes for JavaScript interaction."),
+    )
+
+    # Visibility controls
+    is_visible = blocks.BooleanBlock(
+        required=False,
+        default=True,
+        label=_("Visible"),
+        help_text=_("Toggle visibility of this block."),
+    )
+
+    # visibility_conditions = blocks.ChoiceBlock(
+    #     required=False,
+    #     choices=[
+    #         ('always', _('Always Visible')),
+    #         ('desktop', _('Desktop Only')),
+    #         ('mobile', _('Mobile Only')),
+    #         ('logged_in', _('Logged-in Users Only')),
+    #         ('logged_out', _('Logged-out Users Only')),
+    #     ],
+    #     default='always',
+    #     label=_("Visibility Conditions"),
+    # )
+
+    # # Responsive configuration
+    # responsive_config = blocks.StructBlock(
+    #     [
+    #         (
+    #             "width",
+    #             blocks.ChoiceBlock(
+    #                 required=False,
+    #                 choices=[
+    #                     ("full", _("Full Width")),
+    #                     ("container", _("Container Width")),
+    #                     ("narrow", _("Narrow Width")),
+    #                 ],
+    #                 default="container",
+    #                 label=_("Container Width"),
+    #             ),
+    #         ),
+    #         (
+    #             "padding",
+    #             blocks.ChoiceBlock(
+    #                 required=False,
+    #                 choices=[
+    #                     ("none", _("No Padding")),
+    #                     ("small", _("Small Padding")),
+    #                     ("default", _("Default Padding")),
+    #                     ("large", _("Large Padding")),
+    #                 ],
+    #                 default="default",
+    #                 label=_("Padding Size"),
+    #             ),
+    #         ),
+    #         (
+    #             "background",
+    #             blocks.ChoiceBlock(
+    #                 required=False,
+    #                 choices=[
+    #                     ("none", _("No Background")),
+    #                     ("light", _("Light Background")),
+    #                     ("dark", _("Dark Background")),
+    #                     ("gradient", _("Gradient Background")),
+    #                     ("pattern", _("Pattern Background")),
+    #                 ],
+    #                 default="none",
+    #                 label=_("Background Style"),
+    #             ),
+    #         ),
+    #     ],
+    #     required=False,
+    #     label=_("Responsive Configuration"),
+    # )
+
+    def get_block_classes(self, value):
+        """Get CSS classes for the block container."""
+        base_classes = self.get_styling_config().get("container", "")
+        responsive_classes = self.get_responsive_classes(value)
+        custom_classes = value.get("custom_css_class", "")
+
+        # Add visibility classes
+        visibility_class = ""
+        if value.get("visibility_conditions") != "always":
+            visibility_class = f"visible-{value['visibility_conditions']}"
+
+        classes = [base_classes, responsive_classes, custom_classes, visibility_class]
+        return " ".join(filter(None, classes))
+
+    def get_context(self, value, parent_context=None):
+        context = super().get_context(value, parent_context)
+
+        # Add framework info
+        context["framework"] = self.style_framework
+        context["css_prefix"] = self.css_prefix
+
+        # Generate unique block ID
+        block_id = value.get("custom_css_id") or f"block-{uuid.uuid4().hex[:8]}"
+        context["block_id"] = block_id
+        context["block_classes"] = self.get_block_classes(value)
+
+        return context
+
+    def render(self, value, context=None):
+        # Skip rendering if block is not visible
+        if not value.get("is_visible", True):
+            return ""
+
+        return super().render(value, context)

django_grep-0.1.0/src/django_grep/components/blocks/contact/__init__.py

@@ -0,0 +1,9 @@
+
+from .contactCard import *
+from .contactMethods import *
+from .form import *
+from .hours import *
+from .map import *
+from .socialLinks import *
+from .streamBlocks import ContactMethodsStreamBlock
+from .websiteLinks import *