$ git config

$ git add
$ git rm 
$ git mv
$ git commit -m 'desc commit'

$ git checkout -b branch_name # craete a new branch
$ git checkout branch_name
$ git merge REMOTE BRANCH # ex. git merge origin master

$ git reset
$ git revert

$ git status
$ git log
$ git diff

$ git init
$ git clone
$ git remote → git remote add, git remote -v, git remote rm
$ git fetch

$ git pull
$ git push

$ git config --global user.name "Stefano Borzì"
$ git config --global user.email "stefano@example.com"
$ git config --global core.editor nano


$ git config --list
user.name=Stefano Borzì
user.email=stefano@example.com
core.editor=nano
...


$ git config user.name
Stefano Borzì

$ git init

$ git add
$ git rm 
$ git mv

$ git status
$ git diff

$ git commit -m 'desc commit'

$ git log

/*
Make a BRANCH per each task.

- fix warning and errors
- fix the code
- make N dynamic, let the user choose N
- remove unused
- make some improvements on your own
*/

$ git config

$ git init

$ git add
$ git rm 
$ git mv
$ git commit -m 'desc commit'

$ git checkout -b branch_name # craete a new branch
$ git checkout branch_name
$ git merge BRANCH # ex. git merge feature-1

$ git reset
$ git revert

$ git status
$ git log
$ git diff

print('Hello World!')

#include <iostream>
using namespace std;

int main() {
    cout << "Hello World!" << endl;
    return 0;
}

if 5 > 2:
  print("Five is greater than two!")

#include <iostream>
using namespace std;

int main() {
    if (5 > 2) {
	    cout << "Five is greater than two!" << endl;
    }
    return 0;
}

if 5 > 2:
        print("Five is greater than two!")
  
if 5 > 2:
	print("Five is greater than two!")
 

if 5 > 2:
  print("Five is greater than two!")
  
if 5 > 2:
    print("Five is greater than two!")
 

# This is a comment
print("OpenSource ❤️") # This is another comment

"""
Multiple comments in
multiple lines
"""
print("Linux is an excellent operative system")

x = 4
print(type(x))

x = "Sally"
print(type(x))

<class 'int'>
<class 'str'>

x = str(3)    # x will be '3'
y = int(3)    # y will be 3
z = float(3)  # z will be 3.0

x, y, z = "Orange", "Banana", "Cherry"

print(x) # Orange
print(y) # Banana
print(z) # Cherry

fruits = ["apple", "banana", "cherry"]
x, y, z = fruits
print(x) # apple
print(y) # banana
print(z) # cherry

x = "awesome"

def myfunc() -> None:
  print("Python is " + x)

myfunc()

x = "awesome"

def myfunc() -> None:
  x = "fantastic"
  print("Python is " + x)

myfunc()

print("Python is " + x)
# Python is awesome

def myfunc() -> None:
  global x
  x = "fantastic"

myfunc()

print("Open source is " + x)
# Open source is fantastic

x = "awesome"

def myfunc() -> None:
  global x
  x = "fantastic"

myfunc()

print("Python is " + x) # Python is fantastic

a = "Hello, World!"
print(a[1]) # e

for x in "mock":
  print(x)

# m
# o
# c
# k

a = "Hello, World!"
print(len(a))

txt = "freedom"
print("free" in txt)

txt = "freedom"
if "free" in txt:
  print('there is!')

if "free" not in txt:
  print("there isn't!")

b = "Hello, World!"
print(b[2:5]) # llo

print(b[:5]) # Hello

print(b[2:]) # llo, World!

print(b[-5:-2]) # orl

b[:]

x in y     # x is in the object y
x not in y

x is y     # id(x) == id(y)
x is not y

x and y    # x && y
x or y     # x || y
not(x < 5) # !(x < 5)

>>> x = 10
>>> y = 10
>>> id(x)
11760968
>>> id(y)
11760968
>>> a = 300
>>> b = 300
>>> id(a)
140601663305712
>>> id(b)
140601663306832

thislist = ["apple", "linux", "microsoft"]
[print(x) for x in thislist]

thislist = ["apple", "linux", "microsoft"]
for i in range(len(thislist)):
  print(thislist[i])

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

for x in fruits:
  if "a" in x:
    newlist.append(x)

