DEV Community: Shane Nolan

Decoupling Python Code: Implementing the Unit of Work and Repository Pattern

Shane Nolan — Fri, 24 Feb 2023 15:58:19 +0000

The repository and unit of work architectural patterns are utilised to create loosely coupled abstractions between the data access and business logic layers. Implementing these patterns helps insulate your application from changes, facilitates automated unit testing or test-driven development (TDD) and makes it easier to manage and maintain over time.
When introducing an architectural pattern, a cost-benefit analysis should be performed. Repositories are an excellent example of this; they add low-level complexity but reduce high-level complexity, meaning each domain object will need its own repository class. In return, a simple interface over the data access layer is provided. A concrete implementation would look something like this:

Concrete Implementation of the Repository and Unit of Work Architectural Patterns.

Repository Pattern

The repository is a layer that sits between the business logic of the application and the data storage and is responsible for retrieving and storing data. Every repository will have two methods: add()to store an object and get_by_id(id: int) to retrieve a stored object by its ID. I prefer to use generics since implementation logic is mostly the same and prevents code duplication.

Generic Repository Interface.

This implementation uses an Account model class with a username and password field. Since Account is a domain model, it requires a repository. Repositories can have a variety of unique methods to query the backend. For example, IAccountRepository has an additional method: get_all() to return all accounts.

Concrete AccountRepository Implementation.

The AccountRepository is loosely coupled to SQLAlchemy's Session class through the use of Dependency Injection via its constructor and inherits the IAccountRepository interface. This is important because, let's say, a future feature requires a NoSQL backend database. It can be easily implemented by passing the NoSQL database context into a repository class and implementing the interface without any change to high-level modules.

Unit of Work Pattern

The unit of work implementation is responsible for managing the changes made to a set of objects. It tracks the changes made to these objects and, when asked, can commit or roll back the changes as a single transaction. Put simply; it ensures that multiple repositories share a single database context. That way, when a unit of work is committed, all related changes will be coordinated and saved.

Interface for the UnitOfWork Pattern.

The IUnitOfWork interface provides access to the AccountsRepository through its public account attribute. The enter magic method retrieves a session, normally from a session factory. For example, SQLAlchemy has sessionmaker. The exit magic method handles rolling back any changes and closing the session.

Concrete UnitOfWork Implementation.

For demonstration purposes, let's assume there's a requirement to get the sum of all account balances. This can be easily implemented by using the UnitOfWork class, calling the AccountRepository.get_all() method and adding each account's balance together.

Implement to get the Sum Of All Account Balances.

In summary, the unit of work and repository design pattern are powerful techniques for decoupling code in Python. These patterns provide a modular, reusable approach to organizing code that promotes maintainability and testability and helps developers build more robust and flexible applications by separating concerns. Thus, these patterns are excellent choices for anyone looking to write clean, decoupled and maintainable code in Python.

Thanks for reading 🙌. You can find me on Linkedin or Github if you want to connect with me.

References:
Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices
Implementing the Repository and Unit of Work Patterns in an ASP.NET MVC Application

Loosely coupled Python code with Dependency Injection

Shane Nolan — Wed, 09 Nov 2022 23:55:09 +0000

Loosely coupled Python code with Dependency Injection

Software has to be flexible in order to respond to change. Dependency injection is a technique for managing the dependencies between software components. It is a design pattern that uses inversion of control to provide the ability to swap out components for testing or other purposes without changing any other part of the system.

The main idea behind dependency injection is to pass the responsibility for providing services from constructor functions or direct instantiation methods onto other objects. In other words, an object is given its dependencies instead of creating them. This way, if we want to add new features, we don’t have to change the existing code but instead, pass new dependencies into it.

Creating Abstractions with Interfaces

There are three steps in writing loosely coupled Python code with dependency injection. The first step is to identify what dependencies the code needs, the second step is to create interfaces for each dependency, and the third step is to pass them into the dependent object through its constructor or method parameters.

