EASS 2022

Admin
Technical debt
Business logic
Bash and commandline (based on MIT's missing semester)
Git, GitHub
Interactive class

{ width=150px }

Admin stuff

Discord
Github account
HW on Github
Creating a Canvas account (https://canvas.instructure.com/)
Accepted invitation from AWS Academy and GitHub (I have sent links)
AWS on Cavnvas
LinkedIn
Commandline (WSL)
Docker
Moodle (minimal interaction over there)
Volunteer to summarize the lectures
Stackoverflow
Engagment on Discord
Hackernews

References:

Missing Semester MIT

AWS cloud certificate

What is Technical Debt?

"In software development, there is always a constant need to balance speed and quality. Some quality will always have to be sacrificed to release features within a reasonable timeframe, so any of these shortcuts will often be tasked as future projects. Those unattended tasks become what is called technical debt."
"There are several reasons why technical debt happens. Product owners may focus more on the need to implement and release new features and less on fixing past problems or create a generic enough infrastructure to support future developments. In some severe cases, product owners completely underestimate the outcomes of dealing with poor infrastructure, bugs and poorly designed software."
"Ultimately, technical debt can sometimes lead to software users having bad experiences and thereby increasing user churn rates. Together, a lack of developer awareness and task ownership can lead to more technical debt."

References:

https://logz.io/blog/technical-debt/

Business logic

"Business rules are what your non-software developers tell you what your software needs to do."
"Business logic is the part of your code that specifically implements business rules."

{ height=200px }

References:

https://softwareengineering.stackexchange.com/questions/234251/what-really-is-the-business-logic

http://www.ritholtz.com

Intro to commandline and tools (interactive)

Vim
Bash
Git
Docker

Bash

Important tools and commands

echo, while, find, vars, printenv, htop, shebang, wild cards
cp, touch, mkdir, ls, uniq, awk, rm
man man
brew
wget
curl

References:

https://missing.csail.mit.edu/2020/shell-tools/

Sneak peek to docker

docker run
docker ps
docker run -ti

Stackoverflow good questions usually have

Must have:

Problem statement
Sample code and data
Spelling, grammar and formatting

Example:

https://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-processing-an-unsorted-array

References:

https://codeblog.jonskeet.uk/2010/08/29/writing-the-perfect-question/

https://stackoverflow.com/help/how-to-ask

First task

Checkout github classroom and the first task about git and github https://classroom.github.com/classrooms/99552739-eass-hit-2022-part-a

AWS course (due a week after Passover == April 30, 2022)

S3, EC2, RDS, and EBS modules
must get 100 on all 4 modules
grading will be 25% per module

A bit more about EC2 instances and types of hardwares (HW)

EC2 provides secure, resizable compute cloud services. It makes web-scale cloud computing easier and offers HW such as:

ARM vs. Intel vs. AMD (x86, x86_64)
GPUs (Nvidia, Intel)
TPUs (on Google Computing Platform)
Metal instacnes on AWS
FPGA-based nodes

Instance Types and prices (useful links)

https://aws.amazon.com/ec2/instance-types/

https://instances.vantage.sh/

Instance Types (summary)

General Purpose
Compute Optimised
Memory Optimised
Accelerated Computing (P instances are for general-purpose GPU applications)

Pricing

There are four ways to pay for EC2 instances: On-Demand, Reserved Instances, and Spot Instances & Per-Second Billing. You can also pay for Dedicated Hosts which provide you with EC2 instance capacity on physical servers dedicated for your use.

First task on Git and GitHub

Checkout github classroom and the first task about git and github

https://classroom.github.com/classrooms/99552739-eass-hit-2022-part-a

How to test our code/system

General approaches for testing

Static vs. Dynamic
Passive testing
White-box vs. Black-box testing

Types of testing coverage metric

API testing – testing all public and private APIs Code coverage – creating tests to satisfy some criteria of code coverage (e.g., the test designer can create tests to cause all statements in the program to be executed at least once)

Types of tesing systems (CI/CD)

Unit vs. Integration testing
System testing
Compatibility testing
Installation testing
Smoke and sanity testing
Regression testing

We will use pytest and fastapi testing system

https://fastapi.tiangolo.com/tutorial/testing/
https://docs.pytest.org/

All exercises

4 modules on AWS course (S3, EC2, EBS, RDS) - if you finish all the course you get +10 bonus points to final grade
Build full REST/HTTP fastapi backend + Dockerization (due 1/4)
UI (react/streamlit) (due 1/5)
Docker compose the server with UI and backend plus server and write a clear README with git submodules (due 29/5)
Presentation of the system in a demo in a 2-3 minutes video on youtube and clear README (due 29/5)

Ideas for porjects next semester (based on skills we will learn this semester)

AI/ML based predictive system
Smart contracts (web3)
Any other system with at least 3 microservices

List of the subjects in our course

Monolithic vs. Microservices
Docker
Client-Server
REST/HTTP API
FastAPI
Pytest
asyncio
Frontend (React javascript and Streamlit python)
Docker compose
Functional programming
How to compile a new library

What Are The Best Software Engineering Principles?

Measure twice and cut once

{ width=300px }

Based on this nice post

https://luminousmen.com/post/what-are-the-best-engineering-principles

What Are The Best Software Engineering Principles?

Don’t Repeat Yourself (DRY)

If any code occurs more than twice in the codebase, you should think of moving it in a separate function. In fact, you should consider creating a separate method even if you encounter repetition a second time.

{ width=300px }

What Are The Best Software Engineering Principles?

Keep It Simple -Stupid- (KISS)

Some think that this idea transformed from Occam’s Razor philosophical principle. You can interpret it as follows: one should not create extra entities to the system without a strong necessity. It is always a good idea to first consider the usefulness of adding another method/class/tool/process, etc.

What Are The Best Software Engineering Principles?

You Aren’t Gonna Need It (YAGNI)

Don't implement all the "necessary" (most likely unnecessary) functionality at once from the very beginning of the project. { width=300px }

What Are The Best Software Engineering Principles?

Avoid Premature Optimization

"Premature optimization is the root of all evil (or at least most of it) in programming" — Donald Knuth

Watch Knuth on a talk with Lex Friedman https://www.youtube.com/watch?v=EE1R8FYUJm0

Principle Of Least Astonishment

This principle means that your code should be intuitive and obvious, and not surprise another developer when reviewing the code.

Law of Demeter (Olympian goddess of the harvest and agriculture)

The basic idea here is to divide the areas of responsibility between classes and encapsulate the logic within a class, method, or structure.

Decoupling You should try to reduce the number of connections between different classes or entities
Cohesion The associated classes must be in one module/package/directory

SOLID - create code that is easy to maintain and extend over time

Single responsibility states that every module or class should have responsibility for a single part of the functionality and that responsibility should be entirely encapsulated by the class
Open-closed states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification
Liskov substitution states that any inherited class should complement (substitutable), not replace, the behavior of the base class
Interface segregation states that no client of the class should be forced to depend on methods it does not use
Dependency inversion says that programmers should work at the interface level and not at the implementation level

Monolithic vs. Microservices

Monolithic application is a single unified unit that contains all the logic in one entity
Microservice architecture breaks the application down into a collection of smaller independent units

{ width=300px }

Monolithic vs. Microservices

{ width=400px }

Monolithic vs. Microservices

{ width=400px }

Docker

Dockerhub/Registry
Dockerfile
docker build
docker run
docker ps
docker network ls
docker volumes
docker expose ports
docker images
docker exec
docker image prune -a

Further training material

https://training.play-with-docker.com/alacart/

https://towardsdatascience.com/twenty-one-techniques-and-five-concepts-for-better-docker-usage-9ee135dccdc9

Advanced "Setting up a reverse proxy server" (How Docker makes our life easier)

"A very common scenario for developers, is to run their server behind a reverse proxy that sits in front of web servers and forwards client/frontend (e.g., web browser) requests to the web servers ("backend"). There are many reasons why you would want to do this but one of the main reasons is to run your API server on a different network or IP then your front-end application is on. You can then secure this network and only allow traffic from the reverse proxy server. For the sake of simplicity and space, I’ve created a simple frontend application in React.js and a simple backend API written in Node.js. Run the following command to pull the code from GitHub."

Without docker this is not easy to do.

Soon we will see how Docker simplifies the process of building a server that run a reverse proxy

Go through (reverse proxy, react, nginx):

https://www.docker.com/blog/how-to-use-the-official-nginx-docker-image/

Using Docker nginx walkthrough an offical tutorial together

https://www.docker.com/blog/how-to-use-the-official-nginx-docker-image/

docker run -it --rm -d -p 8080:80 --name web nginx
curl http://localhost:8080
docker stop web
Add index.html to local site-content and map it to /usr/share/nginx/html (https://gist.github.com/chrisvfritz/bc010e6ed25b802da7eb)
docker run -it --rm -d -p 8080:80 --name web -v ~/site-content:/usr/share/nginx/html nginx
Doing stuff via Dockerfile (docker build -t webserver):

FROM nginx:latest
COPY ./index.html /usr/share/nginx/html/index.html

docker run -it --rm -d -p 8080:80 --name web webserver

Recap - linux commands everyone should know

host/network commands

ip
ifconfig
hostname
whoami
uname
ping

file-realted commands

mkdir rmdir cp mv, rm
cd ls -l
find
wc
xxd
du -h /
chown chmod

archives:

zip, tar gzip, unzip, gunzip
tar -czvf name-of-archive.tar.gz /path/to/dir-or-file

c - create, v verbose, f - allow to chose the name

Recap - linux commands everyone should know

more commands

cat touch echo
locate whereis which find
grep
df du
awk head tail
diff
jobs (to see background jobs command&)
kill (sending signals to processes)

SIGTERM (15) -- requests the job to stop

SIGKILL (9) -- forces programs to stop

wget curl
top, htop, brew (should be installed), apt-install

How microservices talk to each other

What is API?

API stands for Application Programming Interface. This interface allows users to build upon another application's functionality.

What is web API?

Web API is when other SW services uses other application's/service's functionbality over the web/network.

What is HTTP?

HTTP stands for Hypertext Transfer Protocol: an application layer protocol in the Internet protocol suite model for distributed, collaborative, hypermedia information systems. - http://facebook.com - https://facebook.com

How microservices talk to each other

GET method

GET /microservice/v1/function?param1=value1&param=value2

POST method

POST /microservice/v1/function HTTP/1.1
Host: localhost

param1=value1&param=value2

How do we perform HTTP requests (postman and cli)

Postman https://web.postman.co/home
curl or wget in the command line

How do we perform HTTP requests (python)

requests library in python:

>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>> r.status_code
200
>> r.headers['content-type']
'application/json; charset=utf8'
>> r.encoding
'utf-8'
>> r.text
'{"type":"User"...'
>> r.json()
{'private_gists': 419, 'total_private_repos': 77, ...}

httpx library in python https://www.python-httpx.org/quickstart/

Demo performing HTTP reqeusts `httpx` vs. `curl`

Perform GET https://httpbin.org/get
Perform POST https://httpbin.org/post with data={'key': 'value'}
Note that POST/GET could be "overloaded" (have the same endpoint)

How microservices talk to each other

What is a REST API?

"When a client request is made via a RESTful API, it transfers a representation of the state of the resource to the requester or endpoint. This information, or representation, is delivered in one of several formats via HTTP: JSON (Javascript Object Notation), HTML, XLT, Python, PHP, or plain text. JSON is the most generally popular file format to use because, despite its name, it’s language-agnostic, as well as readable by both humans and machines"

In class hands-on session (training for Ex1)

Please complete due next class (March 7th, 2022) and use Discord for help

Create a remote git repo on our organization GitHub https://github.com/EASS-HIT-2022/ (private/public)
Name the repo http-api-demo-<your github name>
Include a README, Dockerfile, client.py files
In client.py include at least two POST/GET requests from httpbin demo HTTP API (http://httpbin.org/):
POST to any endpoint of your choice (e.g., http://httpbin.org/post)
GET to any endpoint of your choice (e.g., http://httpbin.org/get)
Make a Dockerfile that execute client.py on startup and prints the status and output from the http requests it performs from step 3. Helpful snippet:

FROM ubuntu
RUN  apt-get update
RUN  apt-get -y install python
CMD ["echo", "Hello, EASS 2022"]

Now, create a second Dockerfile in your git repo localhost.Dockerfile which call to the local hosted httpbin and call it via http://localhost: docker run -p 80:80 kennethreitz/httpbin
build the second docker image. Useful command:

docker build -t tab ./ -f localhost.Dockerfile

Hello World, FastAPI

Install

pip install fastapi
pip install "uvicorn[standard]" Uvicorn is an ASGI (Asynchronous Server Gateway Interface) web server implementation for Python

code of the server (`main.py`)

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def get_root():
    return {"message": "Hello World", "method": "GET"}

@app.post("/")
async def post_root():
    return {"message": "Hello World", "method": "POST"}

Hello World, FastAPI

Running the server

uvicorn main:app --reload

Ex 1 (Due April 10, 2022)

Build only the backend (using FastAPI)
Include a Dockerfile, README and the source code of the app
Be OOP-friendly (recall the SOLID principle) and use pydantic
Include both integartion and unit tests inside using pytest, httpx, or pip install docker (you may use some bash scripting as well). The idea is to be robust, simple and test the whole system wisely and efficently.

Suggested layout of the repo:

.
|- app
|             |- main.py
|             |- unit_tests.py
|             |- requirements.txt
|
|- integration_test.py
|- Dockerfile
|- README.md

List of ideas ideas for projects

Building the backend of a voting app
Personal wallet (keep expenses, images)
Weather application
The backend of a US/IL stock viewer analyzer webapp
The backend of a twitter summarizer webapp (focus on one field e.g., stock symbols)

Handling Data/Models over the wire

We want to send data (JSONs) over the wire, but in the code we would like to work with objects.

DTO (Data Transfer Object)
ORM (Object Relational Mapping)
MVC (Model View Controller)

Model The model manages the data, logic and rules of the application.
View Any representation of information such as a chart, diagram or table.
Controller Accepts input and converts it to commands for the model or view.

{ width=200px }

ref (Mozilla is great for web resources) https://developer.mozilla.org/en-US/docs/Glossary/MVC/model-view-controller-light-blue.png

Pydantic

pydantic helps us to define what type of JSONs are valid and what are their interperation. With Pydantic's Model classes we can define the input/outputs of each API endpoint. It helps fastapi with validation, serialization, and documentation.

Between microservices (request vs. response)
Between Databases microservices
Or between any two entities or the user and the application

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name = 'Jane Doe'

Pydantic

from pydantic import BaseModel

class Client(BaseModel):
    id: int
    balance: float

class Transaction(BaseModel):
    from_client: Client
    to_client: Client
    amount: float

class Request(BaseModel):
    id: int
    transaction: Transaction

class Response(Request):
    approved: bool
    executed: bool

Accesing the data

@app.post("/v1/handle")
def handle(req: Request):
  if req.from_client.balance > req.transaction.amount:
    pass # do something

  res = Response()

  res.id = req.id
  return res

Using dataclasses, understanding what's pydantic is doing

from pydantic.dataclasses import dataclass
import json

@dataclass
class User:
  id: int
  name: str

user = User(id=123, name="James")
d = asdict(user)  # {'id': 123, 'name': 'James'
user_json = json.dumps(d)
print(user_json)  # '{"id": 123, "name": "James"}'

# Or directly with pydantic_encoder
json.dumps(user, default=pydantic_encoder)

json_raw = '{"id": 123, "name": "James"}'
user_dict = json.loads(json_raw)
user = User(**user_dict)

user = User.__pydantic_model__.parse_raw('{"id": 123, "name": "James"}')
print(user)

ref:

https://stackoverflow.com/questions/67621046/initializing-a-pydantic-dataclass-from-json

How to design a project

architecture
draw.io

{width=250px}

Step 1: Outline use cases, constraints, and assumptions

Gather requirements and scope the problem. Ask questions to clarify use cases and constraints. Discuss assumptions.

Who is going to use it?
How are they going to use it?
How many users are there?
What does the system do?
What are the inputs and outputs of the system?
How much data do we expect to handle?
How many requests per second do we expect?
What is the expected read to write ratio?

ref

https://github.com/donnemartin/system-design-primer

Step 2: Create a high level design

Outline a high level design with all important components.
Sketch the main components and connections
Justify your ideas

How to use draw.io: https://reneelin2019.medium.com/drawing-cloud-architectures-neural-network-diagrams-and-more-with-draw-io-4f7128ee1aea

Step 3: Design core components

Dive into details for each core component. For example, if you were asked to design a url shortening service, discuss:

Generating and storing a hash of the full url
- MD5 and Base62
- Hash collisions
- SQL or NoSQL
- Database schema
Translating a hashed url to the full url
- Database lookup
API and object-oriented design between the microservices

ref

https://github.com/donnemartin/system-design-primer

Step 4: Scale the design

Identify and address bottlenecks, given the constraints. For example, do you need the following to address scalability issues?

Load balancer
Horizontal scaling
Caching
Database sharding (breaking the rows or columns of a large table into multiple smaller tables)
Blue-green deployment to reduce downtime and risk
Discuss potential solutions and trade-offs. Everything is a trade-off. Address bottlenecks using principles of scalable system design.

Tips

Use back of the envelope calculations
Powers of two table

Power           Exact Value         Approx Value        Bytes
---------------------------------------------------------------
7                             128
8                             256
10                           1024   1 thousand           1 KB
16                         65,536                       64 KB
20                      1,048,576   1 million            1 MB
30                  1,073,741,824   1 billion            1 GB
32                  4,294,967,296                        4 GB
40              1,099,511,627,776   1 trillion           1 TB

Tips

Latency numbers every programmer should know

Latency Comparison Numbers
--------------------------
L1 cache reference                    0.5 ns
Branch mispredict                       5 ns
L2 cache reference                      7 ns   14x L1 cache
Mutex lock/unlock                      25 ns
Main memory reference                 100 ns   20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy           10 us
Send 1 KB bytes over 1 Gbps network    10 us
Read 4 KB randomly from SSD*          150 us  ~1GB/sec SSD
Read 1 MB sequentially from memory    250 us
Round trip within same datacenter     500 us
Read 1 MB sequentially from SSD*        1 ms  ~1GB/sec SSD, 4X memory
HDD seek                               10 ms   20x datacenter roundtrip
Read 1 MB sequentially from 1 Gbps     10 ms   40x memory, 10X SSD
Read 1 MB sequentially from HDD        30 ms   120x memory, 30X SSD
Send packet CA->Israel->CA            200 ms

ref

https://github.com/donnemartin/system-design-primer

How would you implement google search engine (discussion)

https://softwareengineering.stackexchange.com/questions/38324/how-would-you-implement-google-search

Testing and Profiling

Testing

SW testing is the process of evaluating and verifying that a software product or application does what it is supposed to do.
Integration testing
Unit testing

Profiling

Flat profiler - computes the average call times (callers & callees)
Call-graph profiler - shows the call times, frequencies of the functions and their call graph

References

https://docs.python.org/3/library/profile.html

https://stackoverflow.com/questions/582336/how-can-you-profile-a-python-script

https://medium.com/@alaminopu.me/profiling-your-python-3-code-8c3f695e62da

https://pypi.org/project/pytest-benchmark/

https://www.ibm.com/topics/software-testing

pytest

Unit tests are written and run by software developers to ensure that a section of an application ("unit") meets its design and behaves as intended.

installing

pip install pytest

hello world


# content of test_sample.py
def inc(x):
    return x + 1

def test_pos():
    assert inc(3) == 5

def test_neg():
    assert inc(-1) == 0

References

https://realpython.com/pytest-python-testing/ https://docs.pytest.org/en/7.1.x/

profiling code via testing

profiling ("program profiling", "software profiling") is a form of dynamic program analysis that measures, for example, the space (memory) or time complexity of a program, the usage of particular instructions, or the frequency and duration of function calls. Most commonly, profiling information serves to aid program optimization, and more specifically, performance engineering.

import cProfile

def fibonnaci(n):
    if n in [0, 1]:
        return n
    else:
        return fibonnaci(n-1) + fibonnaci(n-2)

if __name__ == '__main__':
  pr = cProfile.Profile()
  pr.enable()
  fibonnaci(100)
  pr.disable()
  pr.print_stats()

profiling code

$ pip install pytest-benchmark
$ pip install aspectlib

import time
import pytest
class Foo(object):
  def __init__(self, arg=0.01):
    self.arg = arg

  def run(self):
    self.internal(self.arg)

  def internal(self, duration):
    time.sleep(duration)

def test_foo(benchmark):
  benchmark.weave(Foo.internal, lazy=True)
  f = Foo()
  f.run()

$ py.test test_file.py

profiling code

import time
import pytest

@pytest.mark.benchmark(
  group="group-name",
  min_time=0.1,
  max_time=0.5,
  min_rounds=5,
  timer=time.time,
  disable_gc=True,
  warmup=False
)
def test_my_stuff(benchmark):
  @benchmark
  def result():
    # Code to be measured
    return time.sleep(0.001)

  # Extra code, to verify that the run
  # completed correctly.
  # Note: this code is not measured.
  assert result is None

$ py.test test_file.py

pytest fastapi (https://www.fastapitutorial.com/blog/unit-testing-in-fastapi/)

# content of main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_main():
  return {"msg": "Hello World"}

# content of test_main.py
from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

@app.get("/")
async def read_main():
  return {"msg": "Hello World"}

client = TestClient(app)

def test_read_main():
  response = client.get("/")
  assert response.status_code == 200
  assert response.json() == {"msg": "Hello World"}

Linting/Formatting your source code

$ pip install black

{ width=420px }

https://black.vercel.app/?version=stable

Midterm survey, touchbase, pep talk, and review

Survey
Touchbase/pep-talk
Review of fundamental technical material (recap CLI, docker, Dockerfile, HTTP, GET/POST, docker exec, docker ps, docker network, how to use vim, visual studio code, git and github, CMD, CP, WORKDIR, RUN, execute bash scripts/complex logic inside a dockerfile)
Review of SW development principles: early testing, github, README, arch diagram, name the services

Doing same thing in different ways (redis client-server)

# running redis DB container
$ docker run --rm --name redis-container -d redis
7ea29d853d72749870851cbc677664a3d252aafd2c16f79d7823a7f75167bcf9
# running the client CLI
$ docker run -it --name redis-cli --link redis-container:redis  \ 
  --rm redis redis-cli -h red
is -p 6379
redis:6379> HELLO
 1) "server"
 2) "redis"
 3) "version"
 4) "6.2.6"
 5) "proto"
 6) (integer) 2
 7) "id"
 8) (integer) 3
 9) "mode"
