pyfrontkit 1.0.56__py3-none-any.whl

pyfrontkit/__init__.py

@@ -0,0 +1,87 @@
+# ----------------------------------------------------------------------
+# Package Configuration
+# ----------------------------------------------------------------------
+__version__ = "1.0.56"
+__author__ = "Eduardo Antonio Ferrera Rodriguez"
+__license__ = "GPLv3"
+
+# ----------------------------------------------------------------------
+# Expose CSS submodule
+# ----------------------------------------------------------------------
+from . import css
+
+# Expose CreateColor directly
+from .css import CreateColor
+from .css import CreateWithColor
+from .css.fonts import CreateFont
+from .css.fonts import FooterFont
+from .css.fonts import HeaderFont
+from .css.fonts import MainFont
+# ----------------------------------------------------------------------
+# Core modules
+# ----------------------------------------------------------------------
+from .html_doc import HtmlDoc
+from .css_register import CSSRegistry
+from .block import Block
+
+# ----------------------------------------------------------------------
+# Tags
+# ----------------------------------------------------------------------
+from .tags import (
+    Div, Section, Article, Header, Footer, Nav, Main, Aside, Button, Form, Ul, Li, A,
+    div, section, article, header, footer, nav, main, aside,
+    button, form, ul, li, a
+)
+
+# ----------------------------------------------------------------------
+# Void elements
+# ----------------------------------------------------------------------
+from .void_element import (
+    VoidElement, Img, Input, Hr, Meta, Link, Source, Embed, Param, Track,
+    Wbr, Area, Base, Col,
+    img, Input, hr, meta, link, source, embed, param, track,
+    wbr, area, base, col
+)
+
+# ----------------------------------------------------------------------
+# Special containers
+# ----------------------------------------------------------------------
+from .special import (
+    Video, Audio, Picture, ObjectElement,
+    video, audio, picture, Object
+)
+
+# ----------------------------------------------------------------------
+# Public API
+# ----------------------------------------------------------------------
+__all__ = [
+    # CSS
+    "css",
+    "CreateColor",
+    "CreateWithColor",
+    "CreateFont", 
+    "FooterFont",
+    "HeaderFont",
+    "MainFont",
+    
+    # Core
+    "HtmlDoc",
+    "CSSRegistry",
+    "Block",
+
+    # Tags
+    "Div", "Section", "Article", "Header", "Footer", "Nav", "Main", "Aside",
+    "Button", "Form", "Ul", "Li", "A",
+    "div", "section", "article", "header", "footer", "nav", "main", "aside",
+    "button", "form", "ul", "li", "a",
+
+    # Void elements
+    "VoidElement", "Img", "Input", "Hr", "Meta", "Link", "Source",
+    "Embed", "Param", "Track", "Wbr", "Area", "Base", "Col",
+    "img", "input", "hr", "meta", "link", "source", "embed",
+    "param", "track", "wbr", "area", "base", "col",
+
+    # Special containers
+    "Video", "Audio", "Picture", "ObjectElement",
+    "video", "audio", "picture", "Object",
+]   

pyfrontkit/block.py

