vesta-web 1.1.2__py3-none-any.whl → 1.1.3__py3-none-any.whl

vesta/http/baseServer.py

@@ -1,3 +1,5 @@
+"""Vesta HTTP Server - Base server implementation with routing and request handling."""
+
 import fastwsgi
 import inspect
 
@@ -6,40 +8,58 @@ import time
 import json
 import hashlib
 import base64
-
 import re
-import urllib
-
-#requests modules
-import multipart as mp
+import urllib.parse
+import traceback
+from pathlib import Path
+from typing import Dict, Any, Optional, Callable
 from io import BytesIO
 
+import multipart as mp
 from configparser import ConfigParser
 
 from vesta.http import response
 from vesta.http import error
 from vesta.http import redirect
 from vesta.db import db_service as db
+
 Response = response.Response
 HTTPRedirect = redirect.HTTPRedirect
 HTTPError = error.HTTPError
 
+# Compile regex patterns once for performance
 RE_URL = re.compile(r"[\&]")
 RE_PARAM = re.compile(r"[\=]")
 
-routes = {}
-
 from colorama import Fore, Style
 from colorama import init as colorama_init
 colorama_init()
 
+routes: Dict[str, Dict[str, Any]] = {}
+
 class BaseServer:
-    features = {}
+    """Base HTTP server with routing, request parsing, and file handling capabilities."""
+
+    def __init__(self, path: str, configFile: str, noStart: bool = False):
+        """
+        Initialize the Vesta server.
+
+        Args:
+            path: Base path for the server
+            configFile: Path to configuration file
+            noStart: If True, don't start the server (useful for testing)
+
+        Raises:
+            ValueError: If path is invalid
+            FileNotFoundError: If config file doesn't exist
+        """
+        self.log("Starting Vesta server...")
 
-    def __init__(self, path, configFile, noStart=False):
-        print(Fore.GREEN,"[INFO] starting Vesta server...")
         self.path = path
 
+        # Instance-specific features
+        self.features: Dict[str, Any] = {}
+
         self.importConf(configFile)
 
         if noStart:
@@ -47,19 +67,25 @@ class BaseServer:
 
         self.start()
 
+
     #----------------------------HTTP SERVER------------------------------------
-    def expose(func):
-        def wrapper(self, *args, **kwargs):
+    def expose(func: Callable) -> Callable:
+        """
+        Decorator to expose a method as an HTTP route.
 
-            res = func(self, *args, **kwargs)
-            # print("[DEBUG] res : ", res)
+        Args:
+            func: Function to expose as a route
 
+        Returns:
+            Wrapped function
+        """
+        def wrapper(self, *args, **kwargs):
+            res = func(self, *args, **kwargs)
             self.response.ok()
             if res:
-
                 return res.encode()
             else:
-                return "".encode()
+                return b""
 
         name = func.__name__
         if func.__name__ == "index":
@@ -69,19 +95,42 @@ class BaseServer:
         else:
             name = "/" + func.__name__
 
-        routes[name] = {"params": inspect.signature(func).parameters, "target": wrapper}
+        routes[name] = {
+            "params": inspect.signature(func).parameters,
+            "target": wrapper
+        }
         return wrapper
 
-    def saveFile(self, content, name="",ext=None, category=None):
+
+    def saveFile(self, content: str, name: str = "", ext: Optional[str] = None,
+                 category: Optional[str] = None) -> str:
+        """
+        Save a base64-encoded file to the attachments' directory.
+
+        Args:
+            content: Base64-encoded file content with data URI prefix
+            name: Optional filename (generated from hash if not provided)
+            ext: Optional file extension override
+            category: Optional subdirectory category
+
+        Returns:
+            Relative path to saved file
+
+        Raises:
+            ValueError: If content is invalid or file size exceeds limit
+            IOError: If file cannot be saved
+        """
         content = content.split(",")
         extension = content[0].split("/")[1].split(";")[0]
         content = base64.b64decode(content[1])
 
