DEV Community: Soumyajyoti Biswas

ChatGPT, Domain driven design and python - Using openAI to dive into software development

Soumyajyoti Biswas — Mon, 05 Dec 2022 19:37:24 +0000

1. Table of contents

1. Table of contents
2. What is ChatGPT?
3. What is domain driven design?
4. Example python project 1
5. Example python project 2
6. Example python project 3
7. Example python project 4
8. Example python project 5
9. Example python project 6

2. What is ChatGPT?

From openAI's website,

We’ve trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer followup questions, admit its mistakes, challenge incorrect premises, and reject inappropriate requests. ChatGPT is a sibling model to InstructGPT, which is trained to follow an instruction in a prompt and provide a detailed response.

Go try it out here

3. What is domain driven design?

Domain-driven design (DDD) is a software development approach that focuses on defining the business domain, identifying key concepts and vocabulary, and developing a model that reflects the business requirements. In the context of a Python project, implementing DDD would involve the following steps:

Identify the business domain for the project and define the key concepts and vocabulary for that domain. This will involve working closely with domain experts to understand the business requirements and identify the key entities, relationships, and operations involved in the domain.

Develop a domain model that reflects the key concepts and vocabulary identified in the previous step. This model should capture the structure and behavior of the domain, including the entities, relationships, and operations involved.

Define the interfaces and implementations for the entities, relationships, and operations in the domain model. This will involve designing classes and methods that can be used to manipulate the domain model and perform the operations required by the business domain.

Implement the domain model using Python. This will involve writing the code for the classes and methods defined in the previous step, and testing them to ensure they work as expected.

Refine and iterate on the domain model as needed. As the project progresses, it may be necessary to make changes to the domain model in order to better reflect the business requirements or to improve its design. This can be done by updating the interfaces and implementations, and testing the changes to ensure they work as expected.

Overall, implementing DDD in a Python project involves a deep understanding of the business domain, careful design of the domain model, and diligent implementation and testing of the model. It can be a challenging but rewarding process that can lead to more effective and maintainable software.

4. Example python project 1

"""
In this example, we have defined a User class to represent a domain entity (in this case, a user of a system), a UserRepository class to manage User objects, and a UserService class to provide business logic for working with User objects. The UserService class uses the UserRepository to perform persistence operations, such as saving and finding User objects.

By using this approach, we are able to clearly separate the different concerns of our software system and build a flexible and maintainable solution.
"""

# Import the necessary libraries
from typing import List

# Define a class to represent the domain entity
class User:
    def __init__(self, id: int, name: str, email: str):
        self.id = id
        self.name = name
        self.email = email

# Define a repository class to manage User objects
class UserRepository:
    def __init__(self):
        self.users = []

    def save(self, user: User):
        # Implement logic to save the user to a database or other persistence layer
        pass

    def find_by_id(self, id: int) -> User:
        # Implement logic to find a user by their ID
        pass

    def find_by_email(self, email: str) -> User:
        # Implement logic to find a user by their email address
        pass

# Define a service class to provide business logic
class UserService:
    def __init__(self, repository: UserRepository):
        self.repository = repository

    def register_user(self, name: str, email: str):
        # Implement logic to create a new user and save it using the repository
        pass

    def get_user_by_id(self, id: int) -> User:
        # Use the repository to find a user by their ID
        return self.repository.find_by_id(id)

    def get_user_by_email(self, email: str) -> User:
        # Use the repository to find a user by their email address
        return self.repository.find_by_email(email)

5. Example python project 2

"""
In this example, the Product and Cart classes represent the domain entities in our system. The CartService class is the application layer, which defines the business logic for managing a shopping cart. The InMemoryRepository class is the infrastructure layer, which handles storing and retrieving products from memory.

In DDD, the domain layer is the heart of the application, containing the core business logic and entities. The application and infrastructure layers serve as supporting layers, providing the means for the domain layer to interact with external resources (e.g. databases) and define the application's business logic.
"""

from typing import List

# Domain layer

class Product:
    def __init__(self, id: int, name: str, price: float):
        self.id = id
        self.name = name
        self.price = price


class Cart:
    def __init__(self, products: List[Product]):
        self.products = products

    def add_product(self, product: Product):
        self.products.append(product)

    def remove_product(self, product_id: int):
        self.products = [p for p in self.products if p.id != product_id]

    def get_total(self):
        return sum(p.price for p in self.products)

# Application layer

class CartService:
    def __init__(self, cart: Cart):
        self.cart = cart

    def add_product_to_cart(self, product: Product):
        self.cart.add_product(product)

    def remove_product_from_cart(self, product_id: int):
        self.cart.remove_product(product_id)

    def get_cart_total(self):
        return self.cart.get_total()

# Infrastructure layer

class InMemoryRepository:
    def __init__(self):
        self.products = []

    def add_product(self, product: Product):
        self.products.append(product)

    def get_product(self, product_id: int):
        return next(p for p in self.products if p.id == product_id)

    def remove_product(self, product_id: int):
        self.products = [p for p in self.products if p.id != product_id]

    def get_all_products(self):
        return self.products

# Usage

repo = InMemoryRepository()
repo.add_product(Product(1, 'Test product', 10.99))

cart = Cart([])
service = CartService(cart)

service.add_product_to_cart(repo.get_product(1))
service.get_cart_total()  # 10.99

service.remove_product_from_cart(1)
service.get_1cart_total()  # 0.0

6. Example python project 3


"""
In this example, the Employee class is a representation of the concept of an employee in the business domain. The EmployeeRepository class is responsible for managing a collection of employees, and provides methods for adding and retrieving employees. Finally, the PayrollSystem class uses the EmployeeRepository to calculate the payroll for a given employee.

By dividing the program into these distinct classes, each with a specific responsibility, the design of the software follows the principles of DDD. The Employee class provides a clear and concise representation of the business domain, the EmployeeRepository class manages the employees in a way that is consistent with the real-world domain, and the PayrollSystem class uses the EmployeeRepository to support the complex business process of calculating payroll. This helps to ensure that the software accurately reflects the real-world domain and can support the complex business rules and processes that exist within it.
"""
class Employee:
    def __init__(self, employee_id, first_name, last_name):
        self.employee_id = employee_id
        self.first_name = first_name
        self.last_name = last_name

    def get_full_name(self):
        return f"{self.first_name} {self.last_name}"


class EmployeeRepository:
    def __init__(self):
        self.employees = []

    def add_employee(self, employee):
        self.employees.append(employee)

    def get_employee_by_id(self, employee_id):
        for employee in self.employees:
            if employee.employee_id == employee_id:
                return employee

        return None


class PayrollSystem:
    def __init__(self, employee_repository):
        self.employee_repository = employee_repository

    def calculate_payroll(self, employee_id):
        employee = self.employee_repository.get_employee_by_id(employee_id)

        if employee is None:
            raise ValueError(f"Employee with ID {employee_id} not found")

        payroll_amount = 0

        # Calculate payroll amount based on employee's salary and hours worked

        return payroll_amount

7. Example python project 4


"""
In this example, the UserApplication class uses the UserController and InMemoryUserService classes to create a complete application that can perform operations on User objects. This is an example of onion architecture, because the application is built in layers, with the core domain layer at the center, surrounded by layers of infrastructure and application logic. This allows the application to be easily adapted to different infrastructure implementations.
"""

from abc import ABC, abstractmethod

# Domain Layer
class UserService(ABC):
    @abstractmethod
    def get_user(self, user_id: int) -> User:
        pass

    @abstractmethod
    def create_user(self, user: User) -> User:
        pass