Recently, I implemented functionality that required a byte encoder and decoder to manipulate business data (I’ve simplified its implementation for readability purposes). I abstracted out their responsibilities to interfaces. Python doesn’t have an interface keyword like Golang, but you can replicate interface functionality with the ABC library.

Focusing on the IPacketEncoder interface, a concrete encoder class must implement it. The initial business requirements required all types to be encoded and strings to be padded with their length. Luckily, Python provides the struct library to do most of the hard work.

Implementing Dependency Injection

The encode_name function is a simple implementation for creating an encoded payload with the specified name. It takes an IPacketEncoder object and a string as parameters.

The two key implementation details are using the IPacketEncoder interface instead of the PaddedPacketEncoder concrete class and encoder is an argument rather than being initialized inside the function. This is dependency injection. Because IPacketEncoder is passed in, it can be easily extended, changed or provided with a stub, thus keeping the system loosely coupled.

A few weeks later, there was a new requirement for an encoder to handle null terminated encodings. Luckily, due to the existing implementation, it can be easily implemented.

NullTerminatedPacketEncoder essentially adds NULL_BYTE after each encoded string. Going back to the encode_name function, an instance of NullTerminatedPacketEncoder is a valid encoder argument since NullTerminatedPacketEncoder implements the IPacketEncoder interface similarly to PaddedPacketEncoder.

If dependency injection wasn’t used here, it could result in code that is tightly coupled and difficult to change, for example:

If a new encoder is required, the encode_name function will have to be changed almost entirely along with its tests, extending delivery times. What’s worse, it could result in hidden side effects, especially if the original developer is no longer available.

To conclude, I’ll provide a less simplistic example using this technique. SocketService is responsible for decoding an operation code, calling its relevant handler and returning its result. All of its argument types are interface abstractions, including its constructor. The CLI is responsible for determining which encoder to use, i.e. NullTerminated or Padded, and passing its instance down to the SocketService class.

As projects continue to grow, its recommended to utilise a dependency injection framework to “inject” these dependencies automatically, such as Dependency Injector.

Hopefully, this demonstrates how to write loosely coupled Python code with dependency injection. Many Python developers dislike dependency injection because they feel it's not “pythonic”, but I would argue that its benefits can’t be discredited, especially when it's present in so many other programming languages.

Thanks for reading 😊. If you would like to connect with me, you can find me on Linkedin or Github.

Creating an HTTPS Lambda Endpoint without API Gateway

Shane Nolan — Fri, 15 Apr 2022 19:32:57 +0000

Amazon Web Services (AWS) recently announced Function URLs, a new in-built feature that allows you to invoke your functions through an HTTPS endpoint. By default, the endpoint is secure using AWS Identity Access Management (IAM) but you can allow public access with optional Cross-Origin Resource Sharing (CORS) configurations and/or custom authorisation logic. Originally, if you wanted to invoke a Lambda function publicly via HTTPS you would need to set up and configure AWS API Gateway or AWS Elastic Load Balancing and pay additional fees once you exceeded their free tier. Fortunately, Function URLs don't incur an additional cost 🎉. I’d recommend you continue to use these services if you’re building a serverless REST API or require additional features such as request-response transformations. For small use-cases such as webhooks or determining the price of a cryptocurrency, Function URLs are more suited.

This blog post will demonstrate how to create an HTTPS Lambda endpoint using Function URLs, Python and Terraform, an open-source infrastructure as code tool. If you’d rather not use Terraform, Function URLs can be created directly via the AWS user interface (UI). You can follow the official AWS guide here. You can use any compatible programming language with AWS Lambda for this demonstration since the principles are the same. You can view the project's source code on Github.

Python Lambda Function

First, create a Python project with main.py being the entry point for Lambda. I recommend using this modern Python development environment for a more straightforward implementation but your own will suffice. This project will use the Python version 3.9.0 . You can view a list of supported versions here. Your project directory structure should replicate this:

