Sunday, May 16, 2021

Saturday, May 15, 2021

Django - Simple Registration Form


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <p>Register</p>

    <form method="POST" action="">
        {% csrf_token %}
        {{form.username.label}}
        {{form.username}}
        {{form.email.label}}
        {{form.email}}
        {{form.password1.label}}
        {{form.password1}}
        {{form.password2.label}}
        {{form.password2}}
        <input type="submit" name="new_user">


    </form>


</head>
<body>

</body>
</html>

Monday, March 22, 2021

CORRELATED SUBQUERIES

SubQuery :
Simple subquery doesn't use values from the outer query and is being calculated only once:

SELECT id, first_name FROM student_details
WHERE id IN (SELECT student_id FROM student_subjects

WHERE subject= 'Science');

CoRelated Subquery -
Query To Find all employees whose salary is above average for their department

SELECT employee_number, name FROM employees emp
WHERE salary > ( SELECT AVG(salary) FROM employees

WHERE department = emp.department);

Sunday, March 14, 2021

Saturday, March 13, 2021

FastApi : Create Production ready Api

FastApi : Create Production ready Api (faster than Flask)

https://fastapi.tiangolo.com/

Features

1. Asynchronous

2. High Perfromance

3. Less Code

4. Data Type and Data Models auto Conversions

5. Auto Documentation

- swagger (/docs)

- ReDoc (/redoc)

Pre-Req:

Install and activate virtual environment to be safe.

Steps:

pip install fastapi
pip install hypercorn #server
touch main.py
copy paste below code
hypercorn main:app --reload

from fastapi import FastAPI 
from pydantic import BaseModel #model
# import requests

app = FastAPI()
db = []

class Person(BaseModel):
    name: str

@app.get('/')
def index():return {'person' : 'name'}

@app.get('/persons')
def get_persons():
    results = []
    for person in db:results.append(person)
    return results

@app.get('/persons/{person_id}')
def get_person(person_id: int):return db[person_id-1]

@app.post('/persons')
def create_person(person: Person):
    db.append(person)
    return db[-1]

@app.delete('/persons/{person_id}')
def delete_person(person_id: int):
    db.pop(person_id-1)
    return {}

Friday, February 5, 2021

Sunday, January 31, 2021

CIRCUITPYTHON :SEEEDUINO XIAO [SEED]

CIRCUITPYTHON :SEEEDUINO XIAO

Steps:

Uses SAMD21 Processor

1. connect SEEEDuino xiao to PC using TYPE-C cable
2. short RST pins using a cable fast , 2 times.
3. Once done successfully,Audrino drives appears
4. Go website -

https://circuitpython.org/board/seeeduino_xiao/

https://wiki.seeedstudio.com/Seeeduino-XIAO-CircuitPython/

5. Download latest .UF2 file
6. Copy and paste it inside the drive
7. Now the drive will be converted to CIRCUITPY
8. Create a file code.py
9. Copy paste below code into code.py (same for all circuit py IC)

import time
import board
from digitalio import DigitalInOut,Direction

led = DigitalInOut(board.D13) #D13 is a built in LED

#A1 - A10 can be used as well if u use a separate LED and a Resistor 100 - 400 ohms refer below for calculations
led.direction=tinker .OUTPUT

while True:
    led.value = True
    time.sleep(1)
    led.value=False
    time.sleep(1)

10. Save file
11. The LED should start blinking

A simple LED circuit consists of a LED and resistor. The resistor is used to limit the current that is being drawn and is called a current limiting resistor. Without the resistor the LED would run at too high of a voltage, resulting in too much current being drawn which in turn would instantly burn the LED, and likely also the GPIO port.

To calculate the resistor value we need to examine the specifications of the LED. Specifically we need to find the forward voltage (VF) and the forward current (IF).

A regular red LED has a

forward voltage (VF) of 1.7V

forward current of 20mA (IF).

