lapis-api 0.2.0__tar.gz

lapis_api-0.2.0/.github/workflows/pylint.yml

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint .

lapis_api-0.2.0/.github/workflows/python-publish.yml

@@ -0,0 +1,70 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      # url: https://pypi.org/p/YOURPROJECT
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

lapis_api-0.2.0/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+venv/

lapis_api-0.2.0/.pylintrc

@@ -0,0 +1,2 @@
+[MASTER]
+ignore=tests

lapis_api-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Chandler Van]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lapis_api-0.2.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: lapis-api
+Version: 0.2.0
+Summary: An organized way to create REST APIs
+Project-URL: Homepage, https://github.com/CQVan/Lapis
+Project-URL: Issues, https://github.com/CQVan/Lapis/issues
+Author: Chandler Van
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+Lapis is a file-based REST API framework inspired by Modern Serverless Cloud Services
+
+To create a basic Lapis server, create a folder called *api* and create python script named *path.py*
+then within your main folder create a python script to start the server (we will call this script *main.py* in our example)
+
+Your project directory should look like this:
+
+```
+project-root/
+|-- api/
+|  |-- path.py
+`-- main.py
+```
+
+Then within the *api/path.py* file create your first GET api endpoint by adding the following code:
+```py
+from lapis import Response, Request
+
+async def GET (req : Request) -> Response:
+    return Response(status_code=200, body="Hello World!")
+```
+
+Finally by adding the following code to *main.py* and running it:
+```py
+from lapis import Lapis
+
+server = Lapis()
+
+server.run("localhost", 80)
+```
+
+You can now send an HTTP GET request to localhost:80 and recieve the famous **Hello World!** response!

lapis_api-0.2.0/README.md

@@ -0,0 +1,32 @@
+Lapis is a file-based REST API framework inspired by Modern Serverless Cloud Services
+
+To create a basic Lapis server, create a folder called *api* and create python script named *path.py*
+then within your main folder create a python script to start the server (we will call this script *main.py* in our example)
+
+Your project directory should look like this:
+
+```
+project-root/
+|-- api/
+|  |-- path.py
+`-- main.py
+```
+
+Then within the *api/path.py* file create your first GET api endpoint by adding the following code:
+```py
+from lapis import Response, Request
+
+async def GET (req : Request) -> Response:
+    return Response(status_code=200, body="Hello World!")
+```
+
+Finally by adding the following code to *main.py* and running it:
+```py
+from lapis import Lapis
+
+server = Lapis()
+
+server.run("localhost", 80)
+```
+
+You can now send an HTTP GET request to localhost:80 and recieve the famous **Hello World!** response!

lapis_api-0.2.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lapis"]
+
+[project]
+name = "lapis-api"
+version = "0.2.0"
+description = "An organized way to create REST APIs"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+  { name = "Chandler Van" },
+]
+
+
+
+license = {text = "MIT"}
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/CQVan/Lapis"
+Issues = "https://github.com/CQVan/Lapis/issues"

lapis_api-0.2.0/src/Lapis.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: Lapis
+Version: 0.1.0
+Summary: A small example package
+Author: Chandler Van
+Project-URL: Homepage, https://github.com/CQVan/Lapis
+Project-URL: Issues, https://github.com/CQVan/Lapis/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.bak
+Dynamic: license-file

lapis_api-0.2.0/src/Lapis.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE.bak
+README.md
+pyproject.toml
+src/Lapis.egg-info/PKG-INFO
+src/Lapis.egg-info/SOURCES.txt
+src/Lapis.egg-info/dependency_links.txt
+src/Lapis.egg-info/top_level.txt
+src/lapis/__init__.py
+src/lapis/lapis.py
+src/lapis/server_types.py

lapis_api-0.2.0/src/Lapis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lapis_api-0.2.0/src/Lapis.egg-info/top_level.txt

@@ -0,0 +1 @@
+lapis

lapis_api-0.2.0/src/lapis/__init__.py

@@ -0,0 +1,10 @@
+"""Lapis web framework core exports.
+
+This module exposes the primary public classes for consumers of the
+lapis package.
+"""
+
+from .lapis import Lapis
+from .server_types import ServerConfig, Protocol
+from .protocols.http1 import Request, Response, StreamedResponse
+from .protocols.websocket import WebSocketProtocol, WSPortal