10) "standalone"
11) "role"
12) "master"
13) "modules"
14) (empty array)
redis:6379> ping
PONG
redis:6379> ping [hello]
"[hello]"
redis:6379> ping [hello-eass-2022]
"[hello-eass-2022]"
redis:6379>

second way

$ docker run --rm --name redis-container -p1234:6379 -d redis
6c318087da94fc1b863cd4093affc2a0a773f5dcb42764865e9d8b13e03790db
$ python
Python 3.9.5 (default, Jun  4 2021, 12:28:51)
[GCC 7.5.0] :: Anaconda, Inc. on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import redis
>>> r = redis.Redis(host='localhost', port=1234, db=0)
>>> r.set('foo', 'bar')
True
>>> r.get('foo')
b'bar'

third way

$ docker run --rm --name redis-container -p1234:6379 -d redis
$ docker network create --subnet 172.20.0.0/16 \
  --ip-range 172.20.240.0/20 redis-demo-network
$ docker network connect --ip=172.20.0.1 redis-demo-network redis-container
$ docker run -it --network redis-demo-network --rm python:3.9 bash

# INSIDE THE CONTIANER
root@e2a2e4951955:/# pip install redis

# start python cli inside client container
root@e2a2e4951955:/# python
>>> import redis
>>>  r = redis.Redis(host='172.20.0.1', port=6379, db=0)
>>> r.set('foo', 'bar')
True
>>> r.get('foo')
b'bar'