output voltage of the IC which is 3.3V.

We can then calculate the resistor needed-

R Ω = V I = 3.3 - V F I F = 3.3 - 1.7 20 m A = 80 Ω

V I = 3.3 = 3.3 - 1.7

Sunday, November 29, 2020

Django

Django:

What is Django ?

Web Framework

Creates pre-existing code
Can be used to create mulitple apps like - blogs , authentication etc .,
Uses MVT architecture

MVT architecture (Model View Template)

No Controller unlike MVC
Browser > Django > urls.py > View
View pulls data from model(DB) and Displays it on Template (HTML)

How to use:

No need to stop Django server when doing development
There will be only 1 settings file in the main project to handle auths , templates etc.,
When you want to create a new webpage do not modify the auto generated Framework.
Always create your own app with the command ($python manage.py startapp app_name)

Example Source Code

Pre-Req:

make sure python is installed.
$pip install virtual env
$virtualenv venv
$source venv/bin/activate
$pip install django
If ur using Pycharm than goto : Preference>Select virtual Env created

Create django specific project , Create APP

django-admin startproject Main #Start django project
$cd Main
python manage.py startapp PersonApp #Create App
python manage.py runserver
open http://127.0.0.1:8000/
comment - settings.py > MIDDLEWARE >

settings.py > Installed APP ['PersonApp']
settings.py > TEMPLATES > 'DIRS': [os.path.join(BASE_DIR, 'PersonApp','html')] #import os
Under urls.py

from django.urls import path,include
path('', include('PersonApp.urls'))

Steps:

1)PersonApp >html>person.html

<form method="POST">
<p>{{ data }}</p>
<textarea name="fname">{{fname}}</textarea>
<textarea name="sname">{{sname}}</textarea>
<input type="submit">
</form>

2) #Under PersonApp/views.py

from django.shortcuts import render
def person(request):
if request.method == "GET":
return render(request, 'person.html', {"data":"enter ur name"})
elif request.method == "POST":
fname = request.POST.get('fname', None)
sname= request.POST.get('sname', None)
print("accepted :"+fname)
return render(request, 'person.html', {"data":"Accepted !"})

3)#Under PersonApp/urls.py

from django.urls import path
from . import views
urlpatterns= [path('',views.person,name='person')]

4) Create Model - #PersonApp/models.py

class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)

#Under admin.py

from .models import Person
admin.site.register(Person)

5) Create a DB from Model

python manage.py makemigrations
python manage.py migrate

python manage.py createsuperuser
0.0.0.0/admin

6) Adding and Retrieving Data fro Db

from .models import Person
def person():
person=Person()
person.first_name=fname
person.last_name=sname
person.save()
print("records ="+str(len(Person.objects.all())))

Ref for HTML looping and API:

https://github.com/j-thepac/django_sampler/blob/main/README.md

URL Dispatching

Copy a urls.py from base Framework into the new App folder
Notice line "path('admin/', admin.site.urls)" in Framework urls.py eg: path is /admin than redirect to admin page
Add below line in url.py in Base Framework

path('test', include('app_name.urls')) #make sure "include" is imported

This redirects "/test" to urls.py in the App folder.
Add below lines in urls.py in app_name :

from app_name import views
urlpatterns = [path('test', views.test,name="test")]

In views.py of app_name add below lines:

from django.shortcuts import render,HttpResponse
def test(request):
return HttpResponse("Testpage")

Notice here controls goes from url.py(base) >> url.py >> views.py

StaticFolders:

The files inside static folders are made public
Can Contain CSS / JS to be used in the webpage
Create folder "static" inside project
create file "test.txt" with some contents inside and save
Add this to settings.py : STATICFILES_DIRS = [BASE_DIR / "static",'/var/www/static/',]
open link -http://127.0.0.1:8000/static/test.txt

Create Templates with paramaters

Create folder "templates" inside project
Create a home.html inside templates with following :

