Version 1.2.0: Updated ORM, finished tutorial on Docs and Added Versioning Tags

Author: Sas2k

Lemon/create_lemon_app.py

@@ -14,6 +14,8 @@
 from Lemon.ui.buttons import Buttons
 from random import choice
 
+from models.model import insert_fake_data
+
 Root = Component(\"Lemon\", \"public/css/style.css\", \"public/js/script.js\")
 app = Server(static_dir=\"public\")
 
@@ -40,6 +42,7 @@ def item(props: dict):
 
 @app.route("/")
 def home(request, response):
+    insert_fake_data()
     response.text = Root.render('<App/>')
 
 app.run()
@@ -96,18 +99,19 @@ def home(request, response):
 
 class model(baseModel):
     base_model = ClassBase
-    table_name = "model"
+    tablename = "model"
     fields = ("field1", "field2")
 
 model_list = [model]
 
 migrate(model_list).migrate()"""
 
-sql_model = """from Lemon.orm import DBManager
+sql_model = """from Lemon.orm.DBManager import SqliteManager
 
-sql = DBManager.SQLConnectionManager("../model.db")
+sql = SqliteManager("../model.db")
 # inserts some fake data to field1 and field2
-sql.insert("model", [("field1", "field2"), ("Hello", "World")])
+def insert_fake_date():
+    sql.insert("model", [("field1", "field2"), ("Hello", "World")])
 """
 
 def main():
@@ -139,6 +143,8 @@ def main():
 
     open("models/model.py", "w+", encoding="utf-8").write(sql_model)
 
+    open("models/__init__.py", "w+", encoding="utf-8").write("")
+
     open("README.md", "w+", encoding="utf-8").write(readme_code)
 
     print(f"App created @ /{args.app_name}/")

Lemon/orm/DBManager.py

@@ -1,24 +1,20 @@
 import sqlite3 as sql3
 import datetime
 
-class SQLConnectionManager:
-    """SQL Connection Manager"""
 
+class SQLConnectionManager():
     def __init__(self,filename):
-        """SQL Connection Manager: Init"""
         self.filename = filename
-        self.connection = sql3.connect(filename)
+        self.connection = sql3.connect(self.filename)
         self.cursor = self.connection.cursor()
 
     def __enter__(self):
-        """when the class is entered as a context manager"""
         print("Connection started ...")
         self.connection = sql3.connect(self.filename)
         self.cursor = self.connection.cursor()
         return self
 
     def commit(operation):
-        """Commit Operation"""
         def wrapper(self, tablename, fields):
             operation(self, tablename, fields)
             self.connection.commit()
@@ -27,7 +23,6 @@ def wrapper(self, tablename, fields):
 
     @commit
     def create_table(self, tablename, fields):
-        """Create Table"""
         fields = list(fields)
         fields = " text, ".join(fields) +" text"
         drop_command = f"DROP TABLE IF EXISTS {tablename}"
@@ -40,98 +35,112 @@ def create_table(self, tablename, fields):
         finally:
             print(f"{tablename}: created successfully!")
 
-    @commit
-    def insert(self, tablename, fields: list):
-        """Insert"""
-        values = fields[1]
-        fields = fields[0]
-        fields = ", ".join(fields)
-        values = ", ".join(values)
-        insert_command = f"INSERT INTO {tablename} ({fields}) VALUES ({values})"
-        try:
-            self.cursor.execute(insert_command)
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+    def alter_table(self, ):
+        pass
 
-    @commit
-    def delete(self, tablename, fields):
-        """Delete"""
-        delete_command = f"DELETE FROM {tablename} WHERE {fields[0]} = {fields[1]}"
-        try:
-            self.cursor.execute(delete_command)
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+    @property
+    def show_tables(self):
+        command = "SELECT * FROM sqlite_master WHERE type='table';"
+        return self.cursor.execute(command)
 
-    @commit
-    def update(self, tablename, fields):
-        """Update"""
-        update_command = f"UPDATE {tablename} SET {fields[0]} = {fields[1]} WHERE {fields[2]} = {fields[3]}"
-        try:
-            self.cursor.execute(update_command)
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+    def __exit__(self, type, value, traceback):
+        print("Connection ended ...")
+        self.connection.close()
 
-    @commit
-    def select(self, tablename, fields):
-        """Select"""
-        select_command = f"SELECT {fields[0]} FROM {tablename} WHERE {fields[1]} = {fields[2]}"
-        try:
-            self.cursor.execute(select_command)
-            return self.cursor.fetchall()
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+
+class SqliteManager():
+    def __init__(self, filename):
+        self.filename = filename
+        self.connection = sql3.connect(self.filename)
+        self.cursor = self.connection.cursor()
+
+    def __enter__(self):
+        return self
+
+    def commit(operation):
+        def wrapper(self, tablename, fields):
+            operation(self, tablename, fields)
+            self.connection.commit()
+            print(f"{datetime.datetime.now()}: Commit is successful!!")
+        return wrapper
 
     @commit
-    def drop_table(self, tablename, fields = None):
-        """Drop Table"""
+    def create_table(self, tablename, fields):
+        fields = list(fields)
+        fields = " text, ".join(fields) +" text"
         drop_command = f"DROP TABLE IF EXISTS {tablename}"
+        create_command = f"CREATE TABLE {tablename} ({fields})"
         try:
             self.cursor.execute(drop_command)
+            self.cursor.execute(create_command)
         except sql3.Error as er:
             print(f"SQLite error: {' '.join(er.args)}")
+        finally:
+            print(f"{tablename}: created successfully!")
 
     @commit
-    def get_column(self, tablename, fields):
-        """Get Column"""
-        get_column_command = f"SELECT {fields[0]} FROM {tablename}"
-        try:
-            self.cursor.execute(get_column_command)
-            return self.cursor.fetchall()
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+    def insert(self, tablename, fields):
+        fields = list(fields)
+        print(fields)
+        values = fields[1]
+        fields = fields[0]
+        fields = ", ".join(fields)
+        values = ", ".join(values)
+        print(fields, values)
+        command = f"INSERT INTO {tablename} ({fields}) VALUES ({values})"
+        print(command)
+        self.cursor.execute(command)
 
     @commit
-    def get_table(self, tablename, fields = None):
-        """Get Table"""
-        get_table_command = f"SELECT * FROM {tablename}"
-        try:
-            self.cursor.execute(get_table_command)
-            return self.cursor.fetchall()
-        except sql3.Error as er:
-            print(f"SQLite error: {' '.join(er.args)}")
+    def update(self, tablename, fields):
+        fields = list(fields)
+        values = fields[1]
+        fields = fields[0]
+        fields = ", ".join(fields)
+        values = ", ".join(values)
+        command = f"UPDATE {tablename} SET {fields} WHERE {values}"
+        self.cursor.execute(command)
+
+    @commit
+    def delete(self, tablename, fields):
+        fields = list(fields)
+        values = fields[1]
+        fields = fields[0]
+        fields = ", ".join(fields)
+        values = ", ".join(values)
+        command = f"DELETE FROM {tablename} WHERE {fields} = {values}"
+        self.cursor.execute(command)
+    
+    @commit
+    def select(self, tablename, fields):
+        fields = list(fields)
+        values = fields[1]
+        fields = fields[0]
+        fields = ", ".join(fields)
+        values = ", ".join(values)
+        command = f"SELECT {fields} FROM {tablename} WHERE {values}"
+        self.cursor.execute(command)
+        return self.cursor.fetchall()
+
+    @commit
+    def select_all(self, tablename):
+        command = f"SELECT * FROM {tablename}"
+        self.cursor.execute(command)
+        return self.cursor.fetchall()
 
     @property
     def show_tables(self):
-        """Show Tables"""
         command = "SELECT * FROM sqlite_master WHERE type='table';"
         return self.cursor.execute(command)
 
     @property
     def show_columns(self):
-        """Show Columns"""
-        command = "SELECT * FROM sqlite_master WHERE type='table';"
-        return self.cursor.execute(command)
-
-    @property
-    def show_rows(self):
-        """Show Rows"""
         command = "SELECT * FROM sqlite_master WHERE type='table';"
         return self.cursor.execute(command)
 
     def __exit__(self, type, value, traceback):
-        """when the class is exited as a context manager"""
-        print("Connection ended ...")
         self.connection.close()
+    
 
 class base:
     """Base Class"""

docs/versioned_docs/version-1.0.0/Hello-World.md

@@ -0,0 +1,104 @@
+---
+title: Hello World!
+sidebar_position: 3
+---
+
+# Lemon 🍋: Hello-World!
+
+Hello, in this part. we're going to build a small lemon app.
+
+## Getting Started
+
+first of, let's create a virtual environment.
+
+```bash
+#with venv
+python -m venv venv
+
+#with virtualenv
+python -m virtualenv venv
+```
+
+then activate it with the below command.
+
+```bash
+#windows
+.\\venv\\Scripts\\activate
+```
+
+after that install Lemon in it.
+
+```bash
+pip install Lemon-Library
+```
+
+## creating the app
+
+now in that app create a file called `app.py`
+
+now in that app paste this code (don't worry I will explain the code).
+
+```python
+from Lemon.components import Component
+from Lemon.Server.server import Server
+
+app = Server(None)
+Root = Component("Home")
+
+class home(Component):
+    
+    name = "home"
+
+    def item(props: dict):
+        return """
+            <h1>Hello World!</h1>
+            <p>This is generated in Python!</p>
+            <p><strong>This is in BOLD</strong></p>
+            <p><em>This is in ITALICS</em></p>
+            <a href=\"https://github.com/Sas2k\">My Github Profile</a>
+        """
+
+Root.add(home)
+
+@app.route("/")
+def student(request, response):
+    home_page = Root.render("<home/>")
+    response.text = home_page
+
+app.run()
+```
+
+now to run it, just do this.
+
+`python app.py`
+
+## Code Break Down 🥚🍳
+
+Now let's break the code down.
+
+in the first 2 lines, it imports the server and the Component Class. (which is the base class to create the components.)
+
+then we define an `app` variable, which is the server instance.
+the `root` variable is the root component where the components are rendered.
+
+then there is the `Home` Class, which is a component.
+
+in the component class, there is a `name` variable, which is the variable that says the name of the variable.
+
+then the `item` function is where the components stuff is there (like the filling of a pie 🥧).
+
+the `item` function has a `props` dictionary object. Which are the properties of the element.
+
+For example: `<exampleComponent name="Sas2k"/>
+
+here the `name="Sas2k"` is the prop.
+
+After that the component is added to the Root with the `Root.add`.
+
+then their is the usual route function.
+
+After, their is the `app.run` which runs it.
+
+And that's basically it.
+
+_A Lemon app, broken down._