class User:
    def __init__(self, id: int, name: str):
        self.id = id
        self.name = name

# Application Layer
class UserController:
    def __init__(self, user_service: UserService):
        self.user_service = user_service

    def get_user(self, user_id: int) -> User:
        return self.user_service.get_user(user_id)

    def create_user(self, user: User) -> User:
        return self.user_service.create_user(user)

# Infrastructure Layer
class InMemoryUserService(UserService):
    def __init__(self):
        self.users = {}

    def get_user(self, user_id: int) -> User:
        return self.users.get(user_id)

    def create_user(self, user: User) -> User:
        self.users[user.id] = user
        return user

# Onion Architecture
class UserApplication:
    def __init__(self):
        user_service = InMemoryUserService()
        self.user_controller = UserController(user_service)

8. Example python project 5


"""
To give a more detailed example of how domain-driven design might be implemented in a Python project, let's consider a simple banking system. In this system, we have the following key concepts and entities:

Account: represents a bank account, with an account number, balance, and list of transactions.
Customer: represents a customer of the bank, with a name, address, and list of accounts.
Transaction: represents a transaction on an account, with a date, amount, and description.
First, we would define a common language for the domain that can be used by all stakeholders. This might include terminology such as "account", "customer", and "transaction", as well as concepts such as "deposit" and "withdrawal".

Next, we would model the business domain using classes and objects in Python. For example, we might define the following classes:


These classes capture the key concepts and entities in the business domain, and define the business logic for managing accounts, customers, and transactions. Note how the common language of the domain is used in the names of the classes, methods, and variables, to make the code more readable and understandable.

Finally, we would use object-oriented design techniques to create a flexible and extensible design that can accommodate changes to the business domain over time. For example, we might define additional subclasses of Account, such as SavingsAccount and CheckingAccount, to represent different types of accounts with different business rules and logic.

Overall, by using domain-driven design principles in our Python project, we can create software that is closely aligned with the needs of the business, and that is easy to understand and maintain.

"""

class Account:
    def __init__(self, number, balance=0):
        self.number = number
        self.balance = balance
        self.transactions = []

    def deposit(self, amount):
        self.balance += amount
        self.transactions.append(Transaction(datetime.now(), amount, "Deposit"))

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        self.transactions.append(Transaction(datetime.now(), amount, "Withdrawal"))


class Customer:
    def __init__(self, name, address):
        self.name = name
        self.address = address
        self.accounts = []

    def open_account(self, number):
        self.accounts.append(Account(number))


class Transaction:
    def __init__(self, date, amount, description):
        self.date = date
        self.amount = amount
        self.description = description

9. Example python project 6

In domain-driven design (DDD), the "ports and adapters" architecture (also known as the "hexagonal" or "onion" architecture) is a way of organizing the structure of a software application to make it more flexible and scalable. It separates the core domain logic from the technical details of the application, such as the user interface, database access, and other external dependencies.

To implement the ports and adapters architecture in Python, you would need to define the core domain logic in the center of your application, and then implement the various adapters that connect the domain to the external dependencies. The adapters would be responsible for translating the domain concepts and objects into the specific formats and protocols used by the external dependencies.

Here is an example of a simple Python class that represents a domain object in the domain layer of a DDD-based application:

class Order:
    def __init__(self, customer, items):
        self.customer = customer
        self.items = items

    def calculate_total(self):
        total = 0
        for item in self.items:
            total += item.price
        return total

This class represents an order in a hypothetical online store. It contains a reference to the customer who placed the order, as well as a list of items that were included in the order. It also has a method for calculating the total price of the order.

To implement the ports and adapters architecture for this domain, you would need to define the "ports" that the domain layer exposes to the outside world. These could be interfaces or abstract base classes that define the methods and data structures that the adapters must implement. For example:

class OrderRepository(ABC):
    @abstractmethod
    def save(self, order: Order) -> None:
        pass

    @abstractmethod
    def find_by_id(self, id: int) -> Optional[Order]:
        pass

This is an abstract base class that defines the methods that an adapter must implement in order to provide access to the order data in the domain layer. The save method is used to store a new order, and the find_by_id method is used to retrieve an existing order by its ID.

To implement the adapters, you would create concrete classes that inherit from these abstract base classes and provide the specific implementation for a particular external dependency. For example, you could create an adapter for a relational database using the Python sqlite3 module:

class SqliteOrderRepository(OrderRepository):
    def __init__(self, connection: sqlite3.Connection):
        self.connection = connection

    def save(self, order: Order) -> None:
        cursor = self.connection.cursor()
        cursor.execute(
            "INSERT INTO orders (customer_id, items) VALUES (?, ?)",
            (order.customer.id, json.dumps(order.items)),
        )
        cursor.connection.commit()

    def find_by_id(self, id: int) -> Optional[Order]:
        cursor = self.connection.cursor()
        cursor.execute("SELECT * FROM orders WHERE id = ?", (id,))
        row = cursor.fetchone()
        if row is None:
            return None
        return Order(
            customer=Customer(id=row["customer_id"]), items=json.loads(row["items"])

AWS Infrastrucutre Maintenance Using AWS Lambda and AWS EventBridge [EC2 instance ebs snapshot cleanup after X days] [Part 2]

Soumyajyoti Biswas — Wed, 06 Apr 2022 17:52:01 +0000

Summary
Architecture diagram and high level overview of all the solutions
- Architecture diagram
- EC2 instance daily ebs volume snapshots
- EC2 instance daily ebs snapshot cleanup after X days
AWS IAM permissions
- Permissions
- Trust relationship
AWS EventBridge and Lambda
EC2 instance ebs snapshot delete solution
Coming up next

Summary

Welcome to PART-2 of a four part tutorial, on how to leverage AWS services like Lambda and EventBridge, to perform housekeeping on your AWS infrastructure on a schedule automatically. In my last post, I talked about how to create EBS snapshots of an instance using python, AWS lambda and AWS eventbridge. In this post we will talk about building the second part, where old EBS snapshots will be cleaned up automatically. 'Old' will be defined as a number of days, in this case 7.

[PART-1] Create EBS volume snapshots of all our AWS EC2 instances in all regions, and tag them. You can find the link to the post here.
[PART-2] Cleanup EBS volume snapshots from all our regions, whose age is greater than X days.

Architecture diagram and high level overview of all the solutions

Architecture diagram

EC2 instance daily ebs volume snapshots

I am going to list out all instances in all of our regions, and its associated volumes, and create EBS snapshots from them. Also I am going to add custom tags to these snapshots.

EC2 instance daily ebs snapshot cleanup after X days

I am going to list all the EBS snapshots that we own in our regions, and then delete those older than X days.

AWS IAM permissions

Create an IAM role with the following permissions and trust policy.

Permissions

Attach a permission policy template to your role which will allow for:

AWS cloudwatch log stream creation and writing.
Describe EC2 instances, volumes, snapshots and AMI's.
EC2 snapshot creation and deletion.
EC2 volume deletion.
EC2 AMI deregistration.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:CreateLogGroup",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateSnapshot",
                "ec2:CreateTags",
                "ec2:DeleteSnapshot",
                "ec2:Describe*",
                "ec2:ModifySnapshotAttribute",
                "ec2:ResetSnapshotAttribute",
                "ec2:DeleteVolume",
                "ec2:DeregisterImage"
            ],
            "Resource": "*"
        }
    ]
}

Trust relationship

Allow the lambda service access to your IAM role.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