<html><body>My First Heading {{key1}}</body></html>

Goto settings.py > Under TEMPLATES > Add 'DIRS': [BASE_DIR / "templates",],
Goto to the app views.py > Add line to the related resource method -

return render(request,"home.html",{"key1":"value"})

BootStraping
Used for ready made websites : https://getbootstrap.com/docs/4.5/getting-started/introduction/
Copy Starter Template html
You can use replace the html in home.html and save
reload page

Template Inheritance

Inherit the base template across the whole of the application
Create base.html in templates folder
Add templates html here , add placeholder for replacement wherever needed

Eg:{% block body %}{% endblock body %} , {% block title %}{% endblock title %}

delete contents of home.html and add :
In first line {% extends 'base.html' %}
Add replacements for placeholder - {% block body %} HI {% endblock body %}
Save

Using Images in Website:

Save any images into static folder
Rename the extension as ".jfif"
In the html file use as "/static/file.jfif"

Admin Logging Creation(We need to create Tables)

$python manage.py createsuperuser
Open http://127.0.0.1:8000/admin

To Create DB Table:

Model is a Table

Inside models.py

Eg:class Person(models.Model):

first_name = models.CharField(max_length=30)

last_name = models.CharField(max_length=30)

from home.models import Person

admin.site.register(Person)

'home.apps.Person'

whenever u touch models.py , u need to run below commands

$python manage.py makemigrations #notice any changes and store in a DB.

$python manage.py migrate #Apply changes

API

1. Create a model

2. migrate it to create a DB

3. Create a serializer : Converts models to Json

4. Create a view and use the serializer

5. Create url.py and use the view

#https://www.youtube.com/watch?v=263xt_4mBNc

#https://www.youtube.com/watch?v=QB9gGEwxxM4

Pre-Req

pip install djangorestframework
pip freeze > requirements.txt
python manage.py startapp api

settings.py > INSTALLED_APPS = 'rest_framework'
url.py > urlpatterns=[path('api/', include('api.urls')),]

create api/serializers.py : Converts models to Json

from rest_framework import serializers
from .models import Person

class personSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Person
fields = ("url","first_name","last_name")

api/views.py

from rest_framework import viewsets
from .models import Person
from .serializers import personSerializer

#make sure Person model is created in models.py and migrated
class personView(viewsets.ModelViewSet):
queryset = Person.objects.all()
serializer_class = personSerializer

create api/url.py : Handles all API endpoint

from django.urls import path , include
from . import views
from rest_framework import routers

router = routers.DefaultRouter()
router.register('person',views.personview)
urlpatterns = [path('', include(router.urls))]

Ref:

https://www.youtube.com/watch?v=JxzZxdht-XY&t=5368s

Python Virtual Environment (venv)

Pre-Req :

This is on Mac
Make sure Python3 is installed in the system
$pip3 install virtualenv #--upgrade
$virtualenv #help

Steps:

create folder
cd inside folderName
$virtualenv env_name #-p /folder_path_of_python_to_clone/bin/python
$source ./env_name/bin/activate

#if u get permission denied "$chmod -R 777 *"
#Note u can also have multiple environments and activate which ever u want

Notice "env_name" in the Terminal line meaning it is activated.
Try:

$python
import requests # you will get error
exit()

Try2 (make sure virtual env is still activated)

$pip install requests
$python
import requests
exit()

$pip freeze > requirements.txt
To install requirements from above file #pip install -r requirements.txt
$deactivate #Deactivate the env

Note:

To use Virtual Environment in Pycharm
Preferences> Settings > Add > Virtualenv
Make sure it is pointing to venv

Tuesday, November 24, 2020

NGINX with DOCKER

Sunday, November 22, 2020

Nginx and Gunicorn

NGINX

Serving Static Content
Reverse Proxy (forward requests from clients to backend servers)
load balancing / distributing traffic across multiple servers.
API Gateway (single entry point for all API requests)
Caching ( caching frequently requested content)

