DEV Community: Abdur-Rahmaan Janhangeer

Educative.io Author Review: Why I Don't Recommend Writing On Educative

Abdur-Rahmaan Janhangeer — Tue, 13 Dec 2022 10:33:24 +0000

One of my worst mistakes in life was accepting an Educative contract which cost me months of my time. Educative.io is a great platform with awesome content. Do check it out if you haven't. It's also built on the belief that reading is faster than watching videos. It also enjoys a solid reputation among coders.

In this post i'd be drawing attention to some points which you might consider before signing a contract with Educative. This is not exactly a bad review of the platform, but sheds some light on contract termination.

You might end up writing the course 3 times.

Educative has 3 review rounds:

The Grammarly round

Where a Grammarly report is sent which also checks for plagiarism. This is a great initiative, but, the reviewer might ask you to change some wordings as you copied a definition as is. Well, if a canonical reference cannot be referenced, this is weird.

The casual review

In this round of review lots of comments are given. Some pretty useless. Among the three reason for terminating my contract, it was stated:

Some illustrations were blurred and were asked to be replaced. Unfortunately, they still have not been rectified.

This concerned screenshots like this one:

Sorry Educative, i cannot unblur a screenshot!

The formal review

This is a phase where they send you a Google docs with edits to be made. Mine, for the quarter milestone had 20+ pages. Yes, 20+ pages of things to correct for only a quarter of my course!

Don't give them the best of yourself

If you write a stuffed, code-intensive course, you are digging a hole for yourself as you will have to deal with the 3 rounds of reviews for each chapter of the course.

Getting penalized for a buggy Docker system

One of the 3 points stated:

Some of the applications in the course are still not working despite numerous revisions and author calls where all issues were addressed and appropriate solutions were provided.

It's true the apps were not working but why? I was writing a Flask course. And how do i know that they don't support basic things as redirection?

Clipping out redirect for render_template is a senseless thing to do in a Flask course.

There are times when a lib version was out of date but there were lots of platform issues.

At last they even forgot why i was waiting. I reminded them.

And yes, there are lots of stuffs

Conclusion

Educative made me a better writer, definitely! But, communication is quite weird and is a waste of time if you are writing many apps for them. It cost me a lot of opportunities and it's a great feeling not having to deal with senseless, unpractical reviews at scale!

This is my opinion, you are free to have a shot at it.

Refs:

The full mail

Hi Abdur-Rahmaan,

I hope this email finds you well.

As you know, your course was undergoing our Formal Review process. After thorough consideration, our team has decided that we will not be moving forward with the course as it does not meet our quality standards.

Here are the key reasons we have taken this decision:

Some of the applications in the course are still not working despite numerous revisions and author calls where all issues were addressed and appropriate solutions were provided.

Some illustrations were blurred and were asked to be replaced. Unfortunately, they still have not been rectified.

Many of the points repeatedly mentioned were not addressed but were crossed out in the document. Moreover, any questions asked were not answered either/ For example, It was requested to run Grammarly across the entire course to correct any typos and grammatical errors. Unfortunately, this is still not done.

We value all your efforts till now, and we highly appreciate the time that you have spent on this course.

Please consider this an official termination of our contract.

Please feel free to reach out to me if you have any questions. I wish you all the best in your future goals.

As for checked but requirements not met, it's solved according to me, so i check it. If it's deemed not met by the reviewer, then, they need to communicate why!

How To Have Django Packages in Flask

Abdur-Rahmaan Janhangeer — Tue, 30 Aug 2022 03:50:48 +0000

Django packages in Flask seems like a far-away dream, but shopyo 4.6.0 allows you to install Shopyo apps from pypi.

What is Shopyo?

Shopyo implements Django functionalities such as the admin panel etc by using existing Flask packages. But, it also implements Django-specifics like the collectstatic command, migrations, apps, even new concepts like boxes etc.

What the fuss about django packages?

Shopyo allows you to use apps in your project. Shopyo apps are in the format

demo/
├── forms.py
├── global.py
├── info.json
├── models.py
├── static
├── templates
│   └── demo
│       ├── blocks
│       │   └── sidebar.html
│       └── dashboard.html
├── tests
│   ├── test_demo_functional.py
│   └── test_demo_models.py
└── view.py

Until now, shopyo apps could not be installed but used locally. Now, the project has been updated to allow it! You can examine shopyo-demo the first shopyo app to get a feel of what it's like. Yes, you even have a sandbox to test the app, just like Django apps.

What to change from older projects?

init.py has a new variable called installed_packages which should contain the installed app you want to add.

Then, nothing to change really, just imports and in info.json make sure to set module name as shopyo_<your module name>

Conclusion

Having such a system for Flask is very convenient instead of having to build components from scratch time and again. Sites like djangopackages.com are very useful to find what we need real quick.

Why I Love Elixir As A Long Time Python User

Abdur-Rahmaan Janhangeer — Tue, 19 Apr 2022 05:45:10 +0000

Discord uses Python for it's API and ELixir for realtime chat capabilities. Functional programming languages are off-putting for everyday uses but Elixir is just beautiful. Here's some musings.

> rem(4, 3)
1

It's very neat to depart from modulo. You want the remainder? Use rem!

The comparison rule is also clearly spelt. Amazing!

number < atom < reference < function < port < pid < tuple < map < list < bitstring

String formatting without weird f letters are welcome!

"Hello #{world_var}"

But concatenation using <> is weird though

["a"] ++ ["b"] sure gives a Python feel ["a"] + ["b"]

Map is convoluted though dict = %{:x => "a", "y" => :z} but access feels at home: dict["hello"]

The iterables could be clearer, the end statement just bugs me: Enum.any?(["a", "aa", "aaa"], fn(s) -> String.length(s) == 3 end)

The . is annoying in fn calls sum.(2, 3)

The pipe operator is really coool!

fucntion() |> decorator()

Documenting feels a lot like docstrings

defmodule Hello do
  ...
  @doc """

  """

For comprehensions, i prefer the in keyword anytime

for x <- list, do: x+2

Filtering is sort of neat

for x <- 1..100, is_even(x), rem(x, 3) == 0, do: x i guess in Python we can do [x for x in range(1, 100) if combined_conditions(x)]

Using <<int>> to represent bytes is very interesting to have natively

The raise use is also very pythonic raise ArgumentError, message: "the argument value is invalid"

Concurreny is also weirdly simple:

defmodule Example do
  def listen do
    receive do
      {:ok, "hello"} -> IO.puts("World")
    end

    listen()
  end
