pyweber 1.2.0.dev20260425__tar.gz → 1.2.0.dev20260427__tar.gz

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

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

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

@@ -1,3 +1,4 @@
+import re
 from uuid import uuid4
 import lxml.html as HTMLPARSER
 from lxml.html import fromstring
@@ -10,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,
@@ -143,12 +146,79 @@ class Element(ElementConstrutor): # pragma: no cover
     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'] = []
 
@@ -156,50 +226,34 @@ class Element(ElementConstrutor): # pragma: no cover
             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:
+            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:
@@ -207,14 +261,14 @@ class Element(ElementConstrutor): # pragma: no cover
 
         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
 
@@ -320,6 +374,11 @@ class Element(ElementConstrutor): # pragma: no cover
         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_,
@@ -328,7 +387,7 @@ class Element(ElementConstrutor): # pragma: no cover
             content=content,
             events=event_obj,
             style=style_dict,
-            attrs=dict(attrib),
+            attrs=attrs,
             childs=None,
             sanitize=False,
             files=[],
@@ -353,7 +412,10 @@ class Element(ElementConstrutor): # pragma: no cover
 
             if get_tail:
                 uuid_child = "{{" + child_el.uuid + "}}"
-                element.content = (element.content or '') + f"{uuid_child} {get_tail}"
+                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

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

@@ -1,6 +1,6 @@
 import os
 from uuid import uuid4
-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
@@ -84,21 +84,43 @@ class Template: # pragma: no cover
 
         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'):

{pyweber-1.2.0.dev20260425 → pyweber-1.2.0.dev20260427}/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.dev20260425 → pyweber-1.2.0.dev20260427}/pyweber/models/element.py

@@ -307,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:
@@ -471,7 +482,6 @@ class ElementConstrutor: # pragma: no cover
                             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):

{pyweber-1.2.0.dev20260425 → pyweber-1.2.0.dev20260427}/pyweber/models/request.py

@@ -42,24 +42,24 @@ class Request: # pragma: no cover
             self.__raw_request_asgi = headers
             self.__raw_body = body or b''
             self.__raw_headers: list[tuple[bytes, bytes]] = headers.get('headers', [])
-            
+
         else:
             raise TypeError('Request type does not valid')
-        
+
         self.client_info = client_info
         self.__additions_headers()
-    
+
     @property
     def request_mode(self):
         return self.__request_mode
-    
+
     @request_mode.setter
     def request_mode(self, value):
         if not isinstance(value, RequestMode):
             raise TypeError('Request mode does not valid')
-        
+
         self.__request_mode = value
-    
+
     @property
     def client_info(self): return self.__client_info
 
@@ -67,63 +67,63 @@ class Request: # pragma: no cover
     def client_info(self, value: ClientInfo):
         if value and not isinstance(value, ClientInfo):
             raise TypeError('client_info must be a ClientInfo instances')
-        
+
         self.__client_info = value or ClientInfo(host=None, port=0)
-        
+
     @property
     def raw_headers(self):
         if self.request_mode.value == 'asgi':
             return self.__raw_request_asgi
-        
+
         return self.__raw_request_wsgi
-    
+
     @property
     def raw_body(self):
         return self.__raw_body
-    
+
     @property
     def host(self):
         return self.headers.get('host')
-    
+
     @property
     def port(self):
         try:
             return int(self.headers.get('host', '0').split(':')[-1])
         except:
             return 0
-    
+
     @property
     def content_length(self):
         return int(self.headers.get('content-length'))
-    
+
     @property
     def content_type(self):
         return self.headers.get('content-type', '')
-    
+
     @property
     def user_agent(self):
         return self.headers.get('user-agent')
-    
+
     @property
     def origin(self):
         return self.headers.get('origin')
-    
+
     @property
     def referrer(self):
         return self.headers.get('referrer')
-    
+
     @property
     def accept(self):
         return [val.strip().split(';') for val in self.headers.get('accept', '').split(',') if val]
-    
+
     @property
     def accept_encoding(self):
         return [val.strip().split(';') for val in self.headers.get('accept-encoding', '').split(',') if val]
-    
+
     @property
     def accept_language(self):
         return [val.strip().split(';') for val in self.headers.get('accept-language', '').split(',') if val]
-    
+
     @property
     def cookies(self):
         return {cookie.split('=')[0]: cookie.split('=')[-1] for cookie in self.headers.get('cookie', '').split(';') if cookie}
@@ -136,9 +136,9 @@ class Request: # pragma: no cover
     def headers(self):
         if self.request_mode.value == 'asgi':
             return {header[0].decode(): header[1].decode() for header in self.__raw_headers}
-        
+
         return self.__parse_headers_wsgi()
-    
+
     @property
     def body(self) -> Union[dict[str, Union[list[File], str]]]:
         if self.content_type == ContentTypes.json.value:
@@ -148,15 +148,18 @@ class Request: # pragma: no cover
         elif ContentTypes.form_data.value in self.content_type:
             return self.__parse_form_data()
         return {'body': self.__raw_body}
-    
+
     @property
     def first_line(self):
         if self.request_mode.value == 'wsgi':
             return self.__raw_headers.split(self.__line_splitter, 1)[0].strip()
-        
+
         full_path = f"{self.path}?{'&'.join(['{key}={value}'.format(key=key, value=value) for key, value in self.query_params.items()])}" if self.query_params else self.path
         return f"{self.method} {full_path} {self.scheme}"
 
