Add files via upload

Author: thelaycon

README.md

@@ -0,0 +1,2 @@
+No Documentation yet.
+Still under development.

config.py

@@ -0,0 +1,11 @@
+import os
+
+# Configuration
+
+DATABASE = {
+        }
+
+favicon = False
+
+#Should be relative to this path
+template_dir = "templates"

http_response.py

@@ -0,0 +1,43 @@
+# Response module
+from config import template_dir
+from parser import set_cookie_header
+
+
+
+def response(context, status, data):
+    """ Set Header and start response """
+    content_type = context.request["content-type"]
+    set_cookie = set_cookie_header(context.session)
+    header = [("Content-Type", content_type),] + set_cookie
+    start_response = context.response["start_response"]
+    start_response(status, header)
+    return data
+
+
+def static_response(context, status, data):
+    """ Set Header and start static response """
+    content_type = context.request["content-type"]
+    header = [("Content-Type", content_type),]
+    start_response = context.response["start_response"]
+    start_response(status, header)
+    return data
+
+
+def encode_html(path):
+    path = template_dir + "/" + path
+    try:
+        with open(path, "rb") as f:
+            data = f.read()
+    except FileNotFoundError:
+        raise Exception("Template cannot be found")
+    return data
+
+
+def redirect(context, status, uri):
+    header = context.response["header"]
+    header["Location"] = uri
+    start_response = context.response["start_response"]
+    start_response(status, list(header.items()))
+    return b""
+
+

parser.py

@@ -0,0 +1,138 @@
+# Parser module to parse environ variables
+from http.cookies import SimpleCookie
+import io
+import cgi
+import re
+
+
+def clean(item):
+    if item != "":
+        return True
+
+def set_cookie_header(cookie):
+    """Parse cookie object to HTTP Set-Cookie header"""
+
+    header = list()
+    cookie_options = cookie.output().split("Set-Cookie:")
+    cookie_options = list(filter(clean, cookie_options))
+    for index, option in enumerate(cookie_options):
+        cookie_options[index] = option.strip("\r\n")
+    cookie_options = ",".join(cookie_options) + '; ' + ';'.join(cookie.options)
+    
+
+    header = [("Set-Cookie", cookie_options),]
+    return header
+
+
+
+
+class Cookie(SimpleCookie):
+    """Cookie class inheriting http.SimpleCookie class"""
+
+    def __init__(self):
+        super().__init__()
+        self.options = ["HttpOnly",]
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        item = self.__getitem__(key)
+
+    def httponly(self, choice):
+        """Set httponly option in Set-Cookie"""
+        if choice == True:
+            if not "HttpOnly" in self.options:
+                self.options.append("HttpOnly")
+        elif choice == False:
+            if "HttpOnly" in self.options:
+                self.options.remove("HttpOnly")
+
+
+    def secure(self, choice):
+        if choice == True:
+            if not "Secure" in self.options:
+                self.options.append("Secure")
+        elif choice == False:
+            if "Secure" in self.options:
+                self.options.remove("Secure")
+    
+
+
+    
+    def flush(self):
+        """Expires a given cookie value"""
+
+        self.options.append("expires=Mon 23 Jun 1967 04:34:23 GMT")
+
+    def will_expire(self, date):
+        """Sets future expiry date for cookie value"""
+
+        self.options.append("expires={}".format(date))
+
+
+
+
+
+
+
+class Context():
+    """Make needed environ variables accessible in a single class"""
+
+    def __init__(self, environ):
+
+        #Get incoming cookies
+        cookie = environ.get("HTTP_COOKIE", "")
+        self.session = Cookie()
+        self.session.load(cookie)
+
+        #HTTP Request
+        self.request = dict()
+        self.request["content-length"] = environ.get("CONTENT_LENGTH", 0)
+        self.request["content-type"] = "text/html"
+        self.request["user-agent"] = environ.get("HTTP_USER-AGENT", "")
+        self.request["ip-address"] = environ.get("REMOTE_ADDR", "")
+        self.request["path"] = environ.get("PATH_INFO", "/")
+        self.query_str = environ.get("QUERY_STRING")
+        self.request["method"] = environ.get("REQUEST_METHOD")
+        self.request["protocol"] = environ.get("SERVER_PROTOCOL", "")
+        self.request["scheme"] = environ.get("wsgi.url_scheme", "http")
+        self.request["data"] = environ.get("wsgi.input", "")
+
+
+        #HTTP Response dict
+        self.response = dict()
+
+        #HTTP Parameters dict()
+        self.params = dict()
+
+        if self.request["content-length"] == '':
+            self.request["content-length"]=0
+
+        #HTTP Form
+        self.form = dict()
+        self.formFile = dict()
+        fp = self.request["data"].read(int(self.request["content-length"]))
+        formValues = cgi.FieldStorage(fp=io.BytesIO(fp), environ=environ, keep_blank_values=True)
+        keys = formValues.keys()
+        for key in keys:
+            value = formValues[key]
+            if value.filename:
+                self.formFile[key] = value
+            else:
+                self.form[key] = formValues.getvalue(key)
+        
+        
+        #Query matching and parsing
+        self.query = dict()
+
+        query_regex = "[a-zA-Z0-9%+]+=[a-zA-Z0-9%+]+"
+        queries = re.findall(query_regex, self.query_str)
+        for index, query in enumerate(queries):
+            queries[index] = query.replace("%20", " ").replace("+", " ")
+        
+        #Populate Query dict
+        for query in queries:
+            q = query.split("=")
+            self.query[q[0]] = q[1]
+
+
+