print(newlist)

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if "a" in x]

print(newlist)

newlist = [expression for item in iterable if condition == True]

'identical' if x == y else 'not identical'

x == y ? 'identical' : 'not identical'

def sum(a, b):
  return a + b

def sum(a: int, b: int) -> int:
  return a + b

from typing import Union

def sum(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
  return a + b

from typing import Union
from typing import Tuple

def sum(a: Union[int, float], b: Union[int, float]) -> Tuple[int, float]:
  return a + b, b + a

x, y = sum(a, b)

from typing import Union
from typing import Tuple

def sum(a: Union[int, float], b: Union[int, float]) -> Tuple[Union[int, float], Union[int, float]]:
  return a + b, b + a

x, y = sum(a, b)

print(sum(3,4))
print(sum(3.0,4.0))
print(sum(3,4.0))
print(sum(3.0,4))

from typing import Union
from typing import Tuple

def sum(a: int, b: int) -> Tuple[int, int]:
  return a + b, b + a

x, y = sum(a, b)

def my_magic_func(arr: list) -> list:
  # my magic code
  return arr

from typing import List

def my_magic_func(arr: List[str]) -> List[str]:
  # my magic code
  return arr

def sum(a: int, b: int) -> int:
  return a + b

sum(3.0, 3) # 6.0
type(sum(3.0, 3)) # float

try:
  print(x)
except:
  print("An exception occurred")

print(x)

try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")
  

for x in range(6):
  print(x)
else:
  print("Finally finished!")

for x in range(6):
  if x == 3: break
  print(x)
else:
  print("Finally finished!")

class MyClass:
  x = 5
  
p1 = MyClass()
print(p1.x)

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("Helias", 26)
p1.myfunc()

class Student(Person):
  def __init__(self, fname, age, year):
    super().__init__(fname, age)
    self.graduationyear = year

x = Student("Lorenzo", 23, 2021)

class P:
   def __init__(self, name, alias):
      self.name = name       # public
      self.__alias = alias   # private
 
x = P(name='Alessio', alias='Admin di Spotted')

x.alias
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: P instance has no attribute 'alias'

x._P__alias
'Admin di Spotted'

def sum(a: int, b: int) -> int:
  return a + b

def test_sum() -> None:
  assert sum(3,5) == 8
  assert type(sum(3,5)) is int

# example.py
from random import random 

def a() -> bool:
  return random() > 0.5

def b() -> int:
  is_a = a()
  if is_a:
    ...
    return 10
  else:
    ...
    return 20
 

def a() -> bool:
  return random() > 0.5

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)

    # act
    res = example.a() 

    # assert
    assert res is False

def a() -> bool:
  return random() > 0.5

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is False
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is False
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

