pyweber 1.2.0.dev20260424__tar.gz → 1.2.0.dev20260425__tar.gz

{pyweber-1.2.0.dev20260424/pyweber.egg-info → pyweber-1.2.0.dev20260425}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyweber
-Version: 1.2.0.dev20260424
+Version: 1.2.0.dev20260425
 Summary: A lightweight Python framework for building and managing web applications.
 Author-email: DevPythonMZ <pypi.dev@gmail.com>
 License-Expression: MIT

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260425}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyweber"
-version = "1.2.0.dev20260424"
+version = "1.2.0.dev20260425"
 description = "A lightweight Python framework for building and managing web applications."
 readme = "README.md"
 authors = [{ name = "DevPythonMZ", email = "pypi.dev@gmail.com" }]

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260425}/pyweber/core/element.py

@@ -1,4 +1,6 @@
 from uuid import uuid4
+import lxml.html as HTMLPARSER
+from lxml.html import fromstring
 from typing import Union, Any, Literal
 from pyweber.utils.types import HTMLTag, GetBy
 from pyweber.models.file import File
@@ -23,6 +25,7 @@ class Element(ElementConstrutor): # pragma: no cover
         data: Any = None,
         sanitize: bool = False,
         files: list[File] = None,
+        include_uuid: bool = True,
         **kwargs: str
     ):
         super().__init__(
@@ -37,72 +40,73 @@ class Element(ElementConstrutor): # pragma: no cover
             events=events,
             sanitize=sanitize,
             files=files,
+            include_uuid=include_uuid,
             **kwargs
         )
         self.uuid = getattr(self, 'uuid', None) or str(uuid4())
         self.data = data
         self.__element_methods: dict[str, dict[str, Any]] = {}
-    
+
     @property
     def parent(self):
         return self.__parent
-    
+
     @parent.setter
     def parent(self, value: 'Element'):
         if value is None:
             self.__parent = None
             return
-        
+
         if not isinstance(value, Element):
             raise TypeError("Parent must be an Element instance")
 
         self.__parent = value
-    
+
     @property
     def childs(self):
         return self.__childs
-    
+
     @childs.setter
     def childs(self, value: ChildElements):
         if not isinstance(value, (list, ChildElements)):
             raise TypeError(f"Children must be a ChildElements instances, but got {type(value).__name__}")
-        
+
         if isinstance(value, list):
             value = ChildElements(self).extend(value)
 
         value = self.__render_dynamic_elements(childs=value)
-        
+
         self.__childs = value
-    
+
     @property
     def index(self) -> Union[int, None]:
         return self.parent.childs.index(self) if self.parent else None
-    
+
     def first_child(self) -> Union['Element', None]:
         return self.childs[0] if self.childs else None
-    
+
     def last_child(self) -> Union['Element', None]:
         return self.childs[-1] if self.childs else None
-    
+
     def previous_child(self) -> Union['Element', None]:
         if self.parent:
             return self.parent.childs[self.index-1] if len(self.parent.childs) > 0 else None
-    
+
     def next_child(self) ->Union['Element', None]:
         if self.parent:
             return self.parent.childs[self.index+1] if len(self.parent.childs) >= self.index+1 else None
-    
+
     def add_child(self, child: 'Element'):
         if not isinstance(child,  Element):
             raise TypeError("Child must be Element instances")
-        
+
         self.__childs.append(child)
         child.parent = self
-    
+
     def remove_child(self, child: 'Element'):
         if child not in self.__childs:
             raise IndexError('Child not defined for this parent Element')
-        
+
         self.__childs.remove(child)
         child.parent = None
 
@@ -111,11 +115,11 @@ class Element(ElementConstrutor): # pragma: no cover
             raise TypeError(f'Index must be a integer, but you got {type(index).__name__}')
 
         return self.__childs.pop(index)
-    
+
     def remove(self):
         if self.parent:
             self.parent.remove_child(self)
-    
+
     def focus(self):
         self.set_selection_range(self.selection_end, self.selection_end)
         self.__set_element_methods(method='focus')
@@ -125,36 +129,36 @@ class Element(ElementConstrutor): # pragma: no cover
 
     def select(self):
         self.__set_element_methods(method='select')
-    
+
     def click(self):
         self.__set_element_methods(method='click')