GitHub's copilot by openai demo

{ width=400px }

Where are we going from now

UI: streamlit, javascript, react
Docker compose
Databases: redis, mongodb, mysql
Basic security, authentication
Advanced SW concepts: functional programming

Python Async IO

How does something which feels concurrent uses a single thread and a single CPU?

{ width=200px }

Event loop

{ width=200px }

References

https://tenthousandmeters.com/blog/python-behind-the-scenes-12-how-asyncawait-works-in-python/

Multithreading, Processes, Asyncio

import threading
import concurrent.futures
import time
from tqdm.asyncio import trange, tqdm
import asyncio
import numpy as np


def run_threading(n_threads=5):
    threads = []
    print("Starting...")
    start = time.time()
    for i in range(n_threads):
        thread = threading.Thread(target=print, args=[f"I am thread {i}."])
        thread.start()
        threads.append(thread)

    for thread in threads:
        thread.join()
    end = time.time()
    print(f"Time to complete: {end - start}")

Multithreading, Processes, Asyncio

import threading
import concurrent.futures
import time
from tqdm.asyncio import trange, tqdm
import asyncio
import numpy as np


def do_concurrent(n=32):
    start = 10_000_000
    print_list = [i for i in range(start, start + n)]
    print("Starting...")
    start = time.time()
    with concurrent.futures.ProcessPoolExecutor(max_workers=2) as executor:
        futures = {executor.submit(print, i): i for i in print_list}
    for f in concurrent.futures.as_completed(futures):
        print(f"done {futures[f]} {f.result()}")
    end = time.time()
    print(f"Time to complete: {end - start}")