def test_a_2(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.6
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is True
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

def b() -> int:
  is_a = a()
  if is_a:
    ...
    return 10
  else:
    ...
    return 20
 

def test_b_1(mocker: MockerFixture) -> None:
    # arrange
    mock_a_return = True
    mocker.patch(__name__ + '.example.a', return_value=mock_a_return)
    spy = mocker.spy(example, "a")

    # act
    res = example.b()

    # assert
    assert res == 10
    assert spy.call_count == 1
    assert spy.spy_return == mock_a_return

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is False
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

def test_a_2(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.6
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is True
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

def test_b_1(mocker: MockerFixture) -> None:
    # arrange
    mock_a_return = True
    mocker.patch(__name__ + '.example.a', return_value=mock_a_return)
    spy = mocker.spy(example, "a")

    # act
    res = example.b()

    # assert
    assert res == 10
    assert spy.call_count == 1
    assert spy.spy_return == mock_a_return

def test_b_2(mocker: MockerFixture) -> None:
    # arrange
    mock_a_return = False
    mocker.patch(__name__ + '.example.a', return_value=mock_a_return)
    spy = mocker.spy(example, "a")

    # act
    res = example.b()

    # assert
    assert res == 20
    assert spy.call_count == 1
    assert spy.spy_return == mock_a_return

import pytest

@pytest.mark.parametrize("x", [0, 1])
@pytest.mark.parametrize("y", [2, 3])
def test_foo(x, y):
    pass

from typing import List
import pytest
from pytest_mock import MockerFixture
import example

tests: List[dict] = [
    { "mock_value": 0.4,   "mock_function": "random", "spy_count": 1, "res": example.a, "expected_res": False  },
    { "mock_value": 0.6,   "mock_function": "random", "spy_count": 1, "res": example.a, "expected_res": True  },
    { "mock_value": True,  "mock_function": "a",      "spy_count": 1, "res": example.b, "expected_res": 10  },
    { "mock_value": False, "mock_function": "a",      "spy_count": 1, "res": example.b, "expected_res": 20  },
]

@pytest.mark.parametrize("test", tests)
def test_generic(mocker: MockerFixture, test: dict) -> None:
    # arrange
    mocker.patch.object(example, test["mock_function"], return_value=test["mock_value"])
    spy = mocker.spy(example, test["mock_function"])

    # act
    res = test["res"]()

    # assert
    assert res is test["expected_res"]
    assert spy.call_count == test["spy_count"]
    assert spy.spy_return == test["mock_value"]

x=0 => y=2, y=3
x=1 => y=2, y=3
4 test cases

def test_stub(mocker):
    def foo(on_something):
        on_something('foo', 'bar')

    stub = mocker.stub(name='on_something_stub')

    foo(stub)

    stub.assert_called_once_with('foo', 'bar')

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # act
    res = example.a() 

    # assert
    assert res is False
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

from pytest_mock import MockerFixture
import example

def test_a_1(mocker: MockerFixture) -> None:
    # arrange
    mock_random_return = 0.4
    mocker.patch.object(example, "random", return_value=mock_random_return)
    spy = mocker.spy(example, "random")

    # assert
    ... # verify the initial conditions

    # act
    res = example.a() 

    # assert
    assert res is False
    assert spy.call_count == 1
    assert spy.spy_return == mock_random_return

name: Hello-World

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  hello-world-job:

    runs-on: ubuntu-latest

    steps:
      - name: Hello World
        run: echo 'Hello World'

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

name: release-hello-world

on:
  workflow_dispatch:

jobs:
  build-hello-world:
    permissions: write-all
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: compile and run
        run: g++ hello_world.cpp -o hello_world_linux

      - name: Create Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: >-
          gh release create ${{ github.ref_name }}
          "hello_world_linux"
          --generate-notes
          --title "Version ${{ github.ref_name }}"

name: release-hello-world

on:
  workflow_dispatch:

jobs:
  create-release:
    permissions: write-all
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Create Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: gh release create ${{ github.ref_name }} --generate-notes --title "Version ${{ github.ref_name }}"

  build-hello-world:
    needs: create-release
    permissions: write-all

    strategy:
      matrix:
        include:
          - os: ubuntu-latest
            file_name: hello_world_linux
          - os: macos-latest
            file_name: hello_world_mac
          - os: windows-latest
            file_name: hello_world_windows.exe

    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4
      - name: compile
        run: g++ hello_world.cpp -o ${{ matrix.file_name }}

      - name: Update Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: gh release upload ${{ github.ref_name }} "${{ matrix.file_name}}"

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

#include <iostream>
using namespace std;

int main() {

  cout << "Hello World" << endl;

  return 0;
}

#include <iostream>
using namespace std;

int main() {
  int x;
  cout << x << endl;

  cout << "Hello World" << endl;

  return 0;
}

#include <iostream>
using namespace std;

int main() {
  int* p = nullptr;

  cout << *p << endl;

  cout << "Hello World" << endl;

  return 0;
}

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++ cppcheck

      - name: run cppcheck
        run: |
          cppcheck hello_world.cpp --output-file=report.txt
          if [ -s report.txt ]; then # if file is not empty
            cat report.txt
            exit 1 # let github action fails
          fi

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

name: CI

on:
  push:
    branches: [main]
    paths-ignore:
      - "README.md"
      - "docs/**"
  pull_request:
    branches: [main]
    paths-ignore:
      - "README.md"
      - "docs/**"

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Set up Python 3.10.0
        uses: actions/setup-python@v2
        with:
          python-version: 3.10.0

      - name: Install dependencies for requirements and testing
        run: |
          python -m pip install --upgrade pip
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
          if [ -f requirements_dev.txt ]; then pip install -r requirements_dev.txt; fi

      - name: Lint with pylint
        run: pylint src

      - name: Test with pytest
        run: pytest --cov src tests/ --cov-fail-under=75

name: Create and publish a Docker image

on:
  workflow_call:
    inputs:
      repo_ref: # "author/repository_name" or ${{ github.repository }}
        required: true
        type: string

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ inputs.repo_ref }}