Unicorn (Web Server Gateway Interface - WSGI)

Unicorn is designed to handle multiple concurrent requests

Ingress is a Kubernetes-specific solution (similar to Nginx)

Sequence of Operation :

Nginx sits in front of Gunicorn/ unicorn.
Gunicorn (uWSGI can be used as well) serves your flask app
For example, if the incoming request is an http request Nginx redirects it to gunicorn, if it is for a static file, it serves it itself.

Example

Pre-Req:

Docker is installed
Create Test Folder with below files:

Dockerfile
requirments.txt
flask.py

---Dockerfile------
FROM python:3
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["gunicorn", "--workers=1", "--bind=0.0.0.0:5000", "flask:app"]

------requirments.txt------
flask==1.1.1
gunicorn

------flask.py------
from flask import Flask, request
app = Flask(__name__)
@app.route('/')
def hello_world() -> str: return "Hello world"
if __name__ == '__main__':app.run(debug=True, host='0.0.0.0')
------------------------------------

Steps:

$ cd to Test Folder
$ docker run -it --rm -p 5000:5000 -v ${PWD}:/app python:3 bash # cd /app
cd /apps
pip install -r requirements.txt
export FLASK_APP=flask.py
gunicorn --bind=0.0.0.0:5000 --workers=1 flask:app

Ref
https://stackoverflow.com/questions/43044659/what-is-the-purpose-of-using-nginx-with-gunicorn
https://rahmonov.me/posts/run-a-django-app-with-gunicorn-in-ubuntu-16-04/

Saturday, November 21, 2020

Login API with Jmeter and Python Request:

Scenario:

To record a login API transaction using Jmeter
Run the same using Jmeter and check the response
Reproduce the same using Jmeter

Pre-Req:

FireFox Browser
Jmeter
Python 3.7+
pip install requests

Settings:

Configure Port numbers

Inorder for Jmeter to capture recording , we need to place Jmeter in-between Browser and external connections
such that all data passes through Jmeter before reaching the Browser and vis versa.
This is done by changing the port number of Browser to use port number of Jmeter. So that Jmeter can listen to the interactions

Browser -----------> JMETER -------------> External Connections

open Jmeter
File > templates > Select Recording >Create
In the folder structure > copy the port name
Open firefox > Preferences>
Scroll to bottom > Network Settings >Click on Settings
Select Manul proxy config
Http proxy = localhost and port = Paste the port number
click on OK

Installing Certificates :

Since configuration such as above is quiet dangerous if it is done by any malicious / unauthorised application . We need to install certificates from Jmeter into the Browser .

In Jmeter , click on Https test Script Recorder
Click on Start button
You will get a message box saying a root CA certificate is created under "Jmeter bin Directory"
Open FireFox preferences > Privacy and Security
View Certificates
Click on import
Select the certificate file created under "Jmeter/bin"
Click on Ok
Close Preferences
stop the recording in Jmeter

Steps to record Capture in Jmeter:

Start recording in Jmeter
Open FireFox
open link https://login.shrm.org/
Enter email -abc@gmail.com , password = 123
click on Sign in
Stop recording in Jmeter
Under Jmeter open Thread Group> Recording Controller and Notice the recording
under Jmeter open Https Test Script Recorder > View Results Tree and Check the response as well
Toggle between Http , Raw Tabs and Sample Result , Request and Response Tabs to understand the Request method and how data is send and received
Close the browser
Now you can run the same for different username and password by changing values in Recording Controller > Http Header manager

Steps to Reproduce in Python

Open Terminal
$python3

import requests
url="https://www.login.shrm.org/"
headers={'Content-Type': 'application/json'}
data={'LoginCredentials.Username': 'deep@xx.com', 'LoginCredential.Password': '123'}
r= requests.post(url,headers=headers,data=data)
print(r.status_code)
print(r.content)