Multithreading, Processes, Asyncio

import threading
import concurrent.futures
import time
from tqdm.asyncio import trange, tqdm
import asyncio
import numpy as np


async def wait_and_print(t, n):
    await asyncio.sleep(t)
    print(f"coroutine {n} slept for {t} seconds")


async def do_tqdm_asyncio(n=10):
    arr = []
    async for i in trange(n):
        print(f"asyncio {i}")
        arr.append(wait_and_print(np.random.randint(1, 5), i))
    await asyncio.gather(*arr)

if __name__ == "__main__":
    run_threading(100)
    do_concurrent(100)
    asyncio.run(do_tqdm_asyncio(100))

The core behind asyncio are `select` and `poll` OS syscalls

import selectors
import socket

sel = selectors.DefaultSelector()

def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)

def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()

The core behind asyncio are `select` and `poll` OS syscalls

import selectors
import socket

sock = socket.socket()
sock.bind(('localhost', 1234))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)

while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)

References

https://docs.python.org/3/library/selectors.html#module-selectors

Classes in python

What is a Class? A class is simply a template for creating objects. Objects are an encapsulation of data (variables) and functionality (methods). A class defines the kind of object that will be created. For example, we can use thebuilt-in list type as a class to create lists of various types:

>>> lst = list()    # Create an empty list object
>>> lst = list([1,2,3])  # Create a list with initial values

