giridhar

I love programming, learning and building new things.  I can develop web applications using Javascript and software applications using Python. 

Creative Web Developer

Giridhar Talla

You can use Auth0 to create and maintain your own user store while also providing a secure authentication system on top of it. Auth0 lets you store users in your own database. Furthermore, Auth0 uses [OAuth 2.0](https://oauth.net/2/) as an authorization framework with which you can be confident in terms of security. Using a custom database as a user store in Auth0 facilitates [user migration](https://auth0.com/docs/users/import-and-export-users) and adds an OAuth and [OpenID Connect](https://openid.net/connect/) layer to your existing user database. You can configure any database or web service, including ASP.NET Membership Provider, MongoDB, MySQL, PostgreSQL, as an Auth0 custom database. In this article, you will learn how to set up PostgreSQL as a custom database for Auth0.

> **Limited Access:** Some features are available depending on your Auth0 subscription. For more information, see [Auth0 pricing plans](https://auth0.com/pricing).

## Enabling Custom Databases

Don't already have an Auth0 account yet? [Sign up for free right now!](https://auth0.com/signup/)

Once you [log in](https://auth0.com/auth/login), navigate to the [Database connections page](https://manage.auth0.com/#/connections/database) (Auth0 Dashboard > Authentication > Database). Click on the **Create DB Connection** button, give your database a nice name, and click the **Create** button. Go to the **Custom Database** tab and enable **Use my own database** to configure the custom database.

![Enabling 'use my own database' on custom database tab of Auth0 interface](https://images.ctfassets.net/23aumh6u8s0i/OGyNXnaAOAwmDmJeSS29o/f2462f845f94aba70a41caac89f0d495/01_8enable-custom-database.png)

Auth0 uses Node.js scripts, called Action Scripts, for connecting and accessing your database. These scripts include JavaScript functions that allow you to execute a variety of tasks such as adding a new user, logging in a user, and so on. You should define **Custom Database Action Scripts** to perform the following actions:

- Create: The **Create** script inserts a new user with `email` and `password` into your PostgreSQL database.
- Login: The **Login** script verifies the identity of the user in your PostgreSQL database whenever a user needs to authenticate.
- Verify: The **Verify** script updates the verification status of a user's email address in your database.
- Change Password: The **Change Password** script modifies the password for the user's email address. It changes the user's password in the database for future logins (forgot password functionality).
- Get User: The **Get User** script retrieves a specified user's information from your database. It returns `undefined` if the user is not present in your database.
- Delete: The **Delete** script removes the specified user identity from your database.

Fortunately, Auth0 provides templates for these custom database scripts. You can use the template and update the **connection string** with your database URL. Refer to the [official documentation](https://auth0.com/docs/connections/database/custom-db/templates) for additional information on Auth0 custom database action scripts. Let's start by creating a PostgreSQL database to connect with Auth0.

## Setting up a PostgreSQL Database

You cannot use the database in your local environment. You should make your database accessible via the internet or use tools like [Database as A Service](https://www.ibm.com/cloud/learn/dbaas). In this tutorial, I'll use [ElephantSQL](https://www.elephantsql.com/), which offers a fully configured and cloud-hosted PostgreSQL database in few minutes. However, it does not display any data inside your database; instead, you can run SQL commands to show your data. You can design your own database and host it on any cloud provider like [AWS](https://aws.amazon.com/rds/postgresql/), [Google Cloud](https://cloud.google.com/sql/docs/postgres/quickstart) or [Heroku](https://devcenter.heroku.com/articles/heroku-postgresql).

![Elephant sql home page](https://images.ctfassets.net/23aumh6u8s0i/67kI5tanFdPenloG7UPWmo/a9901332759fdf407562eedfefce6f0a/02_5elephant-sql.png)

Head over to [https://www.elephantsql.com/](https://www.elephantsql.com/) and create an account for yourself or log in if you already have one. It takes you to the dashboard page; Click on the **Create New Instance** to create a new database instance. Give a suitable name to your database instance and choose a plan and a region. I'll use the free plan for demonstration purposes. Configure the database to meet your requirements, then click **Create instance**.

![Elephantsql create instance confirmation page](https://images.ctfassets.net/23aumh6u8s0i/2KypO18fJdOwAUAUzAvEaI/f0637c4914da6ed6c106f203bf1651a2/03_0create-new-instance.png)

If you encounter any error in creating an instance, refer to the [ElephantSQL documentation](https://www.elephantsql.com/docs/) for troubleshooting.

Now, navigate to the freshly created database instance and copy the **URL** from the details page. You'll need this to connect your Auth0 application to this database. Anyone can access your database with this connection string. It would help if you were to keep it very secret for security purposes.

![Click on show button and copy the 'URL' on the ElephantSQL instance details page](https://images.ctfassets.net/23aumh6u8s0i/6ygHuLT6dz2nL3E7rLGprV/5ac2748f274fec16755aa97402506126/04_9instance-details.png)

**PS:** Auth0 provides several IP addresses to configure your database network connections if you're using a firewall. You can find them under the action scripts.

![List of IP addresses under action scripts](https://images.ctfassets.net/23aumh6u8s0i/7z4pzq4dETiiHaHk3hUY1T/8e22ded36e15b4eaffa7588d65ed30a3/05_3database-ips.png)

> **Note:** Using your own database leads to several security concerns. Allowing your database accessible over the internet without any firewalls or security measures may result in data leakage.

## Creating a Table for Storing Users

Switch to the **Browser** tab and execute the following command.

```sql
CREATE TABLE users(
    id UUID DEFAULT uuid_generate_v4(),
    nickname VARCHAR(255),
    email VARCHAR(255) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    email_Verified BOOLEAN DEFAULT FALSE
);
```

![creating a new table using SQL command in SQL Browser](https://images.ctfassets.net/23aumh6u8s0i/57cmWLADlzyKQcMgIj7hVk/f4758d8ccdc9bcc214b9b30da842b2fe/06_1create-table.png)

The above command creates a new table called `users` to store the user information from Auth0. You need at least the above five columns to save and validate the user identity.

## Defining the Auth0 Custom Database Scripts

Open the custom database tab in the Auth0 interface and navigate to the **Database Action Scripts** section. Select a script (say *Login*) to edit and choose **PostgreSQL** from the templates drop-down. To connect your database to Auth0, you should add the connection string (`conString`) of your database in the action scripts.

Scroll down a little to the **Database Settings** under the Action scripts section. Add the database URL you copied from your ElephantSQL as an environment variable (to keep it as a secret).

![Adding the database URL as an env variable 'POSTGRES_URL' settings section](https://images.ctfassets.net/23aumh6u8s0i/qkAAeUkyauInLsJYqqGZw/fdddd502f0dbf1048d40bf47c3526c56/07_4database-settings.png)

Now, update the `conString` in your action scripts with this value.

```diff
- const conString = 'postgres://user:pass@localhost/mydb';
+ const conString = configuration.POSTGRES_URL;
```

Remember to add the connection string in every database action script, and that's all! Now you can click on **Save and Try** button to test your database.

> **Note:** You can also link an existing user database to Auth0. You should modify some code in the action scripts to match your database configuration.

## Testing the Database

First, try creating a user in the database using **Create** script.

![user created successfully after trying the custom create script](https://images.ctfassets.net/23aumh6u8s0i/7EZTXGBq7Yks8RnklmrcfP/66a3c8c9c4c6c2dcffc6c61c456116ec/08_2create-user.png)

You can find the user in your database. Open the **SQL Browser** in ElephantSQL and run the following command. It retrieves the first 100 records from the database containing information about the users.

```sql
SELECT * FROM "public"."users" LIMIT 100
```

![database rows will be displayed on the browser tab after executing the above command](https://images.ctfassets.net/23aumh6u8s0i/2OEtiruBOBch1KQuxrJxlm/6c799eba9dcd0693d2f08a9e89259b52/09_7elephantsql-users.png)

Similarly, login, validate your email and delete the user. For deleting a user, you should use the unique id of the specific user. Test all the scripts and use this database in applications that you create on the Auth0 dashboard. You can select to use this database on **Connections** tab in your application. If you experience any problem through the whole process, reach out to the [Auth0 community](https://community.auth0.com/) for assistance.

## Conclusion

In this article, you learned how to set up your PostgreSQL database as an Auth0 custom database. Even if you have a different type of database, you can easily connect to Auth0 using the templates provided. In this tutorial, you merely changed the Auth0 templates. Modify the action scripts accordingly if you need to keep more information about the user or want to configure the already existing user store as Auth0 custom database. 

Using a custom database introduces several security issues as well as additional configuration work. You should keep your database in a secure cloud to prevent data leakage. You can rely on Auth0 if you don't want to put in any extra effort. It saves your users' information in very secure databases ([see how Auth0 stores data?](https://auth0.com/blog/how-we-store-data-in-the-cloud-at-auth0/)).

Configuring PostgreSQL as Auth0 Custom Database

[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) are conventional solutions to common challenges in software development using [Object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming). One of the famous design patterns for developing scalable and flexible software is the state pattern. You'll learn about the state pattern and how to apply it to improve your software project in this article.

## Finite State Machine

Let's define a [finite state machine](https://en.wikipedia.org/wiki/Finite-state_machine) (FSM) before moving on to the state design pattern. It is well known that the concepts of state patterns and finite-state machines have a close relationship. An FSM is something that behaves differently depending on its internal state. In computer programming, the behavior of an object in an application varies depending on its state. A switch and a lightbulb are simple examples of FSM. "ON" and "OFF" are the two possible states of the light bulb. To change the state of the bulb 'ON' or 'OFF', simply flip the switch. Transition is the process of moving from one state to another. Transition is affected by several factors. In the case of the light bulb, it is dependent on the input from the switch. The state diagram, which is shown below, graphically depicts the states and transitions.

![light bulb state diagram](https://images.ctfassets.net/23aumh6u8s0i/6Y4Ljm8KBa45GF54np9a8i/b5bff5c1cf9b5a8ead644a110f9db059/01_bulb_state_diagram.png)

We can implement the state machine using any programming language. Depending on a few factors, our code behaves differently. You can implement the preceding light bulb example as follows:

```py
class LightBulb:
  _state = 'OFF'    # initial state of bulb
  
  def onOff(self, switch):
    if switch == 'ON':
        self._state = 'ON'
    elif switch == 'OFF':
        self._state = 'OFF'
    else:
        continue          # if we get wrong input

```

For small systems, such as the one described above, the code appears to be straightforward and simple. However, if there are many states and transitions, our code will get flabby with conditional statements. The code becomes more extensive, and it won't be easy to maintain the application. If you want to add additional states or transitions to the program, you'll have to change the entire code base. You can use the **State Design Pattern** in these cases.

## State Pattern

It is a behavioral design pattern. You can use the state pattern to implement state-specific behavior in which objects can change their functionality at runtime. You can use it to avoid using conditional statements when changing an object's behavior based on its state. In the state pattern, you should [encapsulate](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)) different states in separate `State` classes. The original class keeps a reference to a state object based on its current state rather than using conditional statements to implement state-dependent functionality.

## UML Diagram

![UML class diagram of state pattern](https://images.ctfassets.net/23aumh6u8s0i/7EXrJIISe60aDo65BUFXgW/caabc74e7fe1d13bc1150ce6baa98edb/02_UML_state_class.png)

1) **Context** - it is the original class of our application. It maintains a reference to one of the concrete states on which its behavior depends. It also has a method to modify the internal state.

2) **State interface** - All supported states share the same state interface. Only the state interface allows *Context* to communicate with state objects. *Context* can only communicate with state objects via the state interface.

3) **Concrete states** - For each state, these objects implement the 'State' interface. These are the main objects which contain the state-specific methods.

## How does it work?

![UML sequence diagram of state pattern](https://images.ctfassets.net/23aumh6u8s0i/9jQ2UH5r4b4amneAHwIxG/fa3b9affd7c467bc6513b64cd1362114/03_UML_state_sequence.png)

Assume the *Context* is configured with an initial state, `concreteStateA`.  It behaves according to its initial state. The *Context* now implements the `doSomething` method according to `concreteStateA`. The concrete states should contain a back reference to call back and change *Context's* current state object. If a state transition occurs, the *Context's* `setSate` method is invoked, referencing the new state, `concreteStateB`. The *Context* changed its internal state and behavior. Now, it uses the `concreteStateB` to implement the `doSomething` method. The basic idea is that the states can change the context's state automatically. As a developer, you can modify the states by using any number of instances of `setState`.

If you want to add another state, simply create a new concrete state object without changing the *Context* of the application.

## Implementation

Let's take a step-by-step look at implementing the state pattern.

1) Find an existing class that contains state-dependent code, or create a suitable context class. It should include a reference to a specific state as well as a method for switching between states.

```py
from __future__ import annotations
from abc import ABC, abstractmethod

# the context class contains a _state that references the concrete state and setState method to change between states.
class Context:

    _state = None

    def __init__(self, state: State) -> None:
        self.setState(state)

    def setState(self, state: State):

        print(f"Context: Transitioning to {type(state).__name__}")
        self._state = state
        self._state.context = self

    def doSomething(self):
        self._state.doSomething()

```

2) Create a common State interface for all concrete states. The State interface specifies all of the methods that all Concrete States must implement and a backreference to the *Context* object. States can change the *Context* to another state by using this backreference.

```py
class State(ABC):
    @property
    def context(self) -> Context:
        return self._context

    @context.setter
    def context(self, context: Context) -> None:
        self._context = context

    @abstractmethod
    def doSomething(self) -> None:
        pass

```

You should define the *Context* as a [protected parameter](https://www.geeksforgeeks.org/protected-variable-in-python/). Above, [`@property`](https://www.programiz.com/python-programming/property) decorator is used to make the `context()` method as property and `@context.setter` decorator to another overload of the `context()` method as property setter method. Now, `_context` is protected.

3) You can define the concrete states in the classes that implement the state interface. After the `doSomething` method is called, the state of the *Context* changes. You can also change the state by defining a specific method. The state transitions use the `setState` method of the *Context*.

```py
class ConcreteStateA(State):
    def doSomething(self) -> None:
        print("The context is in the state of ConcreteStateA.")
        print("ConcreteStateA now changes the state of the context.")
        self.context.setState(ConcreteStateB())


class ConcreteStateB(State):
    def doSomething(self) -> None:
        print("The context is in the state of ConcreteStateB.")
        print("ConcreteStateB wants to change the state of the context.")
        self.context.setState(ConcreteStateA()) 

```

4) You can now initiate your application with an initial state and execute the methods.

```py
# sample application
app = Context(ConcreteStateA())
app.doSomething()    # this method is executed as in state 1
app.doSomething()    # this method is executed as in state 2
```

The output of the above code looks something like this:

```
Context: Transitioning to ConcreteStateA
The context is in the state of ConcreteStateA.
ConcreteStateA now changes the state of the context.
Context: Transitioning to ConcreteStateB
The context is in the state of ConcreteStateB.
ConcreteStateB wants to change the state of the context.
Context: Transitioning to ConcreteStateA
```

## Example

Let's create a simple state machine that represents a real-world scenario. Consider an elevator system with buttons in the elevator cabin that allow you to go up or down. Consider that this lift only travels between two floors to keep things simple. There are primarily two possible states for the elevator: `1st floor` and `2nd floor`. The input from the two buttons determines the transition between states. The elevator performs different actions based on its state.

The following code is the implementation of the elevator example. Follow along with the comments for more descriptions about each method.

```py
from __future__ import annotations
from abc import ABC, abstractmethod

# The Elevator class is the context. It should be initiated with a default state.
class Elevator:

    _state = None

    def __init__(self, state: State) -> None:
        self.setElevator(state)

    # method to change the state of the object
    def setElevator(self, state: State):

        self._state = state
        self._state.elevator = self

    def presentState(self):
        print(f"Elevator is in {type(self._state).__name__}")

    # the methods for executing the elevator functionality. These depends on the current state of the object.
    def pushDownBtn(self):
        self._state.pushDownBtn()

    def pushUpBtn(self):
        self._state.pushUpBtn()

    # if both the buttons are pushed at a time, nothing should happen
    def pushUpAndDownBtns(self) -> None:
        print("Oops.. you should press one button at a time")

    # if no button was pushed, it should just wait open for guests
    def noBtnPushed(self) -> None:
        print("Press any button. Up or Down")


# The common state interface for all the states
class State(ABC):
    @property
    def elevator(self) -> Elevator:
        return self._elevator

    @elevator.setter
    def elevator(self, elevator: Elevator) -> None:
        self._elevator = elevator

    @abstractmethod
    def pushDownBtn(self) -> None:
        pass

    @abstractmethod
    def pushUpBtn(self) -> None:
        pass


# The concrete states
# We have two states of the elevator: when it is on the First floor and the Second floor
class firstFloor(State):

    # If the down button is pushed when it is already on the first floor, nothing should happen
    def pushDownBtn(self) -> None:
        print("Already in the bottom floor")

    # if up button is pushed, move upwards then it changes its state to second floor.
    def pushUpBtn(self) -> None:
        print("Elevator moving upward one floor.")
        self.elevator.setElevator(secondFloor())


class secondFloor(State):

    # if down button is pushed it should move one floor down and open the door
    def pushDownBtn(self) -> None:
        print("Elevator moving down a floor...")
        self.elevator.setElevator(firstFloor())

    # if up button is pushed nothing should happen
    def pushUpBtn(self) -> None:
        print("Already in the top floor")


if __name__ == "__main__":
    # The client code.

    myElevator = Elevator(firstFloor())
    myElevator.presentState()

    # Up button is pushed
    myElevator.pushUpBtn()

    myElevator.presentState()

```

The output of the above code looks like this:

```
Elevator is in firstFloor
Elevator moving upward one floor.
Elevator is in secondFloor
```
You can implement many buttons and states elevator like in real-life one for the floor. Try using the state pattern to implement the light bulb example from the Finite state machine.

## Advantages and Disadvantages

The state pattern, like any other programming concept, has a number of benefits as well as some drawbacks. You can avoid writing massive conditional blocks for switching between states by using the state pattern instead of hard-coding state-specific behavior. It allows you to develop a flexible and maintainable application. You can add new states and transitions to the *Context* without changing it.

It's a good idea to use the state pattern if the logic of each state is complex and the states change frequently. Otherwise, it complicates simple things by bringing a plethora of classes and objects. The state pattern adds another level of indirection by imposing clients to rely on a State object, and it extends the context class to allow State objects to change the state of the *Context*.

## Conclusion

In this article, you learned how to use the state pattern in Python programming to design state machines. Without using larger conditional blocks to implement state-specific behavior, the state pattern makes the development process a lot easier. You can also add new states that are not dependent on other states, giving your application more flexibility. The state pattern is very similar to the [strategy pattern](https://en.wikipedia.org/wiki/Strategy_pattern), which alters strategies based on user choices. The main distinction is that concrete states are aware of other states, whereas the strategies do not. Why do we say that states are aware of other states? because each state has to know to which state they should move. For example, the first-floor state knows that they should change to the second-floor state. Another important difference with strategy pattern is that in the case of Strategy pattern, it's the client, which provides a different strategy to Context, on State pattern, the state transition is managed by Context or State itself. Try to make use of the state pattern in your software to make the development process go more smoothly.

State Pattern in Python

While you are developing software applications, you might run into some problems implementing the feature you need. Software design patterns are typical solutions for some of these commonly occurring problems while developing software applications using Object-oriented design. In this article, let's learn about one of the popular design patterns, **Strategy** pattern, and its implementation in Python.

## Introduction

Before diving into the strategy pattern, you should be familiar with some of the basics concepts of [Object-Oriented Programming](https://en.wikipedia.org/wiki/Object-oriented_programming) (OOP). The entire concept of design patterns revolves around *classes* and *objects*. The design patterns are more high-level solutions for commonly occurring problems. They are like the blueprint to solve a specific problem. They are not confined to a single programming language. You can use design patterns in any programming language that supports object-oriented programming; the process will be the same while the syntax changes.
![design patterns](https://images.ctfassets.net/23aumh6u8s0i/4tPzU9nvm5jUwrXAeeHH3e/1badc171178aa953f7df05f08960f228/01_design-types.jpg)
There are several types of design patterns, including **Creational**, **Structural**, and **Behavioral** patterns. Creational patterns are about different ways to create objects that increase the flexibility of our code. Structural patterns are about relations between the objects, making larger structures flexible using objects and classes. Behavioral patterns are about effective communications and interactions between objects.

## Strategy

**Strategy Pattern** is a design pattern that enables our application to select algorithms at runtime, making our application flexible. The original book on [design patterns](https://en.wikipedia.org/wiki/Design_Patterns) written by [GoF](http://wiki.c2.com/?GangOfFour) states that "Strategy pattern intends to define a family of algorithms, encapsulates each one, and
make them interchangeable." More specifically, it lets you define a set of algorithms that are interchangeable according to some factors at runtime. Strategy Pattern falls under the category of behavioral design patterns as it enables an algorithm's behavior to be selected at runtime.

## Usage

While developing software applications, you may have a few alternatives to accomplish something in your code. Depending on your client choices, data sources, or other factors, you want to do something different without changing the code. You often tend to define algorithms using conditional statements for different situations in the main class of the code. But it is not an elegant way of writing better code. It makes the main class of your code quite long, and it becomes too hard to maintain the application.

In situations like these, the strategy pattern is an ideal solution. The strategy pattern suggests you define classes, called *strategies*, for your algorithms of different situations. The strategy is referenced inside the main class, called _context_, and the code works according to that situation. The context does not select an appropriate strategy for the case. Instead, the client passes the desired strategy to the context.

For example, if you have a chess application, you can select the difficulty level between easy, medium, or hard. The computer chooses an algorithm according to the level you choose. It is one of the best examples where the strategy pattern is used.

Strategy pattern follows the [Open/close principle](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle); a software application is open for extension but closed for modification. It means you can add any number of additional strategies without modifying the main class. It makes your code more flexible and easy to maintain.

## UML Diagrams

The following is the UML diagram of the Strategy pattern.

![UML Strategy](https://images.ctfassets.net/23aumh6u8s0i/21fvYspoS3Voqv7pKyDE4E/e89c3e5f81d51b3d15a436cd81e795f7/02_UML-Strategy.jpg)

1. **Context** &mdash; It is the primary class of our application. It maintains a reference to one of the concrete strategies.
2. **Strategy** &mdash; Strategy interface is common to all supported strategies. Context can communicate with other strategies only through the strategy interface.
3. **ConcreteStrategies** &mdash; These are the classes that implement the algorithm using the Strategy interface.

## Implementation

Let's see the step-by-step process of implementing a strategy pattern.

1. You should first identify algorithms you want to execute as concrete strategies in the primary class.
2. Define the *context* (primary class) and add a reference to the strategy, a method to set the strategy, and another method to execute the strategy. You may also define a default strategy to switch between strategies only if they do not like the default one.

```py
## context - the primary class
class Context:
    strategy: Strategy  ## the strategy interface

    def setStrategy(self, strategy: Strategy = None) -> None:
        if strategy is not None:
            self.strategy = strategy
        else:
            self.strategy = Default()

    def executeStrategy(self) -> str:
        print(self.strategy.execute())

```

First, we define the `strategy` field for storing a reference to a strategy object, and two methods, `setStrategy` and `executeStrategy`. The `setStrategy` sets the strategy selected if a user selects an option, or else the `default` one.

3. Define the *Strategy Interface*, which is common to all the concrete strategies. The `Strategy` interface has an abstract method that you can alter in concrete strategies. 

```py
from abc import ABC, abstractmethod

## Strategy interface
class Strategy(ABC):
    @abstractmethod
    def execute(self) -> str:
        pass
```

4. Define the concrete strategies which should implement the `Strategy` interface. These concrete strategies must have a common method that overrides the `execute` method of the `Strategy` interface.

```py
## Concrete strategies
class ConcreteStrategyA(Strategy):
    def execute(self) -> str:
        return "ConcreteStrategy A"

class ConcreteStrategyB(Strategy):
    def execute(self) -> str:
        return "ConcreteStrategy B"

class Default(Strategy):
    def execute(self) -> str:
        return "Default"
```

5. Now, users can select the strategy they want at the runtime. Create an object of *context* and pass a concrete strategy.

```py
## Example application
appA = Context()
appB = Context()
appC = Context()

## selecting stratigies
appA.setStrategy(ConcreteStrategyA())
appB.setStrategy(ConcreteStrategyB())
appC.setStrategy()    ## sets to default strategy

## each object below execute different strategy with same method
appA.executeStrategy()
appB.executeStrategy()
appC.executeStrategy()
```

The output of the above code will be as follow:

```
ConcreteStrategy A
ConcreteStrategy B
Default
```

If you want to use another strategy, replace the ConcreteStrategy instance with the strategy you want. You can add a new concrete strategy without changing anything in the context.

## Example

Let's design a [rock paper scissors](https://en.wikipedia.org/wiki/Rock_paper_scissors) game using strategy pattern. You can select any strategy among rock, paper, scissors, and random to play against the computer. The below example code uses the strategy pattern to implement various strategies.

```py
## Changing the strategy among Rock, Paper, Scissors, and Random

import random
from abc import ABC, abstractmethod

## Strategy interface 
class Strategy(ABC):
    @abstractmethod
    def selection(self) -> None:
        pass

## Concrete strategies
class Rock(Strategy):
    ## actual application will have the algorithm instead this method
    def selection(self) -> str:
        return "Rock"

class Paper(Strategy):
    def selection(self) -> str:
        return "Paper"

class Scissors(Strategy):
    def selection(self) -> str:
        return "Scissors"

class Random(Strategy):
    def selection(self) -> str:
        options = ["Rock", "Paper", "Scissors"]
        return random.choice(options)

## Context class
class Game:
    strategy: Strategy

    def __init__(self, strategy: Strategy = None) -> None:
        if strategy is not None:
            self.strategy = strategy
        else:
            self.strategy = Random()

    def play(self, sec) -> None:
        s1 = self.strategy.selection()
        s2 = sec.strategy.selection()
        if s1 == s2:
            print("It's a tie")
        elif s1 == "Rock":
            if s2 == "Scissors":
                print("Player 1 wins!")
            else:
                print("Player 2 wins!")
        elif s1 == "Scissors":
            if s2 == "Paper":
                print("Player 1 wins!")
            else:
                print("Player 2 wins!")
        elif s1 == "Paper":
            if s2 == "Rock":
                print("Player 1 wins!")
            else:
                print("Player 2 wins!")

## Example application
## PLayer 1 can select his strategy
player1 = Game(Paper())

# Player 2 gets to select
player2 = Game(Rock())

# After the second player choice, we call the play method
player1.play(player2)
```

According to the strategies chosen by the two players, the expected output would be:

```bash
Player 1 wins!
```

Test all the other cases of the game using all the other strategies. To add extra fun to the game, try creating two more strategies to the above example according to [the Lizard-Spock expansion](https://bigbangtheory.fandom.com/wiki/Rock,_Paper,_Scissors,_Lizard,_Spock).

## Conclusion

In this article, you have seen where and how to use the strategy pattern in your code. You can build flexible and maintainable software applications using the strategy pattern. You can switch between algorithms at runtime according to the user's decision without changing the code. But if your code only has a couple of algorithms, there is no need to use strategy. It just makes your code look complex with numerous classes and objects. The Strategy pattern can work as an alternative for conditional statements for selecting the behavior of the application. But the potential drawback of strategy pattern is that the users must know how strategies differ from each other to select what they need. So it would be best if you use the strategy pattern only when the variation in behavior of the application is relevant to the users. So try to make your software applications flexible using the strategy pattern.

Giridhar Talla

Configuring PostgreSQL as Auth0 Custom Database

State Pattern in Python

Strategy Design Pattern in Python

Try for free today