DEV Community: Carlos V.

Parallelism in Python starter pack

Carlos V. — Wed, 06 Jul 2022 21:38:37 +0000

I'm happy to share with you a post that I wrote for Globant Medium. Enjoy!

Parallelism in Python starter pack | by Carlos Villavicencio | Globant | Medium

Carlos Villavicencio ・ Jul 6, 2022 ・
Medium

GitHub Action to run mypy on changed files only

Carlos V. — Wed, 15 Jun 2022 20:13:52 +0000

Recently, I needed a way to perform Python static type checking using mypy only on "changed" files for a GitHub Pull Request.

So I googled a bit and found out this super useful action that you can use it in your workflow right away.

tj-actions / changed-files

:octocat: Github action to retrieve all (added, copied, modified, deleted, renamed, type changed, unmerged, unknown) files and directories.

changed-files

Effortlessly track all changed files and directories relative to a target branch, the current branch (preceding commit or the last remote commit), multiple branches, or custom commits returning relative paths from the project root using this GitHub action.

Note

This action solely identifies files that have changed for events such as pull_request*, push, merge_group, release, and many more. However, it doesn't detect pending uncommitted changes created during the workflow execution.

See: https://github.com/tj-actions/verify-changed-files instead.

Features 🚀

Fast execution, averaging 0-10 seconds.
Leverages either Github's REST API or…

View on GitHub

And after customizing some options like filter only *.py files, I was able to run mypy passing the changed files as argument.

It's worth to mention that I needed to include --ignore-missing-imports argument to mypy because I'm not scanning the whole repo, only some files. The goal of course is to check them all. However, a lot of fixes should be made before it's ready.

This solution can be very useful to you if you want to include static type checking for new files on a legacy project where existing files will be fixed little by little.



name: "mypy check"
on: [pull_request]