@@ -0,0 +1,280 @@
+# Copyright (C) [2025] Eduardo Antonio Ferrera Rodríguez
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY. See the COPYING file for more details.
+
+
+# pyfrontkit/block.py
+
+from .content import ContentFactory
+from .css_register import CSSRegistry
+from typing import Any
+
+# Global whitelist of valid HTML attributes
+VALID_HTML_ATTRS = {
+    "id", "class", "class_", "style", "title", "alt", "src", "href", "target",
+    "type", "name", "value", "disabled", "checked", "readonly", "placeholder",
+}
+
+# Optional tag-specific whitelist
+TAG_SPECIFIC_ATTRS = {
+    "a": {"href", "target", "rel", "title"},
+    "img": {"src", "alt", "title"},
+    "input": {"type", "name", "value", "placeholder", "checked", "disabled", "readonly"},
+    "button": {"type", "name", "value", "disabled"},
+}
+
+class Block:
+    """
+    Base element for container tags (div, section, article, etc.)
+    - Processes and validates HTML attributes (id, class_, style, etc.)
+    - Processes ctn_* into ContentItem (via ContentFactory)
+    - Registers in DOM if an id is present
+    - Allows adding children only if an id is present
+    - All blocks are registered globally to respect creation order
+    """
+
+    _registry = []
+
+    def __init__(self, tag: str, *children: Any, _parent=None, **kwargs):
+        self.tag = tag
+        self._parent = _parent
+
+        # Extract and validate attributes
+        self.attrs = self._extract_attributes(kwargs)
+
+        # CTN content items
+        self.content_items = ContentFactory.create_from_kwargs(**kwargs)
+
+        # Initial children
+        self.children = []
+        for ch in children:
+            self.add_child(ch)
+
+        # Register in DOM if id exists
+        block_id = self.attrs.get("id")
+        if block_id:
+            
+            from .dom import DOM 
+            DOM.register(block_id, self)
+
+       
+        Block._registry.append(self)
+
+        
+        
+
+    # ------------------------------
+    # Attribute extraction and validation
+    # ------------------------------
+    def _extract_attributes(self, kwargs: dict) -> dict:
+        attrs = {}
+        for key, value in kwargs.items():
+            if ContentFactory.is_ctn_key(key):
+                continue
+
+            # Normalize class_
+            if key == "class_":
+                key = "class"
+
+            # Always allow 'style'
+            if key == "style":
+                if value not in (None, False):
+                    attrs[key] = value
+                continue
+
+            # Validate against global list
+            if key not in VALID_HTML_ATTRS:
+                print(f"⚠️ Warning: '{key}' is not a valid HTML attribute for <{self.tag}>")
+                continue
+
+            # Validate against tag-specific list
+            allowed_tag_attrs = TAG_SPECIFIC_ATTRS.get(self.tag, set())
+            if allowed_tag_attrs and key not in allowed_tag_attrs and key not in ("id", "class"):
+                print(f"⚠️ Warning: '{key}' is not valid for <{self.tag}>")
+                continue
+
+            # Boolean attributes
+            if value is True:
+                attrs[key] = None
+            elif value not in (None, False):
+                attrs[key] = value
+        return attrs
+
+    # ------------------------------
+    # Adding children
+    # ------------------------------
+    def add_child(self, *children):
+        if not self.attrs.get("id"):
+            raise RuntimeError(f"The <{self.tag}> block does not have an id; it cannot contain children.")
+
+        for ch in children:
+            if isinstance(ch, (list, tuple)):
+                for sub in ch:
+                    self._attach_child(sub)
+            else:
+                self._attach_child(ch)
+
+    def _attach_child(self, child):
+        if isinstance(child, Block):
+            child._parent = self
+
+        
+        if hasattr(child, "render"):
+            self.children.append(child)
+
+            if isinstance(child, Block):
+                
+                child_id = child.attrs.get("id")
+                if child_id:
+                    from .dom import DOM 
+                    DOM.register(child_id, child)
+
+               
+        else:
+           
+            from .content import ContentItem
+            ci = ContentItem("p", str(child))
+            self.content_items.append(ci)
+
+
+    
+    def _render_opening_tag(self, indent: int) -> str:
+        space = " " * indent
+        attr_text = ""
+        for key, value in self.attrs.items():
+            if value is None:
+                attr_text += f" {key}"
+            else:
+                attr_text += f' {key}="{value}"'
+        return f"{space}<{self.tag}{attr_text}>\n"
+
+    def _render_closing_tag(self, indent: int) -> str:
+        space = " " * indent
+        return f"{space}</{self.tag}>\n"
+
+    def _render_content(self, indent: int) -> str:
+        html = ""
+        for item in self.content_items:
+            html += item.render(indent + 2)
+        for child in self.children:
+            html += child.render(indent + 2)
+        return html
+
+    def render(self, indent: int = 0) -> str:
+        html = self._render_opening_tag(indent)
+        html += self._render_content(indent)
+        html += self._render_closing_tag(indent)
+        return html
+
+    def __str__(self):
+        return self.render(0)
+    
+    def _get_main_selector(self):
+        """
+        Returns the strongest selector based on priority:
+        id > class > tag
+
+        Also returns the selector type for internal logic.
+        """
+        if self.attrs.get("id"):
+            return f"#{self.attrs['id']}", "id"
+
+        elif self.attrs.get("class"):
+            return f".{self.attrs['class']}", "class"
+
+        else:
+            return self.tag, "tag"
+
+
+    def align(self, orientation=None, gap=None, padding=None, grid_column=None):
+        if orientation is None:
+            print("The method align() requires the 'orientation' parameter")
+            return self
+
+        if orientation not in ("column", "row", "grid"):
+            print("align(): invalid orientation. Use 'column', 'row' or 'grid'")
+            return self
+
+        if orientation == "grid" and not grid_column:
+            print("align(): 'grid_column' is required when orientation='grid'")
+            return self
+
+        selector, _ = self._get_main_selector()
+
+        templates = {
+            "column": '''
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    {gap}
+    {padding}
+    ''',
+            "row": '''
+    display: flex;
+    flex-direction: row;
+    flex-wrap: wrap;
+    {padding}
+    {gap}
+    ''',
+            "grid": '''
+    display: grid;
+    grid-template-columns: repeat({grid_column}, 1fr);
+    {gap}
+    {padding}
+    '''
+        }
+
+        gap_text = f"gap: {gap};" if gap else ""
+        padding_text = f"padding: {padding};" if padding else ""
+        
+        template = templates[orientation]
+        css_text = template.format(
+            gap=gap_text,
+            padding=padding_text,
+            grid_column=grid_column if grid_column else "1"
+        )
+
+        from .style_manager import CSS_RULES_STYLE
+        CSS_RULES_STYLE.append({selector: {"css": css_text}})
+
+        return self
+
+    def form(self, width=None, height=None, border_radius=None):
+        """
+        Set the size and shape of the Block container.
+        
+        Parameters:
+            width (str): container width (e.g., '200px', '50%')
+            height (str): container height (e.g., '100px', 'auto')
+            border_radius (str): container shape (e.g., '0', '10px', '50%')
+        """
+        # ------------------------------
+        # Get main selector
+        # ------------------------------
+        selector, _ = self._get_main_selector()
+
+        # ------------------------------
+        # Build CSS lines
+        # ------------------------------
+        css_lines = []
+        if width:
+            css_lines.append(f"width: {width};")
+        if height:
+            css_lines.append(f"height: {height};")
+        if border_radius:
+            css_lines.append(f"border-radius: {border_radius};")
+
+        css_text = "\n".join(css_lines)
+
+        # ------------------------------
+        # Save to global style list
+        # ------------------------------
+        from .style_manager import CSS_RULES_STYLE
+        CSS_RULES_STYLE.append({selector: {"css": css_text}})
+
+        return self