AWS EventBridge and Lambda

I am going to use AWS Lambda to run our python code to do run our infrastructure maintenance.

I am going to use AWS EventBridge to run our code via lambda on a schedule. I am going to define our schedule using a cron expression, to trigger daily at midnight, local to our timezone.
You can create an EventBridge rule by going to AWS EventBridge service ➡️ rules ➡️ create rule. The cron expression we will use will be cron(30 18 * * ? *). I am based in India, and this translate to midnight IST timezone, which is 18:30:00 GMT.

I am going to use AWS Cloudwatch logs to log the data from our lambda runs.

EC2 instance ebs snapshot delete solution

Workflow and code

The workflow that I will use is: > 🕛 Midnight ➡️ AWS EventBridge rule triggers ➡️ Runs Lambda code ➡️ Checks EBS snapshots, and if they are created more than 7 days back, deletes them ➡️ Logs to cloudwatch logs
Install boto3
```
python3 -m pip install boto3
```

Lambda code

Initializaing a boto3 client

ec2_client = boto3.client('ec2')

Fetching all regions

def get_regions(ec2_client):
    return [region['RegionName'] for region in ec2_client.describe_regions()['Regions']]

Initializing a boto3 ec2 client per region

ec2_client = boto3.client('ec2',region_name=region)

List all snapshots in the region for the account id using describe_snapshots(OwnerIds=[account_id]).

def get_snapshots_from_a_region(ec2_client,account_id):
return (ec2_client.describe_snapshots(OwnerIds=[account_id])['Snapshots'])

Compare the age of the snapshots to current date and time, and if the difference is greater than 7 days, delete the snapshot. We will use the delete_snapshot() method of the client to perform this activity.

def get_age_of_snapshot(snap):
return ((datetime.now() - snap['StartTime'].replace(tzinfo=None)).days)

def delete_snapshot_from_a_region(ec2_client,snap):
ec2_client.delete_snapshot(SnapshotId=snap['SnapshotId'])

Putting it all together - Take a look at my GITHUB page for the complete code.

Cloudwatch logs

Coming up next

Part 3 of this tutorial where I will talk about cleaning up unattached ebs volumes after X days.

AWS Infrastrucutre Maintenance Using AWS Lambda and AWS EventBridge [EC2 instance daily ebs volume snapshots] [Part 1]

Soumyajyoti Biswas — Tue, 29 Mar 2022 18:36:43 +0000

Summary
Architecture diagram and high level overview of all the solutions
- Architecture diagram
- EC2 instance daily ebs volume snapshots
- EC2 instance daily ebs snapshot cleanup after X days
- EC2 instance daily unattached ebs volume cleanup after X days
- Deregister old EC2 Amazon machine images after X days
AWS IAM permissions
- Permissions
- Trust relationship
AWS EventBridge and Lambda
EC2 instance daily ebs volume snapshots solution
Coming up next

Summary

Welcome to PART-1 of a four part tutorial, on how to leverage AWS services like Lambda and EventBridge, to perform housekeeping on your AWS infrastructure on a schedule automatically. I am going to perform the following using AWS Lambda, EventBridge and python🐍.

[PART-1] Create EBS volume snapshots of all our AWS EC2 instances in all regions, and tag them.
[PART-2] Cleanup EBS volume snapshots from all our regions, whose age is greater than X days.
[PART-3] Cleanup EBS volumes from all our regions, which is not attached to a resource, and whose age is greater than X days.
[PART-4] Deregister Amazon Machine Images from all our regions whose age is greater than X days.

I am going to do all those using AWS EventBridge, AWS Lambda and python. This is going to automate any manual effort of going to every region and finding artifacts related to these and performing maintenance on them.

Architecture diagram and high level overview of all the solutions

Architecture diagram

EC2 instance daily ebs volume snapshots

I am going to list out all instances in all of our regions, and its associated volumes, and create EBS snapshots from them. Also I am going to add custom tags to these snapshots.

EC2 instance daily ebs snapshot cleanup after X days

I am going to list all the EBS snapshots that we own in our regions, and then delete those older than X days.

EC2 instance daily unattached ebs volume cleanup after X days

I am going to list all the EBS volumes that we own in our regions, and then delete those which are not attached to any resource and older than X days.

Deregister old EC2 Amazon machine images after X days

I am going to list all the Amazon Machine Images that we own in our regions, and then delete those which are not attached to any resource and older than X days.

AWS IAM permissions

Create an IAM role with the following permissions and trust policy.

Permissions

Attach a permission policy template to your role which will allow for:

AWS cloudwatch log stream creation and writing.
Describe EC2 instances, volumes, snapshots and AMI's.
EC2 snapshot creation and deletion.
EC2 volume deletion.
EC2 AMI deregistration.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:CreateLogGroup",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateSnapshot",
                "ec2:CreateTags",
                "ec2:DeleteSnapshot",
                "ec2:Describe*",
                "ec2:ModifySnapshotAttribute",
                "ec2:ResetSnapshotAttribute",
                "ec2:DeleteVolume",
                "ec2:DeregisterImage"
            ],
            "Resource": "*"
        }
    ]
}

Trust relationship

Allow the lambda service access to your IAM role.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

AWS EventBridge and Lambda

I am going to use AWS Lambda to run our python code to do run our infrastructure maintenance.

I am going to use AWS Cloudwatch logs to log the data from our lambda runs.

EC2 instance daily ebs volume snapshots solution

Workflow and code

The workflow that I will use is: > 🕛 Midnight ➡️ AWS EventBridge rule triggers ➡️ Runs Lambda code ➡️ Creates EC2 volume snapshots for all instances in each region ➡️ Logs to cloudwatch logs
Install boto3
```
python3 -m pip install boto3
```

Lambda code

Initializaing a boto3 client

ec2_client = boto3.client('ec2')

Fetching all regions

def get_regions(ec2_client):
    return [region['RegionName'] for region in ec2_client.describe_regions()['Regions']]

Initializing a boto3 ec2 resource per region

ec2_resource = boto3.resource('ec2',region_name=region)

List all instances in the region using instances.all(). You can use filters also if you want.

instances = ec2_resource.instances.all()

List all volumes of each instance using volumes.all(). You can use filters also if you want.

for instance in instances:
    volumes = instance.volumes.all()

Create snapshot of the volume using the create_snapshot() method. Will create a tag of 'Instance_Id' and assign it the value of the 'instance id' the volume is attached to and also a tag of 'Device' and assign it the value of the attribute 'Device' from the volume.

desc = f'Backup for instance: {i.id} and volume: {v.id}.'
tags = [
    {
        'Key':'Instance_Id',
        'Value':f'{instance.id}'
    },
    {
        'Key':'Device',
        'Value':f'{volume.attachments[0]["Device"]}'
    }
]
for volume in volumes:
    snapshot = volume.create_snapshot(
        Description=desc,
        TagSpecifications=[
            {
                'ResourceType':'snapshot',
                'Tags': tags
            }
        ]
    )

Putting it all together - Take a look at my GITHUB page for the complete code.

Cloudwatch logs

Coming up next

Part 2 of this tutorial where I will talk about creating code for daily ebs snapshot cleanup older than X days.

Python scripting basics - Tic-tac-toe game.

Soumyajyoti Biswas — Mon, 21 Mar 2022 17:13:43 +0000