lapis_api-0.2.0/src/lapis/lapis.py

@@ -0,0 +1,273 @@
+"""
+The main script for the Lapis server handling initial request handling and response
+"""
+
+import asyncio
+import inspect
+import select
+import socket
+import pathlib
+import runpy
+import sys
+from threading import Thread
+from datetime import datetime
+
+from lapis.protocols.websocket import WebSocketProtocol
+from lapis.protocols.http1 import HTTP1Protocol, Request, Response
+from .server_types import (
+    BadAPIDirectory,
+    BadConfigError,
+    BadRequest,
+    Protocol,
+    ServerConfig,
+    ProtocolEndpointError
+)
+
+class Lapis:
+    """
+    The Lapis class implements the centeral object used to run a Lapis REST server
+    """
+    cfg: ServerConfig = ServerConfig()
+
+    __s: socket.socket = None
+    __paths: dict = {}
+    __taken_endpoints : list[str] = []
+    __protocols : list[type[Protocol]] = []
+
+    __running : bool = False
+
+    def __init__(self, config: ServerConfig | None = None):
+
+        if config is not None:
+            self.cfg = config
+
+        self.__register_protocol(HTTP1Protocol)
+        self.__register_protocol(WebSocketProtocol)
+
+        self.__paths = self._bake_paths()
+
+    def run(self, ip: str, port: int):
+        """
+        Starts the Lapis server to listen on a given ip and port
+        
+        :param ip: The ip for the server to listen on
+        :type ip: str
+        :param port: The port for the server to listen on
+        :type port: int
+        """
+        self.__s = socket.socket()
+        self.__s.bind((ip, port))
+        self.__s.listen()
+
+        self.__running = True
+        print(f"{self.cfg.server_name} is now listening on http://{ip}:{port}")
+
+        try:
+            while True:
+                readable, _, _ = select.select([self.__s], [], [], 0.1)
+                if self.__s in readable:
+                    client, _ = self.__s.accept()
+                    t = Thread(target=self._handle_request, args=(client,), daemon=True)
+                    t.start()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.__close()
+
+    def __register_protocol(self, protocol : type[Protocol]):
+
+        if self.__running:
+            raise RuntimeError("Cannot register new Protocol while server is running")
+
+        endpoints : list[str] = protocol().get_target_endpoints()
+        if bool(set(endpoints) & set(self.__taken_endpoints)):
+            raise ProtocolEndpointError("Cannot reuse target endpoint method!")
+
+        self.__protocols.insert(0, protocol)
+        self.__taken_endpoints.extend(endpoints)
+
+    def register_protocol(self, protocol : type[Protocol]):
+        """
+        Registers new protocol for the server to use to communicate with clients
+
+        Cannot be called while server is running
+
+        :param protocol: Description
+        :type protocol: type[Protocol]
+        """
+        self.__register_protocol(protocol=protocol)
+
+        self.__paths = self._bake_paths()
+
+    def _get_dynamic_dirs(self, directory: pathlib.Path):
+        return [
+            p for p in directory.iterdir()
+            if p.is_dir() and p.name.startswith("[") and p.name.endswith("]")
+        ]
+
+    def _bake_paths(self) -> dict:
+
+        server_path = pathlib.Path(sys.argv[0]).resolve()
+        root : pathlib.Path = server_path.parent / pathlib.Path(self.cfg.api_directory)
+
+        try:
+            root.parent.resolve(strict=False)
+        except (OSError, RuntimeError) as err:
+            raise BadConfigError("\"api_directory\" in config must be a valid file path") from err
+
+        if not root.exists():
+            raise BadAPIDirectory(f"api directory \"{root}\" does not exist")
+
+        result = {}
+
+        for path in root.rglob(f"{self.cfg.path_script_name}.py"):
+            if not path.is_file():
+                continue
+
+            parts = path.relative_to(root).parts
+            current_level = result
+            current_fs_level = root
+
+            for part in parts[:-1]:
+                dynamic_dirs = self._get_dynamic_dirs(current_fs_level)
+                if len(dynamic_dirs) > 1:
+                    raise BadAPIDirectory(
+                        f"Multiple dynamic route folders in {current_fs_level}: "
+                        f"{', '.join(d.name for d in dynamic_dirs)}"
+                    )
+
+                # move filesystem pointer
+                current_fs_level = current_fs_level / part
+
+                current_level = current_level.setdefault(part, {})
+
+            script_globals = runpy.run_path(str(path.absolute()))
+
+            # Grab just endpoint methods
+            api_routes = {
+                f"/{k}": v
+                for k, v in script_globals.items()
+                if k in self.__taken_endpoints
+            }
+
+            # Add endpoints
+            current_level.update(api_routes)
+        return result
+
+    def __has_endpoint_path(self, base_url : str) -> tuple[dict[str, any] | None, dict[str,str]]:
+        # Digs through api cache map to find the correct endpoint directory
+        slugs = {}
+        path = pathlib.Path(f"{self.cfg.api_directory}{base_url}")
+        parts : list[str] = path.relative_to(self.cfg.api_directory).parts
+
+        leaf : dict = self.__paths
+        for part in parts:
+            if part in leaf:
+                leaf = leaf[part]
+                continue
+
+            # checks if there are dynamic routes available
+            dynamic_routes: list[str] = list(
+                {
+                    key
+                    for key in leaf
+                    if key.startswith("[") and key.endswith("]")
+                }
+            )
+
+            if len(dynamic_routes) == 1:
+                slugs[dynamic_routes[0].strip("[]")] = part
+                leaf = leaf[dynamic_routes[0]]
+            else:
+                return (None, {})
+
+        if len(leaf) == 0:
+            return (None, {})
+
+        return (leaf, slugs)
+
+    def _handle_request(self, client: socket.socket):
+        data = client.recv(self.cfg.max_request_size)
+
+        try:
+            request : Request = Request(data)
+
+        except BadRequest:
+            self.__send_response(client, Response(status_code=400, body="400 Bad Request"))
+            client.close()
+            return
+
+        try:
+            (endpoint, request.slugs) = self.__has_endpoint_path(request.base_url)
+
+            if endpoint is None:
+                raise FileNotFoundError()
+
+            # Finds the correct protocol based on the inital request
+            for protocol_cls in self.__protocols:
+                protocol: Protocol = protocol_cls()
+
+                if not protocol.identify(initial_data=data):
+                    continue
+
+                if not protocol.handshake(client=client):
+                    raise BadRequest("Failed Handshake with protocol!")
+
+                target_endpoints = protocol.get_target_endpoints()
+
+                endpoints = {
+                    f"/{k}": endpoint[f"/{k}"]
+                    for k in target_endpoints
+                    if f"/{k}" in endpoint
+                }
+
+                endpoints = { key.lstrip("/"): value for key, value in endpoints.items() }
+
+                if inspect.iscoroutinefunction(protocol.handle):
+                    asyncio.run(protocol.handle(
+                        client=client,
+                        slugs=request.slugs,
+                        endpoints=endpoints,
+                    ))
+                else:
+                    protocol.handle(
+                        client=client,
+                        slugs=request.slugs,
+                        endpoints=endpoints,
+                    )
+
+                break
+            else: # No Protocol was found to be compatible
+                raise BadRequest("No Compatible Protocol Found!")
+
+
+        except BadRequest:
+            response : Response = Response(status_code=400, body="400 Bad Request")
+            self.__send_response(client=client, response=response)
+
+        except FileNotFoundError:
+            response : Response = Response(status_code=404, body="404 Not Found")
+            self.__send_response(client, response)
+
+        except RuntimeError as e:
+            print(f"Error handling request: {e}")
+            response = Response(status_code=500, body="Internal Server Error")
+            self.__send_response(client, response)
+
+        finally:
+            client.close()
+
+    def __send_response(self, client : socket.socket, response : Response):
+        client.sendall(response.to_bytes())
+        current_time = datetime.now().strftime("%H:%M:%S")
+        ip, _ = client.getpeername()
+        print(f"{current_time} {response.status_code.value} -> {ip}")
+
+    def __close(self):
+        if self.__s is not None:
+            try:
+                print("Closing Server...")
+                self.__running = False
+                self.__s.close()
+            except socket.error as e:
+                print(f"Error when closing socket: {e}")