pyfrontkit/content.py

@@ -0,0 +1,67 @@
+
+# Copyright (C) [2025] Eduardo Antonio Ferrera Rodríguez
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; see the COPYING file for more details.
+
+
+# pyfrontkit/content.py
+
+class ContentItem:
+    """
+    Represents a simple content element:
+    <tag>text</tag>
+    
+    Supports Python newline (\n) conversion into <br /> automatically.
+    """
+
+    def __init__(self, tag: str, text: str):
+        self.tag = tag
+        self.lines = text.split("\n")  # split text by newline
+
+    def render(self, indent: int = 0):
+        space = " " * indent
+        html = f"{space}<{self.tag}>"
+        for i, line in enumerate(self.lines):
+            html += line
+            if i < len(self.lines) - 1:
+                html += "<br />"
+        html += f"</{self.tag}>\n"
+        return html
+
+
+class ContentFactory:
+    """
+    Responsible for creating ContentItem objects from keys like 'ctn_p', 'ctn_h1', etc.
+    """
+
+    # Official list of supported tags
+    SUPPORTED_TAGS = {
+        "p", "span",
+        "b", "strong", "i", "u", "em", "small", "mark", "code",
+        "h1", "h2", "h3", "h4", "h5", "h6"
+    }
+
+    @classmethod
+    def is_ctn_key(cls, key: str) -> bool:
+        """Checks if the key follows the 'ctn_tag' pattern."""
+        return key.startswith("ctn_") and key[4:] in cls.SUPPORTED_TAGS
+
+    @classmethod
+    def create_from_kwargs(cls, **kwargs):
+        """
+        Processes kwargs and returns a list of ContentItem.
+        Example: ctn_p="hello" → ContentItem("p", "hello")
+        """
+        items = []
+
+        for key, value in kwargs.items():
+            if cls.is_ctn_key(key):
+                tag = key[4:]  # remove 'ctn_'
+                items.append(ContentItem(tag, value))
+
+        return items