Summary
Code
- Let's talk logic
- Building the score board and displaying it
- Inputs from players
- Validating player provided name
- Validating player provided symbol
- Setting the symbol for the computer
- Checking which cells are available to add input to
- Validating if a player is providing correct input for cell value
- Auto populating the last cell
- Checking who won
Bonus
- Adding a time delay
- Ascii art
Putting it all together

Summary

Okay, who hasn't played tic-tac-toe? Okay, try noughts and crosses? Still no? This is one of the classic games out there, quick, short and fun. Take a look at the wikipedia page.
Today we are going to build the game from scratch, to be played on a terminal, and yes, we are going to use python. So let's begin shall we?

LINK TO GITHUB VIDEO

Code

Let's talk logic

Tic-tac-toe is played between two players on a 3x3 grid. One playes chooses 'X' and the other player chooses 'O'. Anyone can play first, but for our game, let us consider whoever chooses 'X' gets to play first. Any player who gets three 'X' or 'O' in a row or column or diagonally wins the game. If at the end of the game, no player is able to achieve that, the game ends in a draw.

The following table demostrates how a 3x3 grid would look like. Each row and its associated column number is displayed as the cell value. For row 1 column 1 it is R1C1, row 2 column 2 it is R2C2, etc.

R1C1	R1C2	R1C3
R2C1	R2C2	R2C3
R3C1	R3C2	R3C3

For a player to win, they have to get their chosen symbol of 'X' or 'O' in one of the following series. It doesn't matter the order which they went for one first.

Winning Combinations
R1C1,R1C2,R1C3
R2C1,R2C2,R2C3
R3C1,R3C2,R3C3
R1C1,R2C1,R3C1
R1C2,R2C2,R3C2
R1C3,R2C3,R3C3
R1C1,R2C2,R3C3
R3C1,R2C2,R1C3

We will do the following in order

Display the set of rules to the player.
Ask the player to enter their name, and if they don't we will assign one, say Bob. How does Bob sound?
Ask the player if they want 'X' as their playing symbol or 'O', and assign the other one to the computer.
Let our computer side player green our human.
Design a pretty looking score board to keep track of their scores.
While the game is being played we will
- Display the cell locations which are not yet occupied by 'X' or 'O'.
- Let the computer decide randomly which cell value to pick as its choice. I am keeping this basic. At a later point of time, will add difficulty levels to the game, and will let the computer play offensive.
- After both the player and computer has provided their input, check if anyone has won.

Building the score board and displaying it

We will use two modules here, pandas, and tabulate. Pandas will give as the dataframe to store data into, and we will tabulate to make it pretty.

You can install both into your environment using the following command:

python3.10 -m pip install pandas
python3.10 -m pip install tabulate

#This is how our dataframe will look like
>>> import pandas
>>> pandas.DataFrame([['11','12','13'],['21','22','23'],['31','32','33']],columns=['C1','C2','C3'],index=['R1','R2','R3'])
    C1  C2  C3
R1  11  12  13
R2  21  22  23
R3  31  32  33
>>>

# This is how our final scoreboard will look like on display
>>> import tabulate
>>> d = pandas.DataFrame([['11','12','13'],['21','22','23'],['31','32','33']],columns=['C1','C2','C3'],index=['R1','R2','R3'])
>>> print(tabulate.tabulate(d, tablefmt = 'fancy_grid', showindex=False))
╒════╤════╤════╕
│ 11 │ 12 │ 13 │
├────┼────┼────┤
│ 21 │ 22 │ 23 │
├────┼────┼────┤
│ 31 │ 32 │ 33 │
╘════╧════╧════╛

Inputs from players

Validating player provided name

Store the user provided name in a global variable. If the name is empty assign a default name Bob.

>>> validate_user_input_name()
Enter your name: SB
>>> print(user_input_name)
Sb
>>> validate_user_input_name()
Enter your name: 
>>> print(user_input_name)
Bob

Validating player provided symbol

Ask the player if they want to choose 'X' as their symbol or 'O' and assign the opposite to the computer to play with. Any invalid attempts, a total of three will end the game.

>>> validate_user_input_name()
Enter your name: sb
>>> user_input_name
'SB'
>>> validate_user_input_symbol()
Player SB enter either ['X', 'O'] without the quotes : x
>>> user_input_symbol
'X'
>>> validate_user_input_symbol()
Player SB enter either ['X', 'O'] without the quotes : z
Player SB enter either ['X', 'O'] without the quotes : a
Player SB enter either ['X', 'O'] without the quotes : b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 13, in validate_user_input_symbol
ValueError: Maximum '3' invalid symbol choice attempts reached. Thank you for playing.
>>> cpu_input_symbol
'O'
>>> validate_user_input_symbol()
Player SB enter either ['X', 'O'] without the quotes : O
>>> user_input_symbol
'O'
>>> cpu_input_symbol
'X'
>>>

Setting the symbol for the computer

In the above section you see that the computer player symbol is automatically set the moment the player chooses a correct symbol. We use a simple if else statement for that.

if user_input_symbol == 'X':
    cpu_input_symbol = 'O'
else:
    cpu_input_symbol = 'X'

Checking which cells are available to add input to

By using list comprehensions we can quickly find out which cells does not have a 'X' or 'O' value in it.

# score_board is our dataframe
# symbol choices is a list of ['X','O']
([score_board.iloc[a][b] for a in range(3) for b in range(3) if score_board.iloc[a][b] not in symbol_choices])

Validating if a player is providing correct input for cell value

Display the cells available for input using the previous method then ask for user input. If the input provided by the user is incorrect three times, exit.

empty_slots = get_empty_slots()
invalid_input_count = 0
while invalid_input_count < 3:
    user_input_cell_choice = input(f"\nEnter either {empty_slots} without the quotes : ")
    if user_input_cell_choice not in empty_slots:
        invalid_input_count += 1
    else:
        return user_input_cell_choice
if invalid_input_count == 3:
    raise ValueError(f"Maximum '{invalid_input_count}' invalid input choice attempts reached. Thank you for playing.")

Auto populating the last cell

The game will be played for 4 rounds, if no one has won before that, and at the start of round 5, only one cell will be left, we can assign it the value of 'X'. We are using 'X' since we are assuming that player using the 'X' symbol starts the game.

X|O|X|O|X|O|X|O|X ← this will always be 'X'

Checking who won

As described previously in our code logic section, the winning combinations are as follows:

Winning Combinations
R1C1,R1C2,R1C3
R2C1,R2C2,R2C3
R3C1,R3C2,R3C3
R1C1,R2C1,R3C1
R1C2,R2C2,R3C2
R1C3,R2C3,R3C3
R1C1,R2C2,R3C3
R3C1,R2C2,R1C3

A simple iteration of 'X' and 'O' and comparing it with the dataframe values, will show us if any of the players have already won or now.

# symbol_choices = ['X','O']
for symbol_choice in symbol_choices:
    for i in range(3):
        if (symbol_choice == score_board.iloc[i][0] == score_board.iloc[i][1] == score_board.iloc[i][2]) or (symbol_choice == score_board.iloc[0][i] == score_board.iloc[1][i] == score_board.iloc[2][i]):
            return(True,symbol_choice,player_choices[symbol_choice])
    if (symbol_choice == score_board.iloc[0][0] == score_board.iloc[1][1] == score_board.iloc[2][2]) or (symbol_choice == score_board.iloc[0][2] == score_board.iloc[1][1] == score_board.iloc[2][0]):
        return(True,symbol_choice,player_choices[symbol_choice])    
return (False,symbol_choice,player_choices[symbol_choice])

Bonus

Adding a time delay