+    @property
+    def full_path(self): return self.first_line.split(' ', 2)[1].strip()
+
     def __parse_form_data(self):
         fs = FieldStorage(self.content_type, callbacks=self.__raw_body)
         body: dict[str, list[File] | str] = {}
@@ -174,10 +177,10 @@ class Request: # pragma: no cover
 
                     body[field.name].append(field.value)
                 else:
-                    body[field.name] = field.value 
-                
+                    body[field.name] = field.value
+
         return body
-    
+
     def __additions_headers(self):
         if self.request_mode.value == 'asgi':
             self.method: str = self.raw_headers.get('method')
@@ -193,17 +196,17 @@ class Request: # pragma: no cover
             self.query_params = {
                 key: ';'.join(val) for key, val in parse_qs(line_info[1].split('?', 1)[-1]).items() if val
             } if len(line_info) >= 2 else {}
-        
+
     def __parse_headers_wsgi(self) -> dict[str, str]:
         return {header.split(':', 1)[0].strip().lower(): header.split(':', 1)[-1].strip() for header in self.__raw_headers.split(self.__line_splitter)[1::]}
-    
+
     @property
     def __line_splitter(self):
         return '\r\n'
-    
+
     @property
     def request_parts_splitter(self):
         return '\r\n\r\n'
 
     def __repr__(self):
-        return f"Request(method={self.method}, mode={self.request_mode})"
+        return f"Request(method={self.method}, mode={self.request_mode})"

{pyweber-1.2.0.dev20260425 → pyweber-1.2.0.dev20260427}/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
     ):
@@ -30,7 +30,7 @@ class Response:
             "Server": 'Pyweber/1.0',
             "Date": datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT"),
             "Set-Cookie": cookies,
-            "Request-Path": request.path,
+            "Request-Path": request.full_path,
             "Response-Path": route,
             "Access-Control-Allow-Origin": request.origin,
             "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
@@ -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.dev20260425 → pyweber-1.2.0.dev20260427}/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})'
@@ -542,6 +548,7 @@ class RouteManager: # pragma: no cover
         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):
@@ -589,14 +596,25 @@ class RouteManager: # pragma: no cover
     def __resolve_path__(route: str, list_routes: dict[str, Route | RedirectRoute]):
         kwargs: dict[str, str] = {}
 
+        # Separa path dos query params antes de qualquer processamento
+        clean_route, _, query_string = route.partition('?')
+
+        # Parse dos query params
+        query_params: dict[str, str] = {}
+        if query_string:
+            for pair in query_string.split('&'):
+                key, _, val = pair.partition('=')
+                if key:
+                    query_params[key] = val
+
         for path in list_routes:
             l_route = path.strip('/').split('/')
-            r_route = route.strip('/').split('/')
+            r_route = clean_route.strip('/').split('/')  # usa o path limpo
 
             if len(l_route) != len(r_route):
                 continue
 
-            if '{' in path and len(route) == 1:
+            if '{' in path and len(clean_route) == 1:
                 continue
 
             match = True
@@ -611,9 +629,9 @@ class RouteManager: # pragma: no cover
                     break
 
             if match:
-                return path, kwargs
+                return path, {**kwargs, **query_params}  # merge kwargs + query_params
 
-        return route, kwargs
+        return clean_route, query_params
 
     @staticmethod
     def inspect_function(callback: Callable):

{pyweber-1.2.0.dev20260425 → pyweber-1.2.0.dev20260427}/pyweber/pyweber/pyweber.py

@@ -476,25 +476,28 @@ class Pyweber(
         try:
             template = state_result.template
 
+            kwargs = {**self.request.body, **self.request.query_params, 'request': self.request} if self.request else {}
             while callable(template) or isinstance(template, RedirectRoute):
+                kwargs = {**kwargs, **state_result.kwargs}
+
                 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}
-                    )
+                    kwargs = {
+                        **kwargs,
+                        **OpenApiProcessor.prepare_callback_kwargs(callback=state_result.callback, **kwargs)
+                    }
 
                     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 = {**kwargs, **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
@@ -568,6 +571,14 @@ class Pyweber(
                     methods=['post'],
                     content_type=ContentTypes.json
                 ),
+                Route(
+                    route='/_pyweber/check-cookies',
+                    template={'message': 'OK'},
+                    methods=['get'],
+                    title='Get Cookies',
+                    process_response=False,
+                    content_type=ContentTypes.json
+                ),
                 Route(
                     route='/docs',
                     template=StaticFilePath.pyweber_docs.value,

{pyweber-1.2.0.dev20260425 → pyweber-1.2.0.dev20260427}/pyweber/static/js.js

@@ -117,6 +117,7 @@ function connectWebSocket() {
         }
 
         if (data.open) {
+            await update_cookies();
             data.open.new_page
                 ? window.open(data.open.path, '_blank')
                 : (window.location.href = data.open.path);
@@ -232,6 +233,13 @@ function connectWebSocket() {
     return socket;
 }
 
+async function update_cookies() {
+    await fetch(`/_pyweber/check-cookies`, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' }
+    });
+}
+
 // ─── Envio de ficheiro via HTTP (mantém binário puro, sem compressão JSON) ────
 async function send_file_chunk(file_id, status, data) {
     await fetch(`/_pyweber/file_chunk?file_id=${file_id}&status=${status}`, {

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

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