In both cases above, we are creating objects of type "list". The first line creates an empty list while the second line creates a list with initial values 1, 2, 3. We can also create our own customized classes to create various objects as we will see in later sections.

Creating Classes

In Python, a class is created by the keyword:class followed by the name of the class. The following code creates a simpleclass named MyClass:

class MyClass:      # Define MyClass 
    pass            # Pass means do nothing for now 

                    # We'll add features later

Creating Instances/Objects from Classes

An instance is an object that contains all the variables and methods defined by itsclass. Tocreate an instance from a class, we simply use theclass name followed by parenthesis (). For example:

 my_instance = MyClass()       # Create an instance of MyClass 

                             # This calls MyClass __init__ method 

 print(my_instance)          # Print memory address of my_instance 

                             # __repr__ method is called automatically

Python OOP

Python is an object-oriented language. This means that everything in Python is an object, and objects can interact with each other. Classes are a way of grouping together similar objects. For example, you could have a class of animals, which contains individual animals like lions, tigers, and bears. Each animal would have its own set of attributes (like size, weight, and fur color) and methods (like how to hunt or what to eat). OOP lets you structure your code in a way that makes it easy to reuse and extend. So if you wanted to create a new type of animal, you could just create a new class that inherits from the original animal class. This would give the new animal all the same attributes and methods as the original, but you could also add new ones or override existing ones.