-    
+
     def scroll_into_view(
         self,
         behavior: Literal['instant', 'smooth'] = 'instant',
         block: Literal['start', 'center', 'end'] = 'start'
     ):
         self.__set_element_methods(method='scrollIntoView', behavior=behavior, block=block)
-    
+
     def set_selection_range(self, start: int, end: str):
         self.__set_element_methods(method='setSelectionRange', start=start, end=end)
-    
+
     def getElement(self, by: GetBy, value: str, element: 'Element' = None) -> 'Element':
         results = self.getElements(by=by, value=value, element=element)
 
         return results[0] if results else None
-    
+
     def getElements(self, by: GetBy, value: str, element: 'Element' = None) -> list['Element']:
         element = element or self
         results: list['Element'] = []
 
         if isinstance(by, GetBy):
             by: str = by.value
-        
+
         if by == 'classes':
             if set(value.split()) <= set(element.classes):
                 results.append(element)
-        
+
         elif by in ['attrs', 'style']:
             conditions: list[str] = [pair.strip() for pair in value.split(';') if pair.strip()]
             has = False
@@ -171,24 +175,24 @@ class Element(ElementConstrutor): # pragma: no cover
 
                 elif key.strip() in el and el.get(key.strip(), None) == val.strip():
                     has = True
-            
+
             if has:
                 results.append(element)
-        
+
         elif getattr(element, by, None) == value:
             results.append(element)
-        
+
         if element.childs:
             for child in element.childs:
                 results.extend(self.getElements(by=by, value=value, element=child))
-        
+
         return results
-    
+
     def querySelector(self, selector: str, element: 'Element' = None) -> 'Element':
         results = self.querySelectorAll(selector=selector, element=element)
 
         return results[0] if results else None
-    
+
     def querySelectorAll(self, selector: str, element: 'Element' = None) -> list['Element']:
         element = element or self
         results: list['Element'] = []
@@ -196,28 +200,28 @@ class Element(ElementConstrutor): # pragma: no cover
         if selector.startswith('.'):
             classes = ' '.join(selector.split('.')).strip()
             return self.getElements(by=GetBy.classes, value=classes)
-        
+
         elif selector.startswith('#'):
             if selector[1:].strip() == element.id:
                 results.append(element)
-        
+
         elif selector.startswith('['):
             sel = selector.removeprefix('[').removesuffix(']')
             return self.getElements(by=GetBy.attrs, value=sel)
-        
+
         else:
             if selector.strip() == element.tag:
                 results.append(element)
-        
+
         for child in element.childs:
             results.extend(self.querySelectorAll(selector=selector, element=child))
 
         return results
-    
+
     @property
     def clone(self):
         from pyweber.core.events import TemplateEvents