jobs:
  build-and-push-image:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Log in to the Container registry
        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

      - name: Build and push Docker image
        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

name: Create and publish a Docker image
on:
  push:
    branches:
      - 'main'

jobs:
  build:
    uses: unict-dmi/reusable-workflows/.github/workflows/docker.yml@main
    with:
      repo_ref: ${{ github.repository }}

name: Telegram-Secret-Token

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  hello-world-job:

    runs-on: ubuntu-latest

    steps:
      - name: Telegram Notify
        run: >-
          curl -s --data-urlencode "text=Hello World ✅"
          "https://api.telegram.org/bot${{ secrets.MY_SECRET_TOKEN }}/sendMessage?chat_id=1044003630" > /dev/null

#include <iostream>
using namespace std;

int SafeDivide(int a, int b) {
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    return a / b;
}


int main() {
    int a, b;

    cout << "Enter a: ";
    cin >> a;

    cout << "Enter b: ";
    cin >> b;

    cout << SafeDivide(a, b) << endl;

    return 0;
}

#include <gtest/gtest.h>
#include "math_utils.h"

TEST(MathUtilsTest, HandlesZeroDivision) {
    EXPECT_EQ(SafeDivide(10, 0), 0);
}

TEST(MathUtilsTest, HandlesNormalDivision) {
    EXPECT_EQ(SafeDivide(10, 2), 5);
}

#include "math_utils.h"

int SafeDivide(int a, int b) {
    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    return a / b;
}

#pragma once

int SafeDivide(int a, int b);

#include <cstdint>
#include <cstddef>
#include "math_utils.h"

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    if (size < 8) return 0;

    int a = *(reinterpret_cast<const int*>(data));
    int b = *(reinterpret_cast<const int*>(data + 4));

    SafeDivide(a, b);

    return 0;
}

name: fuzz-test-example

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  fuzz-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: run build, test and fuzz test
        run: |
          mkdir build
          cd build
          cmake .. -DCMAKE_CXX_COMPILER=clang++
          cmake --build . -- -j$(nproc)
          ./math_utils_test
          timeout 30 ./fuzz_math_utils || echo "Fuzz test crashed or timed out"
          if ls crash-* 1> /dev/null 2>&1; then
            hexdump -v -e '"%d, "' -e '8/1 "0x%02x, " "\n"' ./crash-*
            exit 1 # let github action fails
          fi
          echo "Build, test and fuzz test completed successfully"

#include <iostream>
using namespace std;

int SafeDivide(int a, int b) {
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    if (a == -2147483648 && b < 0) {
        return 2147483647; // Handle overflow case
    }

    return a / b;
}


int main() {
    int a, b;

    cout << "Enter a: ";
    cin >> a;

    cout << "Enter b: ";
    cin >> b;

    cout << SafeDivide(a, b) << endl;

    return 0;
}

import numpy as np

def math_operations(list_):
    # Compute Average
    print(f"the mean is {np.mean(list_)}")

    # Compute Max
    print(f"the max is {np.max(list_)}") 

math_operations(list_ = [1,2,3,4,5])
# the mean is 3.0
# the max is 5

def get_mean(list_: list[int]) -> None:
    '''Compute Mean'''
    print(f"the mean is {np.mean(list_)}")

def get_max(list_: list[int]) -> None:
    '''Compute Max'''
    print(f"the max is {np.max(list_)}")

def main(list_: list[int]) -> None: 
    # Compute Average
    get_mean(list_)
    # Compute Max
    get_max(list_)

main([1,2,3,4,5])
# the mean is 3.0
# the max is 5

class Animal:
    def __init__(self, name: str):
        self.name = name
    
    def get_name(self) -> str:
        pass

animals = [
    Animal('lion'),
    Animal('mouse')
]

def animal_sound(animals: list):
    for animal in animals:
        if animal.name == 'lion':
            print('roar')

        elif animal.name == 'mouse':
            print('squeak')