jobs:

  static-type-check:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - uses: actions/setup-python@v3
      with:
        python-version: '3.x'
    - run: pip install mypy  # you can pin your preferred version
    - name: Get Python changed files
      id: changed-py-files
      uses: tj-actions/changed-files@v23
      with:
        files: |
          *.py
          **/*.py
    - name: Run if any of the listed files above is changed
      if: steps.changed-py-files.outputs.any_changed == 'true'
      run: mypy ${{ steps.changed-py-files.outputs.all_changed_files }} --ignore-missing-imports

Happy type-safety!

How to add type annotations to SQLAlchemy models

Carlos V. — Mon, 21 Mar 2022 13:07:02 +0000

For a long time, I’ve been advocating for using type annotations in languages like Python because of its benefits. To mention some we can improve the robustness, testability, and scalability of our applications. Just as important, we can reduce the number of unit tests that we need to write. The goal is to reduce bugs at run-time. This technique can be used in languages with a strong type system.

Does Python have a strong type system? Of course! This type-safety example is a simple demonstration of this statement:



>>> foo = 5
>>> bar = 'hello'
>>> foo + bar
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>>

People tend to think that while Python is a dynamic "interpreted" language (spoiler alert: it's not), the type system is weak, with similar behavior of JavaScript's implicit type coercion:



Welcome to Node.js v16.13.2.
Type ".help" for more information.
> foo = 5
5
> bar = 'hello'
'hello'
> foo + bar
'5hello'
>

Going back to Python and its type annotations feature, you might have a medium-sized project that needs to use database storage. However, it's common to leave that part out of our safe and sound type annotations. But fear not, you can also annotate your models. In this example, I'm going to show you a small example using Flask and SQLAlchemy.

Some time ago, I built a tiny sample project to demonstrate TDD on Flask. Let’s use it as a starting point for this tutorial. This example will have a small model for storing notifications in a database and a couple of endpoints to get/post some data.

We’re going to use Flask-SQLAlchemy, which provides a quick integration between the framework and the ORM. So after setting up the initialization we can start writing a model:



from flask_sqlalchemy.model import DefaultMeta


BaseModel: DefaultMeta = db.Model


class Notification(BaseModel):
    __tablename__ = "notifications"

    id = Column(Integer, primary_key=True, index=True)
    description = Column(String(100))
    email = Column(String(100), nullable=False)
    date = Column(DateTime, nullable=False)
    url = Column(String(200))
    read = Column(Boolean, default=False)

We can explain some details here:

Why the BaseModel definition? Answer: We're using mypy for the static type checking. Defining a model as Flask-SQLAlchemy suggests causes an issue on that line because the declarative base db.Model is defined dynamically (on runtime) contrary to what a static checker expects.
Flask-SQLAlchemy suggests that we can use db.Column or db.Integer to define our properties, but we won't follow that convention. The reason behind this decision is because Flask-SQLAlchemy does a lot of work dynamically on runtime that can confuse the static type checking system. To avoid that, we are using SQLAlchemy classes directly.

The static type checker combination will be mypy and sqlalchemy-stubs plugin.

Just install them with pip:



pip install mypy
pip install sqlalchemy-stubs

And create a mypy.ini file on the root of the project:



[mypy]
python_version = 3.9
ignore_missing_imports = True
plugins = sqlmypy

Then you're ready to do some static type check analysis to the Python file:



mypy app.py

We're going to expand this model a bit. First, we need a method to "serialize" the model into a dict so it can be returned in the endpoint. Also, we need a couple of methods to get all the records filtered by some criteria.

We will define a NotificationModel dictionary definition.



class NotificationModel(TypedDict):
    id: int
    description: Optional[str]
    email: str
    date: datetime
    url: Optional[str]
    read: bool

Then, our basic serialization method for the Notification model will look like this.



def to_dict(self) -> NotificationModel:
    return {
        "id": self.id,
        "email": self.email,
        "description": self.description,
        "date": self.date,
        "url": self.url,
        "read": self.read,
    }

Here you can see the type annotations in action. Either with a properly configured editor (like VSCode) or with the mypy command, types should match between what to_dict returns and the NotificationModel definition, otherwise the analysis will fail.

Example: if the to_dict method returns a string value on the id property



def to_dict(self) -> NotificationsModel:
        return {
            "id": str(self.id),  # <-- should not be str

Then the error we get will be the following.



app.py:38: error: Incompatible types (expression has type "Optional[str]", TypedDict item "id" has type "int")
Found 1 error in 1 file (checked 1 source file)

Next, we will implement a couple of class methods that will return all the records on the table and another to get only the unread notifications:



@classmethod
def get_all(cls) -> list[Notification]:
    return db.session.query(cls).all()

@classmethod
def get_unread(cls) -> list[Notification]:
    return db.session.query(cls).filter(Notification.read.is_(False)).all()

A key point here in order for a method to return its same class is to have this line on top of the module. See postponed evaluation of annotations for more details.
from __future__ import annotations

At this point, we have our model ready to be used on a presentation layer.

Let's implement a /notifications endpoint that accepts two methods, GET to list all notifications, and POST to save a new one with form data:



@app.route("/notifications", methods=["GET", "POST"])
def notifications() -> Response:
    if request.method == "POST":
        new_notification = Notification(
            **dict(request.form, date=datetime.fromisoformat(request.form["date"]))
        )
        db.session.add(new_notification)
        db.session.commit()

    notifications = Notification.get_all()
    return jsonify([notification.to_dict() for notification in notifications])

We implemented another route to get all unread notifications but it's pretty similar to the GET section of the above endpoint. You can review the entire sample project in this repository:

po5i / flask-mini-orm

How to use type annotations on a SQLAlchemy project

Mini example of Flask ORM with SQLAlchemy

This is a example repository for my article.

Setup

Create and activate the virtual environment

virtualenv venv
source venv/bin/activate

Run the server

python app.py

Run the static type check

mypy app.py

The server will be up on http://localhost:5000 and a database file named db.sqlite3 is created.

How it works

The toy API has four endpoints:

Endpoint	Description
`GET /`	Returns hello world
`GET /notifications`	Returns all notifications
`POST /notifications`	Adds a notification on the DB
`GET /notifications/unread`	Returns all unread notifications

If you want to add a notification on the DB, you can use this cURL command:

curl -X POST \
  'http://localhost:5000/notifications' \
  --header 'Accept: */*' \
  --form 'description="Foo"' \
  --form 'date="2022-03-20T18:09:22"' \
  --form 'url="http://foo.bar.com"' \
  --form 'email="foo@bar.com"'

Requirements

Python >= 3.9

License

MIT

View on GitHub

The usage of these endpoints is beyond the scope of this post. They were only implemented to demonstrate and test the SQLAlchemy Notification model. I also like to point out that this example has everything implemented in a single module. We recommend you to (1) split your models and (2) use a migration tool such as Alembic. Last but not least, (3) test your logic with unit tests. We didn’t add them but feel free to propose some as pull requests. In the meantime, we configured the CI workflow with the mypy type checking.

I encourage you to use a better tool to implement REST APIs like I did on a previous post:

