Adds FlaskAPI

Author: =

FlaskAPI/README.md

@@ -0,0 +1,27 @@
+# FlaskAPI
+
+## Data Structure for Python developers
+
+Working with **Data Structures** by making a **FlaskAPI**
+
+### Run
+
++ ```sh
+  pip install -r requirements.txt
+  ```
+
++ ```sh
+  python server.py
+    ```
+
++ Run Postman to verify API calls
+
+---
+
+## Thanks to
+
+[freeCodeCamp](https://www.freecodecamp.org)
+
+### Author
+
+Kumar Shanu

FlaskAPI/binary_search_tree.py

@@ -0,0 +1,90 @@
+class Node:
+    def __init__(self, data=None) -> None:
+        """Node to store data
+
+        Args:
+            data (Any, optional): Data to be added. Defaults to None.
+        """
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+class BinarySearchTree:
+    def __init__(self) -> None:
+        """BinarySearch Tree Data Structure"""
+        self.root = None
+
+    def _insert_recursive(self, data, node):
+        if data["id"] < node.data["id"]:
+            if node.left is None:
+                node.left = Node(data)
+            else:
+                self._insert_recursive(data, node.left)
+        elif data["id"] > node.data["id"]:
+            if node.right is None:
+                node.right = Node(data)
+            else:
+                self._insert_recursive(data, node.right)
+        else:
+            return
+
+    def insert(self, data):
+        """Insert data in `BinarySearchTree`
+
+        Args:
+            data (Any): Data to be added
+
+        Example:
+            >>> bst = BinarySearchTree()
+            >>> bst.insert({"id" : 1})
+            >>> bst.insert({"id" : 3})
+            >>> bst.insert({"id" : 2})
+            >>> bst.root.data
+            {'id': 1}
+        """
+        if self.root is None:
+            self.root = Node(data)
+        else:
+            self._insert_recursive(data, self.root)
+
+    def _search_recursive(self, blog_post_id, node):
+        if node.left == None and node.right == None:
+            return False
+        if blog_post_id == node.data["id"]:
+            return node.data
+
+        if blog_post_id < node.data["id"] and node.left is not None:
+            if blog_post_id == node.left.data["id"]:
+                return node.left.data
+            return self._search_recursive(blog_post_id, node.left)
+
+        if blog_post_id > node.data["id"] and node.right is not None:
+            if blog_post_id == node.right.data["id"]:
+                return node.right.data
+            return self._search_recursive(blog_post_id, node.right)
+        return False
+
+    def search(self, blog_post_id):
+        """Search data in `BinarySearchTree`
+
+        Args:
+            blog_post_id (int): id to search
+
+        Returns:
+            Any: searched data
+
+        Example:
+            >>> bst = BinarySearchTree()
+            >>> bst.insert({"id" : 1})
+            >>> bst.insert({"id" : 3})
+            >>> bst.insert({"id" : 2})
+            >>> bst.search(3)
+            {'id': 3}
+            >>> bst.search(4)
+            False
+        """
+        blog_post_id = int(blog_post_id)
+        if self.root is None:
+            return False
+        return self._search_recursive(blog_post_id, self.root)

FlaskAPI/custom_q.py

@@ -0,0 +1,54 @@
+class Node:
+    def __init__(self, data=None, next_node=None) -> None:
+        self.data = data
+        self.next_node = next_node
+
+
+class Queue:
+    def __init__(self) -> None:
+        """Queue Data Structure"""
+        self.head = None
+        self.tail = None
+
+    def enqueue(self, data):
+        """Insert data into `Queue`
+
+        Args:
+            data (Any): data to be inserted
+
+        Example:
+            >>> q = Queue()
+            >>> q.enqueue(1)
+            >>> q.enqueue(2)
+            >>> q.head.data
+            1
+            >>> q.tail.data
+            2
+        """
+        if self.tail is None and self.head is None:
+            self.tail = self.head = Node(data, None)
+            return
+        self.tail.next_node = Node(data, None)
+        self.tail = self.tail.next_node
+        return
+
+    def dequeue(self):
+        """remove data from `Queue`
+
+        Returns:
+            Any: Queue data
+
+        Example:
+            >>> q = Queue()
+            >>> q.enqueue(1)
+            >>> q.enqueue(2)
+            >>> q.dequeue().data
+            1
+        """
+        if self.head is None:
+            return None
+        removed = self.head
+        self.head = self.head.next_node
+        if self.head is None:
+            self.tail = None
+        return removed

FlaskAPI/generate_dummy_data.py

@@ -0,0 +1,59 @@
+
+from datetime import datetime
+from random import randrange
+from sqlite3 import Connection as SQLite3Connection
+
+from faker import Faker
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+
+import server
+
+# app
+app = Flask(__name__)
+
+# config
+app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///sqlitedb.file"
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = 0
+
+# configure sqlite3 to enforce foreign key contraints
+
+
+@event.listens_for(Engine, "connect")
+def _set_sqlite_pragma(dbapi_connection, connection_record):
+    if isinstance(dbapi_connection, SQLite3Connection):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON;")
+        cursor.close()
+
+
+db = SQLAlchemy(app)
+now = datetime.now()
+
+faker = Faker()
+
+# create dummy users
+for i in range(200):
+    name = faker.name()
+    address = faker.address()
+    phone = faker.msisdn()
+    email = f'{name.replace(" ", "_")}@email.com'
+    new_user = server.User(name=name, address=address,
+                           phone=phone, email=email)
+    db.session.add(new_user)
+    db.session.commit()
+
+# create dummy blog posts
+for i in range(200):
+    title = faker.sentence(5)
+    body = faker.paragraph(190)
+    date = faker.date_time()
+    user_id = randrange(1, 200)
+
+    new_blog_post = server.BlogPost(
+        title=title, body=body, date=date, user_id=user_id
+    )
+    db.session.add(new_blog_post)
+    db.session.commit()

FlaskAPI/hash_table.py

@@ -0,0 +1,152 @@
+class Node:
+    """Node to store data"""
+
+    def __init__(self, data=None, next_node=None) -> None:
+        """create a Node datatype
+
+        Args:
+            data ([type], optional): data to store. Defaults to None.
+            next_node ([type], optional): pointer to next Node. Defaults to None.
+
+        Example:
+            >>> node = Node("data", None)
+            >>> node.data
+            'data'
+            >>> print(node.next_node)
+            None
+        """
+        self.data = data
+        self.next_node = next_node
+
+
+class Data:
+    """Store data as key, value pair"""
+
+    def __init__(self, key, value) -> None:
+        """Store data as key, value pair
+
+        Args:
+            key ([type]): key
+            value ([type]): value
+
+        Example:
+            >>> d = Data("key", "val")
+            >>> d.key
+            'key'
+            >>> d.value
+            'val'
+        """
+        self.key = key
+        self.value = value
+
+
+class HashTable:
+    """Hash Table to store data as key,value pairs"""
+
+    def __init__(self, table_size) -> None:
+        """Hashtable
+
+        Args:
+            table_size (int): size of the table
+
+        Example:
+            >>> ht = HashTable(10)
+            >>> ht.hash_table
+            [None, None, None, None, None, None, None, None, None, None]
+        """
+        self.table_size = table_size
+        self.hash_table = [None] * table_size
+
+    def custom_hash(self, key):
+        """calculate hash for the given key (hash_function)
+
+        Args:
+            key ([type]): given key
+
+        Returns:
+            [type]: hashed key
+
+        Example:
+            >>> ht = HashTable(5)
+            >>> ht.custom_hash('key')
+            1
+        """
+        hash_value = 0
+        for i in key:
+            hash_value += ord(i)
+            hash_value = (hash_value * ord(i)) % self.table_size
+        return hash_value
+
+    def add_key_value(self, key, value):
+        """Adds key,value pair into `HashTable`
+
+        Args:
+            key ([type]): key to store
+            value ([type]): value to store
+        """
+        hashed_key = self.custom_hash(key)
+        if self.hash_table[hashed_key] is None:
+            self.hash_table[hashed_key] = Node(Data(key, value), None)
+        else:
+            node = self.hash_table[hashed_key]
+            while node.next_node:
+                node = node.next_node
+            node.next_node = Node(Data(key, value), None)
+
+    def get_value(self, key):
+        """Get value corresponde to the given `key`
+
+        Args:
+            key ([type]): given key
+
+        Returns:
+            Any: value for the given key
+        """
+        hashed_key = self.custom_hash(key)
+        if self.hash_table[hashed_key] is not None:
+            node = self.hash_table[hashed_key]
+            if node.next_node is None:
+                return node.data.value
+            while node.next_node:
+                if key == node.data.key:
+                    return node.data.value
+                node = node.next_node
+
+            if key == node.data.key:
+                return node.data.value
+
+        return None
+
+    def print_table(self):
+        """Prints the whole `HashTable`"""
+        print("{")
+        for i, val in enumerate(self.hash_table):
+            if val is not None:
+                llist_string = ""
+                node = val
+                if node.next_node:
+                    while node.next_node:
+                        llist_string += (
+                            str(node.data.key) + " : " +
+                            str(node.data.value) + " --> "
+                        )
+                        node = node.next_node
+                    llist_string += (
+                        str(node.data.key) + " : " +
+                        str(node.data.value) + " --> "
+                    )
+                    print(f"    [{i}] {llist_string}")
+                else:
+                    print(f"    [{i}] {val.data.key} : {val.data.value}")
+            else:
+                print(f"    [{i}] {val}")
+        print("}")
+
+
+if __name__ == "__main__":
+    ht = HashTable(4)
+    ht.add_key_value("hi", "there")
+    ht.add_key_value("hii", "there")
+    ht.add_key_value("hi", "there")
+    ht.add_key_value("heyy", "there")
+    ht.print_table()