animal_sound(animals)

class Animal:
    def __init__(self, name: str):
        self.name = name
    
    def get_name(self) -> str:
        pass

    def make_sound(self) -> None:
        pass


class Lion(Animal):
    def make_sound(self) -> str:
        return 'roar'

class Mouse(Animal):
    def make_sound(self) -> str:
        return 'squeak'

def animal_sound(animals: list) -> None:
    for animal in animals:
        print(animal.make_sound())

animal_sound(animals)

from abc import ABC, abstractmethod


class Notification(ABC):
    @abstractmethod
    def notify(self, message, email):
        pass


class Email(Notification):
    def notify(self, message, email):
        print(f'Send {message} to {email}')


class SMS(Notification):
    def notify(self, message, phone):
        print(f'Send {message} to {phone}')


if __name__ == '__main__':
    notification = SMS()
    notification.notify('Hello', 'john@test.com')

from abc import ABC, abstractmethod


class Notification(ABC):
    @abstractmethod
    def notify(self, message: str) -> None:
        pass

class Email(Notification):
    def __init__(self, email: str):
        self.email = email

    def notify(self, message: str) -> None:
        print(f'Send "{message}" to {self.email}')


class SMS(Notification):
    def __init__(self, phone: str):
        self.phone = phone

    def notify(self, message: str) -> None:
        print(f'Send "{message}" to {self.phone}')

if __name__ == '__main__':
    notification = SMS('+3912345678')
    notification.notify('Hello')

    notification = Email('stefano.borzi@phd.unict.it')
    notification.notify('Hello')

from abc import ABC, abstractmethod

class Mammals(ABC):
    @abstractmethod
    def swim():
        print("Can Swim")

    @abstractmethod
    def walk():
        print("Can Walk")

class Human(Mammals):
    def swim():
        print("Humans can swim")

    def walk():
        print("Humans can walk")

class Whale(Mammals):
    def swim():
        print("Whales can swim")

Human.swim() # Humans can swim
Human.walk() # Humans can walk

Whale.swim() # Whales can swim
Whale.walk() # Can Walk

from abc import ABC, abstractmethod

class Walker(ABC):
  @abstractmethod
  def walk() -> None:
    print("Can Walk") 

class Swimmer(ABC):
  @abstractmethod
  def swim() -> None:
    print("Can Swim") 

class Human(Walker, Swimmer):
  def walk() -> None:
    print("Humans can walk") 
  def swim() -> None:
    print("Humans can swim") 

class Whale(Swimmer):
  def swim() -> None:
    print("Whales can swim") 

if __name__ == "__main__":
  Human.walk() # Humans can walk
  Human.swim() # Humans can swim

  Whale.swim() # Whales can swim
  Whale.walk() # ❌❌❌❌❌

class FXConverter:

  def convert(self, from_curr, to_curr, amount):
    print(
      f'{amount} {from_curr} = {amount * 1.2} {to_curr}'
    )
    return amount * 1.2


class App:
  def start(self):
    converter = FXConverter()
    converter.convert('EUR', 'USD', 100)


if __name__ == '__main__':
  app = App()
  app.start()

from abc import ABC


class CurrencyConverter(ABC):
  def convert(self, from_curr: str, to_curr: str, amount: float) -> None:
    pass

class FXConverter(CurrencyConverter):
  def convert(self, from_curr: str, to_curr: str, amount: float) -> float:
    print('Converting currency using FX API')
    print(
      f'{amount} {from_curr} = {amount * 1.2} {to_curr}'
    )
    return amount * 2

class App:
  def __init__(self, converter: CurrencyConverter):
    self.converter = converter

  def start(self) -> None:
    self.converter.convert('EUR', 'USD', 100)
 
if __name__ == '__main__':
  converter = FXConverter()
  app = App(converter)
  app.start()

text1 = 1
text2 = 2
text3 = 3
text4 = 4
text5 = 5

print(f"Number: {text1}")
print(f"Number: {text2}")
print(f"Number: {text3}")
print(f"Number: {text4}")
print(f"Number: {text5}")

texts = [1, 2, 3, 4, 5]

for i in range(len(texts)):
    print(f"Number: {texts[i]}")