-        
+
         element = self
 
         cln = Element(
@@ -240,20 +244,20 @@ class Element(ElementConstrutor): # pragma: no cover
             cln.childs.append(child.clone)
 
         return cln
-    
+
     def get_element_methods(self):
         return self.__element_methods
-    
+
     def __set_element_methods(self, method: str, **kwargs):
         self.__element_methods[method] = kwargs
-    
+
     def remove_element_methods(self, method: Any = None):
         if not method:
             self.__element_methods.clear()
             return
-        
+
         self.__element_methods.pop(method, None)
-    
+
     def __render_dynamic_elements(self, childs: ChildElements):
         new_childs: ChildElements = ChildElements(self)
         if childs:
@@ -261,7 +265,7 @@ class Element(ElementConstrutor): # pragma: no cover
                 if isinstance(child, str):
                     if not child.startswith('{{') or not child.endswith('}}'):
                         raise ValueError("{} must be starts with '{{' and ends with '}}'".format(child))
-                    
+
                     key = child.removeprefix('{{').removesuffix('}}').strip()
                     element = self.kwargs.get(key, None)
 
@@ -270,18 +274,95 @@ class Element(ElementConstrutor): # pragma: no cover
 
                     elif isinstance(element, ElementConstrutor):
                         new_childs.append(element)
-                
+
                 elif isinstance(child, ElementConstrutor):
                     new_childs.append(child)
-                
+
                 else:
                     raise TypeError(f'all childs must be str or Element instances, but got {type(child).__name__}')
-        
+
         return new_childs
 
+    @classmethod
+    def from_html(cls, html: str, include_uuid: bool = True, **kwargs):
+        HtmlElement = fromstring(html.strip())
+        return cls._create_element(HTMLElement=HtmlElement, parent=None, include_uuid=include_uuid, **kwargs)
+
+    @classmethod
+    def _create_element(cls, HTMLElement, parent=None, include_uuid: bool = True, **kwargs):
+
+        def gettail(val):
+            try: return val.strip()
+            except: return val
+
+        name = 'comment' if isinstance(HTMLElement, HTMLPARSER.HtmlComment) else HTMLElement.tag
+        attrib = HTMLElement.attrib
+
+        id_ = cls.render_dynamic_values(attrib.pop('id', None), **kwargs)
+        class_str = cls.render_dynamic_values(attrib.pop('class', None), **kwargs)
+        classes = class_str.split() if class_str else []
+
+        style_str = cls.render_dynamic_values(attrib.pop('style', None), **kwargs)
+        style_dict = {}
+        if style_str:
+            for pair in [s.strip() for s in style_str.split(';') if s.strip()]:
+                if ':' in pair:
+                    k, v = pair.split(':', 1)
+                    style_dict[k.strip()] = v.strip()
+
+        uuid = attrib.pop('uuid', None)
+        value = cls.render_dynamic_values(attrib.pop('value', None), **kwargs)
+
+        content = cls.render_dynamic_values(HTMLElement.text or None, **kwargs)
+
+        events_dict = {k[1:]: attrib.pop(k) for k in list(attrib) if k.startswith('_on')}
+        event_obj = TemplateEvents()
+        for key, event in events_dict.items():
+            if hasattr(event_obj, key): setattr(event_obj, key, event)
+
+        element = cls(
+            tag=name,
+            id=id_,
+            classes=classes,
+            value=value,
+            content=content,
+            events=event_obj,
+            style=style_dict,
+            attrs=dict(attrib),
+            childs=None,
+            sanitize=False,
+            files=[],
+            include_uuid=include_uuid,
+            **kwargs
+        )
+        element.parent = parent
+        element.uuid = uuid
+
+        if element.tag == 'select' and value:
+            __xyza = value
+
+        for child in HTMLElement.getchildren():
+            child_el = cls._create_element(
+                HTMLElement=child,
+                parent=element,
+                include_uuid=include_uuid,
+                **kwargs
+            )
+            element.childs.append(child_el)
+            get_tail = gettail(child.tail)
+
+            if get_tail:
+                uuid_child = "{{" + child_el.uuid + "}}"
+                element.content = (element.content or '') + f"{uuid_child} {get_tail}"
+
+        if element.tag == 'select' and element.childs:
+            try: element.value = __xyza
+            except: pass
+        return element
+
     def update(self):
         raise NotImplementedError
-    
+
     def __deepy_clone(self, obj):
         if isinstance(obj, list):
             return [self.__deepy_clone(item) for item in obj]
@@ -289,6 +370,6 @@ class Element(ElementConstrutor): # pragma: no cover
             return {chave: self.__deepy_clone(valor) for chave, valor in obj.items()}
         else:
             return obj
-    
+
     def __str__(self):
-        return self.to_html()
+        return self.to_html()

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260425}/pyweber/core/template.py

@@ -1,9 +1,5 @@
 import os
-import re
 from uuid import uuid4
-import lxml.html as HTMLPARSER
-from lxml.etree import Element as LXML_Element
-from pyweber.core.events import TemplateEvents
 from pyweber.core.element import Element
 from pyweber.utils.loads import LoadStaticFiles
 from pyweber.config.config import config
@@ -77,13 +73,11 @@ class Template: # pragma: no cover
         return str(config['app'].get('icon'))
 
     def parse_html(self, html: str = None):
-        if not html:
-            html = self.__template
-
+        if not html: html = self.__template
         return self.__inject_default_elements(root=self.__parse_html(html=html))
 
     def build_html(self, include_doctype: bool = True):
-        html = self.root.to_html(include_uuid=self.__include_uuid)
+        html = self.root.to_html()
 
         if include_doctype:
             html = f'<!DOCTYPE html>\n{html}'
