SQLModel added

Author: scionoftech

FastAPIMongoEngineGraphQL/setup.py

@@ -1,10 +1,10 @@
 from setuptools import setup
 
 setup(
-    name='FastAPIMongoEngine',
+    name='FastAPIMongoEngineGraphQL',
     version='0.0.1',
     author='scionoftech',
-    description='FastAPIMongoEngine is a simple Python API Application',
+    description='FastAPIMongoEngineGraphQL is a simple Python API Application',
     platforms='any',
     install_requires=[
         'fastapi',

FastAPISQLAlchamyGraphQL/setup.py

@@ -1,10 +1,10 @@
 from setuptools import setup
 
 setup(
-    name='FastAPISQLAlchemy',
+    name='FastAPISQLAlchemyGraphQL',
     version='0.0.1',
     author='scionoftech',
-    description='FastAPISQLAlchemy is a simple Python API Application',
+    description='FastAPISQLAlchemyGraphQL is a simple Python API Application',
     platforms='any',
     install_requires=[
         'fastapi',

FastAPISQLModel/Dockerfile

@@ -0,0 +1,9 @@
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7
+
+COPY app /app
+
+RUN ls -l
+
+# RUN apt-get install python3-psycopg2
+
+RUN pip install -r ./requirements.txt

FastAPISQLModel/Jenkinsfile

@@ -0,0 +1,21 @@
+pipeline {
+	agent any
+	    stages {
+	        stage('Clone Repository') {
+	        /* Cloning the repository to our workspace */
+	        steps {
+	        checkout scm
+	        }
+	   }
+	   stage('Build Image') {
+	        steps {
+	        sh 'sudo docker-compose build'
+	        }
+	   }
+	   stage('Run Container') {
+	        steps {
+	        sh 'sudo docker-compose up -d'
+	        }
+	   }
+    }
+}

FastAPISQLModel/README.md

@@ -0,0 +1,88 @@
+# FastAPI-SQLModel
+
+FastAPI-SQLModel is a Python API Application with FastAPI, JWT Authentication,
+Postgresql, SQLModel, Docker and Jenkins Pipeline
+
+## Features
+
+* Full **Docker** integration (Docker based).
+* **Production ready** Python web server using Uvicorn and Gunicorn.
+* Python <a href="https://github.com/tiangolo/fastapi" class="external-link" target="_blank">**FastAPI**</a> backend:
+    * **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic).
+    * **Intuitive**: Great editor support. <abbr title="also known as auto-complete, autocompletion, IntelliSense">Completion</abbr> everywhere. Less time debugging.
+    * **Easy**: Designed to be easy to use and learn. Less time reading docs.
+    * **Short**: Minimize code duplication. Multiple features from each parameter declaration.
+    * **Robust**: Get production-ready code. With automatic interactive documentation.
+    * **Standards-based**: Based on (and fully compatible with) the open standards for APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> and <a href="http://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+    * <a href="https://fastapi.tiangolo.com/features/" class="external-link" target="_blank">**Many other features**</a> including automatic validation, serialization, interactive documentation, authentication with OAuth2 JWT tokens, etc.
+* **Secure password** hashing by default.
+* **JWT token** authentication.
+* **SQLModel** new SQL ORM.
+* Basic starting models for users (modify and remove as you need).
+* **CORS** (Cross Origin Resource Sharing).
+* Load balancing between frontend and backend with **Nginx**, so you can have both under the same domain, separated by path, but served by different containers.
+* Let's Encrypt **HTTPS** certificates automatic generation.
+
+
+## How to use it
+
+**psycopg2**
+
+psycopg2 is postgresql adapter for sqlalchamy this can't be installed directly
+in linux using pip, use below command to install
+
+```bash 
+sudo apt-get install python3-psycopg2
+sudo apt-get install libpq-dev python3-dev
+```
+
+## JWT token authentication
+
+JWT-Signature using RSA256 algorithm.
+
+You can generate a 2048-bit RSA key pair with the following commands:
+
+```bash
+openssl genpkey -algorithm RSA -out rsa_private.pem -pkeyopt rsa_keygen_bits:2048
+openssl rsa -in rsa_private.pem -pubout -out rsa_public.pem
+```
+
+## Create SSL Certificates using Certbot
+
+Generate SSL cerificates from trusted thirdparty or openssl
+
+	For Open SSL use Certbot (Let'sencrypt)
+```bash
+sudo apt-get update
+sudo apt-get install software-properties-common
+sudo add-apt-repository universe
+sudo add-apt-repository ppa:certbot/certbot
+sudo apt-get install certbot python3-certbot-nginx
+
+sudo certbot -d example.com certonly
+```
+certificates will be found in "/etc/letsencrypt/live/example.com/"
+
+Generate a set of 4096-bit diffie-hellman parameters to improve security for some types of ciphers. 
+```bash
+sudo mkdir -p /etc/nginx/ssl
+sudo openssl dhparam -out /etc/nginx/ssl/dhp-4096.pem 4096
+```
+
+## Deployment
+
+FastAPI Backend can be deployed using docker. Use below docker image for deployment.
+
+tiangolo/uvicorn-gunicorn-fastapi-docker - [Docker image with Uvicorn managed by Gunicorn for high-performance FastAPI web applications in Python 3.6 and above with performance auto-tuning. Optionally with Alpine Linux.](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker)
+
+
+#### References
+
+The fundamental repositories:
+- FastAPI - [FastAPI framework, high performance, easy to learn, fast to code, ready for production](https://fastapi.tiangolo.com/)
+- full-stack-fastapi-postgresql - [Full stack, modern web application generator. Using FastAPI, PostgreSQL as database, Docker, automatic HTTPS and more.](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+- blog-posts - [Build a web API from scratch with FastAPI - the workshop](https://github.com/tiangolo/blog-posts/tree/master/pyconby-web-api-from-scratch-with-fastapi)
+- uvicorn - [The lightning-fast ASGI server.](https://www.uvicorn.org/deployment/)
+- tiangolo/uvicorn-gunicorn-fastapi-docker - [Docker image with Uvicorn managed by Gunicorn for high-performance FastAPI web applications in Python 3.6 and above with performance auto-tuning. Optionally with Alpine Linux.](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker)
+- sqlmodel - [SQLModel is a library for interacting with SQL databases from Python code, with Python objects. It is designed to be intuitive, easy to use, highly compatible, and robust.](https://sqlmodel.tiangolo.com/)
+- 

FastAPISQLModel/app/__init__.py

@@ -0,0 +1,8 @@
+from . import auth
+from . import conf
+from . import controller
+from . import crud
+from . import db
+from . import logs
+from . import routes
+from . import util

FastAPISQLModel/app/__pycache__/__init__.cpython-37.pyc

@@ -0,0 +1,2 @@
+from .token import access_token
+

FastAPISQLModel/app/__pycache__/main.cpython-37.pyc

@@ -0,0 +1,69 @@
+from datetime import timedelta, datetime
+import os
+from jwt import (
+    JWT,
+    jwk_from_pem,
+)
+from typing import Dict
+from pathlib import Path
+from jwt.utils import get_int_from_datetime
+from app.conf import EmailSettings
+
+
+def get_root() -> str:
+    return str(Path(__file__).parent.parent) + os.sep
+
+
+class AccessToken:
+    """ Access Token Util Class"""
+
+    def __init__(self):
+
+        self.__instance = JWT()
+        self.__algorithm = "RS256"
+        with open(get_root() + 'auth' + os.sep + 'jwtRS256_private.pem',
+                  'rb') as fh:
+            self.__signing_key = jwk_from_pem(fh.read())
+        with open(get_root() + 'auth' + os.sep + 'jwtRS256_public.pem',
+                  'rb') as fh:
+            self.__verifying_key = jwk_from_pem(fh.read())
+
+    def create_access_token(self, *, data: dict,
+                            expires_delta: timedelta = None) -> str:
+        """Create Access Token Using JWT with RSA256 Encryption"""
+        to_encode = data.copy()
+        if expires_delta:
+            expire = datetime.utcnow() + expires_delta
+        else:
+            expire = datetime.utcnow() + timedelta(minutes=15)
+        to_encode.update({"ist": get_int_from_datetime(datetime.utcnow())})
+        to_encode.update({"exp": get_int_from_datetime(expire)})
+        encoded_jwt = self.__instance.encode(to_encode, self.__signing_key,
+                                             self.__algorithm)
+        return encoded_jwt
+
+    def decode_access_token(self, *, token: str) -> Dict:
+        """ Decode Access Token """
+        return self.__instance.decode(token, self.__verifying_key,
+                                      do_time_check=False)
+
+    def generate_password_reset_token(self, email: str) -> str:
+        """ Generate Access Token for password Reset email"""
+        delta = timedelta(hours=EmailSettings.EMAIL_RESET_TOKEN_EXPIRE_HOURS)
+        now = datetime.utcnow()
+        expires = now + delta
+        encoded_jwt = self.__instance.encode(
+            {"exp": get_int_from_datetime(expires),
+             "ist": get_int_from_datetime(now), "sub": email},
+            self.__signing_key,
+            alg=self.__algorithm,
+        )
+        return encoded_jwt
+
+    def verify_password_reset_token(self, token: str) -> Dict:
+        """ Decode Access Token """
+        return self.__instance.decode(token, self.__verifying_key,
+                                      do_time_check=False)
+
+
+access_token = AccessToken()

FastAPISQLModel/app/auth/__init__.py

@@ -0,0 +1,3 @@
+from .config import ProjectSettings
+from .config import DBSettings
+from .config import EmailSettings

FastAPISQLModel/app/auth/__pycache__/__init__.cpython-37.pyc

@@ -0,0 +1,31 @@
+{
+  "PROJECT_CONF": {
+    "PROJECT_NAME": "FastAPISQLModel",
+    "PROJECT_DESCRIPTION": "A Simple Application to demonstrate SQLModel with FastAPI",
+    "API_VERSION": "1.0.0",
+    "API_VERSION_PATH": "/api/v1",
+    "ACCESS_TOKEN_EXPIRE_MINUTES": 300,
+    "SESSION_TOKEN_EXPIRE_SECONDS": 43200,
+    "SERVER_NAME": "SampleBackEndPROD",
+    "SERVER_HOST": "https://localhost:8088/api/v1/",
+    "BACKEND_CORS_ORIGINS": [
+      "*"
+    ]
+  },
+  "EMAIL_CONF": {
+    "EMAIL_RESET_TOKEN_EXPIRE_HOURS": 15,
+    "EMAIL_ID": "",
+    "EMAIL_PASSWORD": "",
+    "SMTP_SERVER": "",
+    "SMTP_PORT": 465
+  },
+  "DATABASE_CONF": {
+    "DATABASE": "postgresql",
+    "POSTGRES_SERVER": "localhost",
+    "POSTGRES_PORT": "5432",
+    "POSTGRES_USER": "",
+    "POSTGRES_PASSWORD": "",
+    "POSTGRES_DB": "postgres",
+    "POSTGRES_ADAPTER": "psycopg2"
+  }
+}

FastAPISQLModel/app/auth/__pycache__/token.cpython-37.pyc

@@ -0,0 +1,49 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict
+
+
+def get_config() -> Dict:
+    """ Get Config Json"""
+    with open(str(Path(
+            __file__).parent.parent) + os.sep + "conf" + os.sep + "conf.json",
+              'r') as fp:
+        return json.load(fp)
+
+
+class EmailSettings:
+    """ Email Settings"""
+    __DATA = get_config()['EMAIL_CONF']
+    EMAIL_RESET_TOKEN_EXPIRE_HOURS = __DATA["EMAIL_RESET_TOKEN_EXPIRE_HOURS"]
+    EMAIL_ID = __DATA["EMAIL_ID"]
+    EMAIL_PASSWORD = __DATA["EMAIL_PASSWORD"]
+    SMTP_SERVER = __DATA["SMTP_SERVER"]
+    SMTP_PORT = __DATA["SMTP_PORT"]
+
+
+class DBSettings:
+    """ Database Configuration"""
+    __DATA = get_config()['DATABASE_CONF']
+    # 'postgres+psycopg2://USER:PASSWORD@localhost:5432/DATABASE'
+    SQLALCHEMY_DATABASE_URL = __DATA["DATABASE"] + '+' + __DATA[
+        "POSTGRES_ADAPTER"] + '://' + \
+                              __DATA["POSTGRES_USER"] + ':' + __DATA[
+                                  "POSTGRES_PASSWORD"] + '@' + __DATA[
+                                  "POSTGRES_SERVER"] + ':' + \
+                              __DATA["POSTGRES_PORT"] + '/' + __DATA[
+                                  "POSTGRES_DB"]
+
+
+class ProjectSettings:
+    """ Project Configuration"""
+    __DATA = get_config()['PROJECT_CONF']
+    PROJECT_NAME = __DATA["PROJECT_NAME"]
+    PROJECT_DESCRIPTION = __DATA["PROJECT_DESCRIPTION"]
+    API_VERSION = __DATA["API_VERSION"]
+    API_VERSION_PATH = __DATA["API_VERSION_PATH"]
+    SERVER_NAME = __DATA["SERVER_NAME"]
+    SERVER_HOST = __DATA["SERVER_HOST"]
+    BACKEND_CORS_ORIGINS = __DATA["BACKEND_CORS_ORIGINS"]
+    ACCESS_TOKEN_EXPIRE_MINUTES = __DATA["ACCESS_TOKEN_EXPIRE_MINUTES"]
+    SESSION_TOKEN_EXPIRE_SECONDS = __DATA["SESSION_TOKEN_EXPIRE_SECONDS"]

FastAPISQLModel/app/auth/token.py

@@ -0,0 +1 @@
+

FastAPISQLModel/app/conf/__init__.py

@@ -0,0 +1,4 @@
+from .crud_base import (get_user, get_active_user,get_user_password)
+from .crud_users import crud_users
+from .crud_login import crud_login
+from .crud_articles import crud_articles