-        if not name :
+        if not name:
             hash_object = hashlib.sha256(content)
             hex_dig = hash_object.hexdigest()
 
             name = hex_dig
+        else:
+            name = self._sanitize_filename(name)
 
         prefix = self.path + "/static/attachments/"
         if category:
@@ -93,17 +142,65 @@ class BaseServer:
             f.write(content)
         return name
 
-    def parseCookies(self, cookieStr):
+
+    def _sanitize_filename(self, filename: str) -> str:
+        """
+        Sanitize filename to prevent path traversal and other security issues.
+
+        Args:
+            filename: Filename to sanitize
+
+        Returns:
+            Sanitized filename
+        """
+        # Remove path separators and dangerous characters
+        filename = filename.replace('/', '').replace('\\', '').replace('..', '')
+        # Keep only alphanumeric, dash, underscore
+        filename = re.sub(r'[^a-zA-Z0-9_-]', '', filename)
+        if not filename:
+            raise ValueError("Invalid filename after sanitization")
+        return filename
+
+
+    def parseCookies(self, cookieStr: Optional[str]) -> Dict[str, str]:
+        """
+        Parse HTTP cookie header into a dictionary.
+
+        Args:
+            cookieStr: Raw cookie header string
+
+        Returns:
+            Dictionary of cookie name-value pairs
+        """
         if not cookieStr:
-            return
+            return {}
+
         cookies = {}
-        for cookie in cookieStr.split(';'):
-            key, value = cookie.split('=')
-            cookies[key.strip()] = value
+        try:
+            for cookie in cookieStr.split(';'):
+                if '=' in cookie:
+                    key, value = cookie.split('=', 1)
+                    cookies[key.strip()] = value.strip()
+        except Exception as e:
+            self.logWarning(f"Error parsing cookies: {e}")
+
         return cookies
 
 
-    def parseRequest(self,environ):
+
+    def parseRequest(self, environ: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Parse HTTP request into a dictionary of parameters.
+
+        Args:
+            environ: WSGI environ dictionary
+
+        Returns:
+            Dictionary of request parameters
+
+        Raises:
+            ValueError: If content length exceeds maximum
+        """
         self.response.cookies = self.parseCookies(environ.get('HTTP_COOKIE'))
 
         if environ.get('CONTENT_TYPE'):
@@ -112,30 +209,55 @@ class BaseServer:
             content_type = ["text/html"]
 
         args = {}
+
+        # Parse query string
         if environ.get('QUERY_STRING'):
             query = re.split(RE_URL, environ['QUERY_STRING'])
-            for i in range(0, len(query)):
-                query[i] = re.split(RE_PARAM, query[i])
-                args[query[i][0]] = urllib.parse.unquote_plus(query[i][1], encoding='utf-8')
+            for param in query:
+                parts = re.split(RE_PARAM, param)
+                if len(parts) == 2:
+                    args[parts[0]] = urllib.parse.unquote_plus(parts[1], encoding='utf-8')
+
+        content_length = int(environ.get('CONTENT_LENGTH', 0))
+        # Parse multipart form data
         if content_type[0] == "multipart/form-data":
-            length = int(environ.get('CONTENT_LENGTH'))
-            body = environ['wsgi.input'].read(length)
-            sep = content_type[1].split("=")[1]
-            body = mp.MultipartParser(BytesIO(body), sep.encode('utf-8'))
-            for part in body.parts():
-                args[part.name] = part.value
-        if content_type[0] == "application/json":
-            length = int(environ.get('CONTENT_LENGTH'))
-            body = environ['wsgi.input'].read(length)
-            body = json.loads(body)
-            for key in body:
-                args[key] = body[key]
+            try:
+                body = environ['wsgi.input'].read(content_length)
+                sep = content_type[1].split("=")[1]
+                parser = mp.MultipartParser(BytesIO(body), sep.encode('utf-8'))
+                for part in parser.parts():
+                    args[part.name] = part.value
+            except Exception as e:
+                self.logError(f"Error parsing multipart data: {e}")
+                raise ValueError("Invalid multipart data")
+
+        # Parse JSON
+        elif content_type[0] == "application/json" and content_length > 0:
+            try:
+                body = environ['wsgi.input'].read(content_length)
+                data = json.loads(body)
+                if isinstance(data, dict):
+                    args.update(data)
+            except json.JSONDecodeError as e:
+                self.logError(f"Error parsing JSON: {e}")
+                raise ValueError("Invalid JSON data")
 
         return args
 
 
-    def tryDefault(self, environ, target):
-        print(Fore.WHITE,"[INFO] Vesta - using default route")
+
+    def tryDefault(self, environ: Dict[str, Any], target: str) -> bytes:
+        """
+        Try to handle request with default route.
+
+        Args:
+            environ: WSGI environ dictionary
+            target: Request target path
+
+        Returns:
+            Response bytes
+        """
+        self.logInfo("Vesta - using default route")
 
         args = self.parseRequest(environ)
         args["target"] = target
@@ -147,9 +269,19 @@ class BaseServer:
             return self.handleUnexpected(e)
 
 
-    def onrequest(self, environ, start_response):
+    def onrequest(self, environ: Dict[str, Any], start_response: Callable) -> bytes:
+        """
+        Handle incoming HTTP request.
+
+        Args:
+            environ: WSGI environ dictionary
+            start_response: WSGI start_response callable
+
+        Returns:
+            Response bytes
+        """
         self.response = Response(start_response=start_response)
-        print(Fore.WHITE,"[INFO] Vesta - request received :'", str(environ['PATH_INFO']) + "'" + " with "+ str(environ.get('QUERY_STRING')))
+        self.log(f"Vesta - request received: '{environ['PATH_INFO']}' with {environ.get('QUERY_STRING')}")
         target = environ['PATH_INFO']
 
         if routes.get(target):
@@ -162,7 +294,7 @@ class BaseServer:
             except (HTTPError, HTTPRedirect):
                 return self.response.encode()
             except Exception as e:
-               return self.handleUnexpected(e)
+                return self.handleUnexpected(e)
         else:
             if routes.get("default"):
                 return self.tryDefault(environ, target)
@@ -170,21 +302,26 @@ class BaseServer:
             self.response.ok()
             return self.response.encode()
 
-    def handleUnexpected(self, e):
-        print(Fore.RED,"[ERROR] Vesta - UNEXPECTED ERROR :", e)
+    def handleUnexpected(self, e: Exception) -> bytes:
+        """
+        Handle unexpected errors during request processing.
+
+        Args:
+            e: Exception that occurred
+
+        Returns:
+            Error response bytes
+        """
+        self.logError(f"Vesta - UNEXPECTED ERROR: {e}", exc_info=True)
         self.response.code = 500
         self.response.ok()
-        self.response.content = str(e)
-        tb = e.__traceback__
-        while tb is not None:
-            frame = tb.tb_frame
-            lineno = tb.tb_lineno
-            filename = frame.f_code.co_filename
-            funcname = frame.f_code.co_name
-            print(f'  File "{filename}", line {lineno}, in {funcname}')
-            if self.features.get("debug"):
-                self.response.content += f'  File "{filename}", line {lineno}, in {funcname}'
-            tb = tb.tb_next
+
+        # Only expose detailed errors in debug mode
+        if self.config.getboolean("server", "DEBUG"):
+            self.response.content = str(e) + "\n\n" + traceback.format_exc()
+        else:
+            self.response.content = "Internal Server Error"
+
         return self.response.encode()
 
     def onStart(self):
@@ -192,66 +329,160 @@ class BaseServer:
 
     #--------------------------GENERAL USE METHODS------------------------------
 
-    def importConf(self, configFile):
+    def importConf(self, configFile: str):
+        """
+        Import configuration from file.
+
+        Args:
+            configFile: Path to configuration file
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+        """
         self.config = ConfigParser()
+        config_path = self.path + configFile
+
         try:
-            self.config.read(self.path + configFile)
-            print(Fore.GREEN,"[INFO] Vesta - config at " + self.path + configFile + " loaded")
+            self.config.read(config_path)
+            print(Fore.GREEN,"[INFO] Vesta - config at " + config_path + " loaded")
         except Exception:
             print(Fore.RED,"[ERROR] Vesta - Please create a config file")
 
     def start(self):
+        """Start the HTTP server."""
         self.fileCache = {}
 
         if self.features.get("errors"):
             for code, page in self.features["errors"].items():
                 Response.ERROR_PAGES[code] = self.path + page
 
-        if self.features.get("orm") == True:
-            self.db = db.DB(user=self.config.get('DB', 'DB_USER'), password=self.config.get('DB', 'DB_PASSWORD'),
-                            host=self.config.get('DB', 'DB_HOST'), port=int(self.config.get('DB', 'DB_PORT')),
-                            db=self.config.get('DB', 'DB_NAME'))
-
+        if self.features.get("orm"):
+            try:
+                self.db = db.DB(
+                    user=self.config.get('DB', 'DB_USER'),
+                    password=self.config.get('DB', 'DB_PASSWORD'),
+                    host=self.config.get('DB', 'DB_HOST'),
+                    port=int(self.config.get('DB', 'DB_PORT')),
+                    db=self.config.get('DB', 'DB_NAME')
+                )
+            except Exception as e:
+                self.logError(f"Failed to initialize database: {e}")
+                raise
 
         self.onStart()
 
         fastwsgi.server.nowait = 1
         fastwsgi.server.hook_sigint = 1
 
-        print(Fore.GREEN,"[INFO] Vesta - server running on PID:", os.getpid())
-        fastwsgi.server.init(app=self.onrequest, host=self.config.get('server', 'IP'),
-                             port=int(self.config.get('server', 'PORT')))
+        self.logInfo(f"Vesta - server running on PID: {os.getpid()} and port {self.config.get('server', 'PORT')}")
+        fastwsgi.server.init(
+            app=self.onrequest,
+            host=self.config.get('server', 'IP'),
+            port=int(self.config.get('server', 'PORT'))
+        )
+
         while True:
             code = fastwsgi.server.run()
             if code != 0:
                 break
             time.sleep(0)
+
         self.close()
 
     def close(self):
-        print(Fore.GREEN,"[INFO] SIGTERM/SIGINT received")
+        """Shutdown the server gracefully."""
+
+        self.logInfo("SIGTERM/SIGINT received")
+
+        # Close database connection if it exists
+        if hasattr(self, 'db'):
+            try:
+                self.db.close()
+            except Exception as e:
+                self.logError(f"Error closing database: {e}")
+
         fastwsgi.server.close()
-        print(Fore.GREEN,"[INFO] SERVER STOPPED")
-        exit()
+        self.logInfo("SERVER STOPPED")
+
+
+    def file(self, path: str, responseFile: bool = True) -> str:
+        """
+        Read a file with caching support.
+
+        Args:
+        path: Path to file (relative to server path or absolute)
+        responseFile: If True, set response type to HTML
+
+        Returns:
+        File content as string
 
-    def file(self, path, responseFile=True):
-        if responseFile:
-            self.response.type = "html"
-            self.response.headers = [('Content-Type', 'text/html')]
+        Raises:
+        ValueError: If path traversal is detected
+        """
         file = self.fileCache.get(path)
         if file:
             return file
         else:
+            # Validate path to prevent traversal
+            file_path = Path(path)
+            if not file_path.is_absolute():
+                file_path = self.path / file_path
+
+            file_path = file_path.resolve()
+
+            # Ensure path is within server directory
+            if not str(file_path).startswith(str(self.path.resolve())):
+                raise ValueError("Invalid file path: path traversal attempt detected")
+
+            if not file_path.exists():
+                raise FileNotFoundError(f"File not found: {path}")
+
             file = open(path)
             content = file.read()
             file.close()
-            self.fileCache[path] = content
             return content
 
+
     def start_ORM(self):
-        if self.features.get("orm") == True:
-            self.db = db.DB(user=self.config.get('DB', 'DB_USER'), password=self.config.get('DB', 'DB_PASSWORD'),
-                            host=self.config.get('DB', 'DB_HOST'), port=int(self.config.get('DB', 'DB_PORT')),
-                            db=self.config.get('DB', 'DB_NAME'))
-        else:
-            raise Exception("ORM not enabled")
+        """
+        Start ORM connection (for manual initialization).
+
+        Raises:
+            Exception: If ORM is not enabled in features
+        """
+        if not self.features.get("orm"):
+            raise Exception("ORM not enabled in server features")
+
+        try:
+            self.db = db.DB(
+                user=self.config.get('DB', 'DB_USER'),
+                password=self.config.get('DB', 'DB_PASSWORD'),
+                host=self.config.get('DB', 'DB_HOST'),
+                port=int(self.config.get('DB', 'DB_PORT')),
+                db=self.config.get('DB', 'DB_NAME')
+            )
+            self.logInfo("Vesta - ORM database connection established")
+        except Exception as e:
+            self.logError(f"Failed to start ORM: {e}")
+            raise
+
+    def log(self, message):
+        print(Fore.WHITE,"[LOG]", message, Style.RESET_ALL)
+
+    def logInfo(self, message):
+        print(Fore.GREEN,"[INFO]", message, Style.RESET_ALL)
+
+    def logWarning(self, message):
+        print(Fore.ORANGE,"[WARNING]", message, Style.RESET_ALL)
+
+    def logError(self, message: str, exc_info: bool = False):
+        """
+        Log an error message.
+
+        Args:
+            message: Error message to log
+            exc_info: If True, include exception traceback
+        """
+        print(Fore.RED, "[ERROR]", message, Style.RESET_ALL)
+        if exc_info:
+            print(Fore.RED, traceback.format_exc(), Style.RESET_ALL)

vesta/scripts/cli.py

@@ -171,11 +171,16 @@ def main():
     # Commande init
     parser_init = subparsers.add_parser('init', help='Initialize a new Vesta project')
     parser_init = subparsers.add_parser('install', help='Import dependencies')
-    parser_db = subparsers.add_parser('db', help='Manage the database')
     parser_update = subparsers.add_parser('update', help='Update dependencies')
     parser_test = subparsers.add_parser('test', help='Run tests')
     parser_add_feature = subparsers.add_parser('add-feature', help='Add a feature to the project')
 
+    parser_db = subparsers.add_parser('db', help='Manage the database')
+    db_subparsers = parser_db.add_subparsers(dest='db_command')
+    parser_db_create = db_subparsers.add_parser('create', help='Create and initialize the database')
+    parser_db_init = db_subparsers.add_parser('init', help='Initialize the database')
+    parser_db_reset = db_subparsers.add_parser('reset', help='Reset the database ')
+
     parser_nginx = subparsers.add_parser('nginx', help='Setup/manage nginx configuration')
     nginx_subparsers = parser_nginx.add_subparsers(dest='nginx_command')
     parser_nginx_setup = nginx_subparsers.add_parser('setup', help='Install nginx config')
@@ -192,7 +197,19 @@ def main():
     if args.command == 'init':
         init_project()
     elif args.command == 'db':
-        pass
+        installer = Installer(PATH + "/server.ini", PATH)
+
+        if args.db_command == 'create':
+            installer.createDB()
+            installer.createUniauth()
+            installer.initDB()
+        elif args.nginx_command == 'init':
+            installer.initDB()
+        elif args.nginx_command == 'reset':
+            installer.resetDB()
+        else:
+            parser_db.print_help()
+
     elif args.command == 'update':
         updateDeps()
     elif args.command == 'install':

vesta/scripts/utils.py

@@ -2,6 +2,10 @@ import subprocess
 from configparser import ConfigParser
 
 
+from vesta import Server
+import sys
+from psycopg import sql
+
 def ex(command):
     subprocess.run(command, shell=True, check=True)
 
@@ -9,7 +13,7 @@ class Installer:
     def __init__(self, configFile, path):
         self.PATH = path
         self.importConf(configFile)
-        self.uniauth = "N"
+        self.uniauth = False
         self.name = self.config.get("server", "SERVICE_NAME").replace(" ", "_").lower()
 
     def installNginx(self, link=True):
@@ -81,4 +85,72 @@ class Installer:
             for key in templates:
                 data = data.replace(key, templates[key])
         with open(file+"_filled", "w+") as f:
-            f.write(data)
+            f.write(data)
+
+    # -----------------__DB METHODS__----------------- #
+    def initDB(self):
+        initializer = DBInitializer(path=self.PATH, configFile=self.PATH + "/server.ini", noStart=True)
+        if self.uniauth:
+            initializer.initUniauth()
+        initializer.initDB()
+
+
+    def resetDB(self):
+        ex("sudo -u postgres dropdb " + self.config.get("DB", "DB_NAME"))
+        self.initDB()
+
+    def createUniauth(self):
+        while True:
+            uniauth = input("Do you want to create a uniauth database? (y/n)")
+            if uniauth.upper() == 'Y' or uniauth.upper() == 'N':
+                self.uniauth = uniauth.upper()
+                break
+
+        if self.uniauth == 'Y':
+            ex("sudo -u postgres createdb " + self.config.get("UNIAUTH", "DB_NAME"))
+
+    def createDB(self):
+        ex("sudo -u postgres createdb " + self.config.get("DB", "DB_NAME"))
+
+    def createUser(self):
+        ex("sudo -u postgres createuser " + self.config.get("DB", "DB_USER") + " -s --pwprompt ")
+
+
+class DBInitializer(Server):
+    def initUniauth(self):
+        self.uniauth.initUniauth()
+
+    def initDB(self):
+        self.referenceUniauth()
+        self.db.cur.execute(open(self.path + "/db/schema.sql", "r").read())
+        self.db.conn.commit()
+
+    def referenceUniauth(self):
+        self.db.cur.execute("CREATE EXTENSION if not exists postgres_fdw;")
+        self.db.cur.execute(
+            sql.SQL("""
+            CREATE SERVER if not exists uniauth
+            FOREIGN DATA WRAPPER postgres_fdw
+            OPTIONS (host %s, port %s, dbname %s);
+            """),
+            (
+                self.config.get('UNIAUTH', 'DB_HOST'),
+                self.config.get('UNIAUTH', 'DB_PORT'),
+                self.config.get('UNIAUTH', 'DB_NAME')
+            ))
+
+        self.db.cur.execute(
+            sql.SQL("""
+            CREATE USER MAPPING if not exists FOR CURRENT_USER SERVER uniauth
+            OPTIONS (user %s, password %s);
+            """),
+            (
+                self.config.get('DB', 'DB_USER'),
+                self.config.get('DB', 'DB_PASSWORD')
+            ))
+        self.db.cur.execute(
+            """
+            CREATE FOREIGN TABLE if not exists account (id bigserial NOT NULL)
+            SERVER uniauth
+            OPTIONS (schema_name 'public', table_name 'account');
+            """)

{vesta_web-1.1.2.dist-info → vesta_web-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vesta-web
-Version: 1.1.2
+Version: 1.1.3
 Summary: An extensive web framework adding every feature needed for Carbonlab
 Project-URL: Homepage, https://gitlab.com/Louciole/vesta
 Project-URL: Issues, https://gitlab.com/Louciole/vesta/-/issues
@@ -23,6 +23,7 @@ Requires-Dist: fastwsgi
 Requires-Dist: multipart
 Requires-Dist: psycopg
 Requires-Dist: pyjwt
+Requires-Dist: setuptools
 Requires-Dist: websockets
 Description-Content-Type: text/markdown
 

{vesta_web-1.1.2.dist-info → vesta_web-1.1.3.dist-info}/RECORD

@@ -45,18 +45,18 @@ vesta/emptyProject/static/translations/fr.mjs,sha256=ouMluPVTgB4Q5vmb7zGE6YGTH4U
 vesta/emptyProject/static/translations/translation.mjs,sha256=JxJ2peSlYVQK-bUKpfddPLXm0XZiz2yu6A6iWIqpKyM,1422
 vesta/emptyProject/static/ws/onMessage.mjs,sha256=ow5nwSEdiBcvm-Y2zOUMhnqLp-5xWgo11kHviaTRlTw,658
 vesta/emptyProject/tests/example/foo.py,sha256=NS9oIXFBOvIyWK1LHwkJm9amJuSMN4cxJwouBrJlh2I,115
-vesta/http/baseServer.py,sha256=7jN0y1SpIRWE9ohzT8IlehTbzy3ofqrOPeKA4vKOC1k,8312
+vesta/http/baseServer.py,sha256=To64gSOIvpgEeMz5shQnqzexgVVgJcGOBsEbGA_IN8c,14785
 vesta/http/error.py,sha256=fWdp-oI2ObJD2mHHuxs1yVJvhON5oHYgYFRLAcUMs-I,180
 vesta/http/redirect.py,sha256=OiDeOmU-X5Mos8a0BQIeOIJqvgWjDEtaYrM4-x4MXl0,177
 vesta/http/response.py,sha256=G7cmbrXFNbIbQoqNxNkR06I5VymIwjFSAe3LtVa56Ok,3760
 vesta/mailing/mailing_service.py,sha256=GBO5Hnspm9Pqwd5kGB0iekZaMoIrfQvrhMUf8tVma7g,5386
-vesta/scripts/cli.py,sha256=xfY-dVzPAbJdmgpRJoGGNSlSXDsMyrQPwykAK017YqE,7506
+vesta/scripts/cli.py,sha256=3vKp-imzaAxLHkOwFcNznQ8t9j3St9m0G6RJMpErJIc,8230
 vesta/scripts/initDB.py,sha256=TKaK4RZM6CycBEsHeGb9Q9PdphkQgaJDnEWhvRnGC9k,1659
 vesta/scripts/install.py,sha256=GvH_HHx5aU5_54RQ1_2vz4DaLCh42AHfUKy-m0q21vY,2125
 vesta/scripts/testsRun.py,sha256=bXJImdexKQUDW8CR8F9VIKTrgkd7QfnvHQPENEV4x38,2463
-vesta/scripts/utils.py,sha256=MQZ29b4eplF0OR9EimUToOO73CVoV_cTxQeez2F3OoY,3460
-vesta_web-1.1.2.dist-info/METADATA,sha256=F1vBrwheV7MlW4UmsKMehblxF1Cleqk1LkNObRJvgU8,1558
-vesta_web-1.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-vesta_web-1.1.2.dist-info/entry_points.txt,sha256=MHMrWJwtkb4FmNz0CTpxZzwQ3LTqndXBh8YBPDfXlW4,49
-vesta_web-1.1.2.dist-info/licenses/LICENSE.md,sha256=zoPFEFUUoSgosmDBK5fGTWGRHHBaSVuuJT2ZQIYXuIk,177
-vesta_web-1.1.2.dist-info/RECORD,,
+vesta/scripts/utils.py,sha256=g5QKt1Xeezqf56m4ETLvYBhbZ82eg3qHRPKdjE6mjAQ,5860
+vesta_web-1.1.3.dist-info/METADATA,sha256=7EY_IDwbSTQEmK2TXoIcm6A5sCt9Bojo_dhDR6s_mcc,1584
+vesta_web-1.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+vesta_web-1.1.3.dist-info/entry_points.txt,sha256=MHMrWJwtkb4FmNz0CTpxZzwQ3LTqndXBh8YBPDfXlW4,49
+vesta_web-1.1.3.dist-info/licenses/LICENSE.md,sha256=zoPFEFUUoSgosmDBK5fGTWGRHHBaSVuuJT2ZQIYXuIk,177
+vesta_web-1.1.3.dist-info/RECORD,,

{vesta_web-1.1.2.dist-info → vesta_web-1.1.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any