.
├── .editorconfig
├── CHANGELOG.md
├── README.md
├── lambda_function_url_terraform
│   ├── __init__.py
│   └── main.py
├── poetry.lock
├── pyproject.toml
├── setup.cfg
└── tests
    ├── __init__.py
    └── test_main.py

2 directories, 10 files

For this example, the main.py Lambda handler will return a JSON object with a body containing a message and status code of 200.

To ensure the Lambda handler is working as expected write a unit test in tests/test_main.py to validate its response.

Terraform Deployment

If you don’t have Terraform already installed, you can follow the official installation documentation. Once installed, confirm the installation was successful by executing:

First, create the required Terraform deployment file main.tf at the top level of your Python project. Declare 1.0.0 as the Terraform version and 4.9.0 as the Hashicorp AWS provider version since that's when Function URLs functionality was implemented. You can review the merge request here. Next, declare the AWS region, for example eu-west-1 . Once declared main.tf should look like this:

Before the Lambda function can be implemented, an IAM role with a trust policy needs to be created. In this case, the AWS Lambda service will be trusted and allowed to call the AWS Security Token Service (STS) AssumeRole action. Append the IAM role resource to main.tf file. Its implementation should look like this:

Execute the following commands to create a zip file called package.zip containing the projects source code and its requirements for Lambda:

# Install zip package to zip files/folders:
sudo apt-get install zip

