fmpraisebot.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60b6cc42-7a48-4226-963e-3a51fe2fb568",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# GLOBALS\n",
    "training_menu = (130, 636)\n",
    "indy_training_area = (1271, 162)\n",
    "first_player_area = (1267, 405)\n",
    "#top_right_praise_button = (3488, 261)\n",
    "top_right_praise_button = (3505,255)\n",
    "#praise_button = (1809, 1102)\n",
    "praise_button = (1862, 1102)\n",
    "#end_qc_top_right = (2690, 382)\n",
    "end_qc_top_right = (2681, 388)\n",
    "hover_duration = 0.1\n",
    "players_to_praise = 25\n",
    "y_iter = 89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b60f4920-010a-4470-9e3e-c06d75bd6b13",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define separate move and click functions\n",
    "def my_move(coord_tuple):\n",
    "    x, y = coord_tuple\n",
    "    pyautogui.moveTo(x, y, duration=hover_duration)\n",
    "\n",
    "\n",
    "def my_click():\n",
    "    pyautogui.mouseDown()\n",
    "    #time.sleep(0.1)\n",
    "    pyautogui.mouseUp()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f1c3c2e-1f6a-4d5b-9cc5-6c5da5670083",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To display mouse position\n",
    "pyautogui.displayMousePosition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17b74c7c-e909-41a6-925b-f20e498973cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training area setup\n",
    "time.sleep(5)\n",
    "\n",
    "# Navigate to Training Menu\n",
    "my_move(training_menu)\n",
    "my_click()\n",
    "\n",
    "# Click on Individual Training\n",
    "time.sleep(2)\n",
    "my_move(indy_training_area)\n",
    "my_click()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54fbcf56-8a55-4355-89d7-8167f5df36d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "time.sleep(5)\n",
    "indy_training_area = (1149, 151)\n",
    "first_player_area = (828, 419)\n",
    "\n",
    "# Click on Individual Training\n",
    "time.sleep(2)\n",
    "my_move(indy_training_area)\n",
    "my_click()\n",
    "\n",
    "# Move to first player\n",
    "my_move(first_player_area)\n",
    "my_click()\n",
    "\n",
    "#pyautogui.moveTo(828, 419, duration=hover_duration)\n",
    "#pyautogui.mouseDown()\n",
    "#time.sleep(0.2)\n",
    "#pyautogui.mouseUp()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea242232-10c0-4172-878b-c09b3f699c8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_x, test_y = top_right_praise_button\n",
    "print(pyautogui.pixel(test_x, test_y))\n",
    "(255, 255,255) == pyautogui.pixel(test_x, test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dd50531-1f20-4cbd-afd1-b5ad2c0f7bfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Nave method\n",
    "\n",
    "time.sleep(5)\n",
    "for i in range(players_to_praise):\n",
    "    # Praise top right\n",
    "    #my_move(top_right_praise_button)\n",
    "    test_x, test_y = top_right_praise_button\n",
    "    #print(pyautogui.pixel(test_x, test_y))\n",
    "    if pyautogui.pixel(test_x, test_y) == (255,255,255):\n",
    "        my_move(top_right_praise_button)\n",
    "        my_click()\n",
    "        # Click 1st praise choice\n",
    "        my_move(praise_button)\n",
    "        my_click()\n",
    "        # End chat \n",
    "        my_move(end_qc_top_right)\n",
    "        my_click()\n",
    "        print(\"Pressing down arrow after clicking praise\")\n",
    "        pyautogui.press('down')\n",
    "    else:\n",
    "        print(\"Pressing down after failing white pixel test\")\n",
    "        pyautogui.press('down')\n",
    "        continue\n",
    "    printprint(\"Pressing down default\")\n",
    "    pyautogui.press('down')\n",
    "    print(f\"Iteration is {i}\")\n",
    "\n",
    "    # Push down arrow\n",
    "    #pyautogui.press('down')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6ed39db-d891-47ca-a6ac-de40756f13e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Positional method\n",
    "\n",
    "time.sleep(10)\n",
    "\n",
    "def my_praise_click():\n",
    "    my_move(top_right_praise_button)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(praise_button)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(end_qc_top_right)\n",
    "    my_click()\n",
    "\n",
    "# move to starting position\n",
    "\n",
    "#my_move(first_player_area)\n",
    "my_click()\n",
    "\n",
    "#player_x, player_y = first_player_area\n",
    "#player_x, player_y = (1312, 422)\n",
    "player_x, player_y = (1310, 419)\n",
    "\n",
    "\n",
    "player_pos = (player_x, player_y)\n",
    "my_move(player_pos)\n",
    "\n",
    "test_x, test_y = top_right_praise_button\n",
    "# iterate over number of players by moving down a specific Y pixel amount\n",
    "for i in range(players_to_praise):\n",
    "    # iterate across x values\n",
    "    green_x, green_y = 1280, player_y\n",
    "    green_counter = 0\n",
    "    for j in range(50):\n",
    "        red = pyautogui.pixel(green_x, green_y)[0]\n",
    "        green =  pyautogui.pixel(green_x, green_y)[1]\n",
    "        blue =  pyautogui.pixel(green_x, green_y)[2]\n",
    "        if green > 170 and green != red and green != blue:\n",
    "            #print(\"     Player rating is greenish!\")\n",
    "            red = pyautogui.pixel(green_x, green_y)[0]\n",
    "            green =  pyautogui.pixel(green_x, green_y)[1]\n",
    "            blue =  pyautogui.pixel(green_x, green_y)[2]\n",
    "            print(f\"R:{red} G:{green} B:{blue}\")\n",
    "            green_counter += 1\n",
    "            if pyautogui.pixel(test_x, test_y) == (255,255,255):\n",
    "                my_praise_click()\n",
    "                continue\n",
    "                \n",
    "        green_x += 1\n",
    "        #print(f\"i:{i} green test j:{j}\")\n",
    "        #if green_counter > 5:\n",
    "            #print(\"We have green count > 5\")\n",
    "            \n",
    "    praise_button_available = False    \n",
    "    if pyautogui.pixel(test_x, test_y) == (255,255,255):\n",
    "        #print(\"Praise button available\")\n",
    "        praise_button_available = True\n",
    "    else:\n",
    "        pass\n",
    "        #print(\"No praise button\")\n",
    "    if praise_button_available and green_counter > 3:\n",
    "        print(\"Praise button and green counter exceeding 5\")\n",
    "        my_praise_click()\n",
    "    print(\"*\" * 15)\n",
    "    player_y += y_iter\n",
    "    new_move = (player_x, player_y)\n",
    "    my_move(new_move)\n",
    "    my_click()\n",
    "    # check if Praise is available\n",
    "    ## there print \"Praise\" is there!\n",
    "    ## move down\n",
    "    # if not, just click down\n",
    "    # Push down arrow\n",
    "    #pyautogui.press('down')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46158e96-f812-418d-b647-d6d081337462",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To display mouse position\n",
    "pyautogui.displayMousePosition() = foo\n",
    "print(foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0d5c18c-792f-49b3-a52f-541c289018fa",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def orientate():\n",
    "    # Training area setup\n",
    "    time.sleep(5)\n",
    "\n",
    "    # Navigate to Training Menu\n",
    "    my_move(training_menu)\n",
    "    my_click()\n",
    "\n",
    "    # Click on Individual Training\n",
    "    time.sleep(2)\n",
    "    my_move(indy_training_area)\n",
    "    my_click()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0693c52b-20c7-42bb-8a1f-a57f7e0452fe",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#time.sleep(10)\n",
    "time.sleep(7)\n",
    "#orientate()\n",
    "#first_player_button = (1307, 412)\n",
    "first_player_button = (1267, 385)\n",
    "my_move(first_player_button)\n",
    "my_click()\n",
    "\n",
    "\n",
    "def my_praise_click():\n",
    "    my_move(top_right_praise_button)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(praise_button)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(end_qc_top_right)\n",
    "    my_click()\n",
    "\n",
    "def praise_button_exists(button):\n",
    "    x, y = button\n",
    "    return pyautogui.pixel(x, y) == (255,255,255)\n",
    "    \n",
    "def click_praise_button():\n",
    "    my_move(top_right_praise_button)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(praise_button)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(end_qc_top_right)\n",
    "    my_click()\n",
    "\n",
    "    \n",
    "#player_x, player_y = first_player_area\n",
    "#player_x, player_y = (1312, 422)\n",
    "# Starting position of first player\n",
    "#player_x, player_y = (1307, 412)\n",
    "# Nave method\n",
    "\n",
    "\n",
    "for i in range(players_to_praise):\n",
    "    if praise_button_exists(top_right_praise_button):\n",
    "        print(\"Praise is there\")\n",
    "        time.sleep(2)\n",
    "        click_praise_button()\n",
    "        # Asses the rating color\n",
    "    pyautogui.press('down')\n",
    "    print(f\"Iteration is {i}\")\n",
    "\n",
    "    # Push down arrow\n",
    "    #pyautogui.press('down')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72486d9f-6991-41b4-bc34-6e99ee1db9af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "# Get the text widget\n",
    "text_widget = tk.Text()\n",
    "\n",
    "# Get the cursor position\n",
    "cursor_position = text_widget.index(\"insert\")\n",
    "\n",
    "# Print the cursor position\n",
    "print(\"The cursor position is {}\".format(cursor_position)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec00e1c9-2dca-4301-a711-a9871d0f3148",
   "metadata": {},
   "outputs": [],
   "source": [
    "    if praise_button_exists:\n",
    "        # Asses the rating color\n",
    "        click_praise_button()\n",
    "        print(\"Pressing down arrow after clicking praise\")\n",
    "        pyautogui.press('down')\n",
    "    else:\n",
    "        my_click()\n",
    "        print(\"Pressing down after failing white pixel test\")\n",
    "        pyautogui.press('down')\n",
    "        continue\n",
    "    print(\"Pressing down default\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4734ddc8-5791-4fe3-b2c4-2a3abdbf979c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyautogui import *\n",
    "import pyautogui\n",
    "import time\n",
    "import keyboard\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# GLOBALS\n",
    "training_menu = (130, 636)\n",
    "indy_training_area = (1271, 162)\n",
    "first_player_area = (1267, 405)\n",
    "#top_right_praise_button = (3488, 261)\n",
    "top_right_praise_button = (3505,255)\n",
    "#praise_button = (1809, 1102)\n",
    "praise_button = (1862, 1102)\n",
    "#end_qc_top_right = (2690, 382)\n",
    "end_qc_top_right = (2681, 388)\n",
    "hover_duration = 0.1\n",
    "players_to_praise = 65 # Does 22 players total\n",
    "y_iter = 89\n",
    "\n",
    "\n",
    "# Define separate move and click functions\n",
    "def my_move(coord_tuple):\n",
    "    x, y = coord_tuple\n",
    "    pyautogui.moveTo(x, y, duration=hover_duration)\n",
    "\n",
    "\n",
    "def my_click():\n",
    "    pyautogui.mouseDown()\n",
    "    #time.sleep(0.1)\n",
    "    pyautogui.mouseUp()\n",
    "\n",
    "    \n",
    "def orientate():\n",
    "    # Training area setup\n",
    "    time.sleep(5)\n",
    "\n",
    "    # Navigate to Training Menu\n",
    "    my_move(training_menu)\n",
    "    my_click()\n",
    "\n",
    "    # Click on Individual Training\n",
    "    time.sleep(2)\n",
    "    my_move(indy_training_area)\n",
    "    my_click()\n",
    "\n",
    "\n",
    "# To display mouse position\n",
    "# pyautogui.displayMousePosition()\n",
    "\n",
    "\n",
    "def my_praise_click():\n",
    "    my_move(top_right_praise_button)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(praise_button)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(end_qc_top_right)\n",
    "    my_click()\n",
    "\n",
    "    \n",
    "def praise_button_exists(button):\n",
    "    x, y = button\n",
    "    return pyautogui.pixel(x, y) == (255,255,255)\n",
    "\n",
    "\n",
    "def click_praise_buttons():\n",
    "    my_move(top_right_praise_button)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(praise_button)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(end_qc_top_right)\n",
    "    my_click()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Provide time to move alt-tab to app\n",
    "    time.sleep(5)\n",
    "    # Go to Training>Indivdual menus\n",
    "    orientate()\n",
    "\n",
    "    # Set first position on first player and mouse click\n",
    "    first_player_button = (1267, 385)\n",
    "    my_move(first_player_button)\n",
    "    my_click()\n",
    "    \n",
    "    for i in range(players_to_praise):\n",
    "        if praise_button_exists(top_right_praise_button):\n",
    "            print(\"Praise is there\")\n",
    "            #time.sleep(2)\n",
    "            click_praise_buttons()\n",
    "        pyautogui.press('down')\n",
    "        #print(f\"Iteration is {i}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "032acbaa-7174-465c-a757-d9eaf8100c97",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install pyautogui\n",
    "!pip install pytesseract\n",
    "!pip install tesseract\n",
    "!pip install tesseract-ocr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5d713b4-61b9-4e88-a727-66a693bf9428",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#pytesseract.pytesseract.tesseract_cmd = \"C:\\\\Users\\\\lover\\\\AppData\\\\Roaming\\\\Python\\\\Python311\\\\Scripts\\\\pytesseract\"  # your path may be different\n",
    "#c = get_config()\n",
    "#c.InteractiveShellApp.exec_lines = [\n",
    "#'import sys; sys.path.append(\"C:\\\\Users\\\\lover\\\\AppData\\\\Roaming\\\\Python\\\\Python311\\\\Scripts\\\\\")']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "842b5ecb-07d1-4eb5-bfe9-40ea425e28c6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#import sys\n",
    "#sys.path.append(\"C:\\\\Users\\\\lover\\\\AppData\\\\Roaming\\\\Python\\\\Python311\\\\Scripts\\\\\")\n",
    "\n",
    "import sys\n",
    "sys.path.append(\"C:/Users/lover/AppData/Roaming/Python/Python311/Scripts/\")\n",
    "sys.path.append(\"C:/Users/lover/AppData/Roaming/Python/Python39/Scripts/\")\n",
    "sys.path.append(\"C:/Program Files/Tesseract-OCR/\")\n",
    "# Follow directions to try to add pytesseract to system path\n",
    "# https://stackoverflow.com/questions/15137985/how-to-add-directory-to-sys-path-on-ipython-startup\n",
    "# \n",
    "# 1. ipython profile create\n",
    "# \n",
    "# 2. ipython locate\n",
    "# \n",
    "# 3. Edit the 'ipython_config' file and add the following:\n",
    "\n",
    "#c.InteractiveShellApp.exec_lines = ['import sys; sys.path.append(\"C:/Users/lover/AppData/Roaming/Python/Python311/Scripts/\")']\n",
    "\n",
    "# See this for tessaract nigthmare\n",
    "#https://stackoverflow.com/questions/50951955/pytesseract-tesseractnotfound-error-tesseract-is-not-installed-or-its-not-i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29d3863e-a47b-4252-bb60-f2c407fb7565",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ran these manually in iPython\n",
    "#pytesseract.pytesseract.tesseract_cmd = \"C://Program Files//Tesseract-OCR//tesseract.exe\"\n",
    "#screenshot = pyautogui.screenshot()\n",
    "#text = image_to_string(screenshot)\n",
    "#text\n",
    "#history\n",
    "\n",
    "def take_full_screenshot():\n",
    "    time.sleep(5)\n",
    "    screenshot = pyautogui.screenshot()\n",
    "    text = image_to_string(screenshot) \n",
    "    print(text)\n",
    "\n",
    "home_stats_x, home_stats_y = 42, 214\n",
    "origin_point = 196, 214\n",
    "\n",
    "home_stats_top_right_x, home_stats_top_right_y = 1208, 212\n",
    "home_stats_bottom_right_x, home_stats_bottom_right = 1208, 1351\n",
    "home_stats_boundary_point = 1208, 1351\n",
    "\n",
    "def calc_width_and_height(origin_point, boundary_point):\n",
    "    x, y = origin_point\n",
    "    boundary_x, boundary_y = boundary_point\n",
    "    return ((boundary_x - x), (boundary_y - y))\n",
    "    \n",
    "\n",
    "def take_home_match_screenshot(origin, boundary):\n",
    "    x, y = origin\n",
    "    width, height = calc_width_and_height(origin, boundary)\n",
    "    time.sleep(5)\n",
    "    print(f\"{x}, {y}, {width}, {height}\")\n",
    "    screenshot = pyautogui.screenshot(region=(x, y, width, height))\n",
    "    text = image_to_string(screenshot) \n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74f6da26-fe55-4e72-b7d3-7f757f7810f6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "take_home_match_screenshot(origin_point, home_stats_boundary_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c011418-f21a-4aed-8d93-8fc11578b82a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# We will try to use CHATGPT code to read Normal Name and UUID from game\n",
    "# We will need to locate click locations using \n",
    "# # To display mouse position\n",
    "# pyautogui.displayMousePosition()\n",
    "\n",
    "\n",
    "import pyautogui\n",
    "import pandas as pd\n",
    "import time\n",
    "from pytesseract import image_to_string\n",
    "import pytesseract\n",
    "import re\n",
    "import time\n",
    "\n",
    "pytesseract.pytesseract.tesseract_cmd = \"C://Program Files//Tesseract-OCR//tesseract.exe\"\n",
    "\n",
    "# Load your CSV\n",
    "#df = pd.read_csv('players.csv')\n",
    "%store -r df \n",
    "\n",
    "#df = pd.DataFrame(df)\n",
    "\n",
    "# Home coordinates for top left of search bar\n",
    "coord_x = 484\n",
    "coord_y = 31\n",
    "\n",
    "player_profile_coord_x = 167\n",
    "player_profile_coord_y = 475\n",
    "\n",
    "(name_region_x, name_region_y) = (484, 31)\n",
    "\n",
    "(name_region_bottom_right_x, name_region_bottom_right_y) = (2645, 109)\n",
    "\n",
    "(width, height) = ((name_region_bottom_right_x - name_region_x), \n",
    "                   (name_region_bottom_right_y - name_region_y))\n",
    "\n",
    "# Function to search for player and extract information\n",
    "def search_player_and_extract_info(player_name):\n",
    "    # Navigate to the search interface (you'll need to find the exact coordinates)\n",
    "    pyautogui.click(x=coord_x, y=coord_y)\n",
    "    time.sleep(2)  # Wait for the interface to open\n",
    "    #return\n",
    "    # Enter the player's name\n",
    "    pyautogui.write(player_name)\n",
    "    pyautogui.press('enter')\n",
    "    time.sleep(2)  # Wait for the search results\n",
    "    #return\n",
    "\n",
    "    # Click on the player profile (you may need to adjust coordinates or use image recognition)\n",
    "    pyautogui.click(x=player_profile_coord_x, y=player_profile_coord_y)\n",
    "    time.sleep(2)  # Wait for the profile to open\n",
    "    #return\n",
    "    \n",
    "    # Take a screenshot and use OCR to extract the short name and UUID\n",
    "    # Adjust the region to where the short name and UUID would be\n",
    "    #print(\"our region is\")\n",
    "    #print((name_region_x, name_region_y, width, height))\n",
    "    #print()\n",
    "    screenshot = pyautogui.screenshot(region=(name_region_x, name_region_y, width, height))\n",
    "    text = image_to_string(screenshot)\n",
    "    short_name, uuid = extract_name_and_id(text)\n",
    "    #print(f\"Short Name:{short_name}\\nUUID:{uuid}\")\n",
    "    #return\n",
    "    # print(f\"Text we see: {text}\")\n",
    "    # print(\"----\")\n",
    "    # print(\"try to see hidden chars\")\n",
    "    # print( [text] )\n",
    "    # print(\"----\")\n",
    "    # print(\"Try using repr\")\n",
    "    # print( repr(text) )\n",
    "    # player_text_data = text.split(\"\\n\")\n",
    "    # return\n",
    "    \n",
    "    # Parse the extracted text to find the short name and UUID\n",
    "    # This step depends on how the OCR text is formatted\n",
    "    #short_name = 'extracted_short_name'  # Placeholder\n",
    "    #uuid = 'extracted_uuid'  # Placeholder\n",
    "\n",
    "    return short_name, uuid\n",
    "\n",
    "\n",
    "def extract_uuid(input_string):\n",
    "    match = re.search(r'\\(ID:(\\d+)\\)', input_string)\n",
    "    if match:\n",
    "        return match.group(1)\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "def process_uuid_elements(player_data):\n",
    "    for string in [player_data[2], player_data[1]]:\n",
    "        output = extract_uuid(string)\n",
    "        if output:\n",
    "            return output\n",
    "    return None\n",
    "    \n",
    "def extract_name_and_id(player_data):\n",
    "    # Split player data on \"\\n\"\n",
    "    player_data_list = player_data.split(\"\\n\")\n",
    "    \n",
    "    # The length of all lists will be three. Check final element is null\n",
    "    if re.match(\"Q \", player_data_list[0]):\n",
    "        # print(f\"2nd element {player_data_list[1]}\")\n",
    "        # print(f\"3rd element {player_data_list[2]}\")\n",
    "        #print(\"Player is Club player\")\n",
    "        short_name_unclean = player_data_list[0]\n",
    "        #print(f\"We found {short_name_unclean}\")\n",
    "        short_name = short_name_unclean.split(\".\")[1].lstrip()\n",
    "        #short_name = player_data_list[0]\n",
    "    else:\n",
    "        # We have a player at a club\n",
    "        #print(\"Player is Free Agent\")\n",
    "        short_name = player_data_list[0]\n",
    "     \n",
    "    #print( repr(short_name) )\n",
    "    # Now that we have the name we must CLEANSE IT IN FIRE!\n",
    "    short_name = re.sub(r'^.*?\\d+\\.\\s*', \"\", short_name)\n",
    "    #print(f\"FINAL Short Name: {short_name}\")\n",
    "        \n",
    "    # UUID should be third or second element, go \"upwards\" to locate\n",
    "    uuid = process_uuid_elements(player_data_list)\n",
    "    return (short_name, uuid)\n",
    "\n",
    "              \n",
    "iterate_count = 0\n",
    "unchanged_list = []\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Provide time to move alt-tab to app\n",
    "    time.sleep(5)\n",
    "    # Go to Training>Indivdual menus\n",
    "    #orientate()\n",
    "\n",
    "    # Load your CSV\n",
    "    #df = pd.read_csv('players_small.csv')\n",
    "    start_time = time.time()\n",
    "    # Loop over the dataframe\n",
    "    # We can also reuse/change our start point\n",
    "    #last_valid_index = df['short name'].last_valid_index()\n",
    "    #for index, row in df.loc[last_valid_index+1].iterrows():\n",
    "    #for index, row in df.iterrows(): # Originial\n",
    "    for index, row in df.items\n",
    "        try:\n",
    "            player_name = row['Name']\n",
    "            #print(f\"Player Name: {player_name}\")\n",
    "            short_name, uuid = search_player_and_extract_info(player_name)\n",
    "\n",
    "            # Update the dataframe\n",
    "            df.at[index, 'short name'] = short_name\n",
    "            df.at[index, 'UUID'] = uuid\n",
    "\n",
    "            # Go back to the main screen or search screen before next iteration\n",
    "            # This might involve pressing 'esc' or clicking a 'back' button\n",
    "            pyautogui.press('esc')\n",
    "        except IndexError:\n",
    "            #print(f\"Unable to locate: {player_name} in your db\") \n",
    "            unchanged_list.append(player_name)\n",
    "        \n",
    "        iterate_count +=1\n",
    "\n",
    "    # Write the updated dataframe back to CSV\n",
    "    df.to_csv('players_updated.csv', index=False)\n",
    "    \n",
    "    end_time = time.time()\n",
    "    total_time = end_time - start_time\n",
    "              \n",
    "    print(f\"Total time: {total_time}\")\n",
    "    print(f\"Time per iteration: {total_time/iterate_count}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf25168a-b308-4ecf-80ba-375762c0324d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "store -r df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8c040e7-e192-409f-b09c-68b9abe58617",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f68f26ef-36ea-4941-b8a5-13f14e3bb2ba",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "last_valid_index = df['short name'].last_valid_index()\n",
    "print(last_valid_index)\n",
    "# df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6860fd6-744b-4586-8867-0a1655e4b0a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%store df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ebcab6e-4a06-4be8-b5be-804470f27652",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for row, index in df.iterrows():\n",
    "    print(f\"Row:{row} index:{index}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba24788-3a37-4f83-a5d2-3911ae812b83",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def process_df(df):\n",
    "    iterate_count = 0\n",
    "    time.sleep(5)\n",
    "    # Go to Training>Indivdual menus\n",
    "    #orientate()\n",
    "\n",
    "    # Load your CSV\n",
    "    #df = pd.read_csv('players_small.csv')\n",
    "    start_time = time.time()\n",
    "    # Loop over the dataframe\n",
    "    # We can also reuse/change our start point\n",
    "    #last_valid_index = df['short name'].last_valid_index()\n",
    "    for index, row in df.iloc[6171:].iterrows():\n",
    "    #for index, row in df.iterrows(): # Originial\n",
    "    #for index, row in df.items\n",
    "        try:\n",
    "            player_name = row['Name']\n",
    "            #print(f\"Player Name: {player_name}\")\n",
    "            short_name, uuid = search_player_and_extract_info(player_name)\n",
    "\n",
    "            # Update the dataframe\n",
    "            df.at[index, 'short name'] = short_name\n",
    "            df.at[index, 'UUID'] = uuid\n",
    "\n",
    "            # Go back to the main screen or search screen before next iteration\n",
    "            # This might involve pressing 'esc' or clicking a 'back' button\n",
    "            pyautogui.press('esc')\n",
    "        except IndexError:\n",
    "            #print(f\"Unable to locate: {player_name} in your db\") \n",
    "            unchanged_list.append(player_name)\n",
    "        \n",
    "        iterate_count +=1\n",
    "\n",
    "    # Write the updated dataframe back to CSV\n",
    "    df.to_csv('players_updated.csv', index=False)\n",
    "    \n",
    "    end_time = time.time()\n",
    "    total_time = end_time - start_time\n",
    "              \n",
    "    print(f\"Total time: {total_time}\")\n",
    "    print(f\"Time per iteration: {total_time/iterate_count}\") \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04788fe9-0694-410c-b5a4-91e884e7e348",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "process_df(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b81fdc7-6a8f-4357-90e8-202f15d58ef9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd9ba9cd-d8c3-4129-92dd-34533f69c89f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%store df\n",
    "%store df_cleaned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a05dc2d0-9240-4072-a0f6-9d50333f9ca5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_cleaned = df[df['short name'] != 'Q, Game: \"Bangoche FM - NK Sesvete\"']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "763be3b3-7290-4ced-8d76-67bfe4272218",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_cleaned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79af10e5-ec60-441d-abd6-5b6e8296c17d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#!pip install fuzzywuzzy\n",
    "#!pip install fuzzywuzzy[speedup]\n",
    "#from fuzzywuzzy import fuzz\n",
    "\n",
    "#fuzz.ratio(df_cleaned['Name'], df_cleaned['short name'])\n",
    "for index, row in df_cleaned.iterrows():\n",
    "    #print(f\"Long Name: {row['Name']}\")\n",
    "    try:\n",
    "        if fuzz.ratio(row['Name'], row['short name']) < 30 and row['UUID'] is not None:\n",
    "            print(f\"Long Name: {row['Name']}  Short Name: {row['short name']}\")\n",
    "        #print(f\"Fuzz ratio {fuzz.ratio(row['Name'], row['short name'])}\")\n",
    "    except TypeError:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3c3dd1d-a8be-4471-913d-342b332f07a0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_fuzz(x,y):\n",
    "    try:\n",
    "        if fuzz.ratio(x, y) < 30:\n",
    "            print(f\"Long Name: {row['Name']}  Short Name: {row['short name']}\")\n",
    "        #print(f\"Fuzz ratio {fuzz.ratio(row['Name'], row['short name'])}\")\n",
    "    except TypeError:\n",
    "        pass\n",
    "#result = [my_fuzz(x,y) for x,y  in zip(df_cleaned['Name'], df_cleaned['short name'])]\n",
    "#print(result)\n",
    "def my_row_fuzz(long_name, short_name, uuid):\n",
    "    try:\n",
    "        if fuzz.ratio(long_name, short_name) < 30 and uuid is not None:\n",
    "            return (f\"Long Name: {long_name}  Short Name: {short_name}\")\n",
    "        #print(f\"Fuzz ratio {fuzz.ratio(row['Name'], row['short name'])}\")\n",
    "    except TypeError:\n",
    "        pass\n",
    "\n",
    "for row in df_cleaned.itertuples():\n",
    "    result = my_row_fuzz(row[1], row[6], row[7])\n",
    "    if result:\n",
    "        print(f\"Name {result}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3804922c-2f5c-4954-a7f8-ec7592c12c0c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.to_csv('players_updated.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0d23e25-37f3-4a85-abd0-8cfd81fcefa7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_not_nans = df['short name'].count()\n",
    "                  \n",
    "last_valid_index = df['short name'].last_valid_index()\n",
    "#for i in range(last_valid_index +1, len(df)):\n",
    "    # do something with row\n",
    "#    pass\n",
    "print(last_valid_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b62f71ef-caee-4329-a9d2-59433f9b24f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_not_nans = df['short name'].count()\n",
    "                  \n",
    "last_valid_index = df['short name'].last_valid_index()\n",
    "#for i in range(last_valid_index +1, len(df)):\n",
    "    # do something with row\n",
    "#    pass\n",
    "                  \n",
    "# We can also reuse/change our start point\n",
    "last_valid_index = df['short name'].last_valid_index()\n",
    "for index, row in df.loc[last_valid_index+1].iterrows():\n",
    "    # do something with row\n",
    "    pass\n",
    "                  \n",
    "                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "140c9a0f-e16e-41ff-ae5a-82fcc8ffedab",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test with a free agent De Gea\n",
    "david_de_gea = \"David De Gea\"\n",
    "time.sleep(5)\n",
    "search_player_and_extract_info(david_de_gea)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4665e16e-b812-4fc1-822f-f9313c574306",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "de_gea_text = 'David De Gea\\nGoalkeeper (1ID:67030171)\\n'\n",
    "de_gea_text_data = de_gea_text.split(\"\\n\")\n",
    "print(de_gea_text_data)\n",
    "for line in de_gea_text_data:\n",
    "    print(line)\n",
    "len(de_gea_text_data)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07b8b727-6354-4f47-b7d4-b6a8cb051e10",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "lamine_text = 'Q 27. Lamine Yamal\\nAttacking Midfielder (Right, Left), Striker (Center) - Barcelona (ID:2000256231)\\n'\n",
    "lamine_text_data = lamine_text.split(\"\\n\")\n",
    "print(lamine_text_data)\n",
    "for line in lamine_text_data:\n",
    "    print(line)\n",
    "#len(lamine_text_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7878c88-bd77-4cdb-a9bc-09d2b65b0740",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "text = '9. Vitor Roque'\n",
    "#text = '@ 31. Ansu Fati'\n",
    "result = re.sub(r'^.*?\\d+\\.\\s*', \"\",text)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90e6a09b-db68-4ca3-85a4-29d6cd25446e",
   "metadata": {},
   "outputs": [],
   "source": [
    "beautifulsoup4==4.11.1\n",
    "certifi==2022.12.7\n",
    "charset-normalizer==2.1.1\n",
    "idna==3.4\n",
    "lxml==4.9.2\n",
    "Pillow==9.3.0\n",
    "requests==2.28.1\n",
    "soupsieve==2.3.2.post1\n",
    "urllib3==1.26.13\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee6281f9-3aaf-4c51-a7ac-1cb790df6b78",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.getcwd()\n",
    "os.chdir(\"C:\\\\Users\\\\lover\\\\OneDrive\\\\Documents\\\\GitHub\\\\soccer-card-project\\\\\")\n",
    "os.getcwd()\n",
    "\n",
    "#!python -m \"C:\\\\Users\\\\lover\\\\OneDrive\\\\Documents\\\\GitHub\\\\soccer-card-project\\\\main\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "448da292-629c-4df7-b6a2-bc8ba03f6fd3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "import random\n",
    "import pathlib\n",
    "import urllib.request\n",
    "import os.path\n",
    "from lxml import etree\n",
    "from PIL import Image\n",
    "from PIL import ImageDraw\n",
    "from PIL import ImageFont\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36'}\n",
    "\n",
    "playerNames = []\n",
    "playerNos = []\n",
    "playerImageLinks = []\n",
    "teamNames = []\n",
    "teamIds = []\n",
    "\n",
    "def get_team_names_and_ids():\n",
    "\n",
    "    leagueLinkAddress = 'https://www.transfermarkt.com.tr/super-lig/startseite/wettbewerb/TR1'\n",
    "\n",
    "    leagueTreeResponse = requests.get(leagueLinkAddress, headers=headers)\n",
    "    soupLeague = BeautifulSoup(leagueTreeResponse.content, 'html.parser')\n",
    "\n",
    "    teamNamesTree = (etree.HTML(str(soupLeague)).xpath('/html/body/div[2]/main/div[2]/div[1]/div[2]/div[2]/div/table/tbody/tr'))\n",
    "\n",
    "    for i in range(len(teamNamesTree)):\n",
    "\n",
    "        if teamNamesTree[i].xpath('td[2]/a')[0].text != '':\n",
    "            teamNames.append(teamNamesTree[i].xpath('td[2]/a/@href')[0].split('/')[1])\n",
    "            teamIds.append(teamNamesTree[i].xpath('td[2]/a/@href')[0].split('/')[4])\n",
    "\n",
    "def get_team_colors(teamColors):\n",
    "\n",
    "    for i in range(len(teamNames)):\n",
    "\n",
    "        temaColorUrl = 'https://www.transfermarkt.com.tr/' + teamNames[i] + '/datenfakten/verein/' + teamIds[i]\n",
    "\n",
    "        tree = requests.get(temaColorUrl, headers=headers)\n",
    "        soup = BeautifulSoup(tree.content, 'html.parser')\n",
    "\n",
    "        arr = soup.findAll('p', class_='vereinsfarbe')\n",
    "\n",
    "        if len(arr) == 0:\n",
    "            randomColor1 = (\"#\" + ''.join([random.choice('ABCDEF0123456789') for i in range(6)])).lstrip('#')\n",
    "            randomColor2 = (\"#\" + ''.join([random.choice('ABCDEF0123456789') for i in range(6)])).lstrip('#')\n",
    "\n",
    "            teamColors[i][0] = tuple(int(randomColor1[i:i + 2], 16) for i in (0, 2, 4))\n",
    "            teamColors[i][1] = tuple(int(randomColor2[i:i + 2], 16) for i in (0, 2, 4))\n",
    "\n",
    "        else:\n",
    "            h1 = arr[0].findAll('span')[0][\"style\"].split(':')[1].rstrip(\";\").lstrip('#')\n",
    "            h2 = arr[0].findAll('span')[1][\"style\"].split(':')[1].rstrip(\";\").lstrip('#')\n",
    "\n",
    "            teamColors[i][0] = tuple(int(h1[i:i + 2], 16) for i in (0, 2, 4))\n",
    "            teamColors[i][1] = tuple(int(h2[i:i + 2], 16) for i in (0, 2, 4))\n",
    "\n",
    "def get_player_datas(playerInfos):\n",
    "\n",
    "    for i in range(len(teamNames)):\n",
    "\n",
    "        playerNames.clear()\n",
    "        playerImageLinks.clear()\n",
    "        playerNos.clear()\n",
    "\n",
    "        page = 'https://www.transfermarkt.com.tr/' + teamNames[i] + '/startseite/verein/' + teamIds[i]\n",
    "\n",
    "        tree = requests.get(page, headers=headers)\n",
    "        soup = BeautifulSoup(tree.content, 'html.parser')\n",
    "\n",
    "        playerInfos[i][0] = teamNames[i]\n",
    "\n",
    "        players = soup.findAll('img', class_='bilderrahmen-fixed')\n",
    "\n",
    "        for j in range(len(players)):\n",
    "            if players[j]['title'] != '':\n",
    "                playerNames.append(players[j]['title'].replace(\" \", \"-\").lower())\n",
    "\n",
    "                playerLink = soup.find('a', attrs={'title':players[j]['title']})\n",
    "\n",
    "                pagePlayerInfo = 'https://www.transfermarkt.com.tr' + playerLink.findNext('a')['href']\n",
    "                treePlayerInfo = requests.get(pagePlayerInfo, headers=headers)\n",
    "                soupPlayerInfo = BeautifulSoup(treePlayerInfo.content, 'html.parser')\n",
    "\n",
    "                playerName = players[j]['title']\n",
    "\n",
    "                age = soupPlayerInfo.find('span',attrs={'class':'data-header__content', 'itemprop':'birthDate'})\n",
    "                randomAge = random.randint(15, 39)\n",
    "                strAge = age.text.replace(\" \", \"\").split('(')[1][:2] if age is not None else str(randomAge)\n",
    "                playerAge = strAge\n",
    "\n",
    "                number = soupPlayerInfo.find('span',attrs={'class':'data-header__shirt-number'})\n",
    "                randomNumber = random.randint(0, 99)\n",
    "\n",
    "                while randomNumber in playerNos:\n",
    "                    randomNumber = random.randint(0, 99)\n",
    "\n",
    "                playerNos.append(randomNumber)\n",
    "                strNumber = number.text.replace(\" \", \"\")[2:] if number is not None else str(randomNumber)\n",
    "                playerNumber = strNumber\n",
    "\n",
    "                value = soupPlayerInfo.find('a',attrs={'class':'data-header__market-value-wrapper'})\n",
    "\n",
    "                thousandOrMillion = random.randint(0, 1)\n",
    "\n",
    "                if thousandOrMillion == 1:\n",
    "                    randomValue = random.randint(50, 999)\n",
    "                    strValue = value.text.split('€')[0] if value is not None else str(randomValue) + \" Bin \"\n",
    "                else:\n",
    "                    randomValue = random.randint(1, 15)\n",
    "                    strValue = value.text.split('€')[0] if value is not None else str(randomValue) + \".00 mil. \"\n",
    "\n",
    "                playerValue = strValue + \"€\"\n",
    "\n",
    "                height = soupPlayerInfo.find('span',attrs={'class':'data-header__content', 'itemprop':'height'})\n",
    "                playerHeight = height.text if height is not None else str(round(random.uniform(1.6, 2.0), 2)) + \" m\"\n",
    "                strHeight = playerHeight.replace(\" \", \"\").replace(\"m\", \"\").replace(\",\", \"\").replace(\".\", \"\")\n",
    "\n",
    "                playerWeight = str(round(calculate_age_constant(int(playerAge)) * (int(strHeight) - 105))) + \" kg\"\n",
    "\n",
    "                playerInfos[i][1].append(playerName)\n",
    "                playerInfos[i][2].append(playerAge)\n",
    "                playerInfos[i][3].append(playerNumber)\n",
    "                playerInfos[i][4].append(playerValue)\n",
    "                playerInfos[i][5].append(playerHeight)\n",
    "                playerInfos[i][6].append(playerWeight)\n",
    "\n",
    "        for playerImageLink in soup.findAll('img', class_='bilderrahmen-fixed'):\n",
    "\n",
    "            playerImageLinks.append(playerImageLink['data-src'].replace(\"small\", \"header\"))\n",
    "\n",
    "        for j in range(len(playerNames)):\n",
    "\n",
    "            absolute_path = os.path.dirname(__file__)\n",
    "            relative_path = \"output-photos\\\\player-photos\\\\\" + teamNames[i] + \"\\\\\"\n",
    "            full_path = os.path.join(absolute_path, relative_path)\n",
    "\n",
    "            if not os.path.isdir(full_path):\n",
    "                pathlib.Path(full_path).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "            urllib.request.urlretrieve(playerImageLinks[j], full_path + playerNames[j] + '.png')\n",
    "\n",
    "def calculate_age_constant(ageValue):\n",
    "    if ageValue < 15:\n",
    "        return 0.9\n",
    "    elif ageValue >= 15 and ageValue < 20:\n",
    "        return 0.95\n",
    "    elif ageValue >= 20 and ageValue < 25:\n",
    "        return 1.00\n",
    "    elif ageValue >= 25 and ageValue < 30:\n",
    "        return 1.00\n",
    "    elif ageValue >= 30 and ageValue < 35:\n",
    "        return 1.00\n",
    "    elif ageValue >= 35 and ageValue < 40:\n",
    "        return 1.05\n",
    "    else:\n",
    "        return 1.1\n",
    "\n",
    "def create_team_card_templates(teamColors):\n",
    "\n",
    "    for i in range(len(teamNames)):\n",
    "\n",
    "        absolute_path = os.path.dirname(__file__)\n",
    "\n",
    "        flag_inside1 = Image.open(absolute_path + \"\\\\base-photos\\\\flag-inside-1.png\")\n",
    "        flag_inside2 = Image.open(absolute_path + \"\\\\base-photos\\\\flag-inside-2.png\")\n",
    "        inline_border = Image.open(absolute_path + \"\\\\base-photos\\\\inline-border.png\")\n",
    "\n",
    "        new_image1 = []\n",
    "        new_image2 = []\n",
    "        new_image3 = []\n",
    "\n",
    "        flag_inside1 = flag_inside1.convert(\"RGBA\")\n",
    "        flag_inside2 = flag_inside2.convert(\"RGBA\")\n",
    "        inline_border = inline_border.convert(\"RGBA\")\n",
    "\n",
    "        d1 = flag_inside1.getdata()\n",
    "        d2 = flag_inside2.getdata()\n",
    "        d3 = inline_border.getdata()\n",
    "\n",
    "        color1 = teamColors[i][0]\n",
    "        color2 = teamColors[i][1]\n",
    "\n",
    "        for item in d1:\n",
    "\n",
    "            if item[0] in list(range(200, 256)):\n",
    "                new_image1.append(color1)\n",
    "            else:\n",
    "                new_image1.append(item)\n",
    "\n",
    "        for item in d2:\n",
    "\n",
    "            if item[0] in list(range(200, 256)):\n",
    "                new_image2.append(color2)\n",
    "            else:\n",
    "                new_image2.append(item)\n",
    "\n",
    "        for item in d3:\n",
    "\n",
    "            if item[0] in list(range(200, 256)):\n",
    "                new_image3.append(color1)\n",
    "            else:\n",
    "                new_image3.append(item)\n",
    "\n",
    "        flag_inside1.putdata(new_image1)\n",
    "        flag_inside2.putdata(new_image2)\n",
    "        inline_border.putdata(new_image3)\n",
    "\n",
    "        relative_path = \"output-photos\\\\team-templates\\\\\" + teamNames[i] + \"\\\\\"\n",
    "        full_path = os.path.join(absolute_path, relative_path)\n",
    "\n",
    "        if not os.path.isdir(full_path):\n",
    "            pathlib.Path(full_path).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "        flag_inside1.save(full_path + \"flag-inside1.png\")\n",
    "\n",
    "        flag_inside2.save(full_path + \"flag-inside2.png\")\n",
    "\n",
    "        inline_border.save(full_path + \"inline-border.png\")\n",
    "\n",
    "def generate_team_cards(playerInfos):\n",
    "\n",
    "    for i in range(len(playerInfos)):\n",
    "\n",
    "        for j in range(len(playerInfos[i][1])):\n",
    "\n",
    "            absolute_path = os.path.dirname(__file__)\n",
    "\n",
    "            background = Image.open(absolute_path + \"\\\\base-photos\\\\background.png\")\n",
    "            base_info = Image.open(absolute_path + \"\\\\base-photos\\\\base-info.png\")\n",
    "            flag_border = Image.open(absolute_path + \"\\\\base-photos\\\\flag-border.png\")\n",
    "\n",
    "            flag_inside1 = Image.open(absolute_path + \"\\\\output-photos\\\\team-templates\\\\\" + playerInfos[i][0] + \"\\\\\" + \"flag-inside1.png\")\n",
    "            flag_inside2 = Image.open(absolute_path + \"\\\\output-photos\\\\team-templates\\\\\" + playerInfos[i][0] + \"\\\\\" + \"flag-inside2.png\")\n",
    "            inline_border = Image.open(absolute_path + \"\\\\output-photos\\\\team-templates\\\\\" + playerInfos[i][0] + \"\\\\\" + \"inline-border.png\")\n",
    "\n",
    "            photo = Image.open(absolute_path + \"\\\\output-photos\\\\player-photos\\\\\" + playerInfos[i][0] + \"\\\\\" + playerInfos[i][1][j].replace(\" \", \"-\").lower() + \".png\")\n",
    "\n",
    "            photo = photo.resize((550, 700))\n",
    "\n",
    "            im = Image.new(mode=\"RGBA\", size=(background.width, background.height))\n",
    "\n",
    "            im.paste(photo, (150, 110))\n",
    "\n",
    "            relative_path = \"output-photos\\\\resized-player-photos\\\\\" + playerInfos[i][0] + \"\\\\\"\n",
    "\n",
    "            full_path = os.path.join(absolute_path, relative_path)\n",
    "\n",
    "            if not os.path.isdir(full_path):\n",
    "                pathlib.Path(full_path).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "            im.save(full_path + playerInfos[i][1][j].replace(\" \", \"-\").lower() + \".png\")\n",
    "\n",
    "            photo = Image.open(full_path + playerInfos[i][1][j].replace(\" \", \"-\").lower() + \".png\")\n",
    "\n",
    "            img1 = Image.alpha_composite(background, photo)\n",
    "            img2 = Image.alpha_composite(img1, base_info)\n",
    "            img3 = Image.alpha_composite(img2, inline_border)\n",
    "            img4 = Image.alpha_composite(img3, flag_inside1)\n",
    "            img5 = Image.alpha_composite(img4, flag_inside2)\n",
    "            img6 = Image.alpha_composite(img5, flag_border)\n",
    "\n",
    "            i1 = ImageDraw.Draw(img6)\n",
    "\n",
    "            nameFont = ImageFont.truetype(absolute_path + '\\\\fonts\\\\arial-narrow.ttf', 60)\n",
    "            infoFont = ImageFont.truetype(absolute_path + '\\\\fonts\\\\UniversalisADFStd-CondItalic.otf', 53)\n",
    "            numberFont = ImageFont.truetype(absolute_path + '\\\\fonts\\\\arial.ttf', 60)\n",
    "\n",
    "            name = playerInfos[i][1][j]\n",
    "\n",
    "            age = playerInfos[i][2][j]\n",
    "            weight = playerInfos[i][6][j]\n",
    "            height = playerInfos[i][5][j]\n",
    "            value = playerInfos[i][4][j]\n",
    "            number = playerInfos[i][3][j]\n",
    "\n",
    "            i1.text((img6.width/2, 902), name, font=nameFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "\n",
    "            i1.text((img6.width/4, 1028), age, font=infoFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "            i1.text((img6.width*(3/4), 1028), weight, font=infoFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "            i1.text((img6.width/4 + 40, 1120), height, font=infoFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "            i1.text((img6.width*(3/4) + 50, 1120), value, font=infoFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "            i1.text((img6.width*(3/4) + 92, 125), number, font=numberFont, fill=(0, 0, 0), anchor=\"mm\")\n",
    "\n",
    "            relative_path = \"output-photos\\\\final-results\\\\\" + playerInfos[i][0] + \"\\\\\"\n",
    "\n",
    "            full_path = os.path.join(absolute_path, relative_path)\n",
    "\n",
    "            if not os.path.isdir(full_path):\n",
    "                pathlib.Path(full_path).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "            img6.save(full_path + playerInfos[i][1][j].replace(\" \", \"-\").lower() + \".png\")\n",
    "\n",
    "def main():\n",
    "    get_team_names_and_ids()\n",
    "\n",
    "    teamColors = [[0 for i in range(2)] for j in range(len(teamNames))]\n",
    "    playerInfos = [[str(), list(), list(), list(), list(), list(), list()] for j in range(len(teamNames))]\n",
    "\n",
    "    get_team_colors(teamColors)\n",
    "    get_player_datas(playerInfos)\n",
    "    create_team_card_templates(teamColors)\n",
    "    generate_team_cards(playerInfos)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e6e84b-6a2f-4356-b658-ee7ea7e5e492",
   "metadata": {},
   "source": [
    "# How to iterate over Pandas dataframes....( you don't)\n",
    "https://stackoverflow.com/questions/16476924/how-to-iterate-over-rows-in-a-dataframe-in-pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cde5a6d-ffa1-491b-a66d-ff937f42280e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# NK Sesvete Transfermarkt URL\n",
    "# https://www.transfermarkt.com/nk-sesvete/startseite/verein/25029\n",
    "#!pip install requests\n",
    "!pip install html5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51a791f4-12dd-4f14-a355-34fafb70a57f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Read in simple view data from FM\n",
    "\n",
    "simple_sesvete_data = pd.read_html('sesvete_fm_data.html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f55df62-921b-4c48-b9fe-e2936677ea78",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import pprint\n",
    "import shutil\n",
    "import requests\n",
    "\n",
    "import os\n",
    "\n",
    "NULL_IMG = 'https://img.a.transfermarkt.technology/portrait/medium/default.jpg?lm=1'\n",
    "URL = \"https://www.transfermarkt.com/nk-sesvete/kader/verein/25029/saison_id/2023/plus/1\"\n",
    "headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 Edg/118.0.2088.76'}\n",
    "\n",
    "\n",
    "#page = requests.get(URL)\n",
    "\n",
    "headers = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 Edg/118.0.2088.76'\n",
    "\n",
    "\n",
    "def my_tfmrkt_fuzz(player_name, fm_player_name, uuid):\n",
    "    #print(f\"Processing {fm_player_name}\")\n",
    "    try:\n",
    "        if fuzz.ratio(player_name, fm_player_name) > 75:\n",
    "            print(f\"TFMRKT Name: {player_name}  FM Name: {fm_player_name} UUID {uuid}\")\n",
    "            return uuid\n",
    "        #print(f\"Fuzz ratio {fuzz.ratio(row['Name'], row['short name'])}\")\n",
    "    except TypeError:\n",
    "        pass\n",
    "    return None\n",
    "\n",
    "\n",
    "def download_jpg(uuid, url):\n",
    "    out_file_name = './images/' + str(uuid) + '.jpg'\n",
    "    response = requests.get(url, stream=True)\n",
    "    with open(out_file_name, 'wb') as out_file:\n",
    "        shutil.copyfileobj(response.raw, out_file)\n",
    "    del response\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "#sesvete_html_df = pd.read_html('sesvete_web.html')\n",
    "#sesvete_html_df[1]\n",
    "os.chdir(\"C:\\\\Users\\\\lover\\\\OneDrive\\\\Documents\\\\GitHub\\\\football_manager_code\")\n",
    "print(f\"DIR {os.getcwd()}\")\n",
    "\n",
    "# This functions with local file\n",
    "# with open('sesvete_web.html', 'r') as input_html:\n",
    "#    page = input_html.read()\n",
    "\n",
    "\n",
    "headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 Edg/118.0.2088.76'}\n",
    "#url = 'https://www.transfermarkt.com/nk-sesvete/kader/verein/25029/saison_id/2023/plus/1'\n",
    "response = requests.get(URL, headers=headers)\n",
    "\n",
    "soup = BeautifulSoup(response.content, \"html.parser\")\n",
    "\n",
    "\n",
    "#with open('fm_data.html', 'r') as input_fm_html:\n",
    "#    fm_html = input_fm_html.read()\n",
    "    \n",
    "fm_data_df = pd.read_html('fm_data.html')\n",
    "\n",
    "#with open('sesvete_fm_data.html', 'r') as input_fm:\n",
    "#    fm_data = input_fm.read()\n",
    "#soup = BeautifulSoup(page, \"html.parser\")\n",
    "\n",
    "#results = soup.find(id=\"yw1\")\n",
    "#print(results.prettify())\n",
    "#job_elements = results.find_all(\"div\", class_=\"card-content\")\n",
    "#for job_element in job_elements:\n",
    "#    print(job_element, end=\"\\n\"*2)\n",
    "    \n",
    "player_table = soup.find(\"table\", class_=\"items\")\n",
    "# print(player_table.prettify())\n",
    "\n",
    "images_found = player_table.find_all(\"img\", class_=\"bilderrahmen-fixed lazy lazy\")\n",
    "#len(images_found)\n",
    "#pprint.pprint(images_found)\n",
    "\n",
    "for found_image in images_found: \n",
    "    #dir(found_image)\n",
    "    image_source = found_image[\"data-src\"]\n",
    "    if image_source != NULL_IMG:\n",
    "        player_name = found_image[\"title\"]\n",
    "        #print(f\"Name: {player_name.strip()}\\nIMG: {image_source.strip()}\\n\")\n",
    "        # Attempt a fuzzy match based on name in Transfermkrt\n",
    "        for row in fm_data_df[0].itertuples():\n",
    "            fm_player_name = row[5].split(\"-\")[0].strip()\n",
    "            result = my_tfmrkt_fuzz(player_name, fm_player_name, row[2])\n",
    "            if result:\n",
    "                print(f\"Download {image_source} and save as UUID {result}.jpg\")\n",
    "                print(\"\\n\")\n",
    "                # Download image and use UUID to name its download filename\n",
    "                download_jpg(result, image_source)\n",
    "        \n",
    "#img_elements = bilderrahmen-fixed lazy entered loaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c13fd3a-15d5-487f-ba6c-a0668a630189",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "type(fm_data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78332d1a-9187-4635-8e05-b2d3cd93f61a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#for row in fm_data_df:\n",
    "#    print(f\"Row is {row}\")\n",
    "type(fm_data_df[0])\n",
    "\n",
    "# ARE YOU SERIOUS The read_html creates the dataframe inside of a surrounding LIST?!!!\n",
    "#fm_data_df[0]['UID']\n",
    "\n",
    "for data_crap in fm_data_df[0].itertuples():\n",
    "    #print(data_crap[2])\n",
    "    print(data_crap)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2340c6dc-9e4d-4139-a5d9-783067ba85a2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 Edg/118.0.2088.76'}\n",
    "#url = 'https://www.transfermarkt.com/nk-sesvete/kader/verein/25029/saison_id/2023/plus/1'\n",
    "#response = requests.get(url, headers=headers)\n",
    "\n",
    "soup = BeautifulSoup(response.content, \"html.parser\")\n",
    "results = soup.find(id=\"yw1\")\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60d75b56-bd05-47f1-96ba-bf9018ac6014",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install keyboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7295246e-c9ca-4d80-b7e2-1d58b719d884",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from pyautogui import *\n",
    "import cv2\n",
    "import pyautogui\n",
    "import time\n",
    "import keyboard\n",
    "import numpy as np\n",
    "import random\n",
    "import pprint\n",
    "from pywinauto.application import Application\n",
    "\n",
    "\n",
    "# Load the reference image and ensure it is in the correct format\n",
    "reference_image_path = 'green_space_near_player.png'\n",
    "reference_image = cv2.imread(reference_image_path, cv2.IMREAD_COLOR)\n",
    "\n",
    "# Verify that the reference image is loaded properly\n",
    "if reference_image is None:\n",
    "    raise ValueError(\"Reference image not found or unable to load.\")\n",
    "\n",
    "# Define the region of the screen to capture (x, y, width, height)\n",
    "rating_region_bot_right_x, rating_region_bot_right_y = (1189, 2055) \n",
    "rating_region = (1076, 412, (rating_region_bot_right_x - 1076), (rating_region_bot_right_y - 412))\n",
    "\n",
    "# GLOBALS\n",
    "HOVER_DURATION = 0.2\n",
    "# Bookmark link in bottom left \n",
    "INDY_TRAINING_AREA = (1387, 179)\n",
    "# Location of first player row top left\n",
    "TOP_PLAYER_AREA = (1267, 405)\n",
    "\n",
    "# Roughly equivalent to number of players that \n",
    "# have > 7.0 scores in total. \n",
    "PLAYERS_TO_PRAISE = 17  # Start with 17 and see how far we get\n",
    "\n",
    "# Top right praise button, white rectangle top right\n",
    "# We aim for the white baloon\n",
    "TOP_RIGHT_PRAISE_BUTTON = (3474,284)\n",
    "\n",
    "# Praise button in the pop-up dialog after hitting\n",
    "# top right praise button\n",
    "MODAL_PRAISE_BUTTON = (1597, 1018)\n",
    "\n",
    "\n",
    "# Back down button in the pop-up dialog.\n",
    "# MODAL_BACK_DOWN_BUTTON = (1501, 1035)\n",
    "# Back down button in the pop-up dialog.\n",
    "MODAL_BACK_DOWN_BUTTON = (1809, 834)\n",
    "\n",
    "# Back down button in the pop-up dialog.\n",
    "MODAL_BACK_DOWN_BUTTON_1 = (1555, 1035)\n",
    "\n",
    "\n",
    "# End the quick chat in modal pop-up\n",
    "END_QC_BUTTON = (2759, 317)\n",
    "\n",
    "# Set up \"defensive\" player color and position. The color _may_ change\n",
    "# maybe? Not sure if configurable. The \"color bar\" is the bar that \n",
    "# displays player body language. We choose the section that has not text\n",
    "# to prevent this from misfiring.\n",
    "# DEFENSIVE_COLOR = (152, 105, 82) # Red\n",
    "\n",
    "DEFENSIVE_COLOR = (153, 147, 87) # ORANGE\n",
    "DEFENSIVE_PLAYER_COLOR_BAR = (1168, 701)\n",
    "\n",
    "HANDSHAKE_BUTTON = (2235, 750)\n",
    "\n",
    "def group_locations(locations, threshold=10):\n",
    "    \"\"\"\n",
    "    Group nearby locations to treat them as a single location.\n",
    "    \"\"\"\n",
    "    grouped = []\n",
    "    for loc in locations:\n",
    "        if not grouped:\n",
    "            grouped.append([loc])\n",
    "        else:\n",
    "            match = False\n",
    "            for group in grouped:\n",
    "                if abs(group[0][0] - loc[0]) < threshold and abs(group[0][1] - loc[1]) < threshold:\n",
    "                    group.append(loc)\n",
    "                    match = True\n",
    "                    break\n",
    "            if not match:\n",
    "                grouped.append([loc])\n",
    "    return [tuple(np.mean(g, axis=0).astype(int)) for g in grouped]\n",
    "\n",
    "# Define separate move and click functions\n",
    "def my_move(coord_tuple):\n",
    "    x, y = coord_tuple\n",
    "    pyautogui.moveTo(x, y, duration=HOVER_DURATION)\n",
    "\n",
    "\n",
    "def my_click():\n",
    "    pyautogui.mouseDown()\n",
    "    #time.sleep(0.1)\n",
    "    pyautogui.mouseUp()\n",
    "\n",
    "    \n",
    "def orientate():\n",
    "    # Training area setup\n",
    "    time.sleep(5)\n",
    "\n",
    "    # Navigate to Training Menu using FM shortcut\n",
    "    pyautogui.hotkey('ctrl', 'r')\n",
    "    time.sleep(1)\n",
    "\n",
    "    # Click on Individual Training\n",
    "    time.sleep(2)\n",
    "    my_move(INDY_TRAINING_AREA)\n",
    "    my_click()\n",
    "    \n",
    "    # Click first player\n",
    "    my_move(TOP_PLAYER_AREA)\n",
    "    my_click()\n",
    "\n",
    "\n",
    "# Colors to detect in player bar\n",
    "ORANGE_MIN = (200, 100, 0)\n",
    "ORANGE_MAX = (255, 165, 0)\n",
    "\n",
    "RED_MAX = (153, 147, 87)\n",
    "RED_MIN = (152, 105, 82)\n",
    "    \n",
    "    \n",
    "def is_color_in_range(pixel_color, min_color, max_color):\n",
    "    return all(min_color[i] <= pixel_color[i] <= max_color[i] for i in range(3))\n",
    "    \n",
    "def player_is_defensive(position=DEFENSIVE_PLAYER_COLOR_BAR): \n",
    "    x, y = position\n",
    "    for i in range(10):\n",
    "        pixel_color = pyautogui.pixel(x, y)\n",
    "        print(f\"Mouse Position: {x} , {y}\")\n",
    "        print(f\"Pixel Color:{pixel_color}\")\n",
    "        # We try a generic way to discover if player color bar is red or orange\n",
    "        if is_color_in_range(pixel_color, ORANGE_MIN, ORANGE_MAX) or \\\n",
    "            is_color_in_range(pixel_color, RED_MIN, RED_MAX):\n",
    "            return True\n",
    "        y += 8 # Add 21 pixels to the position to shift it downwards\n",
    "    return False\n",
    "\t\t\n",
    "# To display mouse position\n",
    "# pyautogui.displayMousePosition()\n",
    "\n",
    "def my_praise_click():\n",
    "    my_move(TOP_RIGHT_PRAISE_BUTTON)\n",
    "    my_click()\n",
    "    print(\"Clicked top right praise button\")\n",
    "    # Click 1st praise choice\n",
    "    my_move(MODAL_PRAISE_BUTTON)\n",
    "    my_click()\n",
    "    print(\"Clicked modal praise button\")\n",
    "\n",
    "\t# If player gets defensive, we should see an orange-ey down arrow in certain region.\n",
    "\t# We should back down after a praise attempt, and the remaining logic should stand.\n",
    "    print(\"Trying to see if player is defensive\")\n",
    "    if player_is_defensive():\n",
    "        # Back Down\n",
    "        my_move(MODAL_BACK_DOWN_BUTTON)\n",
    "        my_click()\n",
    "        print(\"Attempted Modal back down 1\")\n",
    "        # Shake their hand\n",
    "        my_move(HANDSHAKE_BUTTON)\n",
    "        my_click()\n",
    "        print(\"Attemped Handshake\")\n",
    "        time.sleep(2)\n",
    "    else:\n",
    "        print(\"No defensiveness detected\")\n",
    "    # End chat \n",
    "    my_move(END_QC_BUTTON)\n",
    "    my_click()\n",
    "    print(\"Clicked end QC button\")\n",
    "\n",
    "    \n",
    "    \n",
    "def praise_button_exists(button):\n",
    "    x, y = button\n",
    "    return pyautogui.pixel(x, y) == (255,255,255)\n",
    "\n",
    "\n",
    "def click_praise_buttons():\n",
    "    my_move(TOP_RIGHT_PRAISE_BUTTON)\n",
    "    my_click()\n",
    "    # Click 1st praise choice\n",
    "    my_move(MODAL_PRAISE_BUTTON)\n",
    "    my_click()\n",
    "    # End chat \n",
    "    my_move(END_QC_BUTTON)\n",
    "    my_click()\n",
    "\n",
    "\n",
    "# Function to navigate to Football Manager 2024 Window\n",
    "def navigate_to_fm_window(window_title=\"Football Manager 2024\"):\n",
    "    time.sleep(2)\n",
    "    try:\n",
    "        app = Application().connect(title_re=window_title)\n",
    "        app.top_window().set_focus()\n",
    "        print(f\"{window_title} window is now active.\")\n",
    "    except Exception as e:\n",
    "        print(f\"Failed to activate {window_title} window: {e}\")\n",
    "        \n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    # Navigate to FM Window\n",
    "    navigate_to_fm_window()\n",
    "    \n",
    "    # Hit escape if needed\n",
    "    pyautogui.press('esc')\n",
    "    \n",
    "    # Go to Training>Indivdual menus\n",
    "    orientate()\n",
    "\n",
    "    # Take a screenshot of the specified rating_region\n",
    "    screenshot = pyautogui.screenshot(region=rating_region)\n",
    "    screenshot = np.array(screenshot)\n",
    "    screenshot = cv2.cvtColor(screenshot, cv2.COLOR_RGB2BGR)\n",
    "\n",
    "    # Ensure both images are of the same type (either both grayscale or both color)\n",
    "    # If using grayscale, uncomment the following lines:\n",
    "    # reference_image = cv2.cvtColor(reference_image, cv2.COLOR_BGR2GRAY)\n",
    "    # screenshot = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)    \n",
    "\n",
    "    # Find the reference image within the screenshot\n",
    "    result = cv2.matchTemplate(screenshot, reference_image, cv2.TM_CCOEFF_NORMED)\n",
    "\n",
    "\n",
    "    # Define a threshold\n",
    "    threshold = 0.80\n",
    "\n",
    "    # Get the locations where the matches exceed the threshold\n",
    "    locations = np.where(result >= threshold)\n",
    "    locations = list(zip(*locations[::-1]))\n",
    "\n",
    "    # Group the locations\n",
    "    grouped_locations = group_locations(locations)\n",
    "    \n",
    "    # Pretty print locations detected\n",
    "    #pprint.pprint(locations)\n",
    "    \n",
    "    # Process each matching location\n",
    "    i = 0\n",
    "    for loc in grouped_locations:\n",
    "        # Calculate the center point\n",
    "        center_x = loc[0] + int(reference_image.shape[1] / 2)\n",
    "        center_y = loc[1] + int(reference_image.shape[0] / 2)\n",
    "\n",
    "        # Add the rating_region's offset to get the absolute screen position\n",
    "        screen_x = rating_region[0] + center_x\n",
    "        screen_y = rating_region[1] + center_y\n",
    "\n",
    "        # Perform the click and praise action\n",
    "        pyautogui.click(screen_x, screen_y)\n",
    "        # print(f\"Clicked {screen_x}, {screen_y} and now sleeping\" )\n",
    "        time.sleep(0.5)  # Adjust sleep time as needed\n",
    "        # Add your 'praise player' code here\n",
    "        if praise_button_exists(TOP_RIGHT_PRAISE_BUTTON):\n",
    "            my_praise_click()\n",
    "        # Diagnostic code in case we need to bug fix\n",
    "        #i += 1\n",
    "        #if i > 5:\n",
    "        #    break\n",
    "        # Optionally, add a small delay between processing each location\n",
    "        time.sleep(0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adb75727-bb99-4373-8756-9f9d11a7164d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test code to confirm if we can detect a player is butthurt or nah by color\n",
    "#time.sleep(5)\n",
    "# Navigate to FM Window\n",
    "navigate_to_fm_window()\n",
    "# Set up \"defensive\" player color and position\n",
    "# DEFENSIVE_COLOR = (152, 105, 82) # RED\n",
    "# DEFENSIVE_COLOR = (153, 147, 87) # ORANGE\n",
    "# DEFENSIVE_PLAYER_COLOR_BAR = (1237, 717)\n",
    "\n",
    "DEFENSIVE_PLAYER_COLOR_BAR = (1168, 701)\n",
    "\n",
    "# def player_is_defensive(color=DEFENSIVE_COLOR, position=DEFENSIVE_PLAYER_COLOR_BAR):\n",
    "# \t# Delightfully simple code will return true if we see color in\n",
    "# \t# specified position, false otherwise.\n",
    "#     x, y = position\n",
    "#     return pyautogui.pixel(x, y) == (color)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ORANGE_MIN = (200, 100, 0)\n",
    "ORANGE_MAX = (255, 165, 0)\n",
    "\n",
    "RED_MAX = (153, 147, 87)\n",
    "RED_MIN = (152, 105, 82)\n",
    "    \n",
    "def is_color_in_range(pixel_color, min_color, max_color):\n",
    "    return all(min_color[i] <= pixel_color[i] <= max_color[i] for i in range(3))\n",
    "    \n",
    "def player_is_defensive(position=DEFENSIVE_PLAYER_COLOR_BAR): \n",
    "    x, y = position\n",
    "    for i in range(10):\n",
    "        pixel_color = pyautogui.pixel(x, y)\n",
    "        print(f\"Mouse Position: {x} , {y}\")\n",
    "        print(f\"Pixel Color:{pixel_color}\")\n",
    "        # We try a generic way to discover if player color bar is red or orange\n",
    "        if is_color_in_range(pixel_color, ORANGE_MIN, ORANGE_MAX) or \\\n",
    "            is_color_in_range(pixel_color, RED_MIN, RED_MAX):\n",
    "            return True\n",
    "        y += 8 # Add 21 pixels to the position to shift it downwards\n",
    "    return False\n",
    "\n",
    "print(f\"Player is defensive: {player_is_defensive()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245bf6fa-7c77-486f-be27-7dc2efaa6e93",
   "metadata": {},
   "source": [
    "# Final Version of Praisebot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0ef45a1-9dee-452c-ba0b-de089ad86134",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import cv2\n",
    "import pyautogui\n",
    "import numpy as np\n",
    "from pywinauto.application import Application\n",
    "from typing import List, Tuple\n",
    "\n",
    "# Constants\n",
    "HOVER_DURATION = 0.2\n",
    "INDY_TRAINING_AREA = (1387, 179)\n",
    "TOP_PLAYER_AREA = (1267, 405)\n",
    "TOP_RIGHT_PRAISE_BUTTON = (3474, 284)\n",
    "MODAL_PRAISE_BUTTON = (1597, 1018)\n",
    "MODAL_BACK_DOWN_BUTTON = (1809, 834)\n",
    "HANDSHAKE_BUTTON = (2235, 750)\n",
    "END_QC_BUTTON = (2759, 317)\n",
    "DEFENSIVE_PLAYER_COLOR_BAR = (1168, 701)\n",
    "\n",
    "# Color ranges for defensive body language detection\n",
    "ORANGE_MIN = (200, 100, 0)\n",
    "ORANGE_MAX = (255, 165, 0)\n",
    "RED_MIN = (152, 105, 82)\n",
    "RED_MAX = (153, 147, 87)\n",
    "\n",
    "pyautogui.PAUSE = 0.2  # Set PyAutoGUI's default pause between actions\n",
    "\n",
    "\n",
    "def group_locations(locations: List[Tuple[int, int]], threshold: int = 10) -> List[Tuple[int, int]]:\n",
    "    \"\"\"\n",
    "    Group nearby locations into clusters based on a given threshold.\n",
    "    \n",
    "    Args:\n",
    "        locations (List[Tuple[int, int]]): List of coordinates to group.\n",
    "        threshold (int): Proximity threshold to determine grouping.\n",
    "    \n",
    "    Returns:\n",
    "        List[Tuple[int, int]]: List of grouped coordinates.\n",
    "    \"\"\"\n",
    "    grouped = []\n",
    "    for loc in locations:\n",
    "        if not grouped:\n",
    "            grouped.append([loc])\n",
    "        else:\n",
    "            match = False\n",
    "            for group in grouped:\n",
    "                if abs(group[0][0] - loc[0]) < threshold and abs(group[0][1] - loc[1]) < threshold:\n",
    "                    group.append(loc)\n",
    "                    match = True\n",
    "                    break\n",
    "            if not match:\n",
    "                grouped.append([loc])\n",
    "    return [tuple(np.mean(g, axis=0).astype(int)) for g in grouped]\n",
    "\n",
    "\n",
    "def move_and_click(coord: Tuple[int, int]) -> None:\n",
    "    \"\"\"\n",
    "    Move the mouse to the specified coordinates and perform a click.\n",
    "\n",
    "    Args:\n",
    "        coord (Tuple[int, int]): The (x, y) coordinates to move to and click.\n",
    "    \"\"\"\n",
    "    pyautogui.moveTo(coord[0], coord[1], duration=HOVER_DURATION)\n",
    "    pyautogui.click()\n",
    "\n",
    "\n",
    "def orientate() -> None:\n",
    "    \"\"\"\n",
    "    Navigate to the individual training menu in the game.\n",
    "    \"\"\"\n",
    "    time.sleep(5)\n",
    "    pyautogui.hotkey('ctrl', 'r')\n",
    "    time.sleep(1)\n",
    "    move_and_click(INDY_TRAINING_AREA)\n",
    "    move_and_click(TOP_PLAYER_AREA)\n",
    "\n",
    "\n",
    "def is_color_in_range(pixel_color: Tuple[int, int, int], min_color: Tuple[int, int, int], max_color: Tuple[int, int, int]) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a pixel color falls within a defined color range.\n",
    "    \n",
    "    Args:\n",
    "        pixel_color (Tuple[int, int, int]): The RGB color of the pixel.\n",
    "        min_color (Tuple[int, int, int]): The minimum RGB color bounds.\n",
    "        max_color (Tuple[int, int, int]): The maximum RGB color bounds.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the pixel is within the range, False otherwise.\n",
    "    \"\"\"\n",
    "    return all(min_color[i] <= pixel_color[i] <= max_color[i] for i in range(3))\n",
    "\n",
    "\n",
    "def player_is_defensive(position: Tuple[int, int] = DEFENSIVE_PLAYER_COLOR_BAR) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a player's body language indicates defensiveness based on color detection.\n",
    "    \n",
    "    Args:\n",
    "        position (Tuple[int, int]): The (x, y) coordinates of the player's color bar.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the player is defensive, False otherwise.\n",
    "    \"\"\"\n",
    "    x, y = position\n",
    "    for _ in range(10):\n",
    "        pixel_color = pyautogui.pixel(x, y)\n",
    "        if is_color_in_range(pixel_color, ORANGE_MIN, ORANGE_MAX) or is_color_in_range(pixel_color, RED_MIN, RED_MAX):\n",
    "            return True\n",
    "        y += 8  # Shift downwards by 8 pixels\n",
    "    return False\n",
    "\n",
    "\n",
    "def praise_player() -> None:\n",
    "    \"\"\"\n",
    "    Perform the actions needed to praise a player in the game.\n",
    "    \"\"\"\n",
    "    move_and_click(TOP_RIGHT_PRAISE_BUTTON)\n",
    "    move_and_click(MODAL_PRAISE_BUTTON)\n",
    "\n",
    "    if player_is_defensive():\n",
    "        move_and_click(MODAL_BACK_DOWN_BUTTON)\n",
    "        move_and_click(HANDSHAKE_BUTTON)\n",
    "        time.sleep(2)  # Retain this sleep as the handshake action may need extra time\n",
    "    move_and_click(END_QC_BUTTON)\n",
    "\n",
    "\n",
    "def praise_button_exists(button: Tuple[int, int]) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a praise button exists at the specified coordinates by verifying its color.\n",
    "    \n",
    "    Args:\n",
    "        button (Tuple[int, int]): The (x, y) coordinates of the button.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the button exists (is white), False otherwise.\n",
    "    \"\"\"\n",
    "    return pyautogui.pixel(button[0], button[1]) == (255, 255, 255)\n",
    "\n",
    "\n",
    "def navigate_to_fm_window(window_title: str = \"Football Manager 2024\") -> None:\n",
    "    \"\"\"\n",
    "    Bring the Football Manager 2024 window into focus.\n",
    "    \n",
    "    Args:\n",
    "        window_title (str): The title of the Football Manager window.\n",
    "    \"\"\"\n",
    "    time.sleep(2)\n",
    "    try:\n",
    "        app = Application().connect(title_re=window_title)\n",
    "        app.top_window().set_focus()\n",
    "        print(f\"{window_title} window is now active.\")\n",
    "    except Exception as e:\n",
    "        print(f\"Failed to activate {window_title} window: {e}\")\n",
    "        sys.exit()\n",
    "\n",
    "        \n",
    "def activate_window(window_title):\n",
    "     windows = pyautogui.getWindowsWithTitle(window_title)\n",
    "     if windows:\n",
    "         window = windows[0]\n",
    "         time.sleep(5)\n",
    "         window.activate()\n",
    "         print(f\"Activated window: {window_title}\")\n",
    "     else:\n",
    "         print(f\"Window not found: {window_title}\")\n",
    "\n",
    "def scroll_up_indy_training_bar():\n",
    "    time.sleep(1)\n",
    "    player_list_coords = (858, 812)\n",
    "    pyautogui.moveTo(858, 812, duration=0.25)\n",
    "    pyautogui.scroll(2000)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Navigate to FM Window\n",
    "    #navigate_to_fm_window()\n",
    "    activate_window(\"Football Manager 2024\")\n",
    "    \n",
    "    \n",
    "    # Hit escape if needed\n",
    "    pyautogui.press('esc')\n",
    "\n",
    "    # Go to Training > Individual menus\n",
    "    orientate()\n",
    "    scroll_up_indy_training_bar()\n",
    "\n",
    "    # Define the region of the screen to capture (x, y, width, height)\n",
    "    rating_region = (1076, 412, 113, 1643)\n",
    "\n",
    "    # Take a screenshot of the specified rating region\n",
    "    screenshot = pyautogui.screenshot(region=rating_region)\n",
    "    screenshot = np.array(screenshot)\n",
    "    screenshot = cv2.cvtColor(screenshot, cv2.COLOR_RGB2BGR)\n",
    "\n",
    "    # Load the reference image and ensure it is in the correct format\n",
    "    reference_image_path = 'green_space_near_player.png'\n",
    "    reference_image = cv2.imread(reference_image_path, cv2.IMREAD_COLOR)\n",
    "\n",
    "    if reference_image is None:\n",
    "        raise ValueError(\"Reference image not found or unable to load.\")\n",
    "\n",
    "    # Find the reference image within the screenshot\n",
    "    result = cv2.matchTemplate(screenshot, reference_image, cv2.TM_CCOEFF_NORMED)\n",
    "\n",
    "    # Define a threshold for matching\n",
    "    threshold = 0.80\n",
    "    locations = np.where(result >= threshold)\n",
    "    locations = list(zip(*locations[::-1]))\n",
    "\n",
    "    # Group the locations\n",
    "    grouped_locations = group_locations(locations)\n",
    "\n",
    "    # Process each matching location\n",
    "    for loc in grouped_locations:\n",
    "        center_x = loc[0] + reference_image.shape[1] // 2\n",
    "        center_y = loc[1] + reference_image.shape[0] // 2\n",
    "        screen_x = rating_region[0] + center_x\n",
    "        screen_y = rating_region[1] + center_y\n",
    "\n",
    "        pyautogui.click(screen_x, screen_y)\n",
    "        time.sleep(0.5)  # Retain this sleep for precision timing\n",
    "\n",
    "        if praise_button_exists(TOP_RIGHT_PRAISE_BUTTON):\n",
    "            praise_player()\n",
    "\n",
    "        time.sleep(0.2)  # Add a small delay between actions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "86082889-91c5-46db-a94f-6d203aa5fde2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Football Manager 2024 window is now active.\n",
      "[(0, 18), (0, 117), (0, 216), (1, 315), (1, 414), (1, 513), (1, 612), (2, 810), (1, 1008), (1, 1107), (1, 1206), (1, 1305), (1, 1404), (1, 1503)]\n",
      "[(1, 18), (1, 117), (1, 216), (1, 315), (1, 513), (1, 612), (1, 711), (1, 810), (1, 909), (1, 1008)]\n",
      "Praise button not found after clicking (1102, 1448)\n",
      "[(1, 61), (1, 160)]\n",
      "Praise button not found after clicking (1102, 501)\n",
      "Praise button not found after clicking (1102, 600)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import cv2\n",
    "import pyautogui\n",
    "import numpy as np\n",
    "from pywinauto.application import Application\n",
    "from typing import List, Tuple\n",
    "import tkinter as tk\n",
    "from tkinter import messagebox\n",
    "\n",
    "# Constants\n",
    "HOVER_DURATION = 0.2\n",
    "INDY_TRAINING_AREA = (1387, 179)\n",
    "# TOP_PLAYER_AREA = (1267, 405)\n",
    "TOP_PLAYER_AREA = (450, 850)\n",
    "# Original\n",
    "TOP_RIGHT_PRAISE_BUTTON = (3474, 284)\n",
    "#TOP_RIGHT_PRAISE_BUTTON = (3473, 288)\n",
    "\n",
    "\n",
    "MODAL_PRAISE_BUTTON = (1597, 1018)\n",
    "MODAL_BACK_DOWN_BUTTON = (1809, 834)\n",
    "HANDSHAKE_BUTTON = (2235, 750)\n",
    "END_QC_BUTTON = (2759, 317)\n",
    "DEFENSIVE_PLAYER_COLOR_BAR = (1168, 701)\n",
    "\n",
    "# Color ranges for defensive body language detection\n",
    "\n",
    "ORANGE_MIN = (84, 80, 45)\n",
    "ORANGE_MAX = (229, 192, 74)\n",
    "RED_MIN = (152, 105, 82)\n",
    "RED_MAX = (153, 147, 87)\n",
    "\n",
    "pyautogui.PAUSE = 0.2  # Set PyAutoGUI's default pause between actions\n",
    "\n",
    "\n",
    "def group_locations(locations: List[Tuple[int, int]], threshold: int = 10) -> List[Tuple[int, int]]:\n",
    "    \"\"\"\n",
    "    Group nearby locations into clusters based on a given threshold.\n",
    "    \n",
    "    Args:\n",
    "        locations (List[Tuple[int, int]]): List of coordinates to group.\n",
    "        threshold (int): Proximity threshold to determine grouping.\n",
    "    \n",
    "    Returns:\n",
    "        List[Tuple[int, int]]: List of grouped coordinates.\n",
    "    \"\"\"\n",
    "    grouped = []\n",
    "    for loc in locations:\n",
    "        if not grouped:\n",
    "            grouped.append([loc])\n",
    "        else:\n",
    "            match = False\n",
    "            for group in grouped:\n",
    "                if abs(group[0][0] - loc[0]) < threshold and abs(group[0][1] - loc[1]) < threshold:\n",
    "                    group.append(loc)\n",
    "                    match = True\n",
    "                    break\n",
    "            if not match:\n",
    "                grouped.append([loc])\n",
    "    return [tuple(np.mean(g, axis=0).astype(int)) for g in grouped]\n",
    "\n",
    "\n",
    "def move_and_click(coord: Tuple[int, int]) -> None:\n",
    "    \"\"\"\n",
    "    Move the mouse to the specified coordinates and perform a click.\n",
    "\n",
    "    Args:\n",
    "        coord (Tuple[int, int]): The (x, y) coordinates to move to and click.\n",
    "    \"\"\"\n",
    "    pyautogui.moveTo(coord[0], coord[1], duration=HOVER_DURATION)\n",
    "    pyautogui.click()\n",
    "\n",
    "\n",
    "def orientate() -> None:\n",
    "    \"\"\"\n",
    "    Navigate to the individual training menu in the game.\n",
    "    \"\"\"\n",
    "    time.sleep(5)\n",
    "    pyautogui.hotkey('ctrl', 'r')\n",
    "    time.sleep(1)\n",
    "    move_and_click(INDY_TRAINING_AREA)\n",
    "    move_and_click(TOP_PLAYER_AREA)\n",
    "\n",
    "\n",
    "def is_color_in_range(pixel_color: Tuple[int, int, int], min_color: Tuple[int, int, int], max_color: Tuple[int, int, int]) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a pixel color falls within a defined color range.\n",
    "    \n",
    "    Args:\n",
    "        pixel_color (Tuple[int, int, int]): The RGB color of the pixel.\n",
    "        min_color (Tuple[int, int, int]): The minimum RGB color bounds.\n",
    "        max_color (Tuple[int, int, int]): The maximum RGB color bounds.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the pixel is within the range, False otherwise.\n",
    "    \"\"\"\n",
    "    return all(min_color[i] <= pixel_color[i] <= max_color[i] for i in range(3))\n",
    "\n",
    "\n",
    "def player_is_defensive(position: Tuple[int, int] = DEFENSIVE_PLAYER_COLOR_BAR) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a player's body language indicates defensiveness based on color detection.\n",
    "    \n",
    "    Args:\n",
    "        position (Tuple[int, int]): The (x, y) coordinates of the player's color bar.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the player is defensive, False otherwise.\n",
    "    \"\"\"\n",
    "    x, y = position\n",
    "    for _ in range(10):\n",
    "        pixel_color = pyautogui.pixel(x, y)\n",
    "        if is_color_in_range(pixel_color, ORANGE_MIN, ORANGE_MAX) or is_color_in_range(pixel_color, RED_MIN, RED_MAX):\n",
    "            return True\n",
    "        y += 8  # Shift downwards by 8 pixels\n",
    "    return False\n",
    "\n",
    "\n",
    "def praise_player() -> None:\n",
    "    \"\"\"\n",
    "    Perform the actions needed to praise a player in the game.\n",
    "    \"\"\"\n",
    "    move_and_click(TOP_RIGHT_PRAISE_BUTTON)\n",
    "    move_and_click(MODAL_PRAISE_BUTTON)\n",
    "\n",
    "    if player_is_defensive():\n",
    "        move_and_click(MODAL_BACK_DOWN_BUTTON)\n",
    "        move_and_click(HANDSHAKE_BUTTON)\n",
    "        time.sleep(2)  # Retain this sleep as the handshake action may need extra time\n",
    "    move_and_click(END_QC_BUTTON)\n",
    "\n",
    "\n",
    "def praise_button_exists(button: Tuple[int, int]) -> bool:\n",
    "    \"\"\"\n",
    "    Check if a praise button exists at the specified coordinates by verifying its color.\n",
    "    \n",
    "    Args:\n",
    "        button (Tuple[int, int]): The (x, y) coordinates of the button.\n",
    "    \n",
    "    Returns:\n",
    "        bool: True if the button exists (is white), False otherwise.\n",
    "    \"\"\"\n",
    "    return pyautogui.pixel(button[0], button[1]) == (255, 248, 238)\n",
    "\n",
    "\n",
    "def navigate_to_fm_window(window_title: str = \"Football Manager 2024\") -> None:\n",
    "    \"\"\"\n",
    "    Bring the Football Manager 2024 window into focus.\n",
    "    \n",
    "    Args:\n",
    "        window_title (str): The title of the Football Manager window.\n",
    "    \"\"\"\n",
    "    time.sleep(2)\n",
    "    try:\n",
    "        app = Application().connect(title_re=window_title)\n",
    "        app.top_window().set_focus()\n",
    "        print(f\"{window_title} window is now active.\")\n",
    "    except Exception as e:\n",
    "        print(f\"Failed to activate {window_title} window: {e}\")\n",
    "        sys.exit()\n",
    "\n",
    "        \n",
    "def activate_window(window_title):\n",
    "     windows = pyautogui.getWindowsWithTitle(window_title)\n",
    "     if windows:\n",
    "         window = windows[0]\n",
    "         time.sleep(5)\n",
    "         window.activate()\n",
    "         print(f\"Activated window: {window_title}\")\n",
    "     else:\n",
    "         print(f\"Window not found: {window_title}\")\n",
    "\n",
    "def scroll_up_indy_training_bar():\n",
    "    time.sleep(1)\n",
    "    player_list_coords = (858, 812)\n",
    "    pyautogui.moveTo(858, 812, duration=0.25)\n",
    "    pyautogui.scroll(4000)\n",
    "\n",
    "    \n",
    "def scroll_down_indy_training_bar():\n",
    "    time.sleep(1)\n",
    "    player_list_coords = (858, 812)\n",
    "    pyautogui.moveTo(858, 812, duration=0.25)\n",
    "    pyautogui.scroll(-2000)\n",
    "\n",
    "\n",
    "def show_popup():\n",
    "    # Initialize tkinter root window\n",
    "    root = tk.Tk()\n",
    "    root.withdraw()\n",
    "    \n",
    "    # Display messagebox with \"OK\"\n",
    "    messagebox.showinfo(\"Praising Complete\", \"Praising McMuffins is complete. Subscribe to BangocheFM!!!\")\n",
    "    \n",
    "    # Destroy root window\n",
    "    root.destroy()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    def rate_players():\n",
    "        # Define the region of the screen to capture (x, y, width, height)\n",
    "        # OG\n",
    "        rating_region = (1076, 412, 113, 1643)\n",
    "        \n",
    "        #rating_region = (1070, 412, 113, 1800)\n",
    "        #rating_region = (1080, 399, 118, 1700) \n",
    "\n",
    "        # Take a screenshot of the specified rating region\n",
    "        screenshot = pyautogui.screenshot(region=rating_region)\n",
    "        screenshot = np.array(screenshot)\n",
    "        screenshot = cv2.cvtColor(screenshot, cv2.COLOR_RGB2BGR)\n",
    "\n",
    "        # Load the reference image and ensure it is in the correct format\n",
    "        reference_image_path = 'green_space_near_player.png'\n",
    "        reference_image = cv2.imread(reference_image_path, cv2.IMREAD_COLOR)\n",
    "\n",
    "        if reference_image is None:\n",
    "            raise ValueError(\"Reference image not found or unable to load.\")\n",
    "\n",
    "        # Find the reference image within the screenshot\n",
    "        result = cv2.matchTemplate(screenshot, reference_image, cv2.TM_CCOEFF_NORMED)\n",
    "\n",
    "        # Define a threshold for matching\n",
    "        threshold = 0.80\n",
    "        locations = np.where(result >= threshold)\n",
    "        locations = list(zip(*locations[::-1]))\n",
    "\n",
    "        # Group the locations\n",
    "        grouped_locations = group_locations(locations)\n",
    "\n",
    "        print(grouped_locations)\n",
    "        \n",
    "        # Process each matching location\n",
    "        for loc in grouped_locations:\n",
    "            center_x = loc[0] + reference_image.shape[1] // 2\n",
    "            center_y = loc[1] + reference_image.shape[0] // 2\n",
    "            screen_x = rating_region[0] + center_x\n",
    "            screen_y = rating_region[1] + center_y\n",
    "\n",
    "            pyautogui.click(screen_x, screen_y)\n",
    "            time.sleep(0.5)  # Retain this sleep for precision timing\n",
    "\n",
    "            if praise_button_exists(TOP_RIGHT_PRAISE_BUTTON):\n",
    "                praise_player()\n",
    "            else:\n",
    "                print(f\"Praise button not found after clicking {screen_x, screen_y}\")\n",
    "\n",
    "            time.sleep(0.5)  # Add a small delay between actions\n",
    "    \n",
    "    # Navigate to FM Window\n",
    "    navigate_to_fm_window()\n",
    "    #activate_window(\"Football Manager 2024\")\n",
    "    \n",
    "    \n",
    "    # Hit escape if needed\n",
    "    pyautogui.press('esc')\n",
    "\n",
    "    # Go to Training > Individual menus\n",
    "    orientate()\n",
    "    scroll_up_indy_training_bar()\n",
    "    scroll_up_indy_training_bar()\n",
    "    scroll_up_indy_training_bar()\n",
    "    rate_players()\n",
    "    scroll_down_indy_training_bar()\n",
    "    rate_players()\n",
    "    scroll_down_indy_training_bar()\n",
    "    rate_players()\n",
    "    show_popup()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f57f6dba-8f25-4b16-852e-719b5aa5f827",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scroll_indy_training_bar():\n",
    "    time.sleep(1)\n",
    "    # pyautogui.hotkey('ctrl', 'r')\n",
    "    player_list_coords = (858, 812)\n",
    "    pyautogui.moveTo(858, 812, duration=0.25)\n",
    "    pyautogui.scroll(2000)\n",
    "    \n",
    "# scroll_indy_training_bar()\n",
    "\n",
    "\n",
    "def test_orientate():\n",
    "    time.sleep(5)\n",
    "    orientate()\n",
    "    scroll_indy_training_bar()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bd50a44-21f3-40a5-a38a-fefd83e9877b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# !pip install tk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "478616b5-c442-40a4-a29e-727f7b45027e",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pyinstaller"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b988c5a-0fcb-45a2-a161-c5a202e633a5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sysconfig; print(sysconfig.get_path(\"scripts\"))\n",
    "import site; print(site.USER_BASE + \"\\\\Scripts\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d695cc0f-6411-4efa-be3a-659d23fb7dbf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pyinstaller --onefile praise_fm_player.py"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}