end

pid = spawn(Example, :listen, [])
#PID<0.108.0>

It's also far more friendly than Erlang and more readable than Haskell!

Integrate p5js with socketio using Flask

Abdur-Rahmaan Janhangeer — Fri, 15 Apr 2022 21:28:23 +0000

Github Repo

Main codes

Server:

from shopyo.api.module import ModuleHelp

from flask_socketio import SocketIO, join_room, leave_room, emit

from init import socketio

mhelp = ModuleHelp(__file__, __name__)
globals()[mhelp.blueprint_str] = mhelp.blueprint
module_blueprint = globals()[mhelp.blueprint_str]


@module_blueprint.route("/")
def index():
    return mhelp.render('index.html')


@socketio.on('mouse')
def mouse(data, methods=['GET', 'POST']):
    # print(data)
    emit('mouse', data, broadcast=True)

Client

<!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8" />
  <title>Websockets drawing app</title>
  <link rel="stylesheet" type="text/css" href="styles.css" />
  <script src="https://cdn.socket.io/4.4.1/socket.io.min.js" integrity="sha384-fKnu0iswBIqkjxrhQCTZ7qlLHOFEgNkRmK2vaO/LbTZSXdJfAu6ewRBdwHPhBo/H" crossorigin="anonymous"></script>
  <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.3.1/p5.min.js"></script>
  <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.3.1/addons/p5.sound.min.js"></script>
  <script type="text/javascript">


 let socket
let color = '#FFF'
let strokeWidth = 4