Python OOP

Here's a simple example of a class:

class Animal:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def eat(self):
        print("%s is eating." % self.name)

    def make_sound(self):
        print("%s is making a sound." % self.name)

class Dog(Animal):
    def __init__(self, name, weight, size)
      self._size = size
      super().__init__(name, weight)

    def make_sound(self):
        print("Barking")

Encoding binary data (meaning encoding anything)

Base64 is a binary-to-text encoding scheme that represents binary data in an ASCII string format by translating it into a base-64 representation. This conversion allows for easy transport of binary data through systems that only support safe text characters.

Python provides a base64 encoding module that can be used to encode and decode Base64 strings.

>>> import base64
>>> encoded_string = base64.b64encode(b'binary\x00string')
'YmluYXJ5AHN0cmluZw=='
>>> decoded_bytes = base64.b64decode(encoded_string)
b'binary\x00string'

General idea, example of image

To encode an image using base64, the image file must first be read into a bytestring.

with open('image.png', 'rb') as f:
    data = f.read()

Next, the base64.b64encode() function can be used to encode the bytestring:

encoded_data = base64.b64encode(data)

To decode the encoded string, the base64.b64decode() function can be used:

decoded_data = base64.b64decode(encoded_data)

Finally, the decoded data can be written back to an image file using the open() function:

with open('image_copy.png', 'wb') as f:  # note the 'wb' mode!
    f.write(decoded_data)

Using `FileResponse`

from fastapi.responses import FileResponse
u="https://upload.wikimedia.org/wikipedia/en/2/2c/Holon_Institute_of_Technology_logo.jpg"
@app.get("/v1/get-hit-image")
async def main():
    return FileResponse(u)

binary/images using `base64` (better option with `BytesIO`)

$ pip install imageio

import imageio as iio
import io, base64
u="https://upload.wikimedia.org/wikipedia/en/2/2c/Holon_Institute_of_Technology_logo.jpg"

image = iio.imread(u)
byte_stream = io.BytesIO()
iio.v3.imwrite(byte_stream, image, plugin="pillow", format="PNG")
encoded = base64.b64encode(byte_stream.getbuffer().tobytes())
byte_stream.getbuffer().tobytes() == base64.b64decode(encoded)

May try with local images as well

import base64
import io
from imageio import imread
import matplotlib.pyplot as plt

filename = "yourfile.jpg"
with open(filename, "rb") as fid:
    data = fid.read()

b64_bytes = base64.b64encode(data)
b64_string = b64_bytes.decode()

# reconstruct image as an numpy array
img = imread(io.BytesIO(base64.b64decode(b64_string)))

# show image
plt.figure()
plt.imshow(img, cmap="gray")
plt.show()

Advanced concepts in python

Advanced concepts in Python can include anything from functional programming to working with databases. In this tutorial, we'll focus on a few key advanced concepts that are particularly useful in Python programming. First, let's talk about decorators. Decorators are a way to "wrap" a function so that it behaves differently than it would without the decorator. For example, you might use a decorator to log every time a function is called, or to cache the results of a function so that future calls are faster. Next, we'll talk about generators. Generators are a type of iterator that allows you to write code that lazily generates values, instead of having to compute all the values at once. This can be useful for working with large data sets where you don't want to hold everything in memory at once.

Finally, we'll talk about context managers. Context managers allow you to specify what should happen when you enter and exit a particular block of code (for example, opening and closing a file). This can be handy for making sure your code Cleanup up after itself, or for ensuring that resources are always properly released.

Decorators

Decorators in Python

Python decorators are a powerful tool for modifying functions and classes. Decorators can be used to add or remove functionality from a function or class, making them ideal for customizing code without having to modify the underlying code itself.

In Python, decorators are typically defined as functions that take a single argument (the object to be decorated) and return the modified object. For example, here is a simple decorator that adds logging to a function:

def log_function(func):
   def wrapper(*args, **kwargs):
       print('Calling {0} with args {1} and kwargs {2}'
            .format(func.__name__, args, kwargs))
       return func(*args, **kwargs)
   return wrapper


@log_function  #this is how you would "decorate" a function with the log_function decorator
def some_function(arg1, arg2):  #some_function is now a wrapped function with logging capabilities
    print('Inside some_function')