How to set up a REST API in Flask in 5 steps

Carlos V. ・ Nov 5 '21

#python #rest #api #flask

Are you using Django? There are also some stubs ready to annotate your models: django-stubs and djangorestframework-stubs than can suit your needs. Let me know if you want to read some content about them.

Thanks for reading 🙇

Edit: Article also cross-posted here.

How to generate a TypeScript client from a Swagger documented API

Carlos V. — Mon, 15 Nov 2021 22:04:32 +0000

In my previous tutorial, I built a simple REST API with Swagger documentation. Check it out:

How to set up a REST API in Flask in 5 steps

Carlos V. ・ Nov 5 '21

#python #rest #api #flask

In this tutorial, I will generate a TypeScript client code based on the Swagger documentation and use it on a simple React application (it can be any front-end application).

Why we want to do something like this? First of all, it's better to have one a single source of truth for the contracts in our server-client architecture. Otherwise, one change can break all our consumers.

For this process, I'm gonna use swagger-typescript-api. I've seen this tool constantly evolving throughout the last year, its maintainers are doing an awesome job.

First of all, I bootstrap a React app using create-react-app (CRA) with a TypeScript template, of course 💅



npx create-react-app react-mini-swagger-client --template typescript

Somewhere else, I have my previous flask-mini-rest up and running in localhost:5000. (Recently I pushed some changes in order to support CORS and improve the Swagger model documentation).

CRA places all the source files inside ./src directory, so I will generate my TS client there.



npx swagger-typescript-api -p http://127.0.0.1:5000/api/v1/swagger.json -o ./src/apiClient --modular

swagger-typescript-api is pretty cool, it can be run with npx and it support many flags documented in its repo. It generates 3 files for my API

File	Description
`Items.ts`	It exports the main client to be used on our application. Each method of the `Items` class is one public endpoint. Types were read from the Swagger docs.
`data-contracts.ts`	Are the API models or return types.
`http-client.ts`	This is the code responsible to actually fetch the data to the server.

Let's start the development server:



npm start

Now it comes the interesting part. How to use the generated TS client. I'm going to write some simple examples on how to use the TS client in the src/App.tsx file which is the only one with the bootstrapped app logic.

Let's initialize the API client which is declared in the Items.ts module:



const api = new Items({
  baseUrl: "http://localhost:5000/api/v1",
});

If your app is running a in a production server, the baseUrl path should point to the appropriate API URL.

To get all the Items:



const res = await api.getItemsApi();
setItems(res.data);  // This set the response to the `items` state

Let's suppose we want to insert a new item in the API in a form button:



<button
  onClick={async () => {
    const item: Item = {  // `Item` is imported from the data-contracts
      id,  // this is a variable with the form input
      name,  // this is a variable with the form input
    };
    await api.postItemsApi(item);
    props.setItems([...props.items, item]);
  }}
>
  Add
</button>

It's pretty similar with the getItemApi which gets a simple Item resource.

As you can see, it's pretty simple to use, self-documented and strongly-typed. Having a well defined back-end contract you can ensure robustness and type-safety front-end communication. The types generated can be used in many ways, TypeScript project references for example. Types can be shared among many consumers. My friend and mentor, Fernanda, presented a great talk in this topic called Don't Break the Contract: Keep Consistency with Full Stack Type Safety, please give it a look.

Also, an automated job can generate the a new TS client triggered by some event. But still it's up to us to update the consumers. Hopefully the unit tests can detect breaking changes.

Check out a full working code in my repo. Sorry that I didn't follow all the best practices as I only wanted to show how to use this TS client.

po5i / react-mini-swagger-client

Mini example of swagger-typescript-api

This project was bootstrapped with Create React App.

npx create-react-app react-mini-swagger-client --template typescript

And API client was generated with swagger-typescript-api.

npx swagger-typescript-api -p http://127.0.0.1:5000/api/v1/swagger.json -o ./src/apiClient --modular

... while running flask-mini-rest app.

Run the app

In the project directory, you can run:

npm start

Runs the app in the development mode.
Open http://localhost:3000 to view it in the browser.

The page will reload if you make edits.
You will also see any lint errors in the console.

License

MIT

View on GitHub

How to set up a REST API in Flask in 5 steps

Carlos V. — Fri, 05 Nov 2021 22:07:25 +0000

This small tutorial was built on top of my previous code sample that configures a simple Flask app with testing:

How to add basic unit test to a Python Flask app using Pytest

