Why does my code keep running even after it reaches the end?

Question

I am having some troubles with my program as when it reaches the end of the third() function, it continues to try to execute transactions. I tried having it return None to break out of the seemly infinite loop that it is in with no success. I am sure that I am missing something very simple here and am guessing it has something to do with the recursion that I used. Thanks for any help that you can provide.

import asyncio
import base64
import json
import os
import os.path
import time

import httpcore
import requests
from typing import Awaitable
import solana
import httpx
from rich import print
from solana.keypair import Keypair
from solana.publickey import PublicKey
from solana.rpc.api import Client
from solana.rpc.async_api import AsyncClient
from solana.rpc.commitment import Confirmed
from solana.rpc.types import TxOpts
from solana.transaction import Transaction

# Notes
# This is meant as a bare bones hello world and as such does not have :
#
# - error handling on http calls
# - checks / retries to ensure solana transactions go through
# - logging - just your basic print statement here. But at least you get the Rich pretty printing variant :)
#
# Libraries used
# - https://www.python-httpx.org/ - cause it's shinier and better than requests
# - https://michaelhly.github.io/solana-py/
# - https://github.com/Textualize/rich for pretty printing - because it rocks.
# I use poetry to manage dependencies but am not including the project file here for brevity.

# Mint constants
USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", 6
SOL_MINT = "So11111111111111111111111111111111111111112", 9
FAB_MINT = "EdAhkbj5nF9sRM7XN7ewuW8C9XEUMs8P7cnoQ57SYE96", 9
FUSD_MINT = "B7mXkkZgn7abwz1A3HnKkb18Y6y18WcbeSkh1DuLMkee", 8

# This works ok - most of the time
rpc_host = "https://api.mainnet-beta.solana.com"

filename = r"C:\Users\myname\.config\solana\burner.json"


def get_wallet_keypair(filename: str) -> Keypair:
    """Load a keypair from a filesystem wallet."""

    if not os.path.isfile(filename):
        raise Exception(f"Wallet file '{filename}' is not present.")

    with open(filename) as json_file:
        data = json.load(json_file)

        mid = len(data) // 2
        secret_key = data[:mid]
        secret_bytes = bytes(secret_key)
        keypair = Keypair.from_secret_key(secret_bytes)

        print(f"Public Key is: {keypair.public_key}")
        return keypair


async def get_quote(
        input_mint: str, output_mint: str, amount: int, slippage: int = 0.2):
    url_query = f"https://quote-api.jup.ag/v1/quote?outputMint={output_mint}&inputMint={input_mint}&amount={amount}&slippage={slippage}"
    print(url_query)
    async with httpx.AsyncClient() as client:
        r = await client.get(url_query)
        return r.json()


async def get_transaction(route: dict, user_key: str) -> dict:
    swap_url = "https://quote-api.jup.ag/v1/swap"

    input = {"route": route, "userPublicKey": user_key, "wrapUnwrapSOL": True}
    print(json.dumps(input, indent=2))
    async with httpx.AsyncClient() as client:
        r = await client.post(swap_url, json=input,
                              timeout=6.0)  # slightly longer timout as the free rpc server can be a bit laggy
        return r.json()


def send_transaction(payer: Keypair, cc: Client, swap_transaction: str, opts: TxOpts) -> str:
    """ Send a serialized transaction to the RPC node """
    trans = Transaction.deserialize(base64.b64decode(swap_transaction))

    result = cc.send_transaction(trans, payer, opts=opts)
    txid = result["result"]
    print(f"transaction details :https://solscan.io/tx/{txid}")
    return txid


async def async_main(from_mint, from_decimals, to_mint, quantity):
    cc = Client(rpc_host)

    print(f" Converting {quantity} {from_mint} to {to_mint} with {from_decimals} Decimals")

    quote_quantity = quantity * (10 ** from_decimals)
    r = await get_quote(str(from_mint), str(to_mint), quote_quantity, slippage=2)

    quote, outAmount = r["data"][0], int(r['data'][0]['outAmountWithSlippage']) / (10 ** from_decimals)
    print("Out Amount =", outAmount)

    if quote := r["data"][0]:
        print(quote)
    # get the relevant transaction details
    trans = await get_transaction(quote, str(pubkey))

    setup_transaction = trans["setupTransaction"] if "setupTransaction" in trans else None
    swap_transaction = trans["swapTransaction"] if "swapTransaction" in trans else None
    cleanup_transaction = trans["cleanupTransaction"] if "cleanupTransaction" in trans else None

    opts = TxOpts(skip_preflight=True)

    # Setup transaction. Will create any missing accounts if required.
    if setup_transaction:
        print("Sending setup transaction")
        #print(setup_transaction)
        send_transaction(payer, cc, setup_transaction, opts)

    # This one actually does the business
    if swap_transaction:
        print("Sending swap transaction")
        txid = send_transaction(payer, cc, swap_transaction, opts)

        # Wait for the transaction to complete before looking it up on chain.
        # Clearly this is *not* the right way to do this. Retry in a loop or something fancy.
        await asyncio.sleep(20)
        result = cc.get_transaction(txid, commitment=Confirmed)
        print(result)

    # Haven't seen one of these needed yet. Hopefully the jup.ag devs can explain when it's required.
    if cleanup_transaction:
        print("Sending send transaction")
        send_transaction(payer, cc, cleanup_transaction, opts)
    print("Swap Complete !")
    return outAmount