f = lambda x: 1 if x <= 1 else x * f(x - 1)

def factorial(number: int) -> int:
    if number <= 1:
        return 1

    return number * factorial(number - 1)

# calculator.py
class Calculator():
  def sum(num1: int | float, num2: int | float) -> int | float:
    return num1 + num2

  def convert_to_float(num: int) -> float:
    return float(num)

# calculator.py
class Calculator():
  def sum(num1: int | float, num2: int | float) -> int | float:
    return num1 + num2

# helpers.py
def convert_to_float(num: int) -> float:
  return float(num)

# ❌ This is bad ❌
c = 5
d = 12

# ✅ This is good ✅
city_counter = 5
elapsed_time_in_days = 12

from datetime import datetime


# ❌ This is bad ❌
genyyyymmddhhmmss = datetime.strptime('04/27/95 07:14:22', '%m/%d/%y %H:%M:%S')

# ✅ This is good ✅
generation_datetime = datetime.strptime('04/27/95 07:14:22', '%m/%d/%y %H:%M:%S')

# ❌ This is bad ❌
fna = 'Bob'
cre_tmstp = 1621535852

# ✅ This is good ✅
first_name = 'Bob'
creation_timestamp = 1621535852

# ❌ This is bad ❌
client_first_name = 'Bob'
customer_last_name = 'Smith'

# ✅ This is good ✅
client_first_name = 'Bob'
client_last_name = 'Smith'

import random

# ❌ This is bad ❌
def roll():
    return random.randint(0, 36)  # what is 36 supposed to represent?

# ✅ This is good ✅
ROULETTE_POCKET_COUNT = 36

def roll() -> float:
    return random.randint(0, ROULETTE_POCKET_COUNT)

# ❌ This is bad ❌
class Person:
    def __init__(self, person_first_name, person_last_name, person_age):
        self.person_first_name = person_first_name
        self.person_last_name = person_last_name
        self.person_age = person_age


# ✅ This is good ✅
class Person:
    def __init__(self, first_name: str, last_name: str, age: int):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

numbers = [1, 2, 3, 4, 5]

# This variable stores the average of list of numbers.
average = sum(numbers) / len(numbers)
print(average)

# ❌ This is bad ❌
def get_name(): pass
def fetch_age(): pass

# ✅ This is good ✅
def get_name() -> None: pass
def get_age() -> None: pass

# ❌ This is bad ❌
def fetch_and_display_personnel():
    data = # ...

    for person in data:
        print(person)


# ✅ This is good ✅
def fetch_personnel():
    return # ...

def display_personnel(data: str) -> None:
    for person in data:
        print(person)

# ❌ This is bad ❌
def render_blog_post(title, author, created_timestamp, updated_timestamp, content):
    # ...

render_blog_post("Clean code", "Nik Tomazic", 1622148362, 1622148362, "...")


# ✅ This is good ✅
class BlogPost:
    def __init__(self, title, author, created_timestamp, updated_timestamp, content):
        self.title = title
        self.author = author
        self.created_timestamp = created_timestamp
        self.updated_timestamp = updated_timestamp
        self.content = content

blog_post1 = BlogPost("Clean code", "Nik Tomazic", 1622148362, 1622148362, "...")

def render_blog_post(blog_post):
    # ...

render_blog_post(blog_post1)

# ❌ This is bad ❌
text = "This is a cool blog post."
def transform(text, uppercase):
    if uppercase:
        return text.upper()
    else:
        return text.lower()

uppercase_text = transform(text, True)
lowercase_text = transform(text, False)


# ✅ This is good ✅
text = "This is a cool blog post."
def uppercase(text: str) -> str:
    return text.upper()

def lowercase(text: str) -> str:
    return text.lower()

uppercase_text = uppercase(text)
lowercase_text = lowercase(text)

def get_mean(arr: list[int]) -> None:
    avg = sum(arr) / len(arr)
    print(avg)

x = [1,2,3,4]
get_mean(x)

print('debugging 1')

for x in range(10):
    print('test2: ', x)

    print(x)

print('test3')

  "[python]": {
    "editor.defaultFormatter": "ms-python.black-formatter",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.organizeImports": "explicit"
    }
  },
  "isort.args": ["--profile", "black"]