pyweber 1.2.0.dev20260424__tar.gz → 1.2.0.dev20260426__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyweber
-Version: 1.2.0.dev20260424
+Version: 1.2.0.dev20260426
 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.dev20260426}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyweber"
-version = "1.2.0.dev20260424"
+version = "1.2.0.dev20260426"
 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.dev20260426}/pyweber/core/element.py

@@ -1,4 +1,7 @@
+import re
 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
@@ -8,6 +11,8 @@ from pyweber.models.element import (
     ChildElements
 )
 
+SEARCH_MODE = Literal['exact', 'regex', 'contains', 'startswith', 'endswith']
+
 class Element(ElementConstrutor): # pragma: no cover
     def __init__(
         self,
@@ -23,6 +28,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 +43,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 +118,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,99 +132,150 @@ 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)
+
+    def getElement(self, by: GetBy, value: str, element: 'Element' = None, search_mode: SEARCH_MODE = 'exact') -> 'Element':
+        results = self.getElements(by=by, value=value, element=element, search_mode=search_mode)
 
         return results[0] if results else None
-    
-    def getElements(self, by: GetBy, value: str, element: 'Element' = None) -> list['Element']:
+
+    def getElements(
+        self,
+        by: GetBy,
+        value: str,
+        element: 'Element' = None,
+        search_mode: SEARCH_MODE = 'exact'
+    ) -> list['Element']:
+
+        def matches(target, val) -> bool:
+            if target is None: return False
+
+            # Lista (classes)
+            if isinstance(target, list):
+                search_classes = val.split()  # classes que o utilizador passou
+                match search_mode:
+                    case 'exact':      return set(search_classes) <= set(target)
+                    case 'regex':      return all(any(re.search(cls, t) for t in target) for cls in search_classes)
+                    case 'contains':   return all(any(cls in t for t in target) for cls in search_classes)
+                    case 'startswith': return all(any(t.startswith(cls) for t in target) for cls in search_classes)
+                    case 'endswith':   return all(any(t.endswith(cls) for t in target) for cls in search_classes)
+
+            # Dict (attrs, style)
+            if isinstance(target, dict):
+                conditions = [pair.strip() for pair in val.split(';') if pair.strip()]
+
+                match search_mode:
+                    case 'exact':
+                        for condition in conditions:
+                            key, _, v = condition.partition(':')
+                            if not v: key, _, v = condition.partition('=')
+                            if not v:
+                                if key.strip() not in target: return False
+                            elif target.get(key.strip()) != v.strip():
+                                return False
+                        return True
+
+                    case 'regex':
+                        return all(
+                            any(re.search(cond, k) or re.search(cond, str(v)) for k, v in target.items())
+                            for cond in conditions
+                        )
+                    case 'contains':
+                        return all(
+                            any(cond in k or cond in str(v) for k, v in target.items())
+                            for cond in conditions
+                        )
+                    case 'startswith':
+                        return all(
+                            any(k.startswith(cond) or str(v).startswith(cond) for k, v in target.items())
+                            for cond in conditions
+                        )
+                    case 'endswith':
+                        return all(
+                            any(k.endswith(cond) or str(v).endswith(cond) for k, v in target.items())
+                            for cond in conditions
+                        )
+
+            # String (id, tag, content, etc)
+            target = str(target)
+            match search_mode:
+                case 'exact':      return target == val
+                case 'regex':      return bool(re.search(val, target))
+                case 'contains':   return val in target
+                case 'startswith': return target.startswith(val)
+                case 'endswith':   return target.endswith(val)
+
+            return False
+
         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):
+            if matches(element.classes, value):
                 results.append(element)
-        
-        elif by in ['attrs', 'style']:
-            conditions: list[str] = [pair.strip() for pair in value.split(';') if pair.strip()]
-            has = False
-
-            el: dict[str, str] = getattr(element, by, {})
-            for condition in conditions:
-                key, _, val = condition.partition(':')
 
-                if not val: key, _, val = condition.partition('=')
-
-                if not val:
-                    if key.strip() in el:
-                        has = True
-
-                elif key.strip() in el and el.get(key.strip(), None) == val.strip():
-                    has = True
-            
-            if has:
+        elif by in ['attrs', 'style']:
+            if matches(getattr(element, by, {}), value):
                 results.append(element)
-        
-        elif getattr(element, by, None) == value:
+
+        elif matches(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))
-        
+                results.extend(self.getElements(by=by, value=value, element=child, search_mode=search_mode))
+
         return results
-    
-    def querySelector(self, selector: str, element: 'Element' = None) -> 'Element':
-        results = self.querySelectorAll(selector=selector, element=element)
+
+    def querySelector(self, selector: str, element: 'Element' = None, search_mode: SEARCH_MODE = 'exact') -> 'Element':
+        results = self.querySelectorAll(selector=selector, element=element, search_mode=search_mode)
 
         return results[0] if results else None
