feat: add django-like URLs and views

Author: alexeev-prog

.gitignore

@@ -99,7 +99,7 @@ ipython_config.py
 #   This is especially recommended for binary packages to ensure reproducibility, and is more
 #   commonly ignored for libraries.
 #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
+poetry.lock
 
 # pdm
 #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
@@ -160,3 +160,8 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+*.html
+test*.py
+*.db
+*.log

README.md

@@ -53,6 +53,27 @@ Once installed, you can start using the library in your Python projects. Check o
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
+### Advanced app with flask-like and django-like routes
+Index page and book
+
+```python
+from pyechonext.app import ApplicationType, EchoNext
+from pyechonext.views import View
+from pyechonext.urls import url_patterns
+
+
+echonext = EchoNext(url_patterns, __name__, application_type=ApplicationType.HTML)
+
+
+@echonext.route_page("/book")
+class BooksResource(View):
+	def get(self, request, response, **kwargs):
+		return f"Books Page: {request.query_params}"
+
+	def post(self, request, response, **kwargs):
+		return "Endpoint to create a book"
+```
+
 ### Simple app with database
 In this example we are using SQLSymphony ORM (our other project, a fast and simple ORM for python)
 

examples/advanced_app.py

@@ -0,0 +1,15 @@
+from pyechonext.app import ApplicationType, EchoNext
+from pyechonext.views import View
+from pyechonext.urls import url_patterns
+
+
+echonext = EchoNext(url_patterns, __name__, application_type=ApplicationType.HTML)
+
+
+@echonext.route_page("/book")
+class BooksResource(View):
+	def get(self, request, response, **kwargs):
+		return f"Books Page: {request.query_params}"
+
+	def post(self, request, response, **kwargs):
+		return "Endpoint to create a book"

examples/simple_app.py

@@ -2,7 +2,6 @@
 from sqlsymphony_orm.datatypes.fields import IntegerField, RealField, TextField
 from sqlsymphony_orm.models.session_models import SessionModel
 from sqlsymphony_orm.models.session_models import SQLiteSession
-from sqlsymphony_orm.queries import QueryBuilder
 
 
 echonext = EchoNext(__name__, application_type=ApplicationType.HTML)
@@ -22,7 +21,7 @@ def __repr__(self):
 
 @echonext.route_page("/")
 def home(request, response):
-	user = User(name='John', cash=100.0)
+	user = User(name="John", cash=100.0)
 	session.add(user)
 	session.commit()
 	response.body = "Hello from the HOME page"
@@ -31,5 +30,5 @@ def home(request, response):
 @echonext.route_page("/users")
 def about(request, response):
 	users = session.get_all_by_model(User)
-	
+
 	response.body = f"Users: {[f'{user.name}: {user.cash}$' for user in users]}"

pyechonext/app.py

@@ -1,21 +1,35 @@
+import re
+import inspect
 from enum import Enum
-from typing import Iterable, Callable
+from typing import Iterable, Callable, List, Type
 from socks import method
+from parse import parse
+from pyechonext.urls import URL
+from pyechonext.views import View
 from pyechonext.request import Request
 from pyechonext.response import Response
+from pyechonext.utils.exceptions import RoutePathExistsError, MethodNotAllow
+from pyechonext.utils import _prepare_url
 
 
 class ApplicationType(Enum):
-	JSON = 'application/json'
-	HTML = 'text/html'
+	JSON = "application/json"
+	HTML = "text/html"
 
 
 class EchoNext:
 	"""
 	This class describes an EchoNext WSGI Application.
 	"""
 
-	def __init__(self, app_name: str, application_type: ApplicationType=ApplicationType.JSON):
+	__slots__ = ("app_name", "application_type", "urls", "routes")
+
+	def __init__(
+		self,
+		urls: List[URL],
+		app_name: str,
+		application_type: ApplicationType = ApplicationType.JSON,
+	):
 		"""
 		Constructs a new instance.
 
@@ -25,6 +39,35 @@ def __init__(self, app_name: str, application_type: ApplicationType=ApplicationT
 		self.app_name = app_name
 		self.application_type = application_type
 		self.routes = {}
+		self.urls = urls
+
+	def _find_view(self, raw_url: str) -> Type[View]:
+		url = _prepare_url(raw_url)
+
+		for path in self.urls:
+			match = re.match(path.url, url)
+
+			if match is not None:
+				return path
+
+		return None
+
+		# raise URLNotFound(f'URL "{raw_url}" not found.')
+
+	def _check_request_method(self, view: View, request: Request):
+		if not hasattr(view, request.method.lower()):
+			raise MethodNotAllow(f"Method not allow: {request.method}")
+
+	def _get_view(self, request: Request) -> View:
+		url = request.path
+
+		return self._find_view(url)()
+
+	def _get_request(self, environ: dict) -> Request:
+		return Request(environ)
+
+	def _get_response(self) -> Response:
+		return Response(content_type=self.application_type.value)
 
 	def route_page(self, page_path: str) -> Callable:
 		"""
@@ -36,6 +79,8 @@ def route_page(self, page_path: str) -> Callable:
 		:returns:	wrapper handler
 		:rtype:		Callable
 		"""
+		if page_path in self.routes:
+			raise RoutePathExistsError("Such route already exists.")
 
 		def wrapper(handler):
 			self.routes[page_path] = handler
@@ -47,12 +92,36 @@ def default_response(self, response: Response) -> None:
 		"""
 		Get default response (404)
 