some_function(1, 2)  #Will print: "Calling some_function with args (1, 2) and kwargs {}" followed by "Inside some_function"

Decorators can also be applied to classes in a similar way

class my_decorator(object):
  def __init__(self, func):
    self.func = func
  def __call__(self, *args):
    print("before function call")
    ret = self.func(*args)
    print("after function call")
    return ret


@my_decorator
def simple_function():
  print("inside simple_function")

# equivalent to simple_function = my_decorator(simple_function)

>>> simple_function()
before function call
inside simple_function
after function call

Generators

Generators are a special type of function that allow us to create iterators. They're similar to list comprehensions, but they don't actually construct a list; instead, they return an iterator object that can be used to access the values in the sequence one at a time.

def my_range(start, end):
    while start < end:
        yield start
        start += 1

for i in my_range(0, 5):
    print(i)

Sqlite inside python3 (not via microservice)

For our use cases it is better to work with extenral DB microservices with persistent storage (volumes on host via Docker)

import sqlite3
conn = sqlite3.connect('mydatabase.db')

# Create a table called "users" with three columns: id, name and email:
conn.execute('''CREATE TABLE users
       (id INTEGER PRIMARY KEY AUTOINCREMENT,
       name TEXT NOT NULL,
       email TEXT NOT NULL);''')

# Insert two rows of data:
conn.execute("""INSERT INTO users (name,email) 
  VALUES ('John', 'john@example.com');""")  
conn.execute("""INSERT INTO users (name,email) 
  VALUES ('Mary', 'mary@example.com');""")

# Save the changes and close the connection:
conn.commit()
conn.close()

Retrieving the data from the sqlite DB

>>> cursor = conn.cursor()
>>> cursor.execute("select * from users")
>>> results = cursor.fetchall()
>>> print(results)
[(1, 'John', 'john@example.com'), (2, 'Mary', 'mary@example.com')]

Python modules and packages

Python packages and modules are a great way to organize your code and share it with others. Packages are collections of modules, and modules are Python files with a .py extension. You can easily create and distribute your own Python packages and modules.

Creating a Package

To create a package, simply create a directory with the name of your package. Then, inside that directory, create a __init__.py file. This file can be empty, but it must exist in order for Python to recognize the directory as a package. Now that you have a package, you can start adding modules to it. To add a module to your package, simply create a new Python file with a .py extension and place it inside the package directory.

Distributing Your Package

If you want to share your package with others, you can upload it to the Python Package Index (PyPI). PyPI is the official repository for third-party Python software. Once your package is on PyPI, others can install it using pip, the official tool for installing Python packages:

pip install YOUR-PACKAGE-NAME

Writing a Python package is fairly simple. All you need is a directory structure that matches the package name, and __init__.py files in each subdirectory. The __init__.py files tell Python what modules are in each subpackage, and usually contain initialization code for those modules. Here's an example directory structure for a package named "mypackage":

mypackage/ 
 - __init__.py
 - module1.py
 - module2.py

Each __init__ .py file contains the following code:

from module1 import *
from module2 import *

Another example

# mypackage/
__init__.py
a.py
b.py
c.py

# mypackage/__init__.py
from .a import A  # noqa
from .b import B  # noqa
from .c import C  # noqa

# a.py
CONST=123

Another example

Create a new file called mymodule.py in your project directory with the following contents:

def greeting(name): 
  print("Hello, " + name + "!")

Then, create a new file called "main.py" in the same directory with the following contents:

import mymodule 
import mypackage
mymodule.greeting("World")

Context manager

Python Context managers are a way to control the environment in which a piece of code is executed. They are typically used to manage resources such as files or database connections.

A context manager is a class that defines two special methods, __enter__() and __exit__(). The code that is wrapped in a with statement is executed within the context of the __enter__() method. After the code has been executed, the __exit__() method is called to clean up any resources that were used.

Here is a simple example of a context manager:

class FileManager:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.file = open(self.filename)
        return self.file

    def __exit__(self, type, value, traceback):
        self.file.close()

With this context manager, we can use the with statement to automatically open and close files:

with FileManager('sample.txt') as f:
    for line in f:
        print(line)

Functional programming

Functional programming is a style of programming where we try to make our code more like a mathematical function. That is, we write our code in such a way that it can be easily composed with other code, without worrying about side effects (like mutating data). In Python, we can achieve this by writing our code using higher-order functions and lambdas. Higher-order functions are functions that take other functions as input or return a function as output. Lambdas are anonymous functions that can be passed as arguments to other functions. Say we have a list of numbers and we want to square each number in the list. In imperative style, we would write something like this:

numbers = [1, 2, 3, 4] 
squared_numbers = [] 
for n in numbers: 
    squared_numbers.append(n**2)
print(squared_numbers)

Functional programming

But notice how much boilerplate code there is just to perform a simple operation! We have to initialize an empty list, loop over the numbers list, and append each squared number to the new list.

In functional style, we can achieve the same thing with much less code:

numbers = [1, 2, 3, 4]
squared_numbers = map(lambda x: x**2 , numbers)
print(list(squared_numbers))

All we're doing here is passing a lambda function (which squares its input) to the map function. The map function applies the lambda function to every element in the input list and returns an iterator over the results. Finally ,we convert the iterator into a list so that we can print it out.

Pandas

Pandas is a powerful Python data analysis toolkit. It provides a high-performance DataFrame object that can be used to manipulate and analyze data. Pandas also offers a wide variety of statistical and machine learning algorithms that can be applied to data.