@@ -112,94 +106,13 @@ class Template: # pragma: no cover
                 html = f'<body>{html}</body>'
             html = f'<html>{html}</html>'
 
-        root: HTMLPARSER.HtmlElement = HTMLPARSER.fromstring(html=html)
-
-        if root.find(path='head') is None:
-            root.insert(0, LXML_Element('head'))
-
-        return self.__create_element(HTMLElement=root)
-
-    def __create_element(self, HTMLElement: HTMLPARSER.HtmlElement, parent: Element = None):
-        def gettail(html_element: str | None):
-            try:
-                return html_element.strip()
-            except:
-                return html_element
-
-        if isinstance(HTMLElement, HTMLPARSER.HtmlComment):
-            name = 'comment'
-        else:
-            name = HTMLElement.tag
-
-        id = self.__render_dynamic_values(content=HTMLElement.attrib.pop('id', None), include_uuid=self.__include_uuid)
-
-        class_str = self.__render_dynamic_values(content=HTMLElement.attrib.pop('class', None), include_uuid=self.__include_uuid)
-        classes = class_str.split() if class_str else []
-
-        style_str: str = self.__render_dynamic_values(content=HTMLElement.attrib.pop('style', None), include_uuid=self.__include_uuid)
-        style_dict = {}
-
-        if style_str:
-            style_pair = [s.strip() for s in style_str.split(';') if s.strip()]
-
-            for pair in style_pair:
-                if ':' in pair:
-                    key, value = pair.split(':', 1)
-                    style_dict[key.strip()] = value.strip()
-
-        parent = parent
-        uuid = HTMLElement.attrib.pop('uuid', None)
-        value = self.__render_dynamic_values(content=HTMLElement.attrib.pop('value', None), include_uuid=self.__include_uuid)
-        content: str = self.__render_dynamic_values(content=HTMLElement.text if HTMLElement.text else None, include_uuid=self.__include_uuid)
-        events_dict = {key[1:]: HTMLElement.attrib.pop(key) for key in HTMLElement.attrib if key.startswith('_on')}
-        childrens: list[HTMLPARSER.HtmlElement] = HTMLElement.getchildren()
-
-        event_obj = TemplateEvents()
-        for key, event in events_dict.items():
-            if hasattr(event_obj, key):
-                setattr(event_obj, key, event)
-
-        element = Element(
-            tag=name,
-            id=id,
-            classes=classes,
-            value=value,
-            content=content,
-            events=event_obj,
-            style=style_dict,
-            attrs=dict(HTMLElement.attrib),
-            **self.kwargs
-        )
-        element.parent = parent
-        element.template = self
-        element.uuid = uuid
-
-        if parent:
-            if gettail(HTMLElement.tail):
-                parent.content = parent.content or ''
-                parent.content += f"{{{element.uuid}}} {gettail(HTMLElement.tail)}"
+        element = Element.from_html(html=html, include_uuid=self.__include_uuid, **self.kwargs)
 
-        for child in childrens:
-            element.childs.append(self.__create_element(child, element))
+        if element.tag == 'html':
+            if not element.querySelector('head'): element.childs.insert(0, Element('head'))
 
         return element
 
-    def __render_dynamic_values(self, content: str, include_uuid: bool = True):
-        if content:
-            pattern = r'\{\{(.*?)\}\}'
-            result = re.findall(pattern, content)
-
-            if result:
-                for r in result:
-                    value = self.kwargs.get(r.strip(), None)
-                    if value is not None:
-                        if isinstance(value, Element):
-                            value = self.to_html(element=value, include_uuid=include_uuid)
-
-                        content = content.replace("{{" + r + "}}", str(value))
-
-        return content
-
     def __read_file(self, file_path: str) -> str:
         from pyweber.models.error_pages import ErrorPages
         if file_path.endswith('.html'):

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260425}/pyweber/models/element.py

@@ -16,6 +16,7 @@ from pyweber.utils.types import (
 )
 
 from pyweber.models.file import File
+from questionary import checkbox
 
 if TYPE_CHECKING: # pragma: no cover
     from pyweber.core.template import Template
@@ -68,8 +69,10 @@ class ElementConstrutor: # pragma: no cover
         events: TemplateEvents,
         sanitize: bool,
         files: list[File],