Carlos V. ・ May 18 '20

#python #testing

There are many ways to build REST APIs, the most common is to have a Django app with DRF. Other people are trying FastAPI (I need to take a closer look at it, maybe in a future post).

But if you are using a Flask based app, I recently tried Flask-RESTX library which includes some great features:

Swagger documentation (Heck yes!)
Response marshalling
Request parsing
Error handling, logging and blueprint support. Neat Flask integration.

In this demo, I'll show you how to set up a quick REST API, with Swagger documentation, request parsing and simple response formatting.

Let's start by initializing the blueprint and defining the api object in a new module. I named this one as api.py.



blueprint = Blueprint("api", __name__, url_prefix="/api/v1")

api = Api(
    blueprint,
    version="1.0",
    title="Mini REST API",
    description="A mini REST API",
)
ns = api.namespace("items", description="Item operations")
api.add_namespace(ns)

Flask-RESTX support Flask Blueprint and they are really simple to implement.

My application is served at http://localhost:5000 but my API base URL will be http://localhost:5000/api/v1. This is also the page where you can find the Swagger docs.

Next, let's write the base models. My sample API will manage Items and Details objects, so I need to write the models that will be in charge of presenting them in the API standard response.



detail_model = api.model("Detail", {"id": fields.Integer, "name": fields.String})
item_model = api.model(
    "Item",
    {
        "id": fields.Integer,
        "name": fields.String,
        "details": fields.List(fields.Nested(detail_model)),
    },
)

The idea of writing models is to use Flask-RESTX response marshalling, so no matter if our objects scale, the response will always be as we document it on our models. Flask-RESTX includes a lot of tools for this such as renaming attributes, complex, custom, and nested fields, and more.

The final set up step is to write the request parser.



item_parser = api.parser()
item_parser.add_argument("id", type=int, location="form")
item_parser.add_argument("name", type=str, location="form")

detail_parser = api.parser()
detail_parser.add_argument("id", type=int, location="form")
detail_parser.add_argument("name", type=str, location="form")

In a similar way as before, we make use of Flask-RESTX request parser to read and validate values that we expect to receive in our endpoints. In this case I plan to implement two object APIs that will append elements to our database objects. (Our database is a simple in-memory object 😅)



memory_object = [
    {
        "id": 1,
        "name": "Item 1",
        "details": [
            {"id": 1, "name": "Detail 1"},
            {"id": 2, "name": "Detail 2"},
        ],
    }
]

Now it's time to implement our APIs. The first API I want to build is the one that manages the items. I will call this ItemApi and the route will be / which means the root of the namespace items.



@ns.route("/")
class ItemsApi(Resource):
    """
    API for handling the Item list resource
    """

    @api.response(HTTPStatus.OK.value, "Get the item list")
    @api.marshal_list_with(item_model)
    def get(self) -> list[Item]:
        """
        Returns the memory object
        """
        return memory_object

    @api.response(HTTPStatus.OK.value, "Object added")
    @api.expect(item_parser)
    def post(self) -> None:
        """
        Simple append something to the memory object
        """
        args = item_parser.parse_args()
        memory_object.append(args)

This will enable two endpoints:

Endpoint	Method	Parameters	Returns
`/api/v1/items/`	GET	None	list of `item_model`
`/api/v1/items/`	POST	As defined on `item_parser`	None

All decorators are provided by Flask-RESTX. HTTPStatus class is provided by the http module. Pretty simple huh?, let's build the second one.

This one will manage a single item resource. So, to get its data and add details we need the following implementation:



@ns.route("/<int:item_id>")
class ItemApi(Resource):
    """
    API for handling the single Item resource
    """

    @api.response(HTTPStatus.OK.value, "Get the item list")
    @api.response(HTTPStatus.BAD_REQUEST.value, "Item not found")
    @api.marshal_with(item_model)
    def get(self, item_id: int) -> Item:
        """
        Returns the memory object
        """
        try:
            return self._lookup(item_id)
        except StopIteration:
            return api.abort(HTTPStatus.BAD_REQUEST.value, "Item not found")

    def _lookup(self, item_id):
        return next(
            (item for item in memory_object if item["id"] == item_id),
        )

    @api.response(HTTPStatus.NO_CONTENT.value, "Object added")
    @api.response(HTTPStatus.BAD_REQUEST.value, "Item not found")
    @api.expect(detail_parser)
    def post(self, item_id: int) -> None:
        """
        Simple append details to the memory object
        """
        args = item_parser.parse_args()
        try:
            if item := self._lookup(item_id):
                item["details"].append(args)
            return None
        except StopIteration:
            return api.abort(HTTPStatus.BAD_REQUEST.value, "Item not found")