In this tutorial, we will cover the basics of pandas, including how to create a DataFrame, how to select data, and how to apply some basic statistical methods. We will also show how to use pandas to load and save data from various sources.

import numpy as np
import pandas as pd

s = pd.Series([1, 3, 5, np.nan, 6, 8])

dates = pd.date_range("20130101", periods=6)

df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))

Pandas

df = pd.DataFrame(
    {
        "A": 1.0,
        "B": pd.Timestamp("20130102"),
        "C": pd.Series(1, index=list(range(4)), dtype="float32"),
        "D": np.array([3] * 4, dtype="int32"),
        "E": pd.Categorical(["test", "train", "test", "train"]),
        "F": "foo",
    }
)

df2.dtypes
df2.<TAB>

Pandas

df.head()
df.tail(3)
df.index
df.columns
df.to_numpy()
df.describe()
df.T
df.sort_index(axis=1, ascending=False)
df.sort_values(by="B")
df["A"]
df[0:3]
df["20130102":"20130104"]
df.loc[:, ["A", "B"]]
df.iloc[3]
df.iloc[[1, 2, 4], [0, 2]]
df[df["A"] > 0]
df.mean(1)
df.apply(np.cumsum)

Pandas

left = pd.DataFrame({"key": ["foo", "foo"], "lval": [1, 2]})
right = pd.DataFrame({"key": ["foo", "foo"], "rval": [4, 5]})

pd.merge(left, right, on="key")


df = pd.DataFrame(
    {
        "A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
        "B": ["one", "one", "two", "three", "two", "two", "one", "three"],
        "C": np.random.randn(8),
        "D": np.random.randn(8),
    }
)

df.groupby("A").sum()

ref

https://pandas.pydata.org/docs/user_guide/10min.html

Ex 2 (Due May 30, 2022)

Dockerfile for Frontend
Include in README.md how to run the Backend and Frontend so they can communicate over HTTP (make sure they are connected on the same Docker network)
Short demo with a movie (Windows Key+G or QuickTime)

Suggested layout of the repo:

.
|- app/frontend
|             |- main.py
|             |- unit_tests.py
|             |- requirements.txt
|             |- Dockerfile
|- app/backend dir (Ex1)
|- integration_test.py
|- README.md

Ex 3 (Due June 19, 2022)

Docker compose
At least 3 microservices
Short demo with a movie (Windows Key+G or QuickTime)

Suggested layout of the repo:

.
|- app/backend dir (Ex1)
|- app/frontend dir (Ex2)
|- integration_test.py
|- docker-compose.yml
|- README.md

docker-compose (example)

$ mkdir composetest
$ cd composetest

docker-compose (example)

import time

import redis
from fastapi import FastAPI

app = FastAPI()
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.get('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

docker-compose (example)

FROM tiangolo/uvicorn-gunicorn:python3.8

RUN pip install redis
COPY main.py /app

ref

https://docs.docker.com/compose/gettingstarted/

docker-compose (example)

docker-compose.yml

version: "3.9"
services:
  web:
    build: .
    ports:
      - "8000:80"
  redis:
    image: "redis:alpine"

$ docker-compose build
$ docker-compose up

docker-compose complex scenario (1/2)


version: "3"

services:
  python-fastapi:
    image: tiangolo/uvicorn-gunicorn-fastapi:python3.8
    restart: on-failure
    environment:
      PYTHONPATH: /app
    working_dir: /app
    command: uvicorn main:app --host 0.0.0.0 --port 80
    ports:
      - 80:80
  redis:
    image: redis:6.0.5-alpine
    restart: always
    ports:
      - 6379:6379

docker-compose complex scenario (2/2)

  mysql:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_USER: user
      MYSQL_PASSWORD: password
      MYSQL_DATABASE: db
    ports:
      - 3306:3306
  rabbitmq:
    image: rabbitmq:3.8.2-management
    restart: always
    ports:
      - 5672:5672
      - 15672:15672
  streamlit:
    image: streamlit/streamlit:0.58.0
    command: streamlit run app.py --server.port 80
    ports:
      - 80:80

Streamlit

Streamlit is a powerful Python library that allows you to create beautiful interactive web applications with just a few lines of code. In this tutorial, we'll show you how to use Streamlit to build a simple web application that can be used to predict the price of a stock using machine learning.

We'll first need to install Streamlit and all of the dependencies required for this tutorial. You can do so by running the following command in your terminal:

$ pip install streamlit pandas numpy scikit-learn alpha-vantage plotly

hello world

import streamlit as st
st.title("Hello, Streamlit!")
st.write("Here's our first attempt at using Streamlit")
st.markdown("""
# Streamlit is **awesome**.

That's why we use it for all our projects.
""")

st.latex(r'''
     a + ar + a r^2 + a r^3 + \cdots + a r^{n-1} =
     \sum_{k=0}^{n-1} ar^k =
     a \left(\frac{1-r^{n}}{1-r}\right)
     ''')

refs

https://docs.streamlit.io/library/api-reference https://streamlit.io/gallery

Markdown cheat sheet (vscode can render)

Write your README.md on GitHub
Format text on your Frontend Streamlit app

https://stackedit.io/

https://www.markdownguide.org/cheat-sheet/

https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet

Write a data frame

import streamlit as st
import pandas as pd

st.write("Here's our first attempt at using data to create a table:")
st.write(pd.DataFrame({
    'first column': [1, 2, 3, 4],
    'second column': [10, 20, 30, 40]
}))