def get_balance(input_mint):
    url = "https://api.mainnet-beta.solana.com"
    headers = {'Content-type': 'application/json'}
    if input_mint == "So11111111111111111111111111111111111111112":
        data = {"jsonrpc": "2.0", "id": 1, "method": "getBalance", "params": [f"{pubkey}"]}
        response = requests.post(url, data=json.dumps(data), headers=headers)
        response = response.text
        parsed = json.loads(response)
        # print(json.dumps(parsed, indent=4, sort_keys=True))
        accountBal = (parsed['result']['value']) / 10 ** SOL_MINT[1]
        print(accountBal)

    else:
        data = {"jsonrpc": "2.0", "id": 1, "method": "getTokenAccountsByOwner",
                "params": [f"{pubkey}",
                           {"mint": f"{input_mint}"}, {"encoding": "jsonParsed"}]}
        response = requests.post(url, data=json.dumps(data), headers=headers)
        response = response.text
        parsed = json.loads(response)
        # print(json.dumps(parsed, indent=4, sort_keys=True))
        accountBal = parsed['result']['value'][0]['account']['data']['parsed']['info']['tokenAmount']['uiAmount']
        print(accountBal)
    return accountBal


# usdc buys fusd fusd is sold for sol sol is sold for usdc

# (from_mint, from_decimals, to_mint, quantity):

class swaps:
    def __init__(self, input_mint, decimals, output_mint, amount):
        self.input_mint = input_mint
        self.decimals = decimals
        self.output_mint = output_mint
        self.amount = amount

    def swap(self):
        asyncio.run(async_main(self.input_mint, self.decimals, self.output_mint, self.amount))


def first(count, previous = 0):
    try:
        if get_balance(USDC_MINT[0]) <= 1:
            time.sleep(1)
            count += 1
            if count >= 60:
                third(0)

            first(count)
    except TypeError:
        first(0)

    step1 = swaps(USDC_MINT[0], USDC_MINT[1], FUSD_MINT[0], get_balance(USDC_MINT[0]) if previous == 0 else previous)
    try:
         step1.swap()
    except httpx.ReadTimeout:
        print("Retrying")
        time.sleep(10)
        first(0)
    second(0)


def second(count, previous = 0):
    try:
        if get_balance(FUSD_MINT[0]) <= 1:
            time.sleep(1)
            count += 1

            if count >= 60:
                first(0)
            second(count)
    except TypeError:
        second(0)
    step2 = swaps(FUSD_MINT[0], FUSD_MINT[1], SOL_MINT[0], get_balance(FUSD_MINT[0]) if previous == 0 else previous)
    try:
         step2.swap()
    except:
        print("Retrying")
        time.sleep(10)
        second(0)
    count = 0
    third(0)


def third(count, previous = 0):
    if get_balance(SOL_MINT[0]) < .6:
        time.sleep(1)
        count += 1
        if count >= 60:
            second(0)
        third(count)

    step3 = swaps(SOL_MINT[0], SOL_MINT[1], USDC_MINT[0], get_balance(SOL_MINT[0]) - 0.5 if previous == 0 else previous)
    try:
         step3.swap()
    except:
        print("Retrying")
        time.sleep(10)
        third(previous)
    print("All Swaps Completed")
    return None


payer = get_wallet_keypair(filename)
pubkey = payer.public_key
loops = 0
if __name__ == "__main__":
    previousBalence = get_balance(USDC_MINT[0])
    print(f"Starting Balence: {previousBalence}")
    #for loops in range(5):
    first(0)
    loops += 1
    endBalance = get_balance((USDC_MINT[0]))
    print(f"End balence is {endBalance}")
    totalProfit = endBalance-previousBalence
    print(f"Total Profit is: {totalProfit}")

Edit: The output when the code continues is it keeps trying to swap fUSD for SOL and SOL for USDC over and over again.

Solution: https://pastebin.com/8id7gfe4