pydzn 0.1.0__tar.gz

pydzn-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pydzn-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pydzn
+Version: 0.1.0
+Summary: Tiny design-system utilities (Tailwind-like), composable HTML components, and a grid layout builder for Python/Jinja apps.
+Author-email: Your Name <you@example.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/anthonyrka/pydzn
+Project-URL: Repository, https://github.com/anthonyrka/pydzn
+Project-URL: Issues, https://github.com/anthonyrka/pydzn/issues
+Keywords: design-system,css,utility-classes,jinja2,components,grid,htmx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: Flask
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Jinja2>=3.1
+Provides-Extra: flask
+Requires-Dist: Flask>=2.3; extra == "flask"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: black>=24; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# pydzn
+Python web components for server-side rendering

pydzn-0.1.0/README.md

@@ -0,0 +1,2 @@
+# pydzn
+Python web components for server-side rendering

pydzn-0.1.0/pyproject.toml

@@ -0,0 +1,84 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pydzn"
+version = "0.1.0"
+description = "Tiny design-system utilities (Tailwind-like), composable HTML components, and a grid layout builder for Python/Jinja apps."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [
+  { name = "Your Name", email = "you@example.com" }
+]
+keywords = ["design-system", "css", "utility-classes", "jinja2", "components", "grid", "htmx"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Framework :: Flask",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+dependencies = [
+  "Jinja2>=3.1",
+]
+
+[project.optional-dependencies]
+flask = ["Flask>=2.3"]
+dev = [
+  "pytest>=8",
+  "ruff>=0.5",
+  "black>=24",
+  "mypy>=1.10",
+  "build>=1.2",
+  "twine>=5"
+]
+
+[project.urls]
+Homepage = "https://github.com/anthonyrka/pydzn"
+Repository = "https://github.com/anthonyrka/pydzn"
+Issues = "https://github.com/anthonyrka/pydzn/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+# If your package is exactly "pydzn" at src/pydzn, this will find it (and subpackages).
+
+[tool.setuptools.package-data]
+# Ship component assets next to their modules so BaseComponent can find template.html/styles.css
+pydzn = [
+  "**/*.html",
+  "**/*.css",
+  "**/*.js",
+  "py.typed"
+]
+
+# --- Optional tooling config (nice defaults) ---
+
+[tool.black]
+target-version = ["py310"]
+line-length = 100
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E","F","I","W"]
+exclude = ["build/", "dist/", ".venv/"]
+
+[tool.mypy]
+python_version = "3.10"
+pretty = true
+show_error_codes = true
+strict = false
+ignore_missing_imports = true

pydzn-0.1.0/setup.cfg

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

pydzn-0.1.0/src/pydzn/base_component.py