The time module has the sleep command which can be used to introduce a time delay, making it look like the computer player is actually thinking about a choice.

>>>import time
>>>time.sleep(2) # this is in seconds.

Ascii art


   ###     ######   ######  #### ####       ###    ########  ######## 
  ## ##   ##    ## ##    ##  ##   ##       ## ##   ##     ##    ##    
 ##   ##  ##       ##        ##   ##      ##   ##  ##     ##    ##    
##     ##  ######  ##        ##   ##     ##     ## ########     ##    
#########       ## ##        ##   ##     ######### ##   ##      ##    
##     ## ##    ## ##    ##  ##   ##     ##     ## ##    ##     ##    
##     ##  ######   ######  #### ####    ##     ## ##     ##    ##

If you do not know this or this website already, do pay them a visit. Its fun to add some ascii graphics to terminal code. Our friend "The Machinee" is from here it self.

Putting it all together

Visit my GitHub page to check out the complete code to create a tic-tac-toe game that can be played on the terminal.

Playing rock, paper and scissors using python on a terminal

Soumyajyoti Biswas — Tue, 15 Mar 2022 01:35:22 +0000

Summary
Code
- Let's talk logic
- Of all things random
- Validating user input
- Validating user provided name
- Validating user provided input
Bonus
- Clearing screen for readibility
- Displaying a scoreboard
- Ascii art
Putting it all together

Summary

I have always enjoyed an occasional game of Rock, paper and scissors with my friends. What better way to demonstrate the use of randomness generator in python. We could have just done a simple head and tails, but why not this. Walk with me and see how we can create a simple Rock, paper, scissors game that we can play on the terminal.

LINK TO GITHUB VIDEO - HOW THE GAME WORKS ON A TERMINAL

Code

Let's talk logic

Rock beats scissors, scissors beats paper, and paper beats rock. When playing against an opponent, the possibilities are that either you and your opponent will pick the same or will pick two different elements. If you both pick the same element it will be considered a draw, and if you and your opponent pick different elements, one will win, and the other will lose the round.

The following table demostrates who would win if both pick different elements.

	TABLE
Payer 1	Player 2	Who wins?
----------	----------	-----------
Rock	Paper	Player 2
Rock	Scissors	Player 1
Paper	Scissors	Player 2
Paper	Rock	Player 1
Scissors	Rock	Player 2
Scissors	Paper	Player 1

While keeping scores, each player gets a point every time they win a round. One point is assigned to a draw column every time it is a draw, which means both players picked the same element. At the end of five rounds, the total score for both players is calculated and the winner is declared. If they both score same, it is a tie.

In our case we will play against the computer. To simplify things, instead of entering 'Rock', 'Paper' and 'Scissors' as characters, which eventually we (I) would mispell, I choose to assign numbers to the elements. 'Rock' == 1, 'Paper' == 2 and 'Scissors' == 3.

To quickly check who wins, we can validate the difference between the value of the element picked by the computer vs the value of the element picked by us. For the computer to win, the difference between its value and ours will either be '-2' or '1'.

Of all things random

Making the computer choose randomly from a list of choices. The dictionary provided to the computer is {'Rock':1, 'Paper':2, 'Scissors':3}. The values from the dict is used as a list input to a random generator. We use the random module to do this. We use random.choice to let the computer choose one value from a list of values.

>>> import random
>>> print(machine_choices)
{'Rock': 1, 'Paper': 2, 'Scissors': 3}
>>> def get_machine_choice():
...     return(random.choice(list(machine_choices.values())))
... 
>>> get_machine_choice()
1
>>> get_machine_choice()
3
>>> get_machine_choice()
2
>>> get_machine_choice()
2
>>> get_machine_choice()
2
>>> get_machine_choice()
1

Validating user provided input

User provided name validation

Store the user provided name in a global variable. If the name is empty assign a default name Bob.

def validate_user_input_name():
    global user_input_name # Declaring the name provided by the user to modify the global variable.
    user_input_name = input("\nEnter your name: ") # Take user input for name
    if len(user_input_name.strip()) == 0: # If a space / carriage return is provided instead of a name, default to a name, in our case, Bob. We love Bob.
        user_input_name = 'Bob'

# OUTPUT

>> def validate_user_input_name():
...     global user_input_name # Declaring the name provided by the user to modify the global variable.
...     user_input_name = input("\nEnter your name: ") # Take user input for name
...     if len(user_input_name.strip()) == 0: # If a space / carriage return is provided instead of a name, default to a name, in our case, Bob. We love Bob.
...         user_input_name = 'Bob'
... 
>>> validate_user_input_name()
Enter your name: Sb
>>> print(user_input_name)
Sb
>>> validate_user_input_name()
Enter your name: 
>>> print(user_input_name)
Bob

User provided input validation

Return True if user provided input is either '1' or '2' or '3'. If it is anything else return False, including for empty spaces and carriage returns.

def validate_user_input():
    global user_input # Declaring the user_input provided by the user to modify the global variable.
    user_input = input("\nEnter either 'Rock':1, 'Paper':2 or 'Scissors':3: ")
    if len((str(user_input)).strip()) == 0: # Removing all carriage returns / empty space cases
        return False
    elif int(user_input) not in list(machine_choices.values()): # Removing all invalid integer cases
        return False
    else:
        user_input = int(user_input)
        return True

>>> def validate_user_input():
...     global user_input
...     user_input = input("\nEnter either 'Rock':1, 'Paper':2 or 'Scissors':3: ")
...     if len((str(user_input)).strip()) == 0:
...         return False
...     elif int(user_input) not in list(machine_choices.values()):
...         return False
...     else:
...         user_input = int(user_input)
...         return True
... 
>>> validate_user_input()
Enter either 'Rock':1, 'Paper':2 or 'Scissors':3: 1
True
>>> validate_user_input()
Enter either 'Rock':1, 'Paper':2 or 'Scissors':3: 11
False
>>> validate_user_input()
Enter either 'Rock':1, 'Paper':2 or 'Scissors':3: 
False
>>> validate_user_input()
Enter either 'Rock':1, 'Paper':2 or 'Scissors':3:        
False

Bonus

Clearing screen for readibility

The os module has uses the standard c function system() to help execute system level commands. For clearing the screen in a linux environment you will use the clear command or in case of a windows environment you will use cls command.

import os
x = import.system('clear') # Linux environments

x = import.system('cls') # Windows environments

Displaying scores as via a DataFrame

Welcome to the world of pandas. You can install pandas using the following code

python3.10 -m pip install pandas

The scoreboard that we designed is using pandas.

>>> score_board = pandas.DataFrame(columns=["Player_1_score_card","Player_2_score_card",'Draws'],index=['Round 1','Round 2','Round 3','Round 4','Round 5'])
>>> score_board = score_board.fillna(0)
>>> score_board
         Player_1_score_card  Player_2_score_card  Draws
Round 1                    0                    0      0
Round 2                    0                    0      0
Round 3                    0                    0      0
Round 4                    0                    0      0
Round 5                    0                    0      0

Ascii art


   ###     ######   ######  #### ####       ###    ########  ######## 
  ## ##   ##    ## ##    ##  ##   ##       ## ##   ##     ##    ##    
 ##   ##  ##       ##        ##   ##      ##   ##  ##     ##    ##    
##     ##  ######  ##        ##   ##     ##     ## ########     ##    
#########       ## ##        ##   ##     ######### ##   ##      ##    
##     ## ##    ## ##    ##  ##   ##     ##     ## ##    ##     ##    
##     ##  ######   ######  #### ####    ##     ## ##     ##    ##