This will enable two more endpoints:

Endpoint	Method	Parameters	Returns
`/api/v1/items/<item_id>`	GET	None	a single `item_model` resource.
`/api/v1/items/<item_id>`	POST	As defined on `detail_parser`	None

To wrap up our application, you only need to import the module at app.py and register the Blueprint.



from api import blueprint

app = Flask(__name__)  # This line already exists
app.register_blueprint(blueprint)

You can fork and play with this example using this repo:

po5i / flask-mini-rest

Mini example of Flask and Flask-RESTX

This is a examle repository for my article.

Setup

Create and activate the virtual environment

virtualenv venv
source venv/bin/activate

Run the server

FLASK_ENV=development flask run

Check out the Swagger documentation and playground at

http://localhost:5000/api/v1/

Run the tests

python -m pytest

The server will be up on http://localhost:5000 and the API landing page will be available on http://127.0.0.1:5000/api/v1/.

Requirements

Python >= 3.9

License

MIT

View on GitHub

I also added some unit tests and type annotations for your delight 😉.

Any feedback or suggestions are welcome and I'll be happy to answer any question you may have.

Functional Programming inside OOP? It’s possible with Python

Carlos V. — Tue, 28 Sep 2021 14:30:59 +0000

I'm sharing my EuroPython 2021 talk today.

Please enjoy!

Manage technical debt as a project

Carlos V. — Wed, 27 Jan 2021 19:58:46 +0000

Imagine you spot technical debt items in your project that you need to work on anytime. Sometimes is confusing to manage them all in the PM tool of choice, specially when there will be temporary team members that get access to the repository only.

My suggestion is to use Github Project boards. This is a powerful tool to manage repository issues, assign them to developers, keep track of their work status and create discussion spaces.

Give them a try!

Always use semantic HTML inputs

Carlos V. — Fri, 08 Jan 2021 13:29:40 +0000

I know sometimes is tedious to use a correct component for requesting a user input in HTML. But using the proper component will significatively enhance the user experience and it's easier to see it in action while in mobile devices.

Today I Learned that you can step x decimal in an input type="number". Let's say you want to ask for a price:

<input type="number" required name="price" min="0" value="0" step="any">

If you omit the step="any" part, the input will validate only for integer values.

But if you use instead:

step=".01"

Then, every time you click on the arrows, the value will be updated to ±0.01. Pretty handy isn't it?

Python decorator to measure function's execution time

Carlos V. — Fri, 18 Dec 2020 20:03:36 +0000

I know we do some manual debugging from time to time. I got inspired from some Stack Overflow answers and blogposts to write this decorator

Now, you just need to import it in your code and write something like:

@measure
def foo:
    some_large_computation()

Output:

Total execution time foo: 15 ms

If you want a smaller time unit, use 1000000 instead of 1000 factor to get microseconds (μ)

I hope this can be any help.

Hacktoberfest in Ecuador

Carlos V. — Wed, 14 Oct 2020 21:10:38 +0000

How am I supporting the open-source collaboration?

Last year, I had the initiative of celebrating a small Hacktoberfest with our teammates. We merged around 28 contributions to open source projects and everyone was happy because our company rewarded them with nice gifts.

For this year we wanted to encourage the Ecuadorian community to support open source projects by creating a one-month agenda full of talks, catch-ups, communication channels, and prizes. We called it Stacktoberfest! Fingers crossed 🤞 for the open-source projects to get a lot of contributions.