function setup() {
  // Creating canvas
  const cv = createCanvas(1000, 1000)
  cv.position(600, 100)
  cv.background(0)

  // Start the socket connection
  socket = io.connect('http://127.0.0.1:5000')

  // Callback function
  socket.on('mouse', data => {
    // console.log('received ' + data.color+ ' '+data.x)
    stroke(data.color)
    strokeWeight(data.strokeWidth)
    line(data.x, data.y, data.px, data.py)
  })

  // Getting our buttons and the holder through the p5.js dom
  const color_picker = select('#pickcolor')
  const color_btn = select('#color-btn')
  const color_holder = select('#color-holder')

  const stroke_width_picker = select('#stroke-width-picker')
  const stroke_btn = select('#stroke-btn')

  // Adding a mousePressed listener to the button
  color_btn.mousePressed(() => {
    // Checking if the input is a valid hex color
    if (/(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(color_picker.value())) {
      color = color_picker.value()
      color_holder.style('background-color', color)
    }
    else {console.log('Enter a valid hex value')}
  })

  // Adding a mousePressed listener to the button
  stroke_btn.mousePressed(() => {
    const width = parseInt(stroke_width_picker.value())
    if (width > 0) strokeWidth = width
  })
}

function mouseDragged() {
  // Draw
  stroke(color)
  strokeWeight(strokeWidth)
  line(mouseX, mouseY, pmouseX, pmouseY)

  // Send the mouse coordinates
  sendmouse(mouseX, mouseY, pmouseX, pmouseY)
}

// Sending data to the socket
function sendmouse(x, y, pX, pY) {
  const data = {
    x: x,
    y: y,
    px: pX,
    py: pY,
    color: color,
    strokeWidth: strokeWidth,
  }

  socket.emit('mouse', data)
}
  </script>
  <style type="text/css">
    input.call-picker {
  border: 1px solid #AAA;
  color: #666;
  text-transform: uppercase;
  float: left;
  outline: none;
  padding: 10px;
  text-transform: uppercase;
  width: 85px;
}

.color-picker {
  width: 130px;
  background: #F3F3F3;
  height: 81px;
  padding: 5px;
  border: 5px solid #fff;
  box-shadow: 0px 0px 3px 1px #DDD;
  position: absolute;
  top: 61px;
  left: 2px;
}

.color-holder {
  background: #fff;
  cursor: pointer;
  border: 1px solid #AAA;
  width: 40px;
  height: 36px;
  float: left;
  margin-left: 5px;
}

input.stroke_width_picker {
  border: 1px solid #AAA;
  color: #666;
  text-transform: uppercase;
  float: left;
  outline: none;
  padding: 10px;
  text-transform: uppercase;
  width: 85px;
}

p {
  margin-top: 2rem;
  margin-bottom: 2rem;
}
button {
  margin-left: 1rem;
}
  </style>
</head>

<body>
  <p>Choose color (# hex)</p>
  <input type="text" name="custom_color" placeholder="#FFFFFF" id="pickcolor" class="call-picker" />
  <div id="color-holder" class="color-holder call-picker"></div>
  <button id="color-btn">Change color</button>
  <br />
  <p>Choose stroke width</p>
  <input type="text" name="stroke_width" placeholder="4" id="stroke-width-picker" class="stroke_width_picker" />
  <button id="stroke-btn">Change stroke width</button>
</body>
</html>

Result

Opening same url in two tabs/windows

Github Repo

Build A Note App In Flask The Fastest Possible (Using Shopyo)

Abdur-Rahmaan Janhangeer — Wed, 13 Apr 2022 05:38:16 +0000

Shopyo is a framework to get started with Flask really quick. It includes several libraries to get started by default. In this tutorial we will build a simple app to get started with. We used it for FlaskCon 2021 [site, codebase]. This tuto's app is available here

First steps

The first step is to install the library.

python3.9 -m venv venv # create virtual env
. venv/bin/activate # activate (linux version)
pip install shopyo==4.4.3

Then we create our folder

mkdir note_app

We enter into the folder

cd note_app

Then we create a new Shopyo project

shopyo new

The output looks like this:

creating project note_app...
#######################
[x] Project note_app created successfully!

A tree lookup gives

├── docs
│   ├── conf.py
│   ├── docs.rst
│   ├── index.rst
│   ├── Makefile
│   └── _static
│       └── custom.css
├── MANIFEST.in
├── note_app
├── pytest.ini
├── README.md
├── requirements.txt
├── setup.py
└── tox.ini

Since we are not interested in packaging our app for now, we can switch to the inner note_app/ folder

cd note_app

The inner note_app folder has this structure

├── note_app
│   ├── app.py
│   ├── app.txt
│   ├── autoapp.py
│   ├── CHANGELOG.md
│   ├── cli.py
│   ├── config_demo.json
│   ├── config.py
│   ├── conftest.py
│   ├── __init__.py
│   ├── init.py
│   ├── manage.py
│   ├── modules
│   ├── shopyo_admin.py
│   ├── static
│   ├── tests
│   │   ├── conftest.py
│   │   └── test_configs.py
│   └── wsgi.py

Creating modules

Lets create the notes app

shopyo startapp notes

A new folder will be created under modules/. The content of modules/note_app/ looks like this

modules/notes/
├── forms.py
├── global.py
├── info.json
├── models.py
├── static
├── templates
│   └── notes
│       ├── blocks
│       │   └── sidebar.html
│       └── dashboard.html
├── tests
│   ├── test_notes_functional.py
│   └── test_notes_models.py
└── view.py

These are files created by default.

Writing the first view

The info.json file lists some basics about the module, including it's url namespace (module_name) and url prefix

{
    "author": {
        "mail": "",
        "name": "",
        "website": ""
    },
    "display_string": "Notes",
    "fa-icon": "fa fa-store",
    "module_name": "notes",
    "type": "show",
    "url_prefix": "/notes"
}

Let's change url_prefix to "/"

{
    ...,
    "url_prefix": "/"
}

Our view.py looks like this, which is generated by default.

from shopyo.api.module import ModuleHelp

mhelp = ModuleHelp(__file__, __name__)
globals()[mhelp.blueprint_str] = mhelp.blueprint
module_blueprint = globals()[mhelp.blueprint_str]


@module_blueprint.route("/")
def index():
    return mhelp.info['display_string']

Let's change the return string to String from notes app

@module_blueprint.route("/")
def index():
    return "String from notes app"

Running the app

Run shopyo rundebug to run the app in debug mode.

Going to "http://127.0.0.1:5000/" should return "String from notes app"

You can learn more about the run command here.

Creating models

Our notes will have a title and a content. In modules/notes/models.py write:

from init import db
from shopyo.api.models import PkModel



class Note(PkModel): 

    __tablename__ = 'notes'

    title = db.Column(db.String(80), nullable=False)
    content = db.Text()

The init import comes from the init.py file.
The PkModel is same as db.Model with by default id as primary key

Then we initialise the app. It uses Flask-Migrate under the hood. You can view more initialise options here

$ shopyo initialise
initializing...
Cleaning...
#######################
Auto importing models...
#######################

Creating db...
#######################

Migrating db...
#######################

Upgrading db...
#######################

Collecting static...
#######################

Uploading initial data to db...
#######################

All Done!

This worked as Shopyo adds a shopyo.db as basic sqlalchemy connection string.

Configuring Flask-Admin

Now let's configure flask-admin to have a quick CRUD view. Fortunately, Shopyo already has some basics ongoing.

First, modify shopyo_admin.py to remove Flask-Login authentications

from flask import redirect
from flask import request
from flask import url_for
from flask_admin import AdminIndexView
from flask_admin import expose
from flask_admin.contrib import sqla as flask_admin_sqla
from flask_login import current_user


class DefaultModelView(flask_admin_sqla.ModelView):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    # def is_accessible(self):
    #     return current_user.is_authenticated and current_user.is_admin

    # def inaccessible_callback(self, name, **kwargs):
    #     # redirect to login page if user doesn't have access
    #     return redirect(url_for("auth.login", next=request.url))


class MyAdminIndexView(AdminIndexView):
    # def is_accessible(self):
    #     return current_user.is_authenticated and current_user.is_admin

    # def inaccessible_callback(self, name, **kwargs):
    #     # redirect to login page if user doesn't have access
    #     return redirect(url_for("auth.login", next=request.url))

    @expose("/")
    def index(self):
        # if not current_user.is_authenticated and current_user.is_admin:
        #     return redirect(url_for("auth.login"))
        return super().index()
# 
    @expose("/dashboard")
    def indexs(self):
        # if not current_user.is_authenticated and current_user.is_admin:
        #     return redirect(url_for("auth.login"))
        return super().index()

Then in app.py, don't load Flask-Login by commenting it out.

def load_extensions(app):
    ...
    # login_manager.init_app(app)

Then in app.py import the Note model

from modules.notes.models import Note

And modify the setup_flask_admin function to look like this:

def setup_flask_admin(app):
    admin = Admin(
        app,
        name="My App",
        template_mode="bootstrap4",
        index_view=MyAdminIndexView(),
    )
    admin.add_view(ModelView(Note, db.session))

Now, navigating to /admin gives

Clicking on note allows you to edit the Note model. Let's add few models!

Displaying templates

What remains is using displaying the note on our main page.

Under modules/notes/templates/notes create a file called index.html with content

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title></title>
</head>
<body>
    {% for note in notes %}
        {{note.title}}<br>
        {{note.content}}<hr>
    {% endfor %}
</body>
</html>

Modify the view.py to

from shopyo.api.module import ModuleHelp
from flask import render_template

from .models import Note 


mhelp = ModuleHelp(__file__, __name__)
globals()[mhelp.blueprint_str] = mhelp.blueprint
module_blueprint = globals()[mhelp.blueprint_str]


@module_blueprint.route("/")
def index():
    notes = Note.query.all()
    return render_template('notes/index.html', notes=notes)

Which results in:

Shopyo also provides some utils like

from shopyo.api.templates import yo_render

...
@module_blueprint.route("/")
def index():
    notes = Note.query.all()
    context = {
        'notes': notes
    }
    return yo_render('notes/index.html', context)

Trying out a demo app

If you just want to try a demo app, just run (comment back the flask-login modifications)

mkdir project
cd project
shopyo new -m # -m adds default modules
cd project
shopyo initialise
shopyo rundebug

You can then see how an authed Flask-Admin looks like.

Hope you enjoy this post!

This tuto's app is available here

Github Finally Fixes Issue That Was Costing Lot of Wasted Space

Abdur-Rahmaan Janhangeer — Fri, 10 Dec 2021 11:30:30 +0000

Github had all a GIT-in-the-cloud service needed. It added much more features, like the dark mode. It hit hard on community aspects.

But it missed one thing early on, to identify how people used the app, what for.

Much like foot trails in Urban Planning. You can read more here: Desire paths: the illicit trails that defy the urban planners

People sometimes use the most convenient solution in your setup even if you did not have plans for it. And it might be a flag that your design is flawed, to some degree.

People have always used Github forks as bookmarks

Much to the horror of the Linux/Unix/freeBSD OpenSource community, Github users have been forking projects. Forks are not welcomed. Even a for forking article on opensource.com starts with

Although forking is undesirable, ...

But many many of those forks were unnecessary. And they cost storage space. People have always used forks to bookmark projects. And Github has been battling wastage. At one time i remember Github offering to delete forks when PRs were merged.

Finally fixed

Now you can add your favourite project to your well favourite list. No longer need to fork!

FlaskCon 2021 Links

Abdur-Rahmaan Janhangeer — Wed, 08 Dec 2021 07:50:20 +0000

FlaskCon 2021 / https://youtube.com/c/flaskcon

This edition hosted another round of great Flask content, coupled with the inclusion of Podcasts. Have fun watching!

Flask-Multipass - A pluggable authentication framework for Flask by Adrian Monnich
https://youtu.be/j37wYpiYRQY

Debugging flask application within a docker container using VSCode by Ashok Tankala
https://youtu.be/VjIYcJVZCP0

Enabling multi-tenancy with werkzeug by Abdeali (Ali) Kothari
https://youtu.be/EP0GaIQvr0c

Building Scalable APIs Using Flask and Docker by Emma Donery
https://youtu.be/sbdQPA60BjI

Application config management: Lightweight but enterprise-ready by Abdeali (Ali) Kothari
https://youtu.be/01zPKbRpgOo

Hassle Free Desktop Apps with Flask by Alin Climente
https://youtu.be/RApsKoC1a7s

Whole stream with QnA
https://youtu.be/-KyYRB0ffns

Making Location-Searchable Sites Using Geocoding and Elasticsearch by Jay Miller
https://youtu.be/KZnXjvtgABc

Dockerizing Flask For Production by Nico Plyley
[ speaker out ]

Testing Flask Applications with pytest by Patrick Kennedy
https://youtu.be/OcD52lXq0e8

Improve the efﬁciency of your Flask app's frontend by Randy Duodu
https://youtu.be/CvZQ6bfpL00
[ audio not good, in livetream talk to be found with good audio,
will send updated link soon ]

Building Secured Flask Apps by Randy Duodu
https://youtu.be/F3jCc_RMHMU
[ audio not good, in livetream talk to be found with good audio,
will send updated link soon ]

HTMX + Flask: Modern Python Web Apps, Hold the JavaScript by Michael Kennedy
https://youtu.be/kNXVFB5eQfo

Whole stream with QnA
https://youtu.be/LCDa3RftUu0

Workshop: Building An Awesome SASS App by Sumukh Sridhara
https://youtu.be/biURI5jLGzM

Workshop: Packaging a Flask App: Deep Dive Into The Wheels of Packaging by Alexander Hultner
https://youtu.be/DThFxooHEJk

Podcast: How To Leverage Flask To Win Hackathons by Anush Krishna V
https://youtu.be/dKD0rwTJ3IA

Podcast: Building And Shipping Flask Side Projects Fast With Abhishek Kaushik
https://youtu.be/LGGQ-zRt14k

Podcast: Experience Learning Flask With David Carmichael
https://youtu.be/xsZpLVdEsDk

Getting started with Python-efl

Abdur-Rahmaan Janhangeer — Tue, 26 Oct 2021 21:49:18 +0000

EFL stands for Enlightment Foundation Libraries which was started by Carsten Haitzler aka rasterman. It started originally for the enlightenment desktop project.

About Python-efl

Python-efl are the python bindings for it. Here's the links i prepared so that people can get started quickly. I'll be adding more resources as i come across them!

https://www.pythonkitchen.com/how-to-install-python-efl-on-ubuntu-or-linux-mint/

https://www.pythonkitchen.com/python-efl-1/

https://www.pythonkitchen.com/python-efl-2/

https://www.pythonkitchen.com/python-efl-3/

https://www.pythonkitchen.com/python-efl-4/

https://www.pythonkitchen.com/python-efl-5/

https://www.pythonkitchen.com/python-efl-6/

https://www.pythonkitchen.com/python-efl-7/

https://www.pythonkitchen.com/python-efl-8/

Why FlaskCon insists on having publicly listed reviewers

Abdur-Rahmaan Janhangeer — Tue, 12 Oct 2021 21:54:43 +0000

Python conferences all have a team of reviewers. Not made public. Since the first edition of FlaskCon, we made our list public. This encourages transparency and builds trust. People often ask: Why? If some great conferences don't do it, that means it is not important or necessary. But not necessarily so ...

Before we dig deeper, please have a look at Python conferences having a list of publicly disclosed reviewers for 2021 [1]:

Conference	Has public list of reviewers
PyCon US	❌
EuroPython	❌
PyCon India	❌
PyCon Japan	❌
FlaskCon	Yes

Django Con had a call for community reviewers. First come, first serve.

Well, at FlaskCon we are adamant that people who review talks be competent in the field they are in. And, they should be displayed. So that we know it's not my cat's backyard buddy who is helping out with the reviews. We just want as a conference to get the best talks possible selected.

So if a big conference does not have that feature, that does not mean we should tick it off. And i do think it's very weird for conferences who go to great lengths at perfecting details not to have it. An even more unsettling question is: Why keep it a secret. Is there some dark business going on? We hope no ...

[1] As far as i searched

Why Choose Flask Over FastAPI

Abdur-Rahmaan Janhangeer — Sun, 18 Apr 2021 21:56:37 +0000

FastAPI positions itself as one of the best choices for API development in Python. The project is polished for sure, the docs are sleek and the commit messages awesome. It collected some nice parts and pieced them together to produce an artifact infused and driven by pragmatism. But the community is wrong, completely wrong and over hyped in comparing FastAPI with it's father in inspiration: The awesome, one & only, unique Flask

Index

FastAPI: Standing on the shoulders of giants
A Culture Of Pushy Marketing: When Python Is Suddenly As Fast As Golang
The Tiangolo Docs Says You Are Wrong Comparing FastAPI To Flask
They All Fell Into The Trap: CTO, Respected Authors, StackOverflow's Partner, Big Names and What Not
What To Compare With What?
Why Choose Flask Over FastAPI

FastAPI: Standing on the shoulders of giants

If one was to introduce and understand FastAPI, there is no better introduction than in the moustachu wizard's words:

Here's some extra background that might help understanding where they come from.
The creator of Django-Rest-Framework, Tom Christie, created a new API framework with what he thought would be the best approach for building APIs in modern Python. It was called APIStar.

APIStar had to deal with some complexities underneath like supporting WSGI (the same used by Flask and Django) and ASGI, the new standard, etc. So, at some point, Tom decided that a new approach was needed. So, he created a new framework/toolkit form scratch, based on ASGI, called Starlette. The server part of APIStar was deprecated and from then on APIStar was only a set of tools for OpenAPI validation.

...

Then, FastAPI was created on top of Starlette, inheriting a lot of the ideas form APIStar (that actually come from even before, with Hug) and updating/improving them, to use standard Python type hints, dependency injection, OpenAPI with docs by default, etc. [1]

It's also being used by Microsoft, Netflix and Uber [2]. So it's a respected package, being given serious thoughts and considerations in production.

A Culture Of Pushy Marketing: When Python Is Suddenly As Fast As Golang

FastAPI states in it's README [3]:

The key features are:

Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.

Someone raised an issue entitled: Very poor performance does not align with marketing [4]. Some developers tried to assign a meaning to the phrase

Very high performance, on par with NodeJS and Go

They hold that it means:

If you didn't use FastAPI and used Starlette directly (or another tool, like Sanic, Flask, Responder, etc) you would have to implement all the data validation and serialization yourself. So, your final application would still have the same overhead as if it was built using FastAPI. And in many cases, this data validation and serialization is the biggest amount of code written in applications.

But the author is not going away with on par with.

According to the Cambridge dictionary [5]:

on par with: the same as or equal to someone or something

According to Oxford's learner's dictionary it means [6]:

on a par/level with somebody/something

as good, bad, important, etc. as somebody/something else

Tiangolo actually sheds some light on what it actually means:

Starlette was made to be a minimal micro-framework and toolkit at the same time, so that other tools could be built on top of it, but providing a very solid foundation, and the best performance available in Python, on par with NodeJS and Go. [1]

So unlike the attempted explanation above or what FastAPI fans would try to produce, the author is clearly saying that a minimal micro-framework in Python (that is Starlette) is as fast as Golang.

Well FastAPI folks, you can't explain it better than the author.

It's no wonder that the fan base attempt some wind in sail comparisons. Tiangolo & Co., you set the trend.

The Tiangolo Docs Says You Are Wrong Comparing FastAPI To Flask

There are an awesome amount of articles stating: Why we moved from Flask to FastAPI, Why I quit Flask, How to move from Flask to FastAPI. This is just crazy. I mean, come on folks, how can you miss the basic facts?

The docs might seems misleading. In discussing alternatives to FastAPI, it lists Flask [7].

Flask is a "microframework", it doesn't include database integrations nor many of the things that come by default in Django.

This simplicity and flexibility allow doing things like using NoSQL databases as the main data storage system.

As it is very simple, it's relatively intuitive to learn, although the documentation gets somewhat technical at some points.

It is also commonly used for other applications that don't necessarily need a database, user management, or any of the many features that come pre-built in Django. Although many of these features can be added with plug-ins.

This decoupling of parts, and being a "microframework" that could be extended to cover exactly what is needed was a key feature that I wanted to keep.

Given the simplicity of Flask, it seemed like a good match for building APIs. The next thing to find was a "Django REST Framework" for Flask.

That's why fans go on to compare with Flask? I don't know. It's misleading for sure as people don't bother to actually read the whole page. The very same page actually lists requests saying:

FastAPI is not actually an alternative to Requests. Their scope is very different.

So this is not really a page for comparisons, at least not all. Don't take my words for it. The docs tells you:

If you are comparing FastAPI, compare it against a web application framework (or set of tools) that provides data validation, serialization and documentation, like Flask-apispec, NestJS, Molten, etc. Frameworks with integrated automatic data validation, serialization and documentation. [8]

Before you write Flask-bashing articles, at least read the FastAPI docs.

They All Fell Into The Trap: CTO, Respected Authors, StackOverflow's Partner, Big Names and What Not

Testdriven.io

One of the Testdriven.io blog authors whom i respect a lot, Amal Shaji wrote an article: Moving from Flask to FastAPI [9]. It's really puzzling to see that such an author, on such a blog has such an understanding. The article goes on detailing how do the installs compare etc. Side by side comparison of views templates etc. The author mentions:

You can think of FastAPI as the glue that brings together Starlette, Pydantic, OpenAPI, and JSON Schema.

it should have clicked like: well am i comparing some comparable things or not? Why not compare Flask and Starlette? The author ends with a sweeping statement:

Switching to FastAPI is a solid choice.

These types of articles while seemingly genuine just repel people from Flask.

Yuan Gao, The CTO

Yuan Gao wrote a somewhat lengthy article entitled: Flask vs FastAPI first impressions [10]. The person compares with visible enthusiasm:

I've recently upgraded several of our API endpoints over from Flask to FastAPI, and honestly I haven't felt such a breath of fresh air in development for a long time.

The person was really thinking that jsonify was the tool for apis:

Contrast this with Flask, whose errors are HTML pages by default, and return JSON need to be jsonify()'d

The comparison is a devastating head shaking piece, dripping all the way down:

In Flask, you access both query and request body via the request singleton, which is a magic instance that when referenced inside and endpoint handler contains stuff relating to the request. ... This is actually highly annoying.

He complains of the lack of validation in Flask:

With Flask, there aren't many options for this; you either write a lot of if statements to check every possible part of the data coming in, and then manually make sure to go update your API documentation somewhere, or you use some kind of data validation library.

Even complaining of the lack of web sockets in Flask:

Websockets are another feature that Flask does't support,

And concludes with:

So while it's clear to me that FastAPI is a much better framework than Flask for APIs, Flask still remains a good choice for many other HTTP tasks.

A miss all over and an overall mess.

Pluralsight.com

That one got a 'wow' from me. I mean, pluralsight is busy schooling and rating developers around the world. StackOverflow partnered with them to educate devs. I don't know where to put my head. John Walk writes [14]:

This API will work for serving predictions (try it out yourself!)… but it’s entirely likely it will fall over if you try to put it into production. Notably, it lacks any data validation - any missing, misnamed, or mistyped information in the incoming request results in an unhandled exception, returning a 500 error and a singularly unhelpful response from Flask (along with some rather intimidating HTML in debug mode), while potentially firing alerts into your monitoring systems and waking up your DevOps.

Frequently, error handling in Flask ends up with a brittle, tangled jumble of try-catches and protected dict access. Better approaches will use a package like pydantic or marshmallow to achieve more programmatic data validation. Fortunately, FastAPI includes pydantic validation out of the box.

I mean how can people not blame Flask when pluralsight tells them to? And Flask is not to be blamed.

It's Splashed All Over

AnalyticsVidhya has an article by KAUSTUBH1828 [11] which repeats the arguments mentionned above. Section.io has one [12] by the name of "Choosing between Django, Flask, and FastAPI", Django added for better mismatch. It's published under Engineering Education. Oh my! Same goes for acubits.com [13]. Tivadar Danka from towardsdatascience.com [15] says:

For many years, Flask was the number one tool for the job, but in case you haven’t heard, there is a new challenger in town. FastAPI is a relatively new web framework for Python, taking inspiration from its predecessors, perfecting them and fixing many of their flaws.

and the title of the article is: "You Should Start Using FastAPI Now". And the portrayal are indeed in bashing style like Dieter Jordens from betterprogramming.pub [16] entitled "3 Reasons to Switch to FastAPI":

FastAPI is based on type hints. Up to this point, Flask has just plain ignored them.

The problem is that people hush Flask down under a False starting point, and some go hard on it. Cover to cover, first letter to last dot, these articles made a faux depart.

Re-stating: What these articles did wrong?

They simply compared Flask to FastAPI. They miscompared frameworks.

What To Compare With What?

You can compare Flask with Starlette. You can compare Flask-restx or flask-apispec to FastApi. You can compare Quart to Flask and Starlette. You can compare Quart-schema to FastAPI and Flask-aspispec.

Flask is a micro web framework. Starlette is a "is a lightweight ASGI framework/toolkit". Flask is a WSGI framework and Starlette is an ASGI one. They are barebones, non-purpose specific frameworks. Flask-restx is designed to build APIs, this is closer to FastAPI. It completely misses the point saying Flask misses validation or this and that while FastAPI has this and that. When you compare, compare the frameworks that match in purpose to start with.

Why Choose Flask Over FastAPI

The title is just a note saying why you should not go about writing articles that way. The article is deliberately mistitled and put en relief the point that you should not compare Flask to FastAPI nor compare FastAPI to Flask. Both serve different purposes.

FaQ

Point:

"A miss all over and an overall mess."

Why does the article just state this opinion and then do little else? Did I miss something? I was expecting some paragraphs afterwards about reasons why, but there are none to be found.

This sorta just reeks of bitterness.

A miss all over and an overall mess illustrates the results you get when you compare two things which should not be compared.

Point:

There are certainly reasons to choose Flask over FastAPI, but this article reads like it was written by an AI.

"The problem is that people hush Flask down under a False starting point, and some go hard on it. Cover to cover, first letter to last dot, these articles made a faux depart."

If an actual human wrote this: I have no idea what you are trying to say.

People make points but they are False from the start.

[1] https://news.ycombinator.com/item?id=22776339
[2] https://fastapi.tiangolo.com/
[3] https://github.com/tiangolo/fastapi
[4] https://github.com/tiangolo/fastapi/issues/1664
[5] https://dictionary.cambridge.org/dictionary/english/par
[6] https://www.oxfordlearnersdictionaries.com/definition/english/level_1#level_idmg_6
[7] https://fastapi.tiangolo.com/alternatives/
[8] https://fastapi.tiangolo.com/benchmarks/
[9] https://testdriven.io/blog/moving-from-flask-to-fastapi/
[10] https://dev.to/meseta/flask-vs-fastapi-first-impressions-1bnm
[11] https://www.analyticsvidhya.com/blog/2020/11/fastapi-the-right-replacement-for-flask/
[12] https://www.section.io/engineering-education/choosing-between-django-flask-and-fastapi/
[13] https://blog.accubits.com/flask-vs-fastapi-which-one-should-you-choose/
[14] https://www.pluralsight.com/tech-blog/porting-flask-to-fastapi-for-ml-model-serving/
[15] https://towardsdatascience.com/you-should-start-using-fastapi-now-7efb280fec02
[16] https://betterprogramming.pub/3-reasons-to-switch-to-fastapi-f9c788d017e5owardsdatascience.com/you-should-start-using-fastapi-now-7efb280fec02
[16] https://betterprogramming.pub/3-reasons-to-switch-to-fastapi-f9c788d017e52
[16] https://betterprogramming.pub/3-reasons-to-switch-to-fastapi-f9c788d017e5

Python Generators: The In-depth Article You’ve Always Wanted

Abdur-Rahmaan Janhangeer — Thu, 10 Dec 2020 06:51:48 +0000

Why were Python generators introduced?
How do Python Generators differ from normal functions?
Execution flow
Immediate usefulness
next and for loops
Generators introduced for memory saving
Generators for tasks
The send method
Deriving send
What is yield from
The last part
The limit of generators: Infinity and Beyond

In Python, generators form part of the intermediate topics. Since it differs from conventional functions, beginners have to take sometimes to wrap their head around it. This article presents materials that will be useful both for beginners and advanced programmers. It attempts to give enough to understand generators in depth but don't cover all use cases.

Why were Python generators introduced?

Before we present generators and it's syntax, it's important to know why in the first place were generators introduced. The yield keyword does not mean generators. One has to understand the concept behind. The original PEP introduced "the concept of generators to Python, as well as a new statement used in conjunction with them, the yield statement" [1].

The general use case of generators is as follows:

When a producer function has a hard enough job that it requires maintaining state between values produced, [1]

And more explicitly

provide a kind of function that can return an intermediate result ("the next value") to its caller, but maintaining the function's local state so that the function can be resumed again right where it left off. [1]

So we understand that a new kind of functions was needed that:

1. return intermediate values
2. save the state of functions

How do Python Generators differ from normal functions?

Compared to normal functions, once you return from a function, you can go back to return more values. A normal function in contrast, once you return from it, there is no going back.

Normal function:

def x():
    print('abc')
    return 
    print('def') # not reached
x()

In the above example, def will not be printed as the function exited before. Let's examine a basic generator example:

def x():
  a = 0
  while 1:
    yield a

    a += 1

z = x()

print(z)
print(next(z))
print(next(z))

<generator object x at 0x01ACB760>
0
1

From the example above, once we called next, it returned a value. The purpose of next is to go to the next yield statement. When we called next the first time, it went to the next yield since the beginning which is when a was initially at 0.

The second call of next started executing a += 1 and went to the beginning of the loop where it encountered a yield statement and returned a with the updated value.

By a being updated we see that even when the function was exited the first time, when the program went back into it, it continued on the previous state when a was 0. This accomplishes the two aims of being able to resume functions and saving the previous state.

To understand it better, here are some more names that were proposed instead of yield [1] but were eventually rejected:

return 3 and continue
return and continue 3
return generating 3
continue return 3

Guido gives a summary of generators [1]:

In practice (how you think about them), generators are functions, but with the twist that they're resumable.

Execution flow

The following snippet gives us an idea about the execution:

def x():
  print('started')
  while 1:
    print('before yield')
    yield
    print('after yield')


z = x()

next(z)
print('-- 2nd call')
next(z)

started
before yield
-- 2nd call
after yield
before yield

From it we confirm that the first call to next executes everything in the function until the first yield statement. We did not return any values but used yield purely to control the flow of execution in the same sense of return.

Yield needs not to be in infinite loops, you can use several at once in the same function body:

def x():
  print('start')
  yield 
  print('after 1st yield')
  yield
  print('after 2nd yield')

z = x()
next(z)
next(z)
next(z)

start
after 1st yield
after 2nd yield
Traceback (most recent call last):
  File "lab.py", line 11, in <module>
    next(z)
StopIteration

In case you called next more than there is yield statements, generator functions raise the StopIteration. In case you want to auto-handle StopIteration until there are no more left, use ... a for loop:


def x():
  print('start')
  yield 
  print('after 1st yield')
  yield
  print('after 2nd yield')

z = x()
for _ in z:
  pass

In case you return a value, the loop variable will be equal to that value:

def x():
  print('start')
  yield 1
  print('after 1st yield')
  yield 2
  print('after 2nd yield')

z = x()
for _ in z:
  print(_)

start
1
after 1st yield
2
after 2nd yield

Immediate usefulness

Since we saw that we can use yield with an infinite loop, this is extremely powerful. We can break infinity in steps. Consider this:

def odd_till(number):
  n = 1
  while n < number:
    yield n
    n += 2

for odd_num in odd_till(10):
  print(odd_num)

We yield one number and the function exits, the for loop calls it again. It yields one number and exits. And so on. It goes about it in micro steps. The operations completed in one cycle is is just an increment n += 2 and a check n < number.

odd_till(10) or odd_till(10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) don't not cause memory errors

next and for loops

Two things might puzzle you:

why was next used?
how can a function with 2 yields work when a for loop is used with it?

The answer lies in in the fact that generators implement the iterator protocols, the same one used by lists. Here is a class customised to act as a generator [7]:

# Using the generator pattern (an iterable)
class firstn(object):
    def __init__(self, n):
        self.n = n
        self.num = 0

    def __iter__(self):
        return self

    # Python 3 compatibility
    def __next__(self):
        return self.next()

    def next(self):
        if self.num < self.n:
            cur, self.num = self.num, self.num+1
            return cur
        else:
            raise StopIteration()

sum_of_first_n = sum(firstn(1000000))

Generators introduced for memory saving

Consider a list comprehension:

sum([x*x for x in range(10)])

A generator expression is much, much more efficicent [2]:

sum(x*x for x in range(10))

This was the second addition in the generator story.

Generators for tasks

Lets modify our two functions with print

def odd_till(number):
  n = 1
  while n < number:
    print('odd_till {} currently: {}'.format(number, n))
    yield n
    n += 2

def even_till(number):
  n = 0
  while n < number:
    print('even_till {} currently: {}'.format(number, n))
    yield n
    n += 2

Lets have a class to run functions

from collections import deque

class RunFunc:
  def __init__(self):
    self._queue = deque()

  def add_func(self, func):
    self._queue.append(func)

  def run(self):
    while self._queue:
      func = self._queue.popleft()
      try:
        next(func)
        self._queue.append(func)
      except StopIteration:
        pass

usage

func_runner = RunFunc()

func_runner.add_func(odd_till(5))
func_runner.add_func(even_till(4))
func_runner.add_func(odd_till(6))
func_runner.run()

output

odd_till 5 currently: 1
even_till 4 currently: 0
odd_till 6 currently: 1
odd_till 5 currently: 3
even_till 4 currently: 2
odd_till 6 currently: 3
odd_till 6 currently: 5

If we rename the same thing we get a mini task scheduler [4]

from collections import deque

class TaskScheduler:
  def __init__(self):
    self._queue = deque()

  def add_task(self, task):
    self._queue.append(task)

  def run(self):
    while self._queue:
      task = self._queue.popleft()
      try:
        next(task)
        self._queue.append(task)
      except StopIteration:
        pass

usage

scheduler = TaskScheduler()

scheduler.add_task(odd_till(5))
scheduler.add_task(even_till(4))
scheduler.add_task(odd_till(6))
scheduler.run()

Just a point of note, why do we remove a task (popleft) and readd it (append)?

      task = self._queue.popleft()
      try:
        next(task)
        self._queue.append(task)
      except StopIteration:
        pass

That's because if it was finished (exception raised) well and good, it will go straight to the except block. Else the .append will get executed.

In other words if task terminated, don't add it back else add it back.

The send method

Generators support a way of sending values to generators

def times2():
    while True:
        val = yield
        yield val * 2

z = times2()


next(z)
print(z.send(1))
next(z)
print(z.send(2))
next(z)
print(z.send(3))

2
4
6

This was an important addition. This passage explains why was send introduced and why it's important in asyncio [6]:

Python's generator functions are almost coroutines -- but not quite -- in that they allow pausing execution to produce a value, but do not provide for values or exceptions to be passed in when execution resumes ... However, if it were possible to pass values or exceptions into a generator at the point where it was suspended, a simple co-routine scheduler or trampoline function would let coroutines call each other without blocking -- a tremendous boon for asynchronous applications. Such applications could then write co-routines to do non-blocking socket I/O by yielding control to an I/O scheduler until data has been sent or becomes available. Meanwhile, code that performs the I/O would simply do something like this: data = (yield nonblocking_read(my_socket, nbytes)) in order to pause execution until the nonblocking_read() coroutine produced a value.

yield was fundamentally changed with the addition of send.

1. Redefine yield to be an expression, rather than a statement. The current yield statement would become a yield expression whose value is thrown away. A yield expression's value is None whenever the generator is resumed by a normal next() call.
1. Add a new send() method for generator-iterators, which resumes the generator and sends a value that becomes the result of the current yield-expression. The send() method returns the next value yielded by the generator, or raises StopIteration if the generator exits without yielding another value.

send(None) can also be used instead of the first next()

Deriving send

How do we derive send? A tricky question indeed. Here's a mini snippet showing how [4]

from collections import deque

class ActorScheduler:
  def __init__(self):
    self._actors = { } # Mapping of names to actors
    self._msg_queue = deque() # Message queue

  def new_actor(self, name, actor):
    '''
    Admit a newly started actor to the scheduler and give it a name
    '''
    self._msg_queue.append((actor,None))
    self._actors[name] = actor

  def send(self, name, msg):
    '''
    Send a message to a named actor
    '''
    actor = self._actors.get(name)
    if actor:
      self._msg_queue.append((actor,msg))

  def run(self):
    '''
    Run as long as there are pending messages.
    '''
    while self._msg_queue:
      actor, msg = self._msg_queue.popleft()
      try:
        actor.send(msg)
      except StopIteration:
        pass

# Example use
if __name__ == '__main__':
  def printer():
    while True:
      msg = yield
      print('Got:', msg)

  def counter(sched):
    while True:
    # Receive the current count
      n = yield
      if n == 0:
        break
      # Send to the printer task
      sched.send('printer', n)
      # Send the next count to the counter task (recursive)
      sched.send('counter', n-1)


  sched = ActorScheduler()
  # Create the initial actors
  sched.new_actor('printer', printer())
  sched.new_actor('counter', counter(sched))
  # Send an initial message to the counter to initiate
  sched.send('counter', 100)
  sched.run()

The above can be expanded with more areas like ready, ready to read, ready to write and writing the appropriate code to switch between the areas and ... you have a concurrent app. This is the basics of an operating system [4]. Using sched.send allows to have a loop beyond the recursion limit of python. The recursion limit is import sys; sys.getrecursionlimit() usually 1000. try sched.send('counter', 1001).

What is yield from?

Consider the following code:

def gen_alph():
  for a in 'abc':
    yield a

def gen_nums():
  for n in '123':
    yield n


def gen_data():
  yield from gen_alph()
  yield from gen_nums()


for _ in gen_data():
  print(_)

a
b
c
1
2
3

It behaves exactly as if the alphabet and number loops with their respective yields was inside gen_data.

"yield from is to generators as calls are to functions" as Brett Cannon puts it [8]

The last part

Generators have a close method, caught by a GeneratorExit exception:

def gen_alph():
  try:
    for a in 'abc':
      yield a
  except GeneratorExit:
      print('Generator exited')

z = gen_alph()
next(z)
z.close()

Generator exited

They also have a throw method to catch errors:

def gen_alph():
  try:
    for a in 'abc':
      yield a
  except GeneratorExit:
      print('Generator exited')
  except Exception:
    yield 'error occured'

z = gen_alph()
next(z)
print(z.throw(Exception))

error occured

The limit of generators: Infinity and Beyond

If you really want the best of Python generators the internet can give you
copied over and over by Python sites, see David Beazley's 3 parts series:

It also includes lots of use cases.

Abdur-Rahmaan Janhangeer is an organising member of the Python Mauritius User Group (PyMUG), FlaskCon and maintains pythonkitchen.com. The present article is the continuation of his talk about deriving asyncio

References

[1] https://www.python.org/dev/peps/pep-0255/
[2] https://www.python.org/dev/peps/pep-0289/
[3] https://dev.to/abdurrahmaanj/add-superpowers-to-your-python-lists-using-this-feature-24nf
[4] Python Cookbook, David Beazley
[5] https://docs.python.org/3/library/asyncio-task.html
[6] https://www.python.org/dev/peps/pep-0342/
[7] https://wiki.python.org/moin/Generators
[8] Brett Cannon: Python 3.3: Trust Me, It's Better Than Python 2.7

How to run Linux-only Python projects on windows using git mingw bash

Abdur-Rahmaan Janhangeer — Mon, 07 Dec 2020 16:22:07 +0000

Linux owners configure makefiles so as to have easy commands to perform operations such as make dependencies to pip install required packages. Here are the dry simple steps to run makefiles in Python projects on Windows.

Download git for windows. You should get git bash, git gui etc
Download the mingw GUI setup. Install it wherever you want. After running the setup you should get a screen like that:

On continuing you should get under all packages. Search for make, class bin. Right click and select mark for installation

Under installation, select apply changes

Confirm by clicking on apply

My git for windows' migw is installed at C:\Program Files\Git\mingw32 and my mingw get is installed at C:\MinGW. We need to merge the contents on the mingw32 folder with the MinGW. Ctrl+a to select all folder in MinGW then right click and copy. Then go to mingw32 folder and click paste. When asking is merge, say yes. If same files skip
Verify if there is venv/ in project gitignore. If not add it and reapply gitignore by using the following command (see accepted answer)
create a new virtual environent.

python -m venv venv

activate the env

cd venv
cd scripts
. activate

note the space between . and activate

cd back cd ../..

now try out any command listed here for example make dependencies

Forgot to say under bin rename mingw-get.exe to make.exe

Anything mail me arj.python at gmail dot com

This is something crazily powerful!

You might want to see the other hacky way:

How to run a Flask Linux-only app on windows

DEV Community: Abdur-Rahmaan Janhangeer

Educative.io Author Review: Why I Don't Recommend Writing On Educative

You might end up writing the course 3 times.

Don't give them the best of yourself

Getting penalized for a buggy Docker system

Conclusion

How To Have Django Packages in Flask

What is Shopyo?

What the fuss about django packages?

What to change from older projects?

Conclusion

Why I Love Elixir As A Long Time Python User

Integrate p5js with socketio using Flask

Main codes

Result

Build A Note App In Flask The Fastest Possible (Using Shopyo)

First steps

Creating modules

Writing the first view

Running the app

Creating models

Configuring Flask-Admin

Displaying templates

Trying out a demo app

Github Finally Fixes Issue That Was Costing Lot of Wasted Space

People have always used Github forks as bookmarks

Finally fixed

FlaskCon 2021 Links

Getting started with Python-efl

About Python-efl

Why FlaskCon insists on having publicly listed reviewers

Why Choose Flask Over FastAPI

Index

FastAPI: Standing on the shoulders of giants

A Culture Of Pushy Marketing: When Python Is Suddenly As Fast As Golang

The Tiangolo Docs Says You Are Wrong Comparing FastAPI To Flask

They All Fell Into The Trap: CTO, Respected Authors, StackOverflow's Partner, Big Names and What Not

Testdriven.io

Yuan Gao, The CTO

Pluralsight.com

It's Splashed All Over

Re-stating: What these articles did wrong?

What To Compare With What?

Why Choose Flask Over FastAPI

FaQ

Python Generators: The In-depth Article You’ve Always Wanted

Table of contents

Why were Python generators introduced?

How do Python Generators differ from normal functions?

Execution flow

Immediate usefulness

next and for loops

Generators introduced for memory saving

Generators for tasks

The send method

Deriving send

What is yield from?

The last part

The limit of generators: Infinity and Beyond

References

How to run Linux-only Python projects on windows using git mingw bash