@@ -0,0 +1,153 @@
+from abc import ABC, abstractmethod
+import secrets
+import re
+import html as _html
+import json
+import inspect
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from .base_agent import BaseAssistant
+from .dzn import register_dzn_classes
+
+
+class BaseComponent(ABC):
+    """
+    Abstract base for file-based HTML components using Jinja2.
+
+    Each component subclass must:
+      1. Reside alongside a `template.html` file (or override `template_name`).
+      2. Implement the `context()` method to supply template variables.
+
+    The constructor now accepts optional HTML attributes that get rendered
+    into the top-level tag under the variable `attrs`.
+    """
+    template_name: str = "template.html"
+    _asset_candidates = ("styles.css", "component.js")
+
+    def __init__(
+        self,
+        children: str | None = None,
+        tag: str = "div",
+        id: str | None = None,
+        styles: dict | None = None,
+        dzn: str | None = None,
+        **html_attrs,
+    ):
+        # Content & basic props
+        self.children = children or ""
+        self.tag = tag
+        self.html_attrs = html_attrs or {}
+        self.styles = dict(styles or {})
+        self.error_status = None
+
+        # merge dzn utility classes into class attr + register them
+        if dzn:
+            self.html_attrs["class"] = self._merge_classes(self.html_attrs.get("class", ""), dzn)
+            register_dzn_classes(dzn)
+
+        # Locate component dir/name
+        module_path = inspect.getfile(self.__class__)
+        base_dir = Path(module_path).resolve().parent
+        self.component_dir: Path = base_dir
+        self.component_name: str = base_dir.name
+
+        # Decide on id: explicit arg > html_attrs["id"] > generated
+        provided_id = id or self.html_attrs.get("id")
+        final_id = provided_id or self._gen_id(prefix=self.component_name)
+        self.html_attrs["id"] = str(final_id)
+        self.id = self.html_attrs["id"]
+
+        # Discover adjacent assets
+        discovered = [fname for fname in self._asset_candidates
+                    if (self.component_dir / fname).exists()]
+        self.assets: list[str] = discovered
+
+        # Jinja env
+        self.env = Environment(
+            loader=FileSystemLoader(str(base_dir)),
+            autoescape=select_autoescape(["html", "xml"]),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def _update_error_status(self, error_body: dict, error_status_code: int):
+        self.error_status = (
+            json.dumps(error_body),
+            error_status_code,
+            {
+                "Content-Type": "application/json",
+                "HX-Trigger": json.dumps(
+                    {"showMessage": error_body["message"]
+                   })
+            })
+        return self.error_status
+
+    def set_style(self, key: str, value) -> None:
+        """Set/override a single CSS property. Pass None/False to remove it."""
+        k = key.replace("_", "-")             # allow background_color → background-color
+        if value in (None, False):
+            self.styles.pop(k, None)
+        else:
+            self.styles[k] = str(value)
+
+    def _style_string(self) -> str:
+        """Merge any existing 'style' attr with styles dict; return final string or ''."""
+        parts = []
+        inline = self.html_attrs.get("style")
+        if inline:
+            parts.append(str(inline).rstrip().rstrip(";"))
+        if self.styles:
+            dict_str = "; ".join(f"{k}: {v}" for k, v in self.styles.items())
+            if dict_str:
+                parts.append(dict_str)
+        return "; ".join(parts) if parts else ""
+
+    def _merge_classes(self, base: str, extra: str) -> str:
+        seen, out = set(), []
+        for c in (base.split() + extra.split()):
+            if c and c not in seen:
+                seen.add(c); out.append(c)
+        return " ".join(out)
+
+    def _gen_id(self, prefix: str | None = None) -> str:
+        """Generate a short, readable, unique-ish id."""
+        # sanitize prefix to valid id-ish token
+        base = re.sub(r"[^a-zA-Z0-9_-]+", "-", (prefix or "x"))
+        token = secrets.token_hex(4)  # 8 hex chars
+        return f"{base}-{token}"
+
+    @abstractmethod
+    def context(self) -> dict:
+        """
+        Return dict of template variables for rendering.
+        """
+        pass
+
+    def render(self) -> str:
+        """
+        Render `template_name` with the provided context,
+        injecting any HTML attributes into the variable `attrs`.
+        Templates should use `{{ attrs|safe }}` on their top-level tag.
+        """
+        # Build attribute string
+        attr_parts = []
+        for k, v in self.html_attrs.items():
+            if k == "style":
+                continue
+            attr_parts.append(f'{k}="{_html.escape(str(v), quote=True)}"')
+
+        # Merge style attr + styles dict; only add if non-empty
+        style_str = self._style_string()
+        if style_str:
+            attr_parts.append(f'style="{_html.escape(style_str, quote=True)}"')
+
+        attrs = " ".join(attr_parts)
+
+        # Context
+        ctx = self.context().copy()
+        ctx["attrs"] = attrs
+        ctx["children"] = self.children
+        ctx["tag"] = self.tag
+
+        tpl = self.env.get_template(self.template_name)
+        return tpl.render(**ctx)

pydzn-0.1.0/src/pydzn/components/button/component.py

@@ -0,0 +1,27 @@
+from src.base_component import BaseComponent
+
+class Button(BaseComponent):
+    """
+    Renders a button element.
+    Expects `template.html`
+    """
+
+    DEFAULT_DZN = (
+        "px-5 py-2 rounded-sm border-2 border-blue-500 "
+        "shadow-sm hover:shadow-md bg-[transparent] text-[#2563eb] "
+    )
+
+    def __init__(self, text: str = "", children: str | None = None,
+                 tag: str = "button", dzn: str | None = None, **attrs):
+        # 2) Accept dzn both as a named arg and as a stray attribute (attrs["dzn"])
+        user_dzn = dzn or attrs.pop("dzn", None)
+
+        # 3) Merge: default + user-provided (so user can extend the default easily)
+        effective_dzn = (self.DEFAULT_DZN + " " + user_dzn).strip() if user_dzn else self.DEFAULT_DZN
+
+        # 4) Pass the merged dzn to BaseComponent (it will register + merge into class)
+        super().__init__(children=children, tag=tag, dzn=effective_dzn, **attrs)
+        self.text = text
+
+    def context(self) -> dict:
+        return {"text": self.text}

pydzn-0.1.0/src/pydzn/components/button/template.html

@@ -0,0 +1,3 @@
+<{{ tag }}{% if attrs %} {{ attrs|safe }}{% endif %}>
+  {{ text }}{{ children|safe }}
+</{{ tag }}>

pydzn-0.1.0/src/pydzn/dzn.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+import re
+from typing import Iterable
+
+# --- tokens (extend as needed) ---
+TOKENS = {
+    "space": {
+        "0": "0",
+        "1": ".25rem",  "2": ".5rem",   "3": ".75rem",  "4": "1rem",
+        "5": "1.25rem", "6": "1.5rem",  "7": "1.75rem", "8": "2rem",
+        "9": "2.25rem", "10": "2.5rem", "11": "2.75rem","12": "3rem",
+        "14": "3.5rem", "16": "4rem",   "20": "5rem",   "24": "6rem",
+        "28": "7rem",   "32": "8rem"
+    },
+    "radius": {
+        "none": "0", "sm": "8px", "md": "12px", "lg": "16px",
+        "xl": "20px", "2xl": "24px", "3xl": "32px", "full": "9999px"
+    },
+    "shadow": {
+        "none": "none",
+        "sm":   "0 1px 3px rgba(0,0,0,.08)",
+        "md":   "0 2px 6px rgba(0,0,0,.10)",
+        "lg":   "0 6px 18px rgba(0,0,0,.12)",
+        "xl":   "0 12px 32px rgba(0,0,0,.14)",
+        "2xl":  "0 20px 56px rgba(0,0,0,.16)",
+        "3xl":  "0 32px 80px rgba(0,0,0,.18)",
+        "inner":"inset 0 2px 6px rgba(0,0,0,.12)"
+    },
+    "border_width": { "0": "0", "DEFAULT": "1px", "2": "2px", "4": "4px", "8": "8px" },
+    "border_color": {
+        "subtle": "rgba(15,23,42,.06)",
+        "transparent": "transparent",
+        "black": "rgba(0,0,0,1)",
+        "white": "rgba(255,255,255,1)",
+        "slate-200": "rgb(226,232,240)",
+        "slate-300": "rgb(203,213,225)",
+        "slate-400": "rgb(148,163,184)",
+        "blue-500": "rgb(59,130,246)",
+        "red-500": "rgb(239,68,68)",
+        "green-500": "rgb(34,197,94)"
+    }
+}
+
+# --- responsive breakpoints ---
+BPS = {
+    "sm": "(min-width: 640px)",
+    "md": "(min-width: 768px)",
+    "lg": "(min-width: 1024px)",
+}
+
+_used: set[str] = set()
+
+def register_dzn_classes(classes: str | Iterable[str]) -> None:
+    if isinstance(classes, str):
+        _used.update(c for c in classes.split() if c)
+    else:
+        _used.update(classes)
+
+# --- selector escaping for arbitrary utilities ---
+def css_escape_class(cls: str) -> str:
+    # Escape any char not [a-zA-Z0-9_-] so the selector matches the literal class in HTML
+    return re.sub(r'([^a-zA-Z0-9_-])', r'\\\1', cls)
+
+# --- emit helpers ---
+def rule(selector: str, body: str) -> str:
+    return f".{selector}{{{body}}}"
+
+def emit_base(name: str) -> str | None:
+    match name:
+        # layout
+        case "flex":            return rule(name, "display:flex")
+        case "flex-col":        return rule(name, "flex-direction:column")
+        case "items-center":    return rule(name, "align-items:center")
+        case "justify-center":  return rule(name, "justify-content:center")
+        case "text-center":     return rule(name, "text-align:center")
+
+        # border (longhand for predictable overrides)
+        case "border":
+            return rule(name,
+                f"border-style:solid;"
+                f"border-width:{TOKENS['border_width']['DEFAULT']};"
+                f"border-color:{TOKENS['border_color']['subtle']}"
+            )
+
+        # quick border colors
+        case "border-subtle":       return rule(name, f"border-color:{TOKENS['border_color']['subtle']}")
+        case "border-transparent":  return rule(name, f"border-color:{TOKENS['border_color']['transparent']}")
+        case "border-black":        return rule(name, f"border-color:{TOKENS['border_color']['black']}")
+        case "border-white":        return rule(name, f"border-color:{TOKENS['border_color']['white']}")
+
+        # radius
+        case "rounded":         return rule(name, "border-radius:12px")
+        case "rounded-none":    return rule(name, "border-radius:0")
+
+        # shadows
+        case "shadow-none":     return rule(name, f"box-shadow:{TOKENS['shadow']['none']}")
+        case "shadow-sm":       return rule(name, f"box-shadow:{TOKENS['shadow']['sm']}")
+        case "shadow":          return rule(name, f"box-shadow:{TOKENS['shadow']['md']}")
+        case "shadow-md":       return rule(name, f"box-shadow:{TOKENS['shadow']['md']}")
+        case "shadow-lg":       return rule(name, f"box-shadow:{TOKENS['shadow']['lg']}")
+        case "shadow-xl":       return rule(name, f"box-shadow:{TOKENS['shadow']['xl']}")
+        case "shadow-2xl":      return rule(name, f"box-shadow:{TOKENS['shadow']['2xl']}")
+        case "shadow-3xl":      return rule(name, f"box-shadow:{TOKENS['shadow']['3xl']}")
+        case "shadow-inner":    return rule(name, f"box-shadow:{TOKENS['shadow']['inner']}")
+
+        # visibility
+        case "hidden":       return rule(name, "display:none")
+        case "block":        return rule(name, "display:block")          # handy for toggling back
+        case "inline-block": return rule(name, "display:inline-block")
+        case "invisible":    return rule(name, "visibility:hidden")      # keeps layout
+        case "visible":      return rule(name, "visibility:visible")
+
+        # positioning
+        case "fixed":    return rule(name, "position:fixed")
+        case "absolute": return rule(name, "position:absolute")
+        case "relative": return rule(name, "position:relative")
+        case "top-0":    return rule(name, "top:0")
+        case "right-0":  return rule(name, "right:0")
+        case "bottom-0": return rule(name, "bottom:0")
+        case "left-0":   return rule(name, "left:0")
+        case "inset-0":  return rule(name, "top:0;right:0;bottom:0;left:0")
+
+        case "flex-1":   return rule(name, "flex:1 1 0%")
+        case "grow":     return rule(name, "flex-grow:1")
+        case "shrink-0": return rule(name, "flex-shrink:0")
+
+        case "grid": return rule(name, "display:grid")
+
+        case "border-solid": return rule(name, "border-style:solid")
+        case "border-dashed": return rule(name, "border-style:dashed")
+        case "border-dotted": return rule(name, "border-style:dotted")
+
+        case "aspect-square": return rule(name, "aspect-ratio:1/1")
+
+    return None
+
+def emit_scale(name: str) -> str | None:
+    # spacing
+    if m := re.fullmatch(r"gap-(\d+)", name):
+        if (val := TOKENS["space"].get(m.group(1))) is not None:
+            return rule(name, f"gap:{val}")
+    if m := re.fullmatch(r"p-(\d+)", name):
+        if (val := TOKENS["space"].get(m.group(1))) is not None:
+            return rule(name, f"padding:{val}")
+    if m := re.fullmatch(r"px-(\d+)", name):
+        if (val := TOKENS["space"].get(m.group(1))) is not None:
+            return rule(name, f"padding-left:{val};padding-right:{val}")
+    if m := re.fullmatch(r"py-(\d+)", name):
+        if (val := TOKENS["space"].get(m.group(1))) is not None:
+            return rule(name, f"padding-top:{val};padding-bottom:{val}")
+
+    # border widths
+    if m := re.fullmatch(r"border-(0|2|4|8)", name):
+        w = TOKENS["border_width"][m.group(1)]
+        return rule(name, f"border-width:{w}")
+    if m := re.fullmatch(r"border-(x|y)(?:-(0|2|4|8))?", name):
+        axis, wkey = m.group(1), m.group(2) or "DEFAULT"
+        w = TOKENS["border_width"][wkey]
+        if axis == "x":
+            return rule(name, f"border-left-width:{w};border-right-width:{w}")
+        else:
+            return rule(name, f"border-top-width:{w};border-bottom-width:{w}")
+    if m := re.fullmatch(r"border-(t|r|b|l)(?:-(0|2|4|8))?", name):
+        side, wkey = m.group(1), m.group(2) or "DEFAULT"
+        w = TOKENS["border_width"][wkey]
+        prop = {"t":"top","r":"right","b":"bottom","l":"left"}[side]
+        return rule(name, f"border-{prop}-width:{w}")
+
+    # border colors by token (e.g., border-slate-300)
+    if m := re.fullmatch(r"border-([a-z0-9-]+)", name):
+        col = TOKENS["border_color"].get(m.group(1))
+        if col is not None:
+            return rule(name, f"border-color:{col}")
+
+    # rounded scale
+    if m := re.fullmatch(r"rounded-([a-z0-9]+)", name):
+        key = m.group(1); val = TOKENS["radius"].get(key)
+        if val is not None:
+            return rule(name, f"border-radius:{val}")
+    if m := re.fullmatch(r"rounded-(t|r|b|l)-([a-z0-9]+)", name):
+        side, key = m.group(1), m.group(2)
+        val = TOKENS["radius"].get(key)
+        if val is None:
+            return None
+        if side == "t":
+            body = f"border-top-left-radius:{val};border-top-right-radius:{val}"
+        elif side == "r":
+            body = f"border-top-right-radius:{val};border-bottom-right-radius:{val}"
+        elif side == "b":
+            body = f"border-bottom-right-radius:{val};border-bottom-left-radius:{val}"
+        else:
+            body = f"border-top-left-radius:{val};border-bottom-left-radius:{val}"
+        return rule(name, body)
+    if m := re.fullmatch(r"rounded-(tl|tr|br|bl)-([a-z0-9]+)", name):
+        corner, key = m.group(1), m.group(2)
+        val = TOKENS["radius"].get(key)
+        if val is None:
+            return None
+        prop = {"tl":"top-left","tr":"top-right","br":"bottom-right","bl":"bottom-left"}[corner]
+        return rule(name, f"border-{prop}-radius:{val}")
+
+    return None
+
+def emit_arbitrary(name: str) -> str | None:
+    esel = css_escape_class(name)
+
+    # width
+    if m := re.fullmatch(r"w-\[(.+?)\]", name):
+        return rule(esel, f"width:{m.group(1)}")
+
+    # padding
+    if m := re.fullmatch(r"p-\[(.+?)\]", name):
+        return rule(esel, f"padding:{m.group(1)}")
+    if m := re.fullmatch(r"px-\[(.+?)\]", name):
+        v = m.group(1); return rule(esel, f"padding-left:{v};padding-right:{v}")
+    if m := re.fullmatch(r"py-\[(.+?)\]", name):
+        v = m.group(1); return rule(esel, f"padding-top:{v};padding-bottom:{v}")
+
+    # gap
+    if m := re.fullmatch(r"gap-\[(.+?)\]", name):
+        return rule(esel, f"gap:{m.group(1)}")
+
+    # border width arbitrary
+    if m := re.fullmatch(r"border-\[(.+?)\]", name):
+        return rule(esel, f"border-width:{m.group(1)}")
+
+    # rounded arbitrary
+    if m := re.fullmatch(r"rounded-\[(.+?)\]", name):
+        return rule(esel, f"border-radius:{m.group(1)}")
+
+    # shadow arbitrary (underscores become spaces)
+    if m := re.fullmatch(r"shadow-\[(.+?)\]", name):
+        return rule(esel, f"box-shadow:{m.group(1).replace('_',' ')}")
+
+    # colors
+    if m := re.fullmatch(r"bg-\[(.+?)\]", name):
+        return rule(esel, f"background:{m.group(1).replace('_',' ')}")
+    if m := re.fullmatch(r"text-\[(.+?)\]", name):
+        return rule(esel, f"color:{m.group(1).replace('_',' ')}")
+
+    # size
+    if m := re.fullmatch(r"h-\[(.+?)\]", name):
+        return rule(css_escape_class(name), f"height:{m.group(1)}")
+
+    # grid template columns: grid-cols-[280px_1fr]  (underscores -> spaces)
+    if m := re.fullmatch(r"grid-cols-\[(.+?)\]", name):
+        v = m.group(1).replace("_", " ")
+        return rule(css_escape_class(name), f"grid-template-columns:{v}")
+
+    # grid template rows: grid-rows-[auto_1fr]  (underscores -> spaces)
+    if m := re.fullmatch(r"grid-rows-\[(.+?)\]", name):
+        v = m.group(1).replace("_", " ")
+        return rule(css_escape_class(name), f"grid-template-rows:{v}")
+
+    return None
+
+# --- variants ---
+def wrap_variant(sel: str, css: str, variant: str) -> str:
+    esel = css_escape_class(sel)
+    if variant in BPS:
+        return f"@media {BPS[variant]}{{{css}}}"
+    if variant == "hover":
+        return css.replace(f".{esel}{{", f".{variant}\\:{esel}:hover{{")
+    if variant == "focus":
+        return css.replace(f".{esel}{{", f".{variant}\\:{esel}:focus{{")
+    return css
+
+def emit_one(cls: str) -> str | None:
+    parts = cls.split(":")
+    base = parts[-1]
+    variants = parts[:-1]
+
+    css = emit_base(base) or emit_scale(base) or emit_arbitrary(base)
+    if not css:
+        return None
+    for v in reversed(variants):
+        css = wrap_variant(base, css, v)
+    return css
+
+def compile_used_css() -> str:
+    out: list[str] = []
+    for cls in sorted(_used):
+        css = emit_one(cls)
+        if css:
+            out.append(css)
+    return "\n".join(out)

pydzn-0.1.0/src/pydzn/grid_builder.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union, Tuple
+import html
+from src.dzn import register_dzn_classes
+
+
+CSSVal = Union[int, str]
+
+
+def _css_px(v: CSSVal) -> str:
+    if isinstance(v, int):
+        return f"{v}px"
+    return str(v)
+
+def _join_tokens(parts: List[str]) -> str:
+    # DZN arbitrary classes use "_" instead of spaces inside [...]
+    return "_".join(p.replace(" ", "_") for p in parts)
+
+def _grid_cols_class(named_cols: List[Tuple[str, str]]) -> str:
+    return f"grid-cols-[{_join_tokens([w for _, w in named_cols])}]"
+
+def _grid_rows_class(named_rows: List[Tuple[str, str]]) -> str:
+    return f"grid-rows-[{_join_tokens([h for _, h in named_rows])}]"
+
+@dataclass
+class _Region:
+    name: str
+    col_name: str
+    row_name: Optional[str]           # if None, will resolve to first row
+    col_span: int = 1
+    row_span: Optional[int] = 1       # if None => span all rows
+    dzn: str = ""
+
+    # placement resolved at build-time (indexes)
+    _col_index: int = 1
+    _row_index: int = 1
+    _row_span_resolved: int = 1
+
+    def placement_style(self) -> str:
+        gc = f"{self._col_index} / span {self.col_span}"
+        gr = f"{self._row_index} / span {self._row_span_resolved}"
+        return f"grid-column:{gc};grid-row:{gr};"
+
+class GridLayoutBuilder:
+    """
+    Intuitive rows/columns named builder.
+
+    You define tracks by NAME (order preserved), then drop regions by name:
+
+        DashboardLayout = (
+            layout_builder()
+              .columns(sidebar=280, main="1fr")
+              .rows(hero="auto", content="1fr")
+              .region("sidebar", col="sidebar", row=None, row_span=None)   # spans all rows
+              .region("hero",    col="main",    row="hero")
+              .region("content", col="main",    row="content")
+              .build(name="DashboardLayout")
+        )
+
+    Then use on any page:
+
+        html = DashboardLayout(debug=True).render(
+            sidebar=sidebar_html,
+            hero=hero_html,
+            content=content_html
+        )
+    """
+
+    def __init__(self):
+        self._named_cols: List[Tuple[str, str]] = [("main", "1fr")]
+        self._named_rows: List[Tuple[str, str]] = [("content", "1fr")]
+        self._regions: List[_Region] = []
+        self._outer_dzn: str = ""          # keep empty by default (no forced classes)
+        self._height_css: str = "100vh"    # default grid height
+
+    # ---------------- tracks (named & ordered) ----------------
+    def columns(self, **spec: CSSVal) -> "GridLayoutBuilder":
+        """
+        Define columns with names, in the order you pass them:
+            .columns(sidebar=280, main="1fr")
+        """
+        if not spec:
+            raise ValueError("columns(): provide at least one named column")
+        self._named_cols = [(k, _css_px(v)) for k, v in spec.items()]
+        return self
+
+    def rows(self, **spec: CSSVal) -> "GridLayoutBuilder":
+        """
+        Define rows with names, in the order you pass them:
+            .rows(hero="auto", content="1fr")
+        """
+        if not spec:
+            raise ValueError("rows(): provide at least one named row")
+        self._named_rows = [(k, _css_px(v)) for k, v in spec.items()]
+        return self
+
+    def add_column(self, name: str, width: CSSVal) -> "GridLayoutBuilder":
+        self._named_cols.append((name, _css_px(width)))
+        return self
+
+    def add_row(self, name: str, height: CSSVal) -> "GridLayoutBuilder":
+        self._named_rows.append((name, _css_px(height)))
+        return self
+
+    def fill_height(self, css_value: str = "100vh") -> "GridLayoutBuilder":
+        self._height_css = css_value
+        return self
+
+    # ---------------- convenience shapes ----------------
+    def with_sidebar(self, *, width: CSSVal = 280, position: str = "left") -> "GridLayoutBuilder":
+        """
+        Quick two-column pattern with sidebar + main.
+        Rows untouched; add rows() or add_row() after if you want multiple rows.
+        """
+        pos = "right" if str(position).lower() == "right" else "left"
+        if pos == "left":
+            self._named_cols = [("sidebar", _css_px(width)), ("main", "1fr")]
+        else:
+            self._named_cols = [("main", "1fr"), ("sidebar", _css_px(width))]
+        return self
+
+    # ---------------- regions ----------------
+    def region(
+        self,
+        name: str,
+        *,
+        col: str,
+        row: Optional[str],
+        col_span: int = 1,
+        row_span: Optional[int] = 1,  # None = span all rows
+        dzn: str = "",
+    ) -> "GridLayoutBuilder":
+        """
+        Add a region by track names. Example:
+          .region("sidebar", col="sidebar", row=None, row_span=None)  # full height
+          .region("hero",    col="main", row="hero")
+          .region("content", col="main", row="content")
+        """
+        self._regions.append(
+            _Region(
+                name=name,
+                col_name=col,
+                row_name=row,
+                col_span=col_span,
+                row_span=row_span,
+                dzn=dzn,
+            )
+        )
+        return self
+
+    # ---------------- build ----------------
+    def build(self, *, name: str = "BuiltGridLayout"):
+        # Prepare grid class names (optional styling)
+        grid_cols = _grid_cols_class(self._named_cols)
+        grid_rows = _grid_rows_class(self._named_rows)
+        register_dzn_classes([grid_cols, grid_rows])  # let /_dzn.css emit helpers if needed
+        register_dzn_classes(["grid"])                # if you have .grid { display:grid } in dzn
+
+        # name→index maps
+        col_index: Dict[str, int] = {n: i + 1 for i, (n, _) in enumerate(self._named_cols)}
+        row_index: Dict[str, int] = {n: i + 1 for i, (n, _) in enumerate(self._named_rows)}
+        total_rows = len(self._named_rows)
+
+        # resolve placements (indices, spans)
+        resolved: Dict[str, _Region] = {}
+        order: List[str] = []
+        for r in self._regions:
+            if r.col_name not in col_index:
+                raise ValueError(f"Unknown column '{r.col_name}' for region '{r.name}'")
+            r._col_index = col_index[r.col_name]
+
+            if r.row_name is None:
+                r._row_index = 1
+                r._row_span_resolved = total_rows if r.row_span is None else r.row_span
+            else:
+                if r.row_name not in row_index:
+                    raise ValueError(f"Unknown row '{r.row_name}' for region '{r.name}'")
+                r._row_index = row_index[r.row_name]
+                r._row_span_resolved = total_rows - (r._row_index - 1) if r.row_span is None else r.row_span
+
+            resolved[r.name] = r
+            order.append(r.name)
+
+        height_css = self._height_css
+
+        class _Layout:
+            __slots__ = ("_grid_cols", "_grid_rows", "_regions", "_order",
+                         "_outer_dzn", "_region_dzn", "_debug")
+
+            def __init__(
+                self,
+                *,
+                outer_dzn: str = "",
+                region_dzn: Optional[Dict[str, str]] = None,
+                debug: bool = False,
+            ):
+                self._grid_cols = grid_cols
+                self._grid_rows = grid_rows
+                self._regions = resolved
+                self._order = order
+                self._outer_dzn = outer_dzn or ""
+                self._region_dzn = region_dzn or {}
+                self._debug = bool(debug)
+
+                if self._outer_dzn:
+                    register_dzn_classes(self._outer_dzn)
+                if self._region_dzn:
+                    register_dzn_classes(" ".join(self._region_dzn.values()))
+
+            def render(self, **slots: str) -> str:
+                # outer wrapper (no template)
+                outer_attr = f' class="{html.escape(self._outer_dzn)}"' if self._outer_dzn else ""
+                # ensure grid without relying on dzn
+                grid_style = f"display:grid;min-height:{html.escape(height_css)};"
+                grid_class = f"{self._grid_cols} {self._grid_rows}".strip()
+
+                out: List[str] = []
+                out.append(f"<div{outer_attr}>")
+                out.append(f'  <div class="{html.escape(grid_class)}" style="{grid_style}">')
+
+                for name in self._order:
+                    R = self._regions[name]
+                    slot_html = slots.get(name, "") or ""
+                    region_cls = " ".join(c for c in [R.dzn, self._region_dzn.get(name, "")] if c).strip()
+                    region_cls_attr = f' class="{html.escape(region_cls)}"' if region_cls else ""
+                    region_style_attr = f' style="{html.escape(R.placement_style())}"'
+
+                    if self._debug:
+                        dbg = "outline:1px dashed rgba(220,38,38,.55);outline-offset:-1px;"
+                        region_style_attr = region_style_attr[:-1] + dbg + '"'  # append
+
+                    out.append(f'    <div data-region="{html.escape(name)}"{region_cls_attr}{region_style_attr}>')
+
+                    if self._debug:
+                        out.append(
+                            '      <div style="font:11px/1.2 system-ui, -apple-system, Segoe UI, Roboto;'
+                            'color:rgba(220,38,38,.8);padding:2px 4px;display:inline-block;">'
+                            f'{html.escape(name)}</div>'
+                        )
+
+                    if slot_html:
+                        out.append(f"      {slot_html}")
+                    out.append("    </div>")
+
+                out.append("  </div>")
+                out.append("</div>")
+                return "\n".join(out)
+
+        _Layout.__name__ = name
+        return _Layout
+
+
+def layout_builder() -> GridLayoutBuilder:
+    return GridLayoutBuilder()

pydzn-0.1.0/src/pydzn.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: pydzn
+Version: 0.1.0
+Summary: Tiny design-system utilities (Tailwind-like), composable HTML components, and a grid layout builder for Python/Jinja apps.
+Author-email: Your Name <you@example.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/anthonyrka/pydzn
+Project-URL: Repository, https://github.com/anthonyrka/pydzn
+Project-URL: Issues, https://github.com/anthonyrka/pydzn/issues
+Keywords: design-system,css,utility-classes,jinja2,components,grid,htmx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: Flask
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Jinja2>=3.1
+Provides-Extra: flask
+Requires-Dist: Flask>=2.3; extra == "flask"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: black>=24; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# pydzn
+Python web components for server-side rendering

pydzn-0.1.0/src/pydzn.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/pydzn/__init__.py
+src/pydzn/base_component.py
+src/pydzn/dzn.py
+src/pydzn/grid_builder.py
+src/pydzn.egg-info/PKG-INFO
+src/pydzn.egg-info/SOURCES.txt
+src/pydzn.egg-info/dependency_links.txt
+src/pydzn.egg-info/requires.txt
+src/pydzn.egg-info/top_level.txt
+src/pydzn/components/__init__.py
+src/pydzn/components/button/__init__.py
+src/pydzn/components/button/component.py
+src/pydzn/components/button/template.html

pydzn-0.1.0/src/pydzn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydzn-0.1.0/src/pydzn.egg-info/requires.txt

@@ -0,0 +1,12 @@
+Jinja2>=3.1
+
+[dev]
+pytest>=8
+ruff>=0.5
+black>=24
+mypy>=1.10
+build>=1.2
+twine>=5
+
+[flask]
+Flask>=2.3

pydzn-0.1.0/src/pydzn.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydzn