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

vesta/emptyProject/static/markdown/markdown.mjs

@@ -0,0 +1,463 @@
+// This in absolutely no spec, it comes exclusively from my deranged mind
+
+export class Markdown {
+    constructor() {
+    }
+
+    HTML_equiv = {
+        "#":"<h${props.level}>${content}</h${props.level}>",
+        "text":"${content}",
+        "start li":"<li>${content}</li>",
+        "*":"<i>${content}</i>",
+        "**":"<b>${content}</b>",
+        ">":"<div class='answer'>${content}</div>",
+        "'''":"<div class='code-wrapper'><code>${content}</code><div class='circle grey' onclick='copyCode(event)'></div></div>",
+        "~~":"<div class='crossed'>${content}</div>",
+        "||":"<div class='spoiler' onclick='showSpoiler(event)'>${content}</div>",
+        "link":"<a href='${props.link}' target='_blank'>${content}</a>",
+        "color":"<div class='color' style='color: ${props.color}'>${content}</div>",
+        "endline":"\n",
+        "newline":"",
+        ")":")",
+        "'":"'",
+        "(":"(",
+        "/>":"/>",
+        "]":"]",
+        "/":"${content}/"
+    }
+
+    tokenize(str) {
+        const tokenList = []
+        let currentToken = new Token("newline")
+        let commitEndline = false
+
+        let char_id=0
+        while (char_id < str.length ){
+
+            //look for url
+            if(str.slice(char_id,char_id+6) === "https:" || str.slice(char_id,char_id+5) === "http:" ){
+                if (currentToken.content !== ""){
+                    tokenList.push(currentToken)
+                    currentToken = new Token("link")
+                }else{
+                    currentToken.type="link"
+                }
+
+                let look_id = 5
+                let nextToken
+                while (char_id+look_id<str.length){
+                    if(str[char_id+look_id]=== "\n"){
+                        nextToken = new Token("newline")
+                        look_id++
+                        break
+                    }
+                    if([" ",")","]"].includes(str[char_id+look_id])){
+                        nextToken = new Token("text")
+                        break
+                    }
+                    look_id++
+                }
+                currentToken.content = str.slice(char_id,char_id+look_id)
+                currentToken.props.link = currentToken.content
+                tokenList.push(currentToken)
+                if(char_id+look_id>=str.length){
+                    return tokenList;
+                }
+                char_id += look_id
+                currentToken = nextToken
+            }else{
+                const char = str[char_id]
+                switch (currentToken.type){
+                    case "text":
+                        switch (char){
+                            case '*':
+                                if (currentToken.content !== ""){
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("*")
+                                currentToken.props.level = 1
+                                break
+                            case '[':
+                            case ']':
+                            case '(':
+                            case ')':
+                                if (currentToken.content !== ""){
+                                    tokenList.push(currentToken)
+                                }
+                                tokenList.push(new Token(char))
+                                currentToken = new Token("text")
+                                break
+                            case '|':
+                            case '~':
+                            case "'":
+                            case '/':
+                            case '&':
+                            case '<':
+                                currentToken.type = char
+                                break
+                            case '\n':
+                                if (commitEndline){
+                                    commitEndline = false
+                                    tokenList.push(currentToken)
+                                    tokenList.push(new Token("endline"))
+                                    currentToken = new Token("newline")
+                                }else{
+                                    currentToken.content = currentToken.content.concat(char)
+                                    currentToken.props.consuming="text"
+                                    currentToken.type="newline"
+                                }
+                                break
+                            default:
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "#":
+                        switch (char){
+                            case '#':
+                                currentToken.props.level = currentToken.props.level<3 ? currentToken.props.level+1 : 3
+                                break
+                            case '\n':
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "newline":
+                        switch (char){
+                            case '#':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("#")
+                                currentToken.props["level"] = 1
+                                break
+                            case '-':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("text")
+                                tokenList.push(new Token("start li"))
+                                commitEndline = true
+                                break
+                            case '>':
+                                if (currentToken.content.trim() !== ""){
+                                    currentToken.type=currentToken.props.consuming
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("text")
+                                tokenList.push(new Token(">"))
+                                commitEndline = true
+                                break
+                            case '*':
+                                currentToken = new Token("*")
+                                currentToken.props.level = 1
+                                break
+                            case '|':
+                            case '~':
+                            case "'":
+                            case '/':
+                            case '&':
+                            case '<':
+                                currentToken.type = char
+                                break
+                            case '[':
+                            case ']':
+                            case '(':
+                            case ')':
+                                tokenList.push(new Token(char))
+                                currentToken = new Token("text")
+                                break
+                            case ' ':
+                                currentToken.content = currentToken.content.concat(char)
+                                break
+                            case '\n':
+                                currentToken.type = "text"
+                                tokenList.push(currentToken)
+                                tokenList.push(new Token("endline"))
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "*":
+                        switch (char){
+                            case "*":
+                                currentToken.props.level = currentToken.props.level<3 ? currentToken.props.level+1 : 3
+                                break
+                            case '\n':
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                currentToken.content = "\n"
+                                if (commitEndline) {
+                                    commitEndline = false
+                                }
+                                break
+                            case '|':
+                            case '~':
+                            case '/':
+                                tokenList.push(currentToken)
+                                currentToken = new Token(char)
+                                break
+                            default:
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case '|':
+                        switch (char){
+                            case "|":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("||")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content="|".concat(char)
+                        }
+                        break
+                    case '~':
+                        switch (char){
+                            case "~":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("~~")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type="text"
+                                currentToken.content="~".concat(char)
+                        }
+                        break
+                    case "'":
+                        switch (char){
+                            case "'":
+                                if(!currentToken.props.level || currentToken.props.level<2){
+                                    currentToken.props.level = currentToken.props.level ? currentToken.props.level+1 : 2
+                                }else{
+                                    currentToken = new Token("'''")
+                                    currentToken.props.level=0
+                                }
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("'",char)
+                        }
+                        break
+                    case "'''":
+                        switch (char){
+                            case "'":
+                                if(currentToken.props.level<2){
+                                    currentToken.props.level += 1
+                                }else{
+                                    tokenList.push(currentToken)
+                                    currentToken = new Token("text")
+                                }
+                                break
+                            default:
+                                if(currentToken.props.level !==0){
+                                    currentToken.content = currentToken.content.concat("'".repeat(currentToken.props.level))
+                                    currentToken.props.level = 0
+                                }
+                                currentToken.content = currentToken.content.concat(char)
+                        }
+                        break
+                    case "&":
+                        if(str.slice(char_id, char_id+3) === "lt;"){
+                            if (currentToken.content !== ""){
+                                currentToken.type = "text"
+                                tokenList.push(currentToken)
+                            }
+                            char_id+=2
+                            currentToken = new Token("<")
+                        }else{
+                            currentToken.content = currentToken.content.concat(char)
+                            currentToken.type = "text"
+                        }
+                        break
+                    case "<":
+                        switch (char){
+                            case "$":
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("color")
+                                currentToken.props.color=""
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("&lt;", char)
+                        }
+                        break
+                    case "color":
+                        switch (char){
+                            case " ":
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            case "\n":
+                                tokenList.push(currentToken)
+                                currentToken = new Token("newline")
+                                break
+                            default:
+                                currentToken.props.color = currentToken.props.color.concat(char)
+                        }
+                        break
+                    case "/":
+                        switch (char){
+                            case '>':
+                                if (currentToken.content !== ""){
+                                    currentToken.type = "text"
+                                    tokenList.push(currentToken)
+                                }
+                                currentToken = new Token("/>")
+                                tokenList.push(currentToken)
+                                currentToken = new Token("text")
+                                break
+                            default:
+                                currentToken.type = "text"
+                                currentToken.content = currentToken.content.concat("/", char)
+                        }
+                        break
+                }
+                char_id += 1
+            }
+        }
+        tokenList.push(currentToken)
+        return tokenList;
+    }
+
+    render(tokens) {
+        let result = ""
+        for(let token_id = 0;  token_id < tokens.length; token_id+=1){
+            const render = this.renderToken(tokens[token_id], token_id, tokens)
+            token_id = render[1]
+            result = result.concat(render[0])
+        }
+        return result;
+    }
+
+    renderToken(token, token_id, tokens){
+        // console.log("render token",token,token_id,tokens)
+        const old_id = token_id
+        let content = ""
+        switch(token.type) {
+            case ">":
+            case "start li":
+                while (token_id + 1 < tokens.length && tokens[token_id + 1].type !== "endline") {
+                    token_id += 1
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = content
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id+1]
+            case "*":
+                // this is suboptimal because we're looking for same size closing
+                // smth like *** a ** b * will not work as intended
+                while (token_id + 1 < tokens.length && tokens[token_id + 1].type !== "endline") {
+                    token_id += 1
+                    if(tokens[token_id].type === "*" && tokens[token_id].props.level === token.props.level){
+                        token.content = content
+                        if (token.props.level % 2) {
+                            if (token.props.level === 3) {
+                                token.content = fillTemplate(this.HTML_equiv["**"], token)
+                            }
+                            return [fillTemplate(this.HTML_equiv["*"], token), token_id]
+                        } else {
+                            return [fillTemplate(this.HTML_equiv["**"], token), token_id]
+                        }
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = "*".repeat(token.props.level)
+                // should be optimized, because we just drop a part of the render here
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "~~":
+            case "||":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === token.type){
+                        token.content = content
+                        return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = token.type
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "[":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === "\n"){
+                        break
+                    }
+                    if(tokens[token_id].type === "]"){
+                        if(tokens[token_id+1].type === "(" && tokens[token_id+2].type === "link" && tokens[token_id+3].type === ")"){
+                            token.content = content
+                            token.props.link = tokens[token_id+2].content
+                            return [fillTemplate(this.HTML_equiv["link"], token), token_id+3]
+                        }else{
+                            break
+                        }
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.content = token.type
+                return [fillTemplate(this.HTML_equiv["text"], token), old_id]
+            case "color":
+                while (token_id + 1 < tokens.length) {
+                    token_id += 1
+                    if(tokens[token_id].type === "/>"){
+                        token.content = content
+                        return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+                    }
+                    const render = this.renderToken(tokens[token_id], token_id, tokens)
+                    token_id = render[1]
+                    content = content.concat(render[0])
+                }
+                token.type="text"
+                token.content = "<$"+token.props?.color
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+            default:
+                return [fillTemplate(this.HTML_equiv[token.type], token), token_id]
+        }
+    }
+}
+
+class Token{
+    constructor(type) {
+        this.type = type
+        this.content=""
+        this.props={}
+    }
+}
+
+const fillTemplate = (template, vars = {}) => {
+    const handler = new Function('vars', [
+        'const tagged = ( ' + Object.keys(vars).join(', ') + ' ) =>',
+        '`' + template + '`',
+        'return tagged(...Object.values(vars))'
+    ].join('\n'));
+    const res = handler(vars)
+    return res;
+};

vesta/emptyProject/static/markdown/utils.mjs

@@ -0,0 +1,21 @@
+import {Markdown} from "./markdown.mjs";
+
+export function MDToHTML(text){
+    const engine = new Markdown()
+    const tokens = engine.tokenize(text)
+    console.log("text",text,"tokens",tokens)
+    return engine.render(tokens)
+}
+window.MDToHTML = MDToHTML
+
+export function showSpoiler(event){
+    event.currentTarget.classList.toggle("clicked")
+}
+window.showSpoiler = showSpoiler
+
+export function copyCode(event){
+    navigator.clipboard.writeText(event.currentTarget.parentElement.firstElementChild.innerHTML).then(
+        event.currentTarget.style.background = "var(--green)"
+    )
+}
+window.copyCode = copyCode

vesta/http/baseServer.py

@@ -116,7 +116,7 @@ class BaseServer:
             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(query[i][1])
+                args[query[i][0]] = urllib.parse.unquote_plus(query[i][1], encoding='utf-8')
         if content_type[0] == "multipart/form-data":
             length = int(environ.get('CONTENT_LENGTH'))
             body = environ['wsgi.input'].read(length)

vesta/http/response.py

@@ -7,7 +7,17 @@ class Response:
     def __init__(self, start_response, code=200, type="html"):
         self.cookies = {}
         self.type = type
-        self.headers = [('Content-Type', 'text/' + type),('Cache-Control', 'no-cache'), ('Server', 'mag v1 Harpie')]
+        self.headers = [
+            ('Content-Type', 'text/' + type + '; charset=utf-8'),
+            ('Cache-Control', 'no-cache'),
+            ('Server', 'Vesta v1 Harpie'),
+            # Security headers
+            ('X-Content-Type-Options', 'nosniff'),
+            ('X-Frame-Options', 'DENY'),
+            ('X-XSS-Protection', '1; mode=block'),
+            ('Referrer-Policy', 'strict-origin-when-cross-origin'),
+            ('Permissions-Policy', 'geolocation=(), microphone=(), camera=()')
+        ]
         self.code = code
         self.start_response = start_response
         self.content = ""
@@ -16,21 +26,21 @@ class Response:
         if self.code != 200 and self.code != 302:
             if self.code in self.ERROR_PAGES.keys():
                 self.type = "html"
-                self.headers = [('Content-Type', 'text/html')]
+                self.headers = [('Content-Type', 'text/html; charset=utf-8')]
                 file = open(self.ERROR_PAGES[self.code])
                 self.content = file.read()
                 file.close()
             else:
                 self.type = "plain"
-                self.headers = [('Content-Type', 'text/plain')]
+                self.headers = [('Content-Type', 'text/plain; charset=utf-8')]
         self.start_response(self.CODES.get(self.code, "500 UNEXPECTED"), self.headers)
 
     def encode(self):
         # print("[INFO] encoding response : ", self.content)
 
         if self.type == "plain":
-            return (self.CODES[self.code] + " " + self.content).encode()
-        return str(self.content).encode()
+            return (self.CODES[self.code] + " " + self.content).encode('utf-8')
+        return str(self.content).encode('utf-8')
 
     def set_cookie(self, name, value, exp=None, samesite=None, secure=False, httponly=False):
         """Set a response cookie for the client.

vesta/mailing/mailing_service.py

@@ -103,15 +103,16 @@ class Mailing:
         self.sendMail(mail_confirmation)
 
     def sendOrgInvite(self, target, company):
-        try:
-            self.template_org_invitation
-        except:
-            f = open(self.path + "/mailing/mailInvite.html", "r")
-            self.template_org_invitation = f.read()
-            f.close()
-            self.mail_invitation = MIMEMultipart('alternative')
-            self.mail_invitation['Subject'] = "🔔 Rejoignez " + company + " 🔔"
-            self.mail_invitation['From'] = self.name + " <" + self.address + ">"
+        if not hasattr(self, 'template_org_invitation'):
+            try:
+                with open(self.path + "/mailing/mailInvite.html", "r") as f:
+                    self.template_org_invitation = f.read()
+                self.mail_invitation = MIMEMultipart('alternative')
+                self.mail_invitation['Subject'] = "🔔 Rejoignez " + company + " 🔔"
+                self.mail_invitation['From'] = self.name + " <" + self.address + ">"
+            except (FileNotFoundError, IOError) as e:
+                print(f"[Vesta - mails] Error loading org invitation template: {e}")
+                raise
 
         self.mail_invitation['Message-ID'] = email.utils.make_msgid(domain='carbonlab.dev')
         self.mail_invitation['Date'] = email.utils.formatdate()

vesta/scripts/initDB.py

@@ -22,20 +22,22 @@ class DBInitializer(Server):
             sql.SQL("""
             CREATE SERVER if not exists uniauth
             FOREIGN DATA WRAPPER postgres_fdw
-            OPTIONS (host {}, port {}, dbname {});
-            """).format(
-                sql.Literal(self.config.get('UNIAUTH', 'DB_HOST')),
-                sql.Literal(self.config.get('UNIAUTH', 'DB_PORT')),
-                sql.Literal(self.config.get('UNIAUTH', 'DB_NAME'))
+            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');
-            """).format(
-                sql.Literal(self.config.get('DB', 'DB_USER')),
-                sql.Literal(self.config.get('DB', 'DB_PASSWORD'))
+            OPTIONS (user %s, password %s);
+            """),
+            (
+                self.config.get('DB', 'DB_USER'),
+                self.config.get('DB', 'DB_PASSWORD')
             ))
         self.db.cur.execute(
             """

vesta/scripts/testsRun.py

@@ -20,14 +20,16 @@ def run_file(file_path):
     # Look for a 'run' function within the module (assuming tests are run from this function)
     if hasattr(test_module, 'run'):
         try:
+            count = (0,0)
             result = test_module.run()
             for res in result:
                 if res[1] == False:
+                    count = (count[0],count[1]+1)
                     print(Fore.RED +f"FAILED: '{res[0]}' @{readable_path}")
-                    return False
                 else:
+                    count = (count[0]+1,count[1]+1)
                     print(Fore.GREEN +f"PASSED: '{res[0]}' @{readable_path}")
-                    return True
+            return count
         except Exception as e:
             print(f"Error running test file '{readable_path}': {e}")
     else:
@@ -45,10 +47,8 @@ def run_folder(folder):
             if file.endswith('.py'):
                 file_path = os.path.join(root, file)
                 res = run_file(file_path)
-                if res == True:
-                    counter = (counter[0]+1,counter[1]+1)
-                elif res == False:
-                    counter = (counter[0],counter[1]+1)
+                if res:
+                    counter = (counter[0] + res[0], counter[1] + res[1])
 
     return counter
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vesta-web
-Version: 1.1.0
+Version: 1.1.2
 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