-    
-    def querySelectorAll(self, selector: str, element: 'Element' = None) -> list['Element']:
+
+    def querySelectorAll(self, selector: str, element: 'Element' = None, search_mode: SEARCH_MODE = 'exact') -> list['Element']:
         element = element or self
         results: list['Element'] = []
 
         if selector.startswith('.'):
             classes = ' '.join(selector.split('.')).strip()
-            return self.getElements(by=GetBy.classes, value=classes)
-        
+            return self.getElements(by=GetBy.classes, value=classes, search_mode=search_mode)
+
         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)
-        
+            return self.getElements(by=GetBy.attrs, value=sel, search_mode=search_mode)
+
         else:
             if selector.strip() == element.tag:
                 results.append(element)
-        
+
         for child in element.childs:
-            results.extend(self.querySelectorAll(selector=selector, element=child))
+            results.extend(self.querySelectorAll(selector=selector, element=child, search_mode=search_mode))
 
         return results
-    
+
     @property
     def clone(self):
         from pyweber.core.events import TemplateEvents
-        
+
         element = self
 
         cln = Element(
@@ -240,20 +298,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 +319,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 +328,103 @@ 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)
+
+        attrs = {
+            cls.render_dynamic_values(c, **kwargs): cls.render_dynamic_values(v, **kwargs)
+            for c, v in attrib.items()
+        }
+
+        element = cls(
+            tag=name,
+            id=id_,
+            classes=classes,
+            value=value,
+            content=content,
+            events=event_obj,
+            style=style_dict,
+            attrs=attrs,
+            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 = cls.render_dynamic_values(
+                    content=(element.content or '') + f"{uuid_child} {get_tail}",
+                    **kwargs
+                )
+
+        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 +432,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.dev20260426}/pyweber/core/template.py

@@ -1,10 +1,6 @@
 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.core.element import Element, SEARCH_MODE
 from pyweber.utils.loads import LoadStaticFiles
 from pyweber.config.config import config
 from pyweber.utils.types import HTTPStatusCode, GetBy
@@ -77,34 +73,54 @@ 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}'
 
         return html
 
-    def getElement(self, by: GetBy, value: str, element: Element = None):
+    def getElement(
+        self,
+        by: GetBy,
+        value: str,
+        element: Element = None,
+        search_mode: SEARCH_MODE='exact'
+    ):
         if not element: element = self.root
-        return element.getElement(by=by, value=value)
-
-    def getElements(self, by: GetBy, value: str, element: Element = None):
+        return element.getElement(by=by, value=value, search_mode=search_mode)
+
+    def getElements(
+        self,
+        by: GetBy,
+        value: str,
+        element: Element = None,
+        search_mode: SEARCH_MODE='exact'
+    ):
         if not element: element = self.root
-        return  element.getElements(by=by, value=value)
-
-    def querySelector(self, selector: str, element: Element = None):
+        return  element.getElements(by=by, value=value, search_mode=search_mode)
+
+    def querySelector(
+        self,
+        selector: str,
+        element: Element = None,
+        search_mode: SEARCH_MODE='exact'
+    ):
         if element is None: element = self.__root
-        return element.querySelector(selector=selector)
-
-    def querySelectorAll(self, selector: str, element: Element = None) -> list[Element]:
+        return element.querySelector(selector=selector, search_mode=search_mode)
+
+    def querySelectorAll(
+        self,
+        selector: str,
+        element: Element = None,
+        search_mode: SEARCH_MODE='exact'
+    ) -> list[Element]:
         if element is None: element = self.__root
-        return element.querySelectorAll(selector=selector)
+        return element.querySelectorAll(selector=selector, search_mode=search_mode)
 
     def __parse_html(self, html: str) -> Element:
         if not html.replace('<!DOCTYPE html>', '').strip().startswith('<html'):
@@ -112,94 +128,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'))
+        element = Element.from_html(html=html, include_uuid=self.__include_uuid, **self.kwargs)
 
-        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)}"
-
-        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.dev20260426}/pyweber/models/cookies.py

@@ -2,12 +2,12 @@ from datetime import datetime, timezone, timedelta
 
 class CookieManager:
     def __init__(self):
-        self.__cookies: list[str] = []
-    
+        self.__cookies: dict[str, str] = {}
+
     @property
     def cookies(self):
         return self.__cookies