If you do not know this or this website already, do pay them a visit. Its fun to add some ascii graphics to terminal code. Our friend "The Machinee" is from here it self.

Putting it all together

Visit my GitHub page to check out the complete code to create a Rock, paper, scissors game that can be played on the terminal.

Python scripting basics - BMI calculator

Soumyajyoti Biswas — Fri, 11 Mar 2022 05:08:33 +0000

Summary
Code
- Taking data from the user
- Calculating the B.M.I
- Getting the B.M.I category
- Putting the code together

Summary

In today's post I will walk you step by step on how to write a basic python script to calculate your body mass index(B.M.I). We will ask the user for some input, and based on it, calculate their B.M.I and return also tell the user, which category their B.M.I falls under. Body mass index is defined by the formula as below:

B.M.I = [your weight in (Kg) / (your height in (m))^2]
Kg - Kilogram
m - metre

There are several defined B.M.I categories, such as:

Underweight = B.M.I below < 18.5.
Normal weight = B.M.I between 18.5-24.9.
Overweight = B.M.I between 25-29.9.
Obesity = B.M.I 30 or above 30.

Code

Taking data from the user

We are going to use the input function, and store the data provided by the user in a variable.

>>> user_name = input("Enter your name: ")
Enter your name: Soumyajyoti Biswas
>>> print(user_name)
Soumyajyoti Biswas
>>>

We are going to ask the user for the name of the user, their weight in Kg(s) and their height in cm(s)

user_name = input("Enter your name: ")
user_weight = float(input("Enter your weight in Kg(s): "))
user_height = float(input("Enter your height in cm(s): "))

Calculating the B.M.I

Lets take the data that the user provided and put it through our B.M.I formula. Note that the user is providing their height in cm(s). So we will convert that to metre first. To convert cm to m, you divide it by 100.

>>> user_name = input("Enter your name: ")
Enter your name: Soumyajyoti Biswas
>>> user_weight = float(input("Enter your weight in Kg(s): "))
Enter your weight in Kg(s): 70
>>> user_height = float(input("Enter your height in cm(s): "))
Enter your height in cm(s): 165
>>> bmi = round(user_weight/((user_height/100) ** 2),1)
>>> print(bmi)
25.7

In the above code I did two things:
- [1] Convert the user input for weight and height from string to a float data type. The input function provides data output as type string. Hence we have to convert it to a float data type to perform numerical operation on it. See what error comes if you do not [Ref1]. You can see the various datatypes here.
- [2] Round the result of B.M.I calculation to a single decimal. See how the round function works.

# Error displayed if you try to cast a string to a float. [Ref1]
>>> x = input()
12345
>>> type(x)
<class 'str'>
>>> x + x
'1234512345'
>>> type(x + x)
<class 'str'>
>>> x / 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'str' and 'int'

Getting the B.M.I category based on calculated B.M.I

Let us take the calculated B.M.I and try and place it in a category as defined above. We will use the If / elif / else to do that.

>>> if bmi < 18.5:
...   result = "Underweight"
... elif bmi >= 18.5 and bmi <= 24.9:
...   result = "Normal"
... elif bmi >= 25 and bmi <= 29.9:
...   result = "Overweight"
... else:
...   result = "Very overweight"
... 
>>> print(result)
Overweight

Putting it all together

Let's put all the code together to build a script

user_name = input("Enter your name: ")
user_weight = float(input("Enter your weight in Kg(s): "))
user_height = float(input("Enter your height in cm(s): "))
bmi = round(user_weight/((user_height/100) ** 2),1)
if bmi < 18.5:
  result = "Underweight"
elif bmi >= 18.5 and bmi <= 24.9:
  result = "Normal"
elif bmi >= 25 and bmi <= 29.9:
  result = "Overweight"
else:
  result = "Very overweight"
print(f"Hello {user_name}. Your BMI is {bmi}. Your body mass index is {result}.")

You can download the file from my GitHub page.

Installing Libre Office in Kali Linux

Soumyajyoti Biswas — Thu, 03 Mar 2022 13:56:02 +0000

Summary

Download from the official source
Extract and install Libre Office

In this tutorial I will show you how to install Libre Office in Kali linux. In their own words

You can find them here.

Download from the official source

Go to their official web page at https://www.libreoffice.org/download/download/.

You can download the latest current version of the .deb file. The current version while writing this is 7.3.1, which you can find here. You can also use a mirror list to use a direct FTP link to download.

┌──(user㉿kali-01)-[~/Downloads/LibreOffice]
└─$ wget "https://ftp.osuosl.org/pub/tdf/libreoffice/stable/7.3.1/deb/x86_64/LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz"
--2022-03-03 18:57:06--  https://ftp.osuosl.org/pub/tdf/libreoffice/stable/7.3.1/deb/x86_64/LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz
Resolving ftp.osuosl.org (ftp.osuosl.org)... 64.50.233.100, 64.50.236.52, 140.211.166.134, ...
Connecting to ftp.osuosl.org (ftp.osuosl.org)|64.50.233.100|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 195897910 (187M) [application/x-gzip]
Saving to: ‘LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz’

LibreOffice_7.3.1_Linux_x86 100%[==========================================>] 186.82M  4.53MB/s    in 53s     

2022-03-03 18:58:00 (3.55 MB/s) - ‘LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz’ saved [195897910/195897910]

Extract and install Libre Office

Once you have downloaded the version of Libre Office that you would like to install, extract the tar.gz file.

┌──(user㉿kali-01)-[~/Downloads/LibreOffice]
└─$ ls
LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz

┌──(user㉿kali-01)-[~/Downloads/LibreOffice]
└─$ tar xvf LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz 
# Extraction lines here <truncated>
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libobasis7.3-base_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libobasis7.3-math_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libobasis7.3-onlineupdate_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libobasis7.3-extension-beanshell-script-provider_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libreoffice7.3_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libobasis7.3-en-us_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/libreoffice7.3-math_7.3.1.3-3_amd64.deb
LibreOffice_7.3.1.3_Linux_x86-64_deb/readmes/
LibreOffice_7.3.1.3_Linux_x86-64_deb/readmes/README_en-US

Once extracted, open a terminal, and go to the download folder. Go inside the DEBS folder and use the dpkg command to install it.


┌──(user㉿kali-01)-[~/Downloads/LibreOffice]
└─$ ls                                                            
LibreOffice_7.3.1.3_Linux_x86-64_deb  LibreOffice_7.3.1_Linux_x86-64_deb.tar.gz

┌──(user㉿kali-01)-[~/Downloads/LibreOffice]
└─$ cd LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS/

┌──(user㉿kali-01)-[~/Downloads/LibreOffice/LibreOffice_7.3.1.3_Linux_x86-64_deb/DEBS]
└─$ sudo dpkg -i *.deb
# Installation lines here <truncated>
Setting up libreoffice7.3-dict-fr (7.3.1.3-3) ...
Setting up libreoffice7.3-draw (7.3.1.3-3) ...
Setting up libreoffice7.3-en-us (7.3.1.3-3) ...
Setting up libreoffice7.3-impress (7.3.1.3-3) ...
Setting up libreoffice7.3-math (7.3.1.3-3) ...
Setting up libreoffice7.3-writer (7.3.1.3-3) ...
Processing triggers for desktop-file-utils (0.26-1) ...
Processing triggers for mailcap (3.70+nmu1) ...
Processing triggers for hicolor-icon-theme (0.17-2) ...
Processing triggers for shared-mime-info (2.1-2) ...