Friday, November 20, 2020

Spark Streaming

Spark Streaming (Scala)

Steps :

1. Open Terminal
2. nc -l 54321 #any port number given in the program
3. Run below code
4. Type anything in terminal
5. Notice the Code Output

build.sbt

name := "MachineLearning"
version := "0.1"
scalaVersion := "2.11.0"
val sparkVersion = "2.4.7"
libraryDependencies ++= Seq(
"org.apache.spark" %% "spark-core" % sparkVersion,
"org.apache.spark" %% "spark-mllib" % sparkVersion,
"org.apache.spark" %% "spark-sql" % sparkVersion,
"org.apache.spark" %% "spark-streaming-flume" % "2.4.7"
)
libraryDependencies += "mysql" % "mysql-connector-java" % "5.1.24"

StreamingNetworkWordCount.scala

package SparkStreaming
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

object StreamingNetworkWordCount {
def main(args:Array[String]) {
val sparkConf = new SparkConf().setAppName("NetworkWordCount").setMaster("local[2]")
val ssc = new StreamingContext(sparkConf, Seconds(10))
val lines = ssc.socketTextStream("localhost",54321)
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)
wordCounts.print()
ssc.start() // Start the computation
ssc.awaitTermination() // Wait for the computation to terminate
}
}

Sunday, November 15, 2020

Docker

Monday, November 9, 2020

AirFlow

AIRFLOW

Pre-Req:

1. Make Sure python3 is installed

2. pip show any_package_name #to get path of installed packages

3. UpGrade Packages

Method 1

pip3 install pip-review

pip-review --local --interactive

Method 2

pip freeze > requirements.txt

pip3 install -r requirements.txt --upgrade

4. default configuration path " ~/airflow/airflow.config"

min_file_process_interval = 60 # after how much seconds a new DAGs should be picked up from the filesystem

max_threads = 1 # This defines how many threads will run.

5. Default Dags path: #/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/airflow/example_dags

Install

pip3 install apache-airflow
$airflow version
$airflow initdb
Open New Terminal Window
$airflow webserver
Open new Terminal Window
$airflow scheduler
In browser - localhost:8080
By default all Dags are stored in example_dags (/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/airflow/example_dags)
Automtically this file should appear in Web UI
run the Task

ViewResult : Click on last Run > click on any Tasks (Graph View) >click on Download Log

Notes:

DAG consists of Operators with unique Task id which is executed in sequence

DAG name has to be unique and this would appear in webconsole

Each DAG file has 1 DAG object , which is passed as argument to all Operators

DAG object has Name , arguments and schedule

Schedule arguement in DAG object should be of past date to trigger immediately

Operator : Used to execute different command / function for Bash , Python etc .,

Once operators are created , symbol ">>" is used to give the sequence of Execution

SubDAG : This is useful when you have repeating processes within a DAG or among other DAGs.

Xcom(“cross-communication”)

a ) lets you pass messages between tasks.It consists of

b) pusher - The pusher sends a message

c) puller -the puller receives the message.

Ref: https://airflow.apache.org/docs/stable/concepts.html

https://big-data-demystified.ninja/2020/04/15/airflow-xcoms-example-airflow-demystified/

##################

Create new SampleScript.py

summary : Create a 1 DAG object and pass it as argument to operators

args -> DAG object -> Operator

For a DAG to be executed, the start_date must be a time in the past,

##################

import logging

from airflow.operators.bash_operator import BashOperator

from airflow.operators.dummy_operator import DummyOperator

from airflow.utils.dates import days_ago

from airflow.models import DAG

from airflow.operators.python_operator import PythonOperator

from airflow.operators.subdag_operator import SubDagOperator

logger = logging.getLogger("airflow.task")

dagname='deepak_example_all_operator'

args = {'owner': 'Airflow', 'start_date': days_ago(2)}

