Plinx 0.0.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

{Plinx-0.0.1.dist-info → Plinx-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Plinx
-Version: 0.0.1
+Version: 1.0.0
 Summary: Plinx is an experimental, minimalistic, and extensible web framework and ORM written in Python.
 Home-page: https://github.com/dhavalsavalia/plinx
 Author: Dhaval Savalia
@@ -15,12 +15,14 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: webob
+Requires-Dist: parse
 
 
 # Plinx
 
 ![purpose](https://img.shields.io/badge/purpose-learning-green.svg)
-![PyPI](https://img.shields.io/pypi/v/bumbo.svg)
+![PyPI](https://img.shields.io/pypi/v/Plinx.svg)
 
 **Plinx** is an experimental, minimalistic, and extensible WSGI-based web framework and ORM written in Python.  
 It is designed to be simple, fast, and easy to extend, making it ideal for rapid prototyping and educational purposes.
@@ -29,8 +31,9 @@ It is designed to be simple, fast, and easy to extend, making it ideal for rapid
 
 ## Features
 
-- 🚀 Minimal and fast web framework
-- 🛣️ Intuitive routing system
+- 🚀 Minimal and fast WSGI web framework
+- 💾 Integrated Object-Relational Mapper (ORM)
+- 🛣️ Intuitive routing system (including parameterized and class-based routes)
 - 🧩 Extensible middleware support
 - 🧪 Simple, readable codebase for learning and hacking
 - 📝 Type hints and modern Python best practices
@@ -39,6 +42,12 @@ It is designed to be simple, fast, and easy to extend, making it ideal for rapid
 
 ## Installation
 
+Install from PyPI:
+
+```bash
+pip install Plinx
+```
+
 Install directly from the git source:
 
 ```bash
@@ -52,19 +61,30 @@ pip install git+https://github.com/dhavalsavalia/plinx.git
 Create a simple web application in seconds:
 
 ```python
+# myapp.py
 from plinx import Plinx
 
 app = Plinx()
 
 @app.route("/")
 def index(request, response):
-    response.text = "Hello, world!"
+    response.text = "Hello, Plinx 1.0.0!"
+
+# Example using the ORM (requires database setup)
+# from plinx.orm import Database, Table, Column
+# db = Database("my_database.db")
+# class Item(Table):
+#     name = Column(str)
+#     count = Column(int)
+# db.create(Item)
+# db.save(Item(name="Example", count=1))
 ```
 
-Run your app (example, assuming you have an ASGI server like `uvicorn`):
+Run your app using a WSGI server (like `gunicorn`):
 
 ```bash
-uvicorn myapp:app
+pip install gunicorn
+gunicorn myapp:app
 ```
 
 ## Testing
@@ -77,19 +97,6 @@ pytest --cov=.
 
 ---
 
-## Roadmap
-
-- [x] Web Framework
-  - [x] Routing
-  - [x] Explicit Routing Methods (GET, POST, etc.)
-  - [x] Parameterized Routes
-  - [x] Class Based Routes
-  - [x] Django-like Routes
-  - [x] Middleware Support
-- [ ] ORM
-
----
-
 ## Contributing
 
 Contributions are welcome! Please open issues or submit pull requests for improvements, bug fixes, or new features.
@@ -104,7 +111,7 @@ This project is licensed under the MIT License. See [LICENSE](LICENSE) for detai
 
 ## Author & Contact
 
-Created and maintained by [Dhaval Savalia](https://github.com/dhavalsavalia).  
+Created and maintained by [Dhaval Savalia](https://github.com/dhavalsavalia).
 For questions or opportunities, feel free to reach out via [LinkedIn](https://www.linkedin.com/in/dhavalsavalia/) or open an issue.
 
 ---

{Plinx-0.0.1.dist-info → Plinx-1.0.0.dist-info}/RECORD

@@ -5,8 +5,11 @@ plinx/middleware.py,sha256=OiNDhKWpmpKkAIbSWxRzP_tQXSyfDToos-MQMDPSUWM,2161
 plinx/response.py,sha256=oDZPF9V76HhqdUZLzSmoLw_q-GG9hc5krfCBgNm3OfU,1460
 plinx/status_codes.py,sha256=V7vX7_ujYIaVjO3I3eVUnuNKiTXMSov56wJt8tvMbAM,700
 plinx/utils.py,sha256=WaU_j7YXsdlZh3M33B2vXjRPAU26lBeQ5sV2ZasXVwE,352
-Plinx-0.0.1.dist-info/LICENSE,sha256=MljMjTJD6oOY41eZWLDZ4x8FrTUcl7ElKxWIXJXUwLM,1066
-Plinx-0.0.1.dist-info/METADATA,sha256=N-vDBHtG4pV2LKumS4yh40_IYzKKh8PgRf1G3Umw_Q0,2568
-Plinx-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-Plinx-0.0.1.dist-info/top_level.txt,sha256=U_4P3aFsTEhhvfiE3sVbJKAG9Fp4IPC5d6zpttayAZw,6
-Plinx-0.0.1.dist-info/RECORD,,
+plinx/orm/__init__.py,sha256=ryDdzvF6Eh6RIHyEgym6UKCaFMnMitwucazpiWuvICQ,61
+plinx/orm/orm.py,sha256=FdwLdT-4I5rnhfTCu7v9iBZZ5xlZHZ36equqPAHYvhk,7335
+plinx/orm/utils.py,sha256=uXT2JV9cVgLTnm_EkguqJglsbIfSPXcnjMQBNFJ8M08,116
+Plinx-1.0.0.dist-info/LICENSE,sha256=MljMjTJD6oOY41eZWLDZ4x8FrTUcl7ElKxWIXJXUwLM,1066
+Plinx-1.0.0.dist-info/METADATA,sha256=cDxPb9HkViq-kG_JWVI3YFWI6APojOUiPSZSotzBfFY,2819
+Plinx-1.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+Plinx-1.0.0.dist-info/top_level.txt,sha256=U_4P3aFsTEhhvfiE3sVbJKAG9Fp4IPC5d6zpttayAZw,6
+Plinx-1.0.0.dist-info/RECORD,,

plinx/orm/__init__.py

@@ -0,0 +1 @@
+from .orm import Column, Database, ForeignKey, Table  # noqa

plinx/orm/orm.py

@@ -0,0 +1,240 @@
+import inspect
+import sqlite3
+from typing import Generic, TypeVar
+
+from .utils import SQLITE_TYPE_MAP
+
+T = TypeVar("T")
+
+
+class Database:
+    def __init__(self, path: str):
+        self.connection = sqlite3.Connection(path)
+
+    def create(self, table: "Table"):
+        self.connection.execute(table._get_create_sql())
+
+    def save(self, instance: "Table"):
+        sql, values = instance._get_insert_sql()
+        cursor = self.connection.execute(sql, values)
+        instance._data["id"] = cursor.lastrowid
+        self.connection.commit()
+
+    def all(self, table: "Table"):
+        sql, fields = table._get_select_all_sql()
+        rows = self.connection.execute(sql).fetchall()
+
+        result = []
+
+        for row in rows:
+            properties = {}
+            for field, value in zip(fields, row):
+                if field.endswith("_id"):
+                    foreign_key = field[:-3]
+                    foreign_table = getattr(table, foreign_key).table
+                    properties[foreign_key] = self.get(foreign_table, id=value)
+                else:
+                    properties[field] = value
+            result.append(table(**properties))
+
+        return result
+
+    def get(self, table: "Table", **kwargs):
+        sql, fields, params = table._get_select_where_sql(**kwargs)
+        row = self.connection.execute(sql, params).fetchone()
+
+        if row is None:
+            raise Exception(f"{table.__name__} instance with {kwargs} does not exist")
+
+        properties = {}
+
+        for field, value in zip(fields, row):
+            if field.endswith("_id"):
+                foreign_key = field[:-3]
+                foreign_table = getattr(table, foreign_key).table
+                properties[foreign_key] = self.get(foreign_table, id=value)
+            else:
+                properties[field] = value
+
+        return table(**properties)
+
+    def update(self, instance: "Table"):
+        sql, values = instance._get_update_sql()
+        self.connection.execute(sql, values)
+        self.connection.commit()
+
+    def delete(self, instance: "Table"):
+        sql, values = instance._get_delete_sql()
+        self.connection.execute(sql, values)
+        self.connection.commit()
+
+    def close(self):
+        if self.connection:
+            self.connection.close()
+        self.connection = None
+
+    @property
+    def tables(self):
+        SELECT_TABLES_SQL = "SELECT name FROM sqlite_master WHERE type = 'table';"
+        return [x[0] for x in self.connection.execute(SELECT_TABLES_SQL).fetchall()]
+
+
+class Column:
+    def __init__(self, type: Generic[T]):
+        self.type = type
+
+    @property
+    def sql_type(self):
+        return SQLITE_TYPE_MAP[self.type]
+
+
+class ForeignKey:
+    def __init__(self, table):
+        self.table = table
+
+
+class Table:
+    def __init__(self, **kwargs):
+        self._data = {"id": None}
+
+        for key, value in kwargs.items():
+            self._data[key] = value
+
+    def __getattribute__(self, key):
+        """
+        Values to be access are in `self._data`
+        Accessing without __getattribute__ will return Column or ForeignKey and not the actual value
+        """
+        # Why use super().__getattribute__ instead of self._data[key]?
+        # Because otherwise it will create an infinite loop since __getattribute__ will call itself
+        # and will never return the value
+        _data = super().__getattribute__("_data")
+        if key in _data:
+            return _data[key]
+        return super().__getattribute__(key)
+
+    def __setattr__(self, key, value):
+        """
+        Values to be set are in `self._data`
+        """
+        super().__setattr__(key, value)
+        if key in self._data:
+            self._data[key] = value
+
+    @classmethod
+    def _get_create_sql(cls):
+        CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS {name} ({fields});"
+        fields = [
+            "id INTEGER PRIMARY KEY AUTOINCREMENT",
+        ]
+
+        for name, field in inspect.getmembers(cls):
+            if isinstance(field, Column):
+                fields.append(f"{name} {field.sql_type}")
+            elif isinstance(field, ForeignKey):
+                fields.append(f"{name}_id INTEGER")
+
+        fields = ", ".join(fields)
+        name = cls.__name__.lower()
+        return CREATE_TABLE_SQL.format(name=name, fields=fields)
+
+    def _get_insert_sql(self):
+        INSERT_SQL = "INSERT INTO {name} ({fields}) VALUES ({placeholders});"
+
+        cls = self.__class__
+        fields = []
+        placeholders = []
+        values = []
+
+        for name, field in inspect.getmembers(cls):
+            if isinstance(field, Column):
+                fields.append(name)
+                values.append(getattr(self, name))
+                placeholders.append("?")
+            elif isinstance(field, ForeignKey):
+                fields.append(name + "_id")
+                values.append(getattr(self, name).id)
+                placeholders.append("?")
+
+        fields = ", ".join(fields)
+        placeholders = ", ".join(placeholders)
+
+        sql = INSERT_SQL.format(
+            name=cls.__name__.lower(), fields=fields, placeholders=placeholders
+        )
+
+        return sql, values
+
+    @classmethod
+    def _get_select_all_sql(cls):
+        SELECT_ALL_SQL = "SELECT {fields} FROM {name};"
+
+        fields = ["id"]
+
+        for name, field in inspect.getmembers(cls):
+            if isinstance(field, Column):
+                fields.append(name)
+            elif isinstance(field, ForeignKey):
+                fields.append(name + "_id")
+
+        return SELECT_ALL_SQL.format(
+            fields=", ".join(fields),
+            name=cls.__name__.lower(),
+        ), fields
+
+    @classmethod
+    def _get_select_where_sql(cls, **kwargs):
+        SELECT_WHERE_SQL = "SELECT {fields} FROM {name} WHERE {query};"
+
+        fields = ["id"]
+        query = []
+        values = []
+
+        for name, field in inspect.getmembers(cls):
+            if isinstance(field, Column):
+                fields.append(name)
+            elif isinstance(field, ForeignKey):
+                fields.append(name + "_id")
+
+        for key, value in kwargs.items():
+            query.append(f"{key} = ?")
+            values.append(value)
+
+        return (
+            SELECT_WHERE_SQL.format(
+                fields=", ".join(fields),
+                name=cls.__name__.lower(),
+                query=", ".join(query),
+            ),
+            fields,
+            values,
+        )
+
+    def _get_update_sql(self):
+        UPDATE_SQL = "UPDATE {name} SET {fields} WHERE id = ?;"
+
+        cls = self.__class__
+        fields = []
+        values = []
+
+        for name, field in inspect.getmembers(cls):
+            if isinstance(field, Column):
+                fields.append(name)
+                values.append(getattr(self, name))
+            elif isinstance(field, ForeignKey):
+                fields.append(name + "_id")
+                values.append(getattr(self, name).id)
+
+        values.append(getattr(self, "id"))
+
+        return UPDATE_SQL.format(
+            name=cls.__name__.lower(),
+            fields=", ".join([f"{field} = ?" for field in fields]),
+        ), values
+
+    def _get_delete_sql(self):
+        DELETE_SQL = "DELETE FROM {name} WHERE id = ?;"
+
+        return DELETE_SQL.format(
+            name=self.__class__.__name__.lower()
+        ), [getattr(self, "id")]

plinx/orm/utils.py

@@ -0,0 +1,7 @@
+SQLITE_TYPE_MAP = {
+    int: "INTEGER",
+    float: "REAL",
+    str: "TEXT",
+    bytes: "BLOB",
+    bool: "INTEGER"
+}