pyfrontkit/css/__init__.py

@@ -0,0 +1,30 @@
+# pyfrontkit/css/__init__.py
+
+"""
+CSS module for PyFrontKit.
+
+Exports:
+    - CreateColor class
+    - palettes
+    - colors_templates
+"""
+
+# expose the create_color package
+from .create_color import CreateColor
+from .create_color import CreateWithColor
+from .create_color import palettes
+from .create_color import colors_templates
+from .fonts import CreateFont
+from .fonts import FooterFont
+from .fonts import HeaderFont
+from .fonts import MainFont
+__all__ = [
+    "FooterFont",
+    "HeaderFont",
+    "MainFont",
+    "CreateFont",
+    "CreateColor",
+    "CreateWithColor",
+    "palettes",
+    "colors_templates",
+]

pyfrontkit/css/create_color/__init__.py

@@ -0,0 +1,11 @@
+# pyfrontkit/css/create_color/__init__.py
+
+# Expose CreateColor
+from .create_colors import CreateColor
+from .create_colors import CreateWithColor
+
+# Expose palettes dictionary
+from .palettes import *  
+
+
+from .colors_templates import *

pyfrontkit/css/create_color/colors_templates/__init__.py

@@ -0,0 +1,28 @@
+from .simple_template import simple
+from .classic_template import classic
+from .dark_reverse_template import dark_reverse
+from .mono_template import mono
+from .enfasis_main_template import enfasis_main
+from .soft_template import soft
+from .classic_reverse_template import classic_reverse
+from .asimetric_template import asimetric
+from .total_template import total
+from .darkness_template import darkness
+from .mono_accent_template import mono_accent
+from .total_v2_template import total_v2
+
+
+__all__ = [
+    "simple",
+    "classic",
+    "dark_reverse",
+    "mono",
+    "enfasis_main",
+    "soft",
+    "classic_reverse",
+    "asimetric",
+    "total",
+    "darkness",
+    "mono_accent",
+    "total_v2"
+]

pyfrontkit/css/create_color/colors_templates/asimetric_template.py