dag = DAG(dag_id=dagname,default_args=args, schedule_interval='@once',tags=['python'])

subdag_id="subdagid"

logging.info('This is an info message - {}'.format(dagname))

def print_kwargs(**op_kwargs):

print (op_kwargs.keys())

return 'Whatever you return gets printed in the logs'

def print_args(*op_args):

print(op_args)

return 'Whatever you return gets printed in the logs'

def my_subdag(parent_dag_name, child_dag_name, args):

dag_subdag = DAG( dag_id="{}.{}".format(parent_dag_name,child_dag_name), default_args=args,schedule_interval="@daily",)

# DummyOperator(task_id=child_dag_name,default_args=args,dag=dag_subdag, )

BashOperator(task_id=child_dag_name, bash_command='echo "hi deepak"', dag=dag_subdag)

return dag_subdag

subdag=my_subdag(dagname, subdag_id, args)

dummy = DummyOperator(task_id='Dummy', dag=dag)

bash_pass = BashOperator(task_id='bash_pass', bash_command='echo 1', dag=dag)

bash_fail = BashOperator(task_id='bash_fail', bash_command='wrong command', dag=dag)

python_dictionary = PythonOperator(task_id='python_dictionary', python_callable=print_kwargs, op_kwargs={"1": "A"}, dag=dag)

python_list = PythonOperator(task_id='python_list', python_callable=print_args, op_args=['one', 'two', 'three'], dag=dag, )

# provide_context=True, #if True , use jinja Template

subdag_operator = SubDagOperator(task_id=subdag_id,subdag=subdag,dag=dag,)

dummy >> python_list >> python_dictionary >> bash_pass >> bash_fail >>subdag_operator

if __name__ == "__main__":

dag.cli()

##################

#Error 1:ImportError: cannot import name 'resolve_types'

pip3 install attr
pip3 install cattrs

#Error 2:unknown locale: UTF-8

Append this to your ~/.bash_profile:
export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8
source ~/.bash_profile

#Error 3: airflow-webserver.pid' is stale error

sudo lsof -i tcp:8080
kill -9 PID#all PIDs
rm -rf airflow-webserver.pid
https://stackoverflow.com/a/59086513

Tuesday, July 21, 2020

Scala : Generic Types in Scala

Generic Types in Scala

a) def func1[T](a : T) : T = a

Explanation :

def listOfDuplicates[A](x: A, length: Int): List[A] = {

if (length < 1)

Nil

else

x :: listOfDuplicates(x, length - 1)

}

println(listOfDuplicates[Int](3, 4)) // List(3, 3, 3, 3)----1

println(listOfDuplicates("La", 8)) // List(La, La, La, La, La, La, La, La)---2

we explicitly provide the type parameter by writing [Int]. Therefore the first argument must be an Int and the return type will be List[Int].

You don’t always need to explicitly provide the type parameter. The compiler can often infer it based on context or on the types of the value arguments. In this example, "La" is a String so the compiler knows A must be String.

class Stack[A] {

private var elements: List[A] = Nil

def push(x: A) { elements = x :: elements }

def peek: A = elements.head

}

Explanation:

This implementation of a Stack class takes any type A as a parameter.

This means the underlying list, var elements: List[A] = Nil, can only store elements of type A.

The procedure def push only accepts objects of type A (note: elements = x :: elements prepending x to the current elements).

Nil here is an empty List and is not to be confused with null.

example 1:

val stack = new Stack[Int]

stack.push(1)

stack.push(2)

println(stack.peek) // prints 2

example 2:

class Fruit

class Apple extends Fruit

class Banana extends Fruit

val stack = new Stack[Fruit]

val apple = new Apple

val banana = new Banana

stack.push(apple)

stack.push(banana)

Sunday, July 12, 2020

Test Drive Development (TDD)

Test Drive Development (TDD)

What is TDD :

Write Failing test First and later test should pass as the development progress

Properties of TDD

Red-Green Refractor ie., Write Failing test First and later test should pass as the development progress
Canary Test = Blank test to validate if the environment is working
Description / Console output / Naming should read like a book
Pending tests ie., Only declared but not implemented
Error message from the Unit test should drive the development
Source Code should be separate from the Unit Test (As it does not need to go to production. It can be in the same repo not the same file)
The method under test initially should return below as the development progress :

"NULL"
Change "NULL" > Constant
Constant > "Complex Expression depending on the requirement"

Eg :

assert (mtsToKm(mtrs) == NULL)

def dev (mtrs) : return NULL

assert (mtsToKm(1000) == 1)

def dev (mtrs) : return 1

assert (mtsToKm(1000) == 1)

def dev (mtrs) : mtrs/1000

Rules of Simple Design:

Pass the tests
Reveal Intention
No Duplication
Fewest number of elements

Pass the tests :

Always Unit test should come first than we start the actual code.
List all the test initially with only declaration ie.,(only describe and it()) these will be considered as pending tests or todo list.
1st test in canary test (No test , pass by default)

Reveal Intention.

Meaningful variable and methods names which reveal intention in tests /Actual Code.
Comments are unnecessary if you have meaningful names.

No Duplication

Code should not be duplicated
should be < 1
use functions /methods for repetitions.

Transformation premises

Pre-Req :

Make Sure all the tests are declared initially
And only Canary Test has test definition.

Cyele 1 :

Write a Unit test which sends null / blank as input to the function under test.
Modify the Actual code to handle null / blank
Run the test it should pass.

Cyele 2:

Write a test / Add definition to empty test declaration which sends a simple constant as input to Actual Code
Modify the Actual code to handle that constant either by returning it directly / other means and make sure both the test passes
Run the test it should pass both the tests.

Cyele 3:

Add definition to next empty test declaration to send little bit complex input.
Modify the Actual code to handle that constant either by using if statements
Run the test it should pass all 3 tests.

Cyele 4:

Add definition to next empty test declaration to send even more complex input to actual code
Modify the Actual code to handle that constant either by using better logic and so on.
.....

Sunday, May 16, 2021

Kubernetes : Basics

Saturday, May 15, 2021

Django - Simple Registration Form

Monday, March 22, 2021

Sunday, March 14, 2021

Postgres : Database (docker)

Saturday, March 13, 2021

FastApi : Create Production ready Api (faster than Flask)

https://fastapi.tiangolo.com/

Features

Pre-Req:

Steps:

Friday, February 5, 2021

Sunday, January 31, 2021

CIRCUITPYTHON :SEEEDUINO XIAO

Steps:

Sunday, November 29, 2020

Django:

What is Django ?

MVT architecture (Model View Template)

How to use:

Example Source Code

URL Dispatching

StaticFolders:

Create Templates with paramaters

Template Inheritance

Using Images in Website:

Admin Logging Creation(We need to create Tables)

To Create DB Table:

API

Pre-Req

create api/serializers.py : Converts models to Json

api/views.py

create api/url.py : Handles all API endpoint

Ref:

Python Virtual Environment (venv)

Pre-Req :

Steps:

Note:

Tuesday, November 24, 2020

Sunday, November 22, 2020

Nginx and Gunicorn

Example

Pre-Req:

Saturday, November 21, 2020

Login API with Jmeter and Python Request:

Scenario:

Pre-Req:

Settings:

Configure Port numbers

Installing Certificates :

Steps to record Capture in Jmeter:

Steps to Reproduce in Python

Friday, November 20, 2020

Spark Streaming (Scala)

Sunday, November 15, 2020

Docker

Monday, November 9, 2020

AIRFLOW

Pre-Req:

Method 1

Method 2

Notes:

Tuesday, July 21, 2020

Generic Types in Scala

Explanation:

Sunday, July 12, 2020