+        include_uuid: bool,
         **kwargs: str
     ):
+        self.include_uuid = include_uuid
         self.sanitize = sanitize
         self.kwargs = kwargs
         self.tag = tag
@@ -147,9 +150,7 @@ class ElementConstrutor: # pragma: no cover
 
     @uuid.setter
     def uuid(self, value: str):
-        if not value:
-            self.__uuid = str(uuid4())
-            return
+        if not value: value = str(uuid4())
 
         self.__uuid = value.strip()
 
@@ -347,16 +348,21 @@ class ElementConstrutor: # pragma: no cover
         if self.tag == 'textarea':
             self.content = value
 
-        if self.tag == 'select':
+        elif self.tag == 'select':
             self.__value = None
             if hasattr(self, 'childs') and self.childs:
                 for child in self.childs:
                     if child.tag == 'option':
-                        if child.value == value:
+                        if child.value == value or child.content == value:
                             child.set_attr('selected', '')
                         else:
                             child.remove_attr('selected')
 
+        elif self.get_attr('type', None) == 'checkbox':
+            self.__value = None
+            if value == 'on':
+                self.set_attr('checked', '')
+
     @property
     def events(self):
         return self.__events
@@ -383,7 +389,7 @@ class ElementConstrutor: # pragma: no cover
 
         setattr(self.__events, event_type.value, None)
 
-    def to_html(self, element: 'ElementConstrutor' = None, indent: int = 0, include_uuid: bool = True):
+    def to_html(self, element: 'Element' = None, indent: int = 0):
         if not element:
             element = self
 
@@ -391,7 +397,7 @@ class ElementConstrutor: # pragma: no cover
             raise TypeError(f'element must be an Element instances, but got {type(element).__name__}')
 
         indentation = ' ' * indent
-        uuid_attribute = f' uuid="{element.uuid}"' if include_uuid else ""
+        uuid_attribute = f' uuid="{element.uuid}"' if self.include_uuid else ""
         html = f'{indentation}<{element.tag}{uuid_attribute}' if element.tag != 'comment' else f'{indentation}<!--'
 
         if element.id:
@@ -425,15 +431,15 @@ class ElementConstrutor: # pragma: no cover
         if element.tag != 'comment':
             html += '>'
 
-        final_content = str((self.__render_dynamic_values(content=element.content, include_uuid=include_uuid) or ''))
+        final_content = str((self.render_dynamic_values(content=element.content, **self.kwargs) or ''))
         has_children = bool(element.childs)
 
         if has_children or '\n' in final_content:
             html += '\n'
 
         for child in element.childs:
-            child_html = self.to_html(child, indent + 4, include_uuid=include_uuid)
-            uuid_placeholder = f'{{{child.uuid}}}'
+            child_html = self.to_html(child, indent + 4)
+            uuid_placeholder = "{{" + child.uuid + "}}"
 
             if uuid_placeholder in final_content:
                 final_content: str = final_content.replace(uuid_placeholder, child_html)
@@ -450,8 +456,8 @@ class ElementConstrutor: # pragma: no cover
 
         return html
 
-    def __render_dynamic_values(self, content: str, include_uuid: bool = True):
-
+    @classmethod
+    def render_dynamic_values(self, content: str, **kwargs):
 
         if content:
             pattern = r'\{\{(.*?)\}\}'
@@ -459,16 +465,15 @@ class ElementConstrutor: # pragma: no cover
 
             if result:
                 for r in result:
-                    value = self.kwargs.get(r.strip(), None)
+                    value = kwargs.get(r.strip(), None)
                     if value is not None:
                         if isinstance(value, ElementConstrutor):
-                            value = self.to_html(element=value, include_uuid=include_uuid)
+                            value = self.to_html(element=value)
 
                         content = content.replace("{{" + r + "}}", str(value))
 
         return content
 
-
     def create_event_id(self, event: Union[Callable, str], type: str, element_id: str = None):
         from pyweber.core.events import EventBook
 

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260425/pyweber.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyweber
-Version: 1.2.0.dev20260424
+Version: 1.2.0.dev20260425
 Summary: A lightweight Python framework for building and managing web applications.
 Author-email: DevPythonMZ <pypi.dev@gmail.com>
 License-Expression: MIT