To open Libre Office post install, you can search under Applications → Type in LibreOffice

Configuring AWS EFS to work with Kali Linux running on AWS EC2

Soumyajyoti Biswas — Mon, 24 Jan 2022 02:58:06 +0000

Summary

In this post I would walk through the following:

Creating an Amazon EFS file system
Configuring an Amazon EFS file system to work with Kali Linux running on AWS EC2
- Pre-requisites
- Mount using AWS efs-mount-helper
Attaching an EFS file system while creating an EC2 instance

[1] Create your own Amazon EFS File System

Log in to your AWS Account.
Go to your region of choice where your EC2 instance is hosted. If you do not have an EC2 instance running Kali linux you can follow my previous post to set one up. Link to post here.
Go to the service EFS and click on Create file system.
Provide a name for your efs file system (note its optional), select the VPC where your EC2 instance is running already or one where you plan to spin one up, and select the availability of your EFS. Regional is recommended option for availability for redundant data storage. Related AWS documentation for creating EFS. link.
Once your EFS file system is created, you will see an available state displayed to you in the EFS console.
Create a securtiy group to allow NFS access.
Create mount targets as in link. You can see them in the network tab of your efs file system.

[2] Configuring an Amazon EFS file system to work with Kali Linux running on AWS EC2

[2.1.] Pre-requisites

Install amazon-efs-utils debian package. AWS documentation link here. Though the efs-utils documentation does not call out Kali linux explicitly, the debian package does work as you will see through this tutorial.

sudo apt-get -y update
sudo apt-get -y install git binutils
git clone https://github.com/aws/efs-utils
cd /path/efs-utils
./build-deb.sh
sudo apt-get -y install ./build/amazon-efs-utils*deb

The connecting EC2 instance must be in a virtual private cloud (VPC) based on the Amazon VPC service. It also must be configured to use the DNS server provided by AWS. For information about the Amazon DNS server, see DHCP Options Sets in the Amazon VPC User Guide.
The VPC of the connecting EC2 instance must have DNS hostnames enabled. For more information, see Viewing DNS Hostnames for Your EC2 Instance in the Amazon VPC User Guide.

[2.2.] Mount the file system using efs-mount-helper

Create a mount directory.

mkdir ~/efs-mount-point

Mount your directory with tls encryption in transit. See AWS documentation here.

sudo mount -t efs -o tls fs-<your fs id> ~/efs-mount-point/

You can verify this using the mount command. You will see an output line from the mount command as

127.0.0.1:/ on /home/<your user>/efs-mount-point type nfs4

To auto-mount using /etc/fstab you can first create an access point for your user see link. Once you have created an access point, you can use the following in the /etc/fstab file.

file-system-id efs-mount-point efs _netdev,tls,accesspoint=access-point-id 0 0

Configure users, groups and permissions as defined in this link, to create an access/permissions hierarchy for using your efs file system.

[3] Attach an EFS file system while creating an instance

You can refer to my post on configuring Kali linux on AWS EC2.
Log into you AWS account, and choose a region nearest to you. If you do not have an account you can sign up for one for free using this link.
Go to EC2 service and click on Launch Instances.
In AMI's seach for the keyword Kali and select the image from AWS marketplace as shown in the image below

Accept the aws marketplace subscription dialog box.
Add an instance type.
Select a VPC and the basic networking setup. Add an EBS volume and choose a keypair to associate with you instance.
Make sure to associate a security group with your instance which has inbound ports 3389 and 22 open.
In the configure instance details page, under file systems, choose the file system you created in step 1.
Review and launch the instance.

Install and configure GUI for Kali linux on AWS EC2

Soumyajyoti Biswas — Tue, 18 Jan 2022 16:10:47 +0000

Summary

In my previous post, I explained in detail, how to setup Kali Linux on a Hyper-V platform hosted on Windows 11. In this post we will set up Kali Linux on the AWS EC2 platform, and we will also configure a GUI for us to access. The following will be covered.

Spin up an EC2 instance with a Kali linux image from AWS Marketplace.
Once the EC2 instance is available install GUI tools on it.
Change hostname.
Change timezone.
Install MS-Edge browser.
Install Homebrew and Github CLI.
Install VSCode and some common extensions.

[1] Spin up an EC2 instance

Log into you AWS account, and choose a region nearest to you. If you do not have an account you can sign up for one for free using this link.
Go to EC2 service and click on Launch Instances.
In AMI's seach for the keyword Kali and select the image from AWS marketplace as shown in the image below

Accept the aws marketplace subscription dialog box.
Add an instance type.
Select a VPC and the basic networking setup. Add an EBS volume and choose a keypair to associate with you instance.
Make sure to associate a security group with your instance which has inbound ports 3389 and 22 open.
Review and launch the instance.

[2] Install GUI tools via ssh

Once the EC2 instance is available use your key-pair to ssh to it.
Once you are in run the following commands to update your OS. You will get a couple of interactive prompts along the way while your packages are being updated. If you do not understand an of them leave them unchanged.



# See the man page for apt-get to understand each command better.
# https://linux.die.net/man/8/apt-get
sudo apt-get -y update
sudo apt-get -y upgrade
sudo apt-get -y dist-upgrade

Install the GUI tools using the following commands



sudo apt-get install -y kali-desktop-xfce xorgxrdp xrdp
sudo systemctl enable xrdp --now

You can check the xrdp status using the following command, it should be in running state.



┌──(kali㉿kali)-[~]
└─$ sudo service xrdp status

● xrdp.service - xrdp daemon
     Loaded: loaded (/lib/systemd/system/xrdp.service; enabled; vendor preset: disabled)
     Active: active (running) since Mon 2022-01-17 08:52:38 UTC; 5min ago
       Docs: man:xrdp(8)
             man:xrdp.ini(5)
    Process: 66628 ExecStartPre=/bin/sh /usr/share/xrdp/socksetup (code=exited, status=0/SUCCESS)
    Process: 66636 ExecStart=/usr/sbin/xrdp $XRDP_OPTIONS (code=exited, status=0/SUCCESS)
   Main PID: 66637 (xrdp)
      Tasks: 1 (limit: 9090)
     Memory: 904.0K
        CPU: 10ms
     CGroup: /system.slice/xrdp.service
             └─66637 /usr/sbin/xrdp

Add user for RDP



# See man page for useradd
# https://linux.die.net/man/8/useradd
# Replace <Username> with the user login
sudo useradd -m <UserName>
# Set the user shell for the user <UserName>
# https://linux.die.net/man/1/chsh
sudo chsh -s /bin/zsh <UserName>

Set a new password for your RDP user



┌──(kali㉿kali)-[~]
└─$ sudo passwd sysadmin                                                                                                                 1 ⨯
New password:
Retype new password:
passwd: password updated successfully

Add the new user to the sudo group



sudo useradd -a -G sudo <UserName>

Download a RDP client like RDC Man and use your EC2 instance IP address / DNS name as configured for your VPC to access the EC2 instance.

[3] Set hostname

Edit the /etc/hosts file using an editor. Add the hostname as in the image where "hostname" is the name of your choice. Use the same name in the next command also.

Now use the below command to set the hostname using hostnamectl. Use the same name set in /etc/hosts file above.



# Make sure <hostname> used here is same as the one used in /etc/hosts file. Else sudo might break.
sudo hostnamectl hostname <hostname>

You can see the hostname you set using hostnamectl command.



┌──(kali㉿kali)-[~]
└─$ sudo hostnamectl
 Static hostname: ll-kali-02
       Icon name: computer-vm
         Chassis: vm