router.py

@@ -0,0 +1,54 @@
+# Router package for matching routes
+import re
+
+
+def path_to_regex(path):
+    path_segments = path.split("/")
+    params = dict()
+    for index, segment in enumerate(path_segments):
+        if segment == ":id":
+            path_segments[index] = "[0-9]+"
+        elif segment == ":slug":
+            path_segments[index] = "[a-zA-Z]+(?:-[a-zA-Z]+)*"
+    path = "/".join(path_segments) + "$"
+    return path
+
+
+
+def match_route(routes, path):
+    for route in routes:
+        match = re.match(route, path)
+        if match is not None:
+            return route
+
+
+def get_params(match, path):
+    path_segments = path.split("/")
+    match_segments = match.split("/")
+    id_ = None
+    slug = None
+    id_index = None
+    slug_index = None
+    if "[0-9]+" in match_segments:
+        id_index = match_segments.index("[0-9]+")
+    if "[a-zA-Z]+(?:-[a-zA-Z]+)*" in match_segments:
+        slug_index = match_segments.index("[a-zA-Z]+(?:-[a-zA-Z]+)*")
+    if id_index != None:
+        id_ = path_segments[id_index]
+    if slug_index != None:
+        slug = path_segments[slug_index]
+
+    return (id_, slug)
+
+
+
+
+
+
+        
+        
+
+
+
+
+

wsgi.py

@@ -0,0 +1,93 @@
+from parser import Context
+import router
+
+
+class App(object):
+    def __init__(self):
+        self.routes_func = []
+        self.routes_no_func = []
+        self.static_path_prefix = '--'
+        self.static_dir = ''
+
+
+    def match_route(self, context):
+        """Function to match response function for a given request"""
+
+        global resp
+
+        path = context.request["path"]
+        if path[-1] != "/":
+            path += "/"
+
+        #Check if static
+        if path.startswith(self.static_path_prefix):
+            resp = self.serve_static(context, path)
+        else:
+            resp = self.serve_response(context, path)
+        return resp
+       
+
+
+    def serve_response(self, context, path):
+        """Method to serve HTTP response"""
+        global response_
+
+        matched_route = router.match_route(self.routes_no_func, path)
+        if matched_route == None:
+            resp = not_found(context)
+        else:
+            id_, slug = router.get_params(matched_route, path)
+            context.params["slug"] = slug
+            context.params["id"] = id_
+            for route in self.routes_func:
+                if route[0] == matched_route:
+                    response_ = route[1](context)
+        return response_ 
+
+
+
+
+    def run(self, environ, start_response):
+        """ WSGI entry point"""
+
+        context_ = Context(environ)
+        context_.response["start_response"] = start_response
+        response = self.match_route(context_)
+        yield response
+
+
+    def set_static(self, static_path_prefix, static_dir):
+        """Set static directory to serve from and path prefix"""
+        self.static_path_prefix = static_path_prefix
+        if static_dir[-1] != '/':
+            self.static_dir = static_dir + '/'
+
+
+    def serve_static(self, context, path):
+        """ Method to serve static files """
+        file_path = self.static_dir + path.lstrip(self.static_path_prefix).rstrip("/")
+        try:
+            with open(file_path, "rb") as file_:
+                static_file = file_.read()
+        except:
+            static_file = b''
+
+        return static_response(context, "200 OK", static_file)
+
+    def add_path(self, uri, method):
+        if uri[-1] != "/":
+            uri += "/"
+        uri = router.path_to_regex(uri)
+        path = (uri, method)
+        self.routes_func.append(path)
+        self.routes_no_func.append(uri)
+
+
+
+
+
+def not_found(context):
+    data = encode_html("404.html")
+    return response(context, "404 NOT FOUND", data)
+
+