-		:param      response:  The response
-		:type       response:  Response
+		:param		response:  The response
+		:type		response:  Response
 		"""
 		response.status_code = "404"
 		response.body = "Page Not Found Error."
 
+	def find_handler(self, request_path: str) -> Callable:
+		"""
+		Finds a handler.
+
+		:param		request_path:  The request path
+		:type		request_path:  str
+
+		:returns:	handler function
+		:rtype:		Callable
+		"""
+		for path, handler in self.routes.items():
+			parse_result = parse(path, request_path)
+			if parse_result is not None:
+				return handler, parse_result.named
+
+		view = self._find_view(request_path)
+
+		if view is not None:
+			parse_result = parse(_prepare_url(view.url), request_path)
+			if parse_result is not None:
+				return view.view, parse_result.named
+
+		return None, None
+
 	def handle_response(self, request: Request) -> Response:
 		"""
 		Handle response from request
@@ -63,31 +132,22 @@ def handle_response(self, request: Request) -> Response:
 		:returns:	Response callable object
 		:rtype:		Response
 		"""
-		response = Response(content_type=self.application_type.value)
+		response = self._get_response()
 
-		handler = self.find_handler(request_path=request.path)
+		handler, kwargs = self.find_handler(request_path=request.path)
 
 		if handler is not None:
-			handler(request, response)
+			if inspect.isclass(handler):
+				handler = getattr(handler(), request.method.lower(), None)
+				if handler is None:
+					raise MethodNotAllow(f"Method not allowed: {request.method}")
+
+			response.body = handler(request, response, **kwargs)
 		else:
 			self.default_response(response)
 
 		return response
 
-	def find_handler(self, request_path: str) -> Callable:
-		"""
-		Finds a handler.
-
-		:param      request_path:  The request path
-		:type       request_path:  str
-
-		:returns:   handler function
-		:rtype:     Callable
-		"""
-		for path, handler in self.routes.items():
-			if path == request_path:
-				return handler
-
 	def __call__(self, environ: dict, start_response: method) -> Iterable:
 		"""
 		Makes the application object callable
@@ -100,7 +160,7 @@ def __call__(self, environ: dict, start_response: method) -> Iterable:
 		:returns:	response body
 		:rtype:		Iterable
 		"""
-		request = Request(environ)
+		request = self._get_request(environ)
 		response = self.handle_response(request)
 
 		return response(environ, start_response)

pyechonext/request.py

@@ -1,4 +1,5 @@
 import json
+from urllib.parse import parse_qs
 from loguru import logger
 
 
@@ -17,12 +18,16 @@ def __init__(self, environ: dict):
 		self.environ = environ
 		self.method = self.environ["REQUEST_METHOD"]
 		self.path = self.environ["PATH_INFO"]
-		self.query_params = self.environ["QUERY_STRING"]
+		self.query_params = self.build_get_params_dict(self.environ["QUERY_STRING"])
 		self.body = self.environ["wsgi.input"].read().decode()
 		self.user_agent = self.environ["HTTP_USER_AGENT"]
 
 		logger.debug(f"New request created: {self.method} {self.path}")
 
+	def build_get_params_dict(self, raw_params: str):
+		self.GET = parse_qs(raw_params)
+		return self.GET
+
 	@property
 	def json(self) -> dict:
 		"""

pyechonext/response.py

@@ -99,7 +99,9 @@ def __call__(self, environ: dict, start_response: method) -> Iterable:
 		self.headers.append(("User-Agent", environ["HTTP_USER_AGENT"]))
 		self.headers.append(("Content-Length", str(len(self.body))))
 
-		logger.debug(f"[{self.status_code}] Run response: {self.content_type}")
+		logger.debug(
+			f"[{environ['REQUEST_METHOD']} {self.status_code}] Run response: {self.content_type}"
+		)
 		start_response(status=self.status_code, headers=self.headers)
 
 		return iter([self.body])

pyechonext/urls.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import Type
+from pyechonext.views import View, IndexView
+
+
+@dataclass
+class URL:
+	url: str
+	view: Type[View]
+
+
+url_patterns = [URL(url="", view=IndexView)]

pyechonext/utils/__init__.py

@@ -0,0 +1,8 @@
+def _prepare_url(url: str) -> str:
+	try:
+		if url[-1] == "/":
+			return url[:-1]
+	except IndexError:
+		return "/"
+
+	return url

pyechonext/utils/exceptions.py

@@ -35,4 +35,40 @@ def __str__(self):
 		:rtype:		str
 		"""
 		logger.error(f"{self.__class__.__name__}: {self.get_explanation()}")
-		return f"SQLSymphonyException has been raised. {self.get_explanation()}"
+		return f"pyEchoNextException has been raised. {self.get_explanation()}"
+
+
+class RoutePathExistsError(pyEchoNextException):
+	def __str__(self):
+		"""
+		Returns a string representation of the object.
+
+		:returns:	String representation of the object.
+		:rtype:		str
+		"""
+		logger.error(f"{self.__class__.__name__}: {self.get_explanation()}")
+		return f"RoutePathExistsError has been raised. {self.get_explanation()}"
+
+
+class URLNotFound(pyEchoNextException):
+	def __str__(self):
+		"""
+		Returns a string representation of the object.
+
+		:returns:	String representation of the object.
+		:rtype:		str
+		"""
+		logger.error(f"{self.__class__.__name__}: {self.get_explanation()}")
+		return f"URLNotFound has been raised. {self.get_explanation()}"
+
+
+class MethodNotAllow(pyEchoNextException):
+	def __str__(self):
+		"""
+		Returns a string representation of the object.
+
+		:returns:	String representation of the object.
+		:rtype:		str
+		"""
+		logger.error(f"{self.__class__.__name__}: {self.get_explanation()}")
+		return f"MethodNotAllow has been raised. {self.get_explanation()}"