[4] Set timezone

You can set the timezone using the timedatectl command where "timezone" is the one of your choice.



# See man for timedatectl
# Example used is Asia/Kolkata timezone
sudo timedatectl set-timezone Asia/Kolkata

Use the timedatectl command to see your timezone.



┌──(kali㉿kali)-[~]
└─$ timedatectl

               Local time: Mon 2022-01-17 15:40:02 IST
           Universal time: Mon 2022-01-17 10:10:02 UTC
                 RTC time: Mon 2022-01-17 10:10:02
                Time zone: Asia/Kolkata (IST, +0530)

[5] Install Microsoft Edge Browser

Use the steps mentioned in this link.



## Installing the stable version
## Setup
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo install -o root -g root -m 644 microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-beta.list'
sudo rm microsoft.gpg
## Install
sudo apt update
## Install the stable update
sudo apt install microsoft-edge-stable

[6] Install Homebrew and GitHub CLI

Use the steps mentioned in this link to install homebrew on your OS.



/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Once this is installed follow the onscreen instructions to add brew to your current and shell profile.

Install Github CLI



brew install gh

[7] Install Visual Studio Code

Download the .deb file for VsCode from the following link.
Install VsCode using the following command



# Once you download the .deb file from the above link use the following command to install VsCode
sudo apt install ./<file>.deb

[7.1] Install common extensions in VsCode

Use the following code to install some of the common extensions using VsCode CLI.



code --install-extension amazonwebservices.aws-toolkit-vscode --force
code --install-extension christian-kohler.path-intellisense --force
code --install-extension CoenraadS.bracket-pair-colorizer --force
code --install-extension DavidAnson.vscode-markdownlint --force
code --install-extension eamodio.gitlens --force
code --install-extension esbenp.prettier-vscode --force
code --install-extension GitHub.vscode-pull-request-github --force
code --install-extension ms-python.python --force
code --install-extension ms-python.vscode-pylance --force
code --install-extension ms-toolsai.jupyter --force
code --install-extension ms-toolsai.jupyter-keymap --force
code --install-extension ms-toolsai.jupyter-renderers --force
code --install-extension VisualStudioExptTeam.vscodeintellicode --force
code --install-extension zhuangtongfa.material-theme  --force

Installing & Configuring Kali Linux on Hyper-v hosted on Windows 11

Soumyajyoti Biswas — Sun, 16 Jan 2022 05:39:24 +0000

Setting up Hyper-V on the host

Open a PowerShell window in admin mode
Run the following command

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All

Restart the computer.

Download the Kali linux iso & create a VM in HyperV

Download the kali linux ISO from here.
Open up the Hyper-V console on your host machine.
Under Action click on New → Virtual Machine. Follow through the steps to create a VM, and in the Installation Options dialog box, choose Install and operating system from an ISO/DVD and point it to the location of your ISO. Once the VM is created, before starting it, turn off the secure boot.
The ISO for Kali linux will boot you in. Select a GUI install and follow through the steps.
Once Kali linux is installed, you still have to install the Hyper-V guest tools. This will help you use the enhanced session mode in Hyper-V. The enhanced session mode provides a full screen experience for the guest OS over XRDP.
To install the enhanced session mode, run the following command in a terminal inside the Kali OS

$ kali-tweaks
#opens up a GUI dialog box

Select Virtulization → configure. Once the installation is complete reboot your Kali OS.
On your Hyper-V host make go to Action → Hyper-V settings → Enhanced Session Mode Policy → Allow enhanced session mode. Make sure the checkbox is ticked.
While keeping your VM in shutdown mode, reboot your host OS.
Once the host OS is up, start the guest Kali OS. Connect to it and you should be presented with a dialog box that allows you to go full screen.

Configuring Kali Linux

Install Ms-Edge

Go to link: Configuring Ms-Edge

## Setup
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo install -o root -g root -m 644 microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-beta.list'
sudo rm microsoft.gpg
## Install
sudo apt update
## Install the stable update
sudo apt install microsoft-edge-stable

Install Homebrew and Github CLI

Go to link: Install homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Once this is installed follow the onscreen instructions to add brew to your current and shell profile.

# Once brew is installed, you can install gh using the following code in the terminal
brew install gh

Install VsCode

Go to Link: Install VsCode on Linux

# Once you download the .deb file from the above link use the following command to install VsCode
sudo apt install ./<file>.deb

[Optional] Common extensions I use

$ code --list-extensions
amazonwebservices.aws-toolkit-vscode
christian-kohler.path-intellisense
CoenraadS.bracket-pair-colorizer
DavidAnson.vscode-markdownlint
eamodio.gitlens
esbenp.prettier-vscode
GitHub.vscode-pull-request-github
ms-python.python
ms-python.vscode-pylance
ms-toolsai.jupyter
ms-toolsai.jupyter-keymap
ms-toolsai.jupyter-renderers
VisualStudioExptTeam.vscodeintellicode
zhuangtongfa.material-theme

[Optional] Turning off telemetry in VsCode

{
    "telemetry.enableTelemetry": false,
    "telemetry.enableCrashReporter": false,
    "aws.telemetry": false,
    "telemetry.telemetryLevel": "off"
}

DEV Community: Soumyajyoti Biswas

ChatGPT, Domain driven design and python - Using openAI to dive into software development

1. Table of contents

2. What is ChatGPT?

3. What is domain driven design?

4. Example python project 1

5. Example python project 2

6. Example python project 3

7. Example python project 4

8. Example python project 5

9. Example python project 6

AWS Infrastrucutre Maintenance Using AWS Lambda and AWS EventBridge [EC2 instance ebs snapshot cleanup after X days] [Part 2]

Contents

Summary

Architecture diagram and high level overview of all the solutions

Architecture diagram

EC2 instance daily ebs volume snapshots

EC2 instance daily ebs snapshot cleanup after X days

AWS IAM permissions

Permissions

Trust relationship

AWS EventBridge and Lambda

EC2 instance ebs snapshot delete solution

Workflow and code

Cloudwatch logs

Coming up next

AWS Infrastrucutre Maintenance Using AWS Lambda and AWS EventBridge [EC2 instance daily ebs volume snapshots] [Part 1]

Contents

Summary

Architecture diagram and high level overview of all the solutions

Architecture diagram

EC2 instance daily ebs volume snapshots

EC2 instance daily ebs snapshot cleanup after X days

EC2 instance daily unattached ebs volume cleanup after X days

Deregister old EC2 Amazon machine images after X days

AWS IAM permissions

Permissions

Trust relationship

AWS EventBridge and Lambda

EC2 instance daily ebs volume snapshots solution

Workflow and code

Cloudwatch logs

Coming up next

Python scripting basics - Tic-tac-toe game.

Contents

Summary

Code

Let's talk logic

Building the score board and displaying it

Inputs from players

Validating player provided name

Validating player provided symbol

Setting the symbol for the computer

Checking which cells are available to add input to

Validating if a player is providing correct input for cell value

Auto populating the last cell

Checking who won

Bonus

Adding a time delay

Ascii art

Putting it all together

Playing rock, paper and scissors using python on a terminal

Contents

Summary

Code

Let's talk logic

Of all things random

Validating user provided input

User provided name validation

User provided input validation

Bonus

Clearing screen for readibility

Displaying scores as via a DataFrame

Ascii art

Putting it all together

Python scripting basics - BMI calculator

Contents

Summary

Code

Taking data from the user