Sadly, there are communities that cheer their members to contribute their own repos and give them stars, which are not open source projects (e.g. their website's readmes 😒). Let's remember that open source is a way to reuse, modify, and redistribute code.

Anyways, this is an open call to end spam and do true contributions. Don't do it (only) for the shirt. And remember, you can opt to plant a tree. Check this cool article:

Hacktoberfest - through a different lens. 🌳

Vaibhav Khulbe ・ Oct 9 '20 ・ 8 min read

#hacktoberfest #opensource #github #discuss

Exploring Pyright

Carlos V. — Fri, 11 Sep 2020 22:18:48 +0000

Are you using Python type annotations? Having fun with mypy? Microsoft created some years ago yet another static type checker called Pyright.

microsoft / pyright

Static Type Checker for Python

Pyright is a full-featured, standards-based static type checker for Python. It is designed for high performance and can be used with large Python source bases.

Pyright includes both a command-line tool and an extension for Visual Studio Code.

Documentation

Refer to the documentation for installation, configuration, and usage details.

Community

Do you have questions about Pyright or Python type annotations in general? Post your questions in the discussion section.

If you would like to report a bug or request an enhancement, file a new issue in either the pyright or pylance-release issue tracker. In general, core type checking functionality is associated with Pyright while language service functionality is associated with Pylance, but the same contributors monitor both repos. For best results, provide the information requested in the issue template.

Contributing

This project welcomes contributions and suggestions. For feature and complex bug fix contributions…

View on GitHub

Some devs said it has a very great speed compared to mypy. I haven't used for any of my project's CI pipeline yet but I have this VSCode extension which, if you use this editor for your Python projects, you will be grateful on how it catches bugs caused by typing issues. So far it catches more issues than mypy and its messages are somehow clearer.

Being both VSCode and Pyright built with JavaScript (yes, Pyright was written in JS), their integration is pretty sweet. Although you can integrate to your favorite editor (vim, emacs, etc...).

The CLI is pretty similar to mypy. I'd suggest to give it a try and let me know how was your experience using it.

Wanna know how to start using type annotations in Python? Check out my tutorial published by Stack Builders.

Do we need more than NPM?

Carlos V. — Tue, 09 Jun 2020 20:43:23 +0000

ekalinin / nodeenv

Virtual environment for Node.js & integrator with virtualenv

Node.js virtual environment

nodeenv (node.js virtual environment) is a tool to create isolated node.js environments.

It creates an environment that has its own installation directories that doesn't share libraries with other node.js virtual environments.

Also the new environment can be integrated with the environment which was built by virtualenv (python).

If you use nodeenv feel free to add your project on wiki: Who-Uses-Nodeenv.

Install

Global installation

You can install nodeenv globally with easy_install:

$ sudo easy_install nodeenv

or with pip:

$ sudo pip install nodeenv

or on Debian using dpkg:

$ ln -s debian-upstream debian
$ dpkg-buildpackage -uc -us -b
$ sudo dpkg -i $(ls -1rt ../nodeenv_*.deb | tail -n1)

Local installation

If you're using virtualenv then you can install nodeenv via pip/easy_install inside any virtual environment built with…

View on GitHub

Why things like these exist, if we can create deterministic isolated environment by just using NPM?

This reminds me of this funny meme:

po5i

@po5i

Why?

21:38 PM - 07 Jun 2020

DEV Community: Carlos V.

Parallelism in Python starter pack

Parallelism in Python starter pack | by Carlos Villavicencio | Globant | Medium

Carlos Villavicencio ・ Jul 6, 2022 ・ Medium

GitHub Action to run mypy on changed files only

tj-actions / changed-files

:octocat: Github action to retrieve all (added, copied, modified, deleted, renamed, type changed, unmerged, unknown) files and directories.

changed-files

Table of contents

Features 🚀

How to add type annotations to SQLAlchemy models

po5i / flask-mini-orm

How to use type annotations on a SQLAlchemy project

Mini example of Flask ORM with SQLAlchemy

Setup

How it works

Requirements

License

How to set up a REST API in Flask in 5 steps

Carlos V. ・ Nov 5 '21

How to generate a TypeScript client from a Swagger documented API

How to set up a REST API in Flask in 5 steps

Carlos V. ・ Nov 5 '21

po5i / react-mini-swagger-client

Mini example of swagger-typescript-api

Run the app

License

How to set up a REST API in Flask in 5 steps

How to add basic unit test to a Python Flask app using Pytest

Carlos V. ・ May 18 '20

po5i / flask-mini-rest

Mini example of Flask and Flask-RESTX

Setup

Requirements

License

Functional Programming inside OOP? It’s possible with Python

Manage technical debt as a project

Always use semantic HTML inputs

Python decorator to measure function's execution time

Hacktoberfest in Ecuador

How am I supporting the open-source collaboration?

Hacktoberfest - through a different lens. 🌳

Vaibhav Khulbe ・ Oct 9 '20 ・ 8 min read

Exploring Pyright

microsoft / pyright

Static Type Checker for Python

Static Type Checker for Python

Documentation

Community

Contributing

Do we need more than NPM?

ekalinin / nodeenv

Virtual environment for Node.js & integrator with virtualenv

Node.js virtual environment

Install

Global installation

Local installation

Carlos Villavicencio ・ Jul 6, 2022 ・
Medium