MahmudCore 0.0.1__py3-none-any.whl

MahmudCore/api.py

@@ -0,0 +1,127 @@
+
+import os
+import inspect
+
+from parse import parse
+from webob import Request
+from .response import Response
+from whitenoise import WhiteNoise
+from requests import Session as RequestsSession
+from jinja2 import Environment, FileSystemLoader
+from wsgiadapter import WSGIAdapter as RequestsWSGIAdapter
+
+from .middleware import Middleware
+
+
+class API:
+    def __init__(self, templates_dir="templates", static_dir="static"):
+        self.routes = {}
+        self.exception_handler = None
+
+        self.templates_env = Environment(
+            loader=FileSystemLoader(os.path.abspath(templates_dir))
+        )
+
+        self.whitenoise = WhiteNoise(self.wsgi_app, root=static_dir)
+        self.middleware = Middleware(self)  
+
+
+    def __call__(self, environ, start_response):
+        path_info = environ["PATH_INFO"]
+
+        if path_info.startswith("/static"):
+            environ["PATH_INFO"] = path_info[len("/static"):]
+            return self.whitenoise(environ, start_response)
+        
+        return self.middleware(environ, start_response)  
+
+
+    def add_middleware(self, middleware_cls):
+        self.middleware.add(middleware_cls)
+
+    
+    def wsgi_app(self, environ, start_response):
+        request = Request(environ)
+        response = self.handle_request(request)
+        return response(environ, start_response)  
+
+
+    def add_route(self, path, handler, allowed_methods=None):
+        assert path not in self.routes, f"Route '{path}' already exists."
+
+        if allowed_methods is None:
+            allowed_methods = ["get", "post", "put", "patch", "delete", "options"]
+
+        self.routes[path] = {
+            "handler": handler, 
+            "allowed_methods": [method.lower() for method in allowed_methods]
+        }
+
+
+    def route(self, path, allowed_methods=None):
+        def wrapper(handler):
+            self.add_route(path, handler, allowed_methods) # Reuse add_route logic
+            return handler
+        return wrapper
+    
+
+    def find_handler(self, request_path):
+        for path, handler_data in self.routes.items():
+            parse_result = parse(path, request_path)
+            if parse_result is not None:
+                return handler_data, parse_result.named
+        return None, None
+    
+
+    def handle_request(self, request):
+        response = Response()
+        handler_data, kwargs = self.find_handler(request_path=request.path)
+        
+        try:
+            if handler_data is not None:
+                handler = handler_data["handler"]
+                allowed_methods = handler_data["allowed_methods"]
+                
+                if inspect.isclass(handler):
+                    # class-based handler — pick method by HTTP verb
+                    handler = getattr(handler(), request.method.lower(), None)
+                    if handler is None:
+                        raise AttributeError("Method not allowed", request.method)
+                else:
+                    # function-based handler — check allowed methods list
+                    if request.method.lower() not in allowed_methods:
+                        raise AttributeError("Method not allowed", request.method)
+                
+                handler(request, response, **kwargs)
+                
+            else:
+                self.default_response(response)
+
+        except Exception as e:
+            if self.exception_handler is None:
+                raise e
+            else:
+                self.exception_handler(request, response, e)
+        
+        return response
+    
+
+    def default_response(self, response):
+        response.status_code = 404
+        response.text = "Request Not found"
+
+
+    def add_exception_handler(self, exception_handler):
+        self.exception_handler = exception_handler
+
+
+    def template(self, template_name, context=None):
+        if context is None:
+            context = {}    
+        return self.templates_env.get_template(template_name).render(**context)
+    
+
+    def test_session(self, base_url="http://127.0.0.1:8082"):
+        session = RequestsSession()
+        session.mount(prefix=base_url, adapter=RequestsWSGIAdapter(self))
+        return session

MahmudCore/middleware.py

@@ -0,0 +1,27 @@
+
+from webob import Request
+
+class Middleware:
+    def __init__(self, app):
+        self.app = app
+
+    def __call__(self, environ, start_response):
+        request = Request(environ)
+        response = self.handle_request(request)
+        return response(environ, start_response)
+
+    def add(self, middleware_cls):
+        self.app = middleware_cls(self.app)
+
+    def process_request(self, req):
+        pass
+
+    def process_response(self, req, resp):
+        pass
+
+    def handle_request(self, request):
+        self.process_request(request)
+        response = self.app.handle_request(request)
+        self.process_response(request, response)
+        
+        return response

MahmudCore/response.py

@@ -0,0 +1,40 @@
+
+import json
+from webob import Response as WebObResponse
+
+
+class Response:
+    def __init__(self):
+        self.json = None
+        self.html = None
+        self.text = None
+        self.content_type = None
+        self.body = b''
+        self.status_code = 200
+        self.headers = {} 
+
+    def __call__(self, environ, start_response):
+        self.set_body_and_content_type()
+        
+        response = WebObResponse(
+            body=self.body, content_type=self.content_type, status=self.status_code
+        )
+
+        # Apply any custom headers
+        for key, value in self.headers.items():
+            response.headers[key] = value
+            
+        return response(environ, start_response)
+
+    def set_body_and_content_type(self):
+        if self.json is not None:
+            self.body = json.dumps(self.json).encode("UTF-8")
+            self.content_type = "application/json"
+
+        if self.html is not None:
+            self.body = self.html.encode()
+            self.content_type = "text/html"
+
+        if self.text is not None:
+            self.body = self.text.encode()
+            self.content_type = "text/plain"

mahmudcore-0.0.1.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: MahmudCore
+Version: 0.0.1
+Summary: MahmudCore — a Python web framework built from scratch for learning core web framework concepts
+Home-page: https://github.com/dear-mahmud-bd/python-framework-from-scratch
+Author: Md. Mahmudul Hasan
+Author-email: dearmahmud.bd@gmail.com
+License: MIT
+Keywords: wsgi web framework python learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+Requires-Dist: webob==1.8.9
+Requires-Dist: parse==1.21.1
+Requires-Dist: requests==2.33.1
+Requires-Dist: requests-wsgi-adapter==0.4.1
+Requires-Dist: Jinja2==3.1.6
+Requires-Dist: whitenoise==6.12.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: gunicorn; extra == "dev"
+Requires-Dist: waitress; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+MahmudCore — a Python web framework built from scratch for learning core web framework concepts

mahmudcore-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+MahmudCore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MahmudCore/api.py,sha256=956yIUPgYuD-A1GsyNFx020lN3M8yvTFwOHC_OlZSGQ,4268
+MahmudCore/middleware.py,sha256=NmDJkDplkoZ9GnRJQiKL755GirL9TaWg2VYYIbSbU8k,706
+MahmudCore/response.py,sha256=DWAunMjSeMkxog5wgRS-EpmSvY_80rHxmeru6tMNnQM,1179
+mahmudcore-0.0.1.dist-info/METADATA,sha256=TiFo8134Crih7yGnHlFj1_uoy8O7gp971xGVYWtd6gM,1883
+mahmudcore-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mahmudcore-0.0.1.dist-info/top_level.txt,sha256=4HnjvoEI6xLK5fd6-faX2kYdqRgKvBvKFbgPGvD7a8U,11
+mahmudcore-0.0.1.dist-info/RECORD,,

mahmudcore-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mahmudcore-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+MahmudCore