@@ -0,0 +1,19 @@
+asimetric = {
+    "simple_selector": {
+        "body":   {"color": "black", "background-color": "quaternary"},
+        "header": {"color": "principal", "background-color": "quaternary"},
+        "footer": {"color": "white", "background-color": "secondary"},
+        "text_htags": {"color": "principal"},
+        "h3": {"color": "principal"},
+        "h4": {"color": "principal"},
+        "button": {"color": "white", "background-color": "secondary"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"black"},
+        "footer>text_tags": {"color": "white"},
+        "header>button": {"color": "white", "background-color": "principal"}
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/classic_reverse_template.py

@@ -0,0 +1,19 @@
+classic_reverse = {
+    "simple_selector": {
+        "body":   {"color": "white", "background-color": "principal"},
+        "header": {"color": "black", "background-color": "quaternary"},
+        "footer": {"color": "white", "background-color": "secondary"},
+        "text_htags": {"color": "quaternary"},
+        "h3": {"color": "quaternary"},
+        "h4": {"color": "quaternary"},
+        "button": {"color": "black", "background-color": "quaternary"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"black"},
+        "footer>text_tags": {"color": "white"},
+        "header>button": {"color": "white", "background-color": "principal"}
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/classic_template.py

@@ -0,0 +1,22 @@
+
+classic = {
+    "simple_selector": {
+        "body":   {"color": "black", "background-color": "quaternary"},
+        "header": {"color": "quaternary", "background-color": "principal"},
+        "footer": {"color": "quaternary", "background-color": "secondary"},
+        "text_htags": {"color": "principal"},
+        "h3": {"color": "secondary"},
+        "h4": {"color": "secondary"},
+        "button": {"color": "white", "background-color": "principal"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"white"},
+        "header>text_htags":{"color":"white"},
+        "header>button":{"color":"white","background-color":"secondary"},
+        "footer>text_tags": {"color": "white"},
+        "footer>text_htags": {"color": "white"}
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/dark_reverse_template.py

@@ -0,0 +1,19 @@
+dark_reverse = {
+    "simple_selector": {
+        "body":   {"color": "white", "background-color": "secondary"},
+        "header": {"color": "white", "background-color": "principal"},
+        "footer": {"color": "white", "background-color": "principal"},
+        "text_htags": {"color": "quaternary"},
+        "h3": {"color": "quaternary"},
+        "h4": {"color": "quaternary"},
+        "button": {"color": "black", "background-color": "quaternary"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"white"},
+        "footer>text_tags": {"color": "white"},
+        "footer>button": {"color": "black", "background-color": "quaternary"}
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/darkness_template.py

@@ -0,0 +1,26 @@
+darkness = {
+    "simple_selector": {
+        # Esqueleto totalmente oscuro (secondary)
+        "body":   {"color": "white", "background-color": "secondary"},
+        "header": {"color": "white", "background-color": "secondary"},
+        "footer": {"color": "white", "background-color": "secondary"},
+        
+        # Títulos en color claro acentuado
+        "text_htags": {"color": "quaternary"},
+        "text_tags": {"color": "white"},
+        
+        # Los contenedores de bloques usan un fondo ligeramente diferente (principal)
+        "block_tags": {"background-color": "principal", "color": "white"},
+        
+        "button": {"color": "black", "background-color": "quaternary"}
+    },
+
+    "doble_selector": {
+        "header>a": {"color":"quaternary"},
+        "footer>a": {"color": "quaternary"},
+        # El texto en los bloques mantiene el blanco, solo cambia sutilmente el fondo
+        "block_tags>text_tags": {"color": "white"} 
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/enfasis_main_template.py

@@ -0,0 +1,19 @@
+enfasis_main = {
+    "simple_selector": {
+        "body":   {"color": "black", "background-color": "secondary"},
+        "header": {"color": "white", "background-color": "principal"},
+        "footer": {"color": "white", "background-color": "principal"},
+        "text_htags": {"color": "principal"},
+        "h3": {"color": "black"},
+        "h4": {"color": "black"},
+        "button": {"color": "white", "background-color": "tertiary"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"white"},
+        "footer>text_tags": {"color": "white"},
+        "body>button": {"color": "white", "background-color": "principal"}
+    },
+
+    "triple_selector": {}
+}

pyfrontkit/css/create_color/colors_templates/mono_accent_template.py

@@ -0,0 +1,28 @@
+mono_accent = {
+    "simple_selector": {
+        
+        "body":   {"color": "black", "background-color": "quaternary"},
+        "header": {"color": "black", "background-color": "quaternary"},
+        "footer": {"color": "black", "background-color": "quaternary"},
+        
+        "text_htags": {"color": "principal"},
+        "text_tags": {"color": "black"},
+        
+        
+        "block_tags": {"background-color": "tertiary", "color": "black"},
+        
+        "button": {"color": "white", "background-color": "principal"}
+    },
+
+    "doble_selector": {
+        "header>text_tags": {"color":"black"},
+        "footer>text_tags": {"color": "black"},
+        
+        "block_tags>text_htags": {"color": "secondary"}
+    },
+
+    "triple_selector": {
+        
+        "block_tags>p": {"color": "principal"}
+    }
+}