-    
+
     def set_cookie(
         self,
         cookie_name: str,
@@ -25,10 +25,10 @@ class CookieManager:
 
         if httponly:
             cookie += ' HttpOnly;'
-        
+
         if secure:
             cookie += ' Secure;'
-        
+
         if samesite:
             if samesite not in ['Strict', 'Lax']:
                 raise ValueError("SameSite is not valid. Please use one of: ['Strict', 'Lax']")
@@ -54,9 +54,9 @@ class CookieManager:
 
             expires_str = expires.strftime("%a, %d %b %Y %H:%M:%S GMT")
             cookie += f' Expires={expires_str};'
-        
+
         if isinstance(max_age, (int, float)) and max_age > 0:
             cookie += f' Max-Age={max_age};'
-        
+
         if cookie not in self.__cookies:
-            self.__cookies.append(cookie)
+            self.__cookies[cookie_name] = cookie

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260426}/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()
 
@@ -306,6 +307,17 @@ class ElementConstrutor: # pragma: no cover
     def content(self):
         return self.__content
 
+    @property
+    def text_content(self):
+        uuids = re.findall(pattern=r'\{\{(.*?)\}\}', string=self.content or '')
+        child_uuids = {child.uuid for child in self.childs if child.uuid in uuids}
+        result = self.content or ''
+
+        for uuid in child_uuids:
+            u_ = "{{" + uuid + "}}"
+            result = result.replace(u_, '')
+        return result.strip()
+
     @content.setter
     def content(self, value: str):
         if value is None:
@@ -347,16 +359,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 +400,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 +408,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 +442,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 +467,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 +476,14 @@ 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.dev20260426}/pyweber/models/response.py

@@ -10,7 +10,7 @@ class Response:
         request: Request,
         response_content: bytes,
         code: int,
-        cookies: list[str],
+        cookies: dict[str, str],
         response_type: ContentTypes,
         route: str
     ):
@@ -153,7 +153,7 @@ class Response:
         for key, value in self.headers.items():
             if key == 'Set-Cookie':
                 for cookie in value:
-                    response += f'{key}: {cookie}\r\n'
+                    response += f'{key}: {value[cookie]}\r\n'
 
             elif key == 'Response':
                 pass

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260426}/pyweber/models/routes.py

@@ -109,7 +109,12 @@ class Route: # pragma: no cover
         self.__callback = callback or self.template if callable(self.template) else lambda **kwargs: self.template
 
     @property
-    def full_route(self): return f"/{self.group.removeprefix('__')}{self.route}" if self.group != self.default_group() else self.route
+    def full_route(self):
+        return f"/{self.group.removeprefix('__')}{self.route}" if self.group != self.default_group() else self.route
+
+    @property
+    def full_route_with_params(self):
+        return f"{self.full_route}{('?' + self.route_with_params.split('?',1)[-1] if self.query_params else '')}"
 
     @property
     def middlewares(self): return self.__middlewares
@@ -330,6 +335,7 @@ class Route: # pragma: no cover
             f'group={self.group}, '
             f'route={self.route}, '
             f'full_route={self.full_route}, '
+            f'route_with_params={self.route_with_params}, '
             f'name={self.name}, '
             f'methods={self.methods}, '
             f'status_code={self.status_code})'
@@ -538,10 +544,12 @@ class RouteManager: # pragma: no cover
 
     def get_route_by_path(self, route: str, follow_redirect: bool = True):
         path, _ = self.resolve_path(route=route)
+        path = path.split('?', 1)[0]
 
         if follow_redirect in [True, 1] and self.is_redirected(route=path):
             redirect_route = self.get_redirected_route(route=path)
             return redirect_route.route
+
         return self.__routes.get(path)
 
     def get_route_by_name(self, name: str):

{pyweber-1.2.0.dev20260424 → pyweber-1.2.0.dev20260426}/pyweber/pyweber/pyweber.py

@@ -477,8 +477,9 @@ class Pyweber(
             template = state_result.template
 
             while callable(template) or isinstance(template, RedirectRoute):
+                request_params = {**self.request.body, **self.request.query_params, 'request': self.request} if self.request else {}
+
                 if callable(template):
-                    request_params = {**self.request.body, **self.request.query_params, 'request': self.request} if self.request else {}
                     kwargs = OpenApiProcessor.prepare_callback_kwargs(
                         callback=state_result.callback,
                         **{**state_result.kwargs, **request_params}
@@ -487,14 +488,15 @@ class Pyweber(
                     template = await template(**kwargs) if inspect.iscoroutinefunction(template) else template(**kwargs)
 
                 if isinstance(template, RedirectRoute):
-                    redirect_path = self.build_route(route=template.route.full_route, **{**state_result.kwargs, **template.kwargs})
+                    kwargs = {**state_result.kwargs, **request_params, **template.kwargs}
+                    redirect_path = self.build_route(route=template.route.full_route_with_params, **kwargs)
 
                     self._check_recursion(route=redirect_path)
                     state_result = await self._process_redirect_route(
                         state=state_result,
                         redirect_route=template,
                         redirect_path=redirect_path,
-                        **state_result.kwargs
+                        **kwargs
                     )
 
                     template = state_result.template

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

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