poetry build; 
poetry run pip install --upgrade -t package dist/*.whl;
(cd package; zip -r ../package.zip . -x '*.pyc';)

# Pip installation without Poetry or zip:
pip freeze > requirements.txt
pip install -r requirements.txt -t package
# zip the package folder.

Once packaged the Lambda function is ready to be implemented. Depending on your setup you may need to modify the following attributes:

runtime depending on your Python version.
function_name the name you want to give your Lambda function.
handler the path to your Lambda handler.

The Lambda function resource should look like this:

The filename attribute is the filename along with the extension of our packaged project. Similarly, the source_code_hash attribute is used to determine if the packaged project has been updated, i.e. a code change. The role attribute is a reference to the previously implemented IAM role. Append the Lambda function to main.tf .

Lastly, create the Function URL resource and save the generated URL.The authorization_type is set to NONE , meaning it allows public access. You have the option of restricting access to authenticated IAM users only, as well as CORS configuration capabilities. You can read about them here. The Lambda Function URL resource should look like this:

The output resource function_url saves the generated Function URL. Append both the Function URL and output resource to main.tf . With all the Terraform components together, main.tf should replicate this:

Deploying with Terraform requires only a single command after the infrastructure is coded but first, you need to initialise Terraform inside of the project by executing terraform init . Additionally, set your AWS_ACCESS_KEY_ID , AWS_SECRET_ACCESS_KEY and AWS_REGION via the command line. If you’re unfamiliar with configuring your AWS credentials you can read more about it on the official AWS and Terraform documentation.

Once initialised, deploy your Lambda function using terraform apply and accept the confirmation of the required changes. After deployment, it will output the Lambda Function URL 🎉.

Test the public endpoint by either opening the URL in a browser or using an API testing tool such as httpie. The below example uses Terraform to retrieve the generated Function URL via terraform output and a GET request is submitted to the URL via httpie.

Developing my first financial app using React Native, Redux, Figma and FastAPI

Shane Nolan — Tue, 12 Apr 2022 15:57:09 +0000

Nowadays it's normal to have multiple bank accounts, especially with apps such as Revolut becoming a huge success in Ireland. The problem my friends and I find with having multiple bank accounts is, it’s difficult to easily manage our finances. I decided to resolve this problem by designing and developing my first app called Bank Balance, which will instantly tell me my balance across multiple banks, including my savings.

The tech stack I decided on using was Expo React-Native for its cross-platform functionalities, Redux for state management and FastAPI for the Orchestration Layer. Figma was used for UI/UX prototyping. I had no previous experience using any of these technologies besides FastAPI but I’m always up for the challenge.

The initial prototype was designed using Figma and has two screens. The login screen has a single button that starts the authorisation process and upon successful authorisation, the home screen is displayed with the user's bank accounts and their corresponding balances.

Before I began App development I needed to create an Orchestration Layer using FastAPI (a modern, fast, web framework for building APIs with Python) to secure my secret keys provided by TrueLayer since apps can be reverse-engineered. Bank Balance uses TrueLayer to access users' financial data securely since TrueLayer adheres to all the Open Banking regulations. Access tokens provided after authentication are stored securely via Keychain on iOS and Keystore on Android.

The Orchestration Layer has two endpoints, /exchange and /refresh . The exchange endpoint returns an access token to the requested bank account and refresh renews the access token once it has expired. Each bank has a different threshold for how long their access tokens are valid.

By default, iPhone will block any request that is not using SSL (https://developer.apple.com/forums/thread/3544), meaning the App was prevented from making requests to the Orchestration Layer. Therefore, I generated an SSL certificate to provide the layer using mkcert, a simple tool for making locally-trusted development certificates.

It's important to retrieve and create the SSL certificate for your IPv4 Address because that's the IP address the App will use to access the Orchestration Layer. Additionally, the mkcert root certificate needs to be installed and trusted. The cert can be located by running mkcert -CAROOT .

After the Orchestration Layer was deployed I implemented logic to communicate with True Layers APIs and the Orchestration Layer. Using createSlice a function provided by the @reduxjs/toolkit library, I created two reducers, token and account . createSlice hides some of Redux’s complexity and removes boilerplate code. The token reducer is responsible for handling tokens provided by the orchestration layer and account is responsible for handling account information such as bank balance.

The fetchAccessToken function uses createAsyncThunk to return a thunk action creator meaning “a piece of code that does some delayed work” wrapped in a promise, enabling chaining through the use of .then(). The token reducer uses the expo-secure-store library to securely store token information and the account reducer uses the@react-native-async-storage/async-storage library to store account information.

Implementing the logic screen was rather difficult because Expo’s authentication library expo-auth-session would not trigger its linking callback once redirected by the testing TrueLayer environment (it would trigger in the sandbox TrueLayer environment since the app never opened another app i.e. Revolut). Therefore, I created a customisable authorisation component with callback linking functionality.

The CSS style is passed into the authorisation component via the prop buttonStyle and its children are also rendered. For example, the login screen utilises the authorisation component like so:

The home screen was the last to implement. I decided to give the initial prototype a slight revamp to look more like a balance sheet. Displaying the relevant accounts required the chaining of API requests and transforming. The API chaining worked as follows, for each access token (bank account), retrieve the permitted accounts and for each permitted account retrieve its bank balance. Then, merge each bank account with its relevant bank balance and transform the required information i.e. convert balances into local currency.

Up until now the user only had the option to link one bank account via the login screen. I added a plus button to the top right corner that implements the authorisation used previously for the login screen, reusing functionality, adhering to the DRY (do not repeat yourself) software development principle, and saving development time but increasing complexity slightly.

You can view a video demonstration here.

To conclude, this project was a lot of fun but I decided not to deploy it because of the costs involved (Apple Developer Program Fee and Orchestration Layer API fees). I had additional ideas/features for the next iteration which were:

Remove a linked bank account.
Insights such as daily spending across accounts, forecasted spending, etc.
User profiles.
Link multiple bank accounts upon initial login.

Working with all these new technologies was a lot of fun but I would use Typescript for future apps since code readability and maintainability was a concern as the code base grew. Older code examples of Redux had a lot of repetitive code but the @reduxjs/toolkit library removes a significant amount of it. I found Redux to be overkill for this app and unnecessary complexity but if I were to continue with development it would become extremely beneficial since passing props to children would become a nightmare to maintain. Lastly, I found Expo to be a great solution for rapid development on both mobile platforms IOS/Android.

Thank you for reading and if you would like to connect with me you can find me on Linkedin or Github.

Abstract Factory in Python with Generic Typing

Shane Nolan — Tue, 12 Apr 2022 15:52:09 +0000

I found it difficult to find cleanly typed Python code that implemented the abstract factory creational design pattern. Therefore, this is my implementation of a typed abstract factory in Python.

The following code uses Python 3.8 and Mypy 0.91.

Implementation

The abstract factory we are going to implement is a game factory that creates players and items. For this example, we are going to implement a Rogue player which requires an attack greater than 5 to successfully hit and a Sword item that has 10 damage.

The Unified Model Language (UML) diagram at the start of this article might be a bit scary to look at it if you’re not familiar with UML but let's start with the basics. Player is an interface (Python doesn't exactly have interfaces but you can achieve the same result using an abstract class, you’ll see an example below) that contains a single method definition. Any class that implements the Player interface must implement the attack method that matches the signature, i.e.

Therefore, as shown in the UML diagram the Rogue class implements attack. If attack wasn’t implemented a TypeError would be thrown. Let’s implement Rogue and Sword:

Next, we need to create two factories for Player and Item. The factory design pattern has many benefits but my personal favourite benefit is it separates the process of creating an object from the code that depends on the interface of the object. Making the code more extensible and maintainable while improving readability. A lot of articles regarding the factory design pattern use a lot of jargon but in reality it is quite simple, let me show you.

In our UML diagram both the PlayerFactory and ItemFactory implement the AbstractEntityFactory interface, specifically the *generic *createmethod.

This method might look confusing to those who are not familiar with generics (especially Python developers since duck typing essentially allows everything to be “generic”). Generic methods allow for a single function declaration to be called with different arguments or different return types. Let me show you with an example:

AbstractEntityFactory is generic because it inherits Generic[T] and method create returns T .
ItemFactory and PlayerFactory inherit AbstractEntityFactory but look closely, it declares its generic type to be Item for ItemFactory nd Player for PlayerFactory.

Lastly, we need to create our “factory of factories”, GameFactory. GameFactory encapsulates PlayerFactory and ItemFactory without specifying their concrete classes (what the abstract factory design pattern is meant to do). It sounds more complicated than it looks:

Using Mypy we validated our Python code is typed correctly 🙏.

The code snippet directly below is an example of the GameFactory creating a Sword and a Rogue, getting the sword damage and attacking with the rogue.

That’s it! You’ve successfully implemented a typed version of the abstract factory in Python while adhering to the SOLID design principles.

Creating A Modern Python Development Environment

Shane Nolan — Tue, 12 Apr 2022 12:59:54 +0000

Being a Python developer for the past few years I’ve gathered a list of my favourite packages/tools that I use in almost every project. Developing is a team effort and at some point, someone is going to have to read and/or alter the code you have written. If the code is poorly implemented and the developer has a new feature or bug fix to implement it will likely lead to additional technical debt. Therefore, I like to enforce developers (*including myself *😉) to produce code that is tested, maintainable, readable and most importantly consistent, otherwise, it's rejected. This results in the software development process going more smoothly since they will be working on the same dependable code.

This blog post demonstrates how I set up and configure my Python development environment using pyenv and Poetry, on both Unix and Windows systems to produce the same consistent code, helping prevent technical debt.

Installing pyenv 🐍

Downloading and installing Python from the official binary limits you to one specific Python version, which isn’t great if you’re working on multiple projects with different Python versions. Therefore, it's better to use pyenv, a tool that lets you easily switch between multiple versions of Python.

Windows Installation

For Windows users, I recommend you install WSL2, a Windows Subsystem that lets developers run a Linux environment without the overhead of a traditional virtual machine or dual-boot setup. You can install WSL2 by executing the following command in either PowerShell or Command Prompt:

If you don’t want to use WSL2 you can install pyenv-win, a less modern approach *and skip to the **Set Python Version with pyenv* section.

After installation search for Ubuntu on Windows (WSL terminal) and open it. It will present you with a bash shell and request you provide a username and password. Once they have been set your terminal is ready for tinkering 🔨 !

Before installing pyenv you’re going to need to update your environment and install a few build dependencies *(if you don't already have them). *Open your terminal and execute the following commands:

> sudo apt update && sudo apt upgrade
> sudo apt install -y build-essential git curl libexpat1-dev libssl-dev zlib1g-dev libncurses5-dev libbz2-dev liblzma-dev libsqlite3-dev libffi-dev tcl-dev linux-headers-generic libgdbm-dev libreadline-dev tk tk-dev

pyenv is now ready to be installed and configured (tell your terminal where pyenv is):

> curl https://pyenv.run | bash

> echo '\nexport PATH="$HOME/.pyenv/bin:$PATH"' >> ~/.bashrc
> echo '\neval "$(pyenv init -)"' >> ~/.bashrc
> echo '\neval "$(pyenv init --path)"' >> ~/.bashrc

> source ~/.bashrc

# Confirm successful installation:
> pyenv --version
pyenv 2.2.5 # Your version will likely be newer.

Set Python Version with pyenv

Once pyenv is installed successfully, set your global Python version using the following commands:

# Install the required Python version:
> pyenv install 3.9.0

# Refresh pyenv since you installed a new Python version:
> pyenv rehash

# Set your global Python version:
> pyenv global 3.9.0

# You can also set the local Python version, i.e. for a project:
# > pyenv local 3.9.0

# Confirm Python version:
> pyenv version
3.9.0 (set by /home/wsl/.pyenv/version)

If you require another version of Python you can simply execute the same commands with a different version number 🤗.

Installing Poetry 📜

Packaging systems and dependency management in Python are rather convoluted and hard to understand for newcomers. Even for seasoned developers, it might be cumbersome at times to create all files needed in a Python project. Poetry helps you declare, manage and install dependencies of Python projects, ensuring you have the right stack everywhere. It automatically creates isolated environments for each project, preventing modifications to dependencies in another project.

> pyenv shell 3.9.0

> curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

> source ~/.bashrc

# Confirm installation was successful:
> poetry --version
Poetry version 1.1.13 # Your version will likely be newer.

EditorConfig

EditorConfig helps maintain consistent coding styles for multiple developers working on the same project across various editors and integrated development environments (IDE). It works by reading the .editorconfig configuration file provided at the top level of a project. Most IDEs have built-in support but this is a list of IDEs/editors that require a plugin.

This is the standard .editorconfig file that I use in all my Python projects:

Your environment is now ready to create a modern Python project 🥳.

Creating and Configuring a Python Project ⚙️

The following instructs how to *manually *create and configure a Python project using pyenv and Poetry.

To create a new Python project you need to specify the Python version using pyenv and then use Poetry to create the project.

> pyenv shell 3.9.11
> poetry new PROJECT_NAME # Example testproject
> cd testproject
> git init # Initialise the repository

Next, create the .editorconfig configuration provided above. Your project tree structure should look like this:

> tree

.
├── .editorconfig
├── .git
│   ├── ...
├── README.rst
├── pyproject.toml
├── testproject
│   └── __init__.py
└── tests
    ├── __init__.py
    └── test_testproject.py

12 directories, 22 files

Personally, I prefer Markdown instead of reStructuredText so I rename README.rst to README.md . All application logic goes into the folder named after your project and tests go into the tests folder.

My Essential Python Packages 📦

This section details the majority of development packages (packages that are only required during the development phase) I use in Python projects.

pytest with pytest-cov

The pytest framework makes it easy to write small tests, yet scales to support complex functional testing for applications and libraries. I prefer pytest over the inbuilt unittest library because it allows for plugins such as pytest-xdist, which enables the execution of multiple tests at once, expediting test runtimes and requires fewer lines of code to produce the same output as unittest. Additionally, pytest-cov is a plugin that automatically produces a test coverage report.

wemake-python-styleguide

The wemake.services team describe wemake-python-styleguide as *the strictest and most opinionated Python linter ever*. It's essentially the flake8 package, a linting tool that analyses code for defects, with plugins. Its primary objectives are:

Enforcing Python 3.6+ usage.
Significantly reducing the complexity of code and making it more maintainable.
Enforcing “There should be one — and preferably only one — obvious way to do it” rule to coding and naming styles
Protect developers from possible errors and enforce best practices.

I’d also recommend the flake8-pytest-style plugin if you’re using pytest.

For existing projects, you can use the package flakehell with the baseline feature to report new violations since integrating a new linter will likely result in hundreds or even thousands of violations. This guide explains how to integrate flakehell and resolve violations over time.

Mypy

Mypy is an optional static type checker that aims to combine the benefits of dynamic (or “duck”) typing and static typing. The benefits of statically typed code are increased readability and maintainability. For an existing code base here's a guide on how to implement Mypy.

Safety

A 2021 security report by Snyk, states 47% of Python projects contain known vulnerabilities. On the bright hand side, almost 87% of known vulnerabilities can be resolved by upgrading the vulnerable package. Safety checks your installed dependencies for known security vulnerabilities.

pre-commit

pre-commit is a framework for managing and maintaining multi-language pre-commit hooks. For example, a hook that runs pytest must succeed before code can be committed to the repository, preventing code defects. The following pre-commit configuration file is what I use in my Python projects. It ensures that tests, coverage, stating type checking and vulnerability scanning all pass before code is committed.

This is the .pre-commit-config.yaml file used in the above example:

Nitpick

It can become tedious maintaining configurations across projects, especially since EditorConfig, pytest-cov, flake8, Mypy and pre-commit all require configuration files. Nitpick is a tool and flake8 plugin that enforces the same configurations across multiple language-independent projects, automating this tedious configuration.

Once installed, add the following line to your pyproject.toml file:

**[tool.nitpick]**
style = "https://raw.githubusercontent.com/wemake-services/wemake-python-styleguide/master/styles/nitpick-style-wemake.toml"

You’ll need to create a .gitignore and CHANGELOG.md file to successfully pass Nitpick validation.

It will automatically create a setup.cfg file that will contain all the required configurations.

Congratulations, you’ve successfully created a modern Python development environment 🎉. If you would like to connect with me you can find me on Linkedin or Github. Thanks for reading 😊!

Extra: VSCode WSL2 Integration

If your editor is VSCode then you’re in luck because you can integrate the Linux subsystem easily with its remote WSL plugin. Once installed open your WSL terminal and execute code . . This will automatically open the VSCode editor within the Linux subsystem. You can read more about it here.

Extra: Automated Project Setup and Configuration

If you’re any way like me, then you must automate a task when you find yourself doing it more than once. I’ve automated the creation and configuration of a modern Python project using cookiecutter. You will need to set up your environment first. Also, nitpick uses my own take on the wemake-services configuration, you can view the repository here.

> pyenv shell 3.9.11

---------------------------------------------
# Unix: Specify the name of the project.
> export PROJECT_NAME="MY_PROJECT_NAME"
=============================================
# Windows: Specifcy the name of the project.
> set PROJECT_NAME="MY_PROJECT_NAME"
---------------------------------------------

> python -m pip install cookiecutter &&
python -m cookiecutter --no-input gh:ShaneNolan/python-project-template \
project_name=$PROJECT_NAME &&
(cd $PROJECT_NAME && git init &&
poetry init --no-interaction --name $PROJECT_NAME &&
poetry add mypy pytest pytest-cov flake8-pytest-style wemake-python-styleguide safety pre-commit nitpick --dev &&
poetry run nitpick fix &&
poetry run pre-commit install) && python -m uninstall cookiecutter