"C:\Program Files\Google\Chrome\Application\chrome.exe" --proxy-server="http://{IPアドレス}:{ポート}"

import logging
import time
import os
import sys
import atexit
from typing import Optional, Callable
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait, Select
from enum import Enum


# selectをわかりやすくするだけ
class SelectBy(Enum):
    Index = 'index'
    Value = 'value'
    VisibleText = 'visible_text'

class SeleniumWrapper:
    def __init__(self, timeout=10, log_level=logging.INFO):
        # ログ設定
        logging.basicConfig(
            format='[%(asctime)s] %(levelname)s: %(message)s',
            level=log_level
        )
        self.logger = logging.getLogger(__name__)
        self.timeout = timeout
        self.logger.info("SeleniumWrapper initialized")
        self.selenium_flg = False
        atexit.register(self.driver_close) 

    def _scroll_to_center(self, element: WebElement) -> bool:
        '''
        memo:
        -----------
        - jsで指定の要素を画面中央にする
        '''
        try:
            self.driver.execute_script("arguments[0].scrollIntoView({ behavior: 'smooth', block: 'center' });", element)
            # 最後に画面表示確認する
            self.selenium_wait(condition=EC.element_to_be_clickable(element))
        except Exception as e:
            self.logger.error(f'[ScrollError] Failed to scroll element: {str(e)}', exc_info=True)
            return False
        return True

    def _resolve_timeout(self, timeout: float) -> float:
        '''
        memo:
        -----------
        - タイムアウトを引数初期値（-1）ならinitの値にする
        '''
        return timeout if timeout != -1 else self.timeout

    def _safe_click(self, element: WebElement) -> bool:
        '''
        memo:
        -----------
        - selenium標準のclickが失敗したらjsでクリックをする2段構えclick
        '''
        try:
            element.click()
        except Exception as e:
            try:
                self.driver.execute_script('arguments[0].click();', element)
            except Exception as e2:
                self.logger.error(f'[ClickError] JS click failed: {str(e2)}', exc_info=True)
                return False
        return True

    def _get_element_by_index(self, css_selector: str, idx: int = 0, timeout: float = -1) -> Optional[WebElement]:
        '''
        Parameters:
        -----------
        css_selector:遷移先のURL
        timeout:WebDriverWaitの最大待機秒数
        condition:expected_conditions

        memo:
        -----------
        - elementをidx指定で取得するのでEC.presence_of_all_elements_locatedを使う
        - css_selectorがconditionの状態になるまで待機
        '''
        timeout = self._resolve_timeout(timeout)
        try:
            elements = WebDriverWait(self.driver, timeout).until(EC.presence_of_all_elements_located((By.CSS_SELECTOR, css_selector)))
            if len(elements) <= idx:
                self.logger.warning(f'[NoSuchElement] selector={css_selector}, index={idx}')
                return None
        except TimeoutException:
            self.logger.warning(f'[Timeout] selector={css_selector}, timeout={timeout}')
            return None
        except Exception as e:
            self.logger.error(f'[Exception] selector={css_selector}, index={idx}, error={str(e)}', exc_info=True)
            return None
        return elements[idx]

    def driver_open(self, headless: bool = False) -> None:
        '''
        Parameters:
        -----------
        headless:ヘッドレスモードで実行するか

        memo:
        -----------
        - chromedriverを起動する
        - なるべくchromedriver感を隠す
        '''
        options = Options()
        ##### 共通オプション
        options.add_argument('--start-maximized')                                   # 初期のウィンドウ最大化
        options.add_argument("--disable-blink-features=AutomationControlled")       # navigator.webdriver=false となる設定。確認⇒　driver.execute_script("return navigator.webdriver")
        options.add_experimental_option("excludeSwitches", ["enable-automation"])   # Chromeは自動テスト ソフトウェア~~　を非表示
        prefs = {
            "credentials_enable_service": False,                                    # パスワード保存のポップアップを無効
            "download_bubble.partial_view_enabled": False,                          # ダウンロードが完了したときの通知(吹き出し/下部表示)を無効にする。
            "plugins.always_open_pdf_externally": True,                             # Chromeの内部PDFビューアを使わない(＝URLにアクセスすると直接ダウンロードされる)
        }
        ##### 引数で指定するオプション
        # ダウンロード先フォルダが指定されてればフォルダを作ってパラメータを追加する
        # ヘッドレスモードの判定
        if headless is True:
            options.add_argument('--headless=new') 
        options.add_experimental_option("prefs", prefs)
        service = Service()
        service.creation_flags = 0x08000000                                         # ヘッドレスモードで DevTools listening on ws:~~ を表示させない
        self.driver = webdriver.Chrome(service=service, options=options)
        self.driver.maximize_window()
        self.selenium_flg = True
        self.logger.info("WebDriver started")

    def driver_close(self):
        '''
        chromedriverを終わらせる処理
        '''
        self.logger.info("Quitting WebDriver")
        if self.selenium_flg:
            try:
                self.driver.close()
                self.driver.quit()
            except Exception:
                pass
        self.selenium_flg = False

    def selenium_wait(self, condition: Any = EC.presence_of_element_located((By.CSS_SELECTOR, 'body')),
                      timeout: float = 10.0, 
                      final_wait_time: float = COMMON_WAIT_SECONDS                      
                     ) -> bool:
        '''
        Parameters:
        -----------
        condition:expected_conditions ※指定がなければbodyがあることを確認する
        timeout:WebDriverWaitの最大待機秒数
        final_wait_time:最後にsleepする秒数

        memo:
        -----------
        - getだけじゃなくclickとかの後でも使えるようにwait部分だけの関数にする
        '''
        timeout = self._resolve_timeout(timeout=timeout)
        try:
            # JavaScriptを使ってページ全体が読み込まれるまで待機
            wait = WebDriverWait(self.driver, timeout)
            # JavaScriptの読み込み完了を待つ
            wait.until(lambda d: d.execute_script("return document.readyState") == "complete")
            # ロード完了後に指定のCSSが読み込まれたか確認する ※初期値のbodyはさすがにあるでしょ
            wait.until(condition)
            # 最後に無条件待機を入れる
            time.sleep(final_wait_time)
        except Exception as e:
            # おそらく発生しないException
            self.logger.error(f'[WaitError] Failed during wait: {str(e)}', exc_info=True)
            return False
        return True

    def selenium_page_load(self, url: str, condition: Any = EC.presence_of_element_located((By.CSS_SELECTOR, 'body')), timeout: float = 10.0, final_wait_time: float = COMMON_WAIT_SECONDS) -> bool:
        '''
        Parameters:
        -----------
        url:遷移先のURL
        timeout:WebDriverWaitの最大待機秒数
        final_wait_time:最後にsleepする秒数
        load_completion_css:読み込み完了を認知するCSS
        condition:expected_conditions

        memo:
        -----------
        - 結局selenium_waitの前にgetしているだけだけど一番頻度が高いので個別に関数化する
        '''
        try:
            self.driver.get(url=url)
            self.selenium_wait(condition=condition, timeout=timeout, final_wait_time=final_wait_time)
        except Exception:
            return False
        return True

    def selenium_input(self, target: Union[str, WebElement], idx: int = 0, value: str = '', timeout: float = -1.0) -> bool:
        '''
        Parameters:
        -----------
        target: CSSセレクタ（str）または WebElement
        idx: セレクタで複数要素がある場合のインデックス
        value: 入力する文字列
        timeout: タイムアウト秒数

        memo:
        -----------
        - targetがstrなら要素取得して入力、WebElementならそのまま入力
        '''
        timeout = self._resolve_timeout(timeout=timeout)
        # 要素取得
        element: Optional[WebElement] = None
        if isinstance(target, str):
            element = self._get_element_by_index(target, idx, timeout)
        elif isinstance(target, WebElement):
            element = target
        else:
            self.logger.error(f'[InputError] Invalid target type: {type(target)}')
            return False

        # 要素が見つからなかった場合はFalseを返す
        if element is None:
            return False

        try:
            # 入力可能状態まで待機
            self.selenium_wait(condition=EC.element_to_be_clickable(element), timeout=timeout)

            # タグチェック
            if element.tag_name not in ['input', 'textarea']:
                self.logger.error(f'[InputError] Invalid tag for input: {element.tag_name}')
                return False

            # jsで要素を画面中央にスクロール
            self._scroll_to_center(element)
            # 一旦クリアして念のためクリックして入力
            element.clear()
            element.click()
            time.sleep(COMMON_WAIT_SECONDS)
            element.send_keys(value)
            # 入力後にTabキーを送ってフォーカスを外す
            element.send_keys(Keys.TAB)
            time.sleep(COMMON_WAIT_SECONDS)

        except TimeoutException:
            self.logger.error(f'[Timeout] Element not clickable for input: timeout={timeout}')
            return False
        except Exception as e:
            self.logger.error(f'[Exception] Error in selenium_input: {str(e)}', exc_info=True)
            return False
        return True

    def selenium_get(self, target: Union[str, WebElement], idx: int = 0, att: str = 'text_or_value', timeout: float = -1.0,  default_value: str = '') -> str:
        '''
        Parameters:
        -----------
        target: CSSセレクタ（str）または WebElement
        idx:インデックスの指定が必要な場合 ※初期値は0
        att:取得する対象 ※textかattributeに指定する値
        timeout:タイムアウトまでの秒数 ※初期値は別途設定
        default_value: elementが見つからなかった時の返値

        memo:
        -----------
        - 文字だけでなく指定要素の値も取得できるようにする
        - hidden要素の取得もあるのでpresence_of_element_locatedを使う
        - 要素がない時は引数で制御して初期値空白を返すようにしている
        '''
        timeout = self._resolve_timeout(timeout=timeout)
        # 要素取得
        element: Optional[WebElement] = None
        if isinstance(target, str):
            element = self._get_element_by_index(target, idx, timeout)
        elif isinstance(target, WebElement):
            element = target
        else:
            self.logger.error(f'[InputError] Invalid target type: {type(target)}')
            return default_value

        # 要素が見つからなかった場合はdefault_valueを返す
        if element is None:
            return default_value                

        try:
            # 引数の属性に合わせて取得
            ret: str
            if att == 'text_or_value':
                # textが空ならvalueを返す
                ret = element.text.strip()
                if not ret:
                    ret = str(element.get_attribute('value')).strip()
            elif att == 'text':
                # 明示的にtextが指定された場合はtextしか確認しない
                ret = element.text.strip()
            else:
                # text以外はattの指定にする
                ret = str(element.get_attribute(att)).strip()
        
        except Exception as e:
            self.logger.error(f'[GetError] Failed to get attribute {att}: {str(e)}', exc_info=True)
            return default_value
        return ret

    def selenium_click(self, target: Union[str, WebElement], idx: int = 0, timeout: float = -1.0) -> bool:
        '''
        Parameters:
        -----------
        target: CSSセレクタ（str）または WebElement
        idx:インデックスの指定が必要な場合 ※初期値は0
        timeout:タイムアウトまでの秒数 ※初期値は別途設定

        memo:
        -----------
        - クリックするため事前に画面中央に移動してクリックする
        - seleniumのクリックが失敗したらjsでクリックするように内部関数を呼び出す
        '''
        timeout = self._resolve_timeout(timeout=timeout)
        # 要素取得
        element: Optional[WebElement] = None
        if isinstance(target, str):
            element = self._get_element_by_index(target, idx, timeout)
        elif isinstance(target, WebElement):
            element = target
        else:
            self.logger.error(f'[InputError] Invalid target type: {type(target)}')
            return False

        # 要素が見つからなかった場合はFalseを返す
        if element is None:
            return False          

        try:
            # clickしようとしてるから element_to_be_clickable を使う
            self.selenium_wait(condition=EC.element_to_be_clickable(element), timeout=timeout)
        except TimeoutException:
            self.logger.warning(f'[Timeout] Element not clickable: tag={element.tag_name}, timeout={timeout}')
            return False
        except Exception as e:
            # おそらく発生しないException
            self.logger.error(f'[Exception] Unexpected error in selenium_click_elm: {str(e)}', exc_info=True)
            return False

        # jsで要素を画面中央にスクロール
        self._scroll_to_center(element=element)
        # clickでエラーになったらjsを試してみる
        return self._safe_click(element)

    def selenium_select(self, target: Union[str, WebElement], idx: int = 0, select_by: SelectBy = SelectBy.VisibleText, value: str = '', timeout: float = -1.0) -> bool:
        '''
        Parameters:
        -----------
        target: CSSセレクタ（str）または WebElement
        idx:インデックスの指定が必要な場合 ※初期値は0
        select_by: select_byの値
        value: select_byで指定した値
        timeout:タイムアウトまでの秒数 ※初期値は別途設定

        memo:
        -----------
        入力可能状態まで待機するのでelement_to_be_clickableを使う
        '''
        timeout = self._resolve_timeout(timeout=timeout)
        # 要素取得
        element: Optional[WebElement] = None
        if isinstance(target, str):
            element = self._get_element_by_index(target, idx, timeout)
        elif isinstance(target, WebElement):
            element = target
        else:
            self.logger.error(f'[InputError] Invalid target type: {type(target)}')
            return False

        # 要素が見つからなかった場合はFalseを返す
        if element is None:
            return False

        # selectタグ以外は使わないはず ※select以外で正常タグを見つけたときは修正する
        if element.tag_name != 'select':
            self.logger.error(f'[SelectError] Invalid tag for select: {element.tag_name}')
            return False

        # jsで要素を画面中央にスクロール
        self._scroll_to_center(element=element)

        # 選択可能状態まで待機
        self.selenium_wait(condition=EC.element_to_be_clickable(element))

        # ここから正常時の操作
        select = Select(element)
        try:
            # 引数のselect_byに合わせて選択
            match select_by:
                case SelectBy.Index:
                    select.select_by_index(int(value))
                case SelectBy.Value:
                    select.select_by_value(str(value))
                case SelectBy.VisibleText:
                    select.select_by_visible_text(str(value))
                case _:
                    self.logger.error(f"[SelectError] Invalid select_by value: {select_by}")
                    return False

        except ValueError as e:
            self.logger.error(f"[SelectError] ValueError during selection by {select_by.name}: {e}")
            return False

        except Exception as e:
            self.logger.error(f"[SelectError] Failed to select option by {select_by.name}: {e}", exc_info=True)
            return False

        time.sleep(COMMON_WAIT_SECONDS)
        return True

    def window_scroll(self, step: int=10, delay: float=0.1):
        '''
        js対応のためにゆっくり画面を一番下にスクロールする
        '''
        try:
            top = 1
            last_height = self.driver.execute_script('return document.body.scrollHeight')
            while top < last_height:
                top = top + step
                self.driver.execute_script(f'window.scrollBy(0, "{str(step)}")')
                last_height = self.driver.execute_script('return document.body.scrollHeight')
                time.sleep(delay)
        except Exception as e:
            self.logger.error(f'[ScrollError] Failed during window scroll: {str(e)}', exc_info=True)

wait.Init driver, {最大待機秒数}, {判定間隔}

Sub main()
'---Chromedriverの自動更新 ※別モジュールを参照
If ChromeDriverAutoUpdateModule.ChromeDriverAutoUpdate Then
    Exit Sub
End If

'－－・－－・－－以下にプログラムを－－・－－・－－
End Sub

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://example.com")

element = driver.find_element(By.ID, "username")

driver.find_element(By.CLASS_NAME, "description")

import dataclasses
import logging
import logging.config
import logging.handlers

import os
import datetime
from time import sleep

import bs4
from bs4 import BeautifulSoup
from fake_useragent import UserAgent
from selenium import webdriver
from selenium.common.exceptions import TimeoutException, NoSuchElementException
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common import utils
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.ui import WebDriverWait

# ---今回はoptionsとserviceは考慮しない
driver = webdriver.Chrome()

driver.get(url=url)
try:
    # JavaScriptを使ってページ全体が読み込まれるまで待機
    WebDriverWait(driver, 30).until(lambda d: d.execute_script("return document.readyState") == "complete") # ---①
    sleep(0.1) # ---②
except Exception:
    logger.error('Page Transition Error!!')

driver.find_element(By.CSS_SELECTOR, '#email').send_keys(id)
driver.find_element(By.CSS_SELECTOR, '#password').send_keys(pw)
driver.find_element(By.CSS_SELECTOR, 'button.login_bunt').click()
try:
    # JavaScriptを使ってページ全体が読み込まれるまで待機
    WebDriverWait(driver, 30).until(lambda d: d.execute_script("return document.readyState") == "complete") # ---①
    sleep(0.1) # ---②
except Exception:
    logger.error('Page Transition Error!!')

'''

～～～ ログイン後の処理 ～～～

'''

css_selector = '#target_id'
# ---入力する要素が見える状態か確認する
try:
    _ = WebDriverWait(driver, 3).until(EC.visibility_of(driver.find_element(By.CSS_SELECTOR, css_selector)))
except NoSuchElementException:
    print('No Such Element')
except TimeoutException:
    print('Timeout Error')
except Exception:
    print('Unknown Error', exc_info=True)

# ---WebDriverWait以外でもチェックする
element = driver.find_element(By.CSS_SELECTOR, css_selector)
# ---タグがinputかtextareaじゃないか確認する
if element.tag_name != 'input' and element.tag_name != 'textarea':
    print('This element tagName is not input and textarea')
    return False
# ---タグが入力可能か確認する
if element.is_enabled() is False:
    print('This element is disable')
    return False
# ---readonly属性が付いてないか確認する
if not element.get_attribute('readonly') is None:
    print('This element is readonly')
    return False

# ---念のため画面をelementへ動かしておく
ActionChains(driver).move_to_element(element).perform()
# ---send_keysだと追記になってしまうので一旦クリアしておく
element.clear()
# ---念のため待機処理を入れる
sleep(0.1)
# ---ようやく実際に文字入力する
element.send_keys('hoge')
# ---入力後に発火するjsの可能性があるのでタブ移動する
element.send_keys(Keys.TAB)
# ---念のため待機処理を入れる
sleep(0.1)

def frame_to_be_available_and_switch_to_it(locator: Union[Tuple[str, str], str]) -> Callable[[WebDriver], bool]:
    """An expectation for checking whether the given frame is available to
    switch to.

    If the frame is available it switches the given driver to the
    specified frame.
    """

    def _predicate(driver: WebDriver):
        try:
            if isinstance(locator, Iterable) and not isinstance(locator, str):
                driver.switch_to.frame(driver.find_element(*locator))
            else:
                driver.switch_to.frame(locator)
            return True
        except NoSuchFrameException:
            return False

    return _predicate

css_selector = '#target_id'
try:
    # ---初期Frameに戻す
    driver.switch_to.default_content()
    # ---5回までリトライするようにする
    for _ in range(5):
        # ---5秒でFrameの遷移が完了するかチェック
        if WebDriverWait(driver, 5).until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, css_selector))) is False:
            sleep(1)
        else:
            # 選択したフレームが見えなくなっていることを確認して終わりにする
            if len(driver.find_elements(By.CSS_SELECTOR, css_selector)) == 0:
                return True
            else:
                sleep(1)
                continue
    else:
        raise NoSuchFrameException(msg=f'"{css_selector}" に遷移できませんでした')
except Exception:
    # ---エラーになったら画面ショットを残しておく
    driver.save_screenshot(R'errorshot_{}.png'.format(datetime.datetime.now().strftime("%Y%m%d%H%M%S")))

import sqlite3

#　---db接続（ファイルがなければ作成される）---
db_file= "test.sqlite3" # 拡張子は"*.db","*.sqlite","*.db3","*.sqlite3"からお好きなものを
conn = sqlite3.connect(db_file) 
# SQLiteを操作するためのカーソルを作成
cur = conn.cursor()

#　---テーブルを作成---
# テーブルが既にあれば削除する
sql = "DROP TABLE IF EXISTS test_table"
cur.execute(sql)

# item_cdを主キーにテーブルを新規作成
sql = """
    CREATE TABLE test_table(
    item_cd INTEGER PRIMARY KEY,
    item_name TEXT,
    item_count INTEGER,
    price INTEGER
    )
    """
cur.execute(sql)
conn.commit() # コミットしないと反映しない

# データを挿入 ※execute
sql = "INSERT INTO test_table (item_cd, item_name, item_count, price) VALUES (1, 'mouse', 1, 3000)"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# まとめてデータを挿入 ※executemany
sql = "INSERT INTO test_table (item_cd, item_name, item_count, price) VALUES (?,?,?,?)"
data = [(2, "keyboard", 1, 8000), (3, "monitor", 1, 15000), (4, "USB cable", 3, 300), (5, "HDMI cable", 1, 1000)]
cur.executemany(sql, data)
conn.commit()  # コミットしないと反映しない

# データベースからデータを取得
sql = "SELECT * FROM test_table"
_ = cur.execute(sql)
rows = cur.fetchall()
for row in rows:
    print(row)

# データを削除
sql = "DELETE FROM test_table WHERE item_cd=1"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データを更新
sql = "UPDATE test_table SET price=5000 WHERE item_name='keyboard'"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データ削除と挿入を同時にする
sql = """
    REPLACE INTO test_table (item_cd, item_name, item_count, price)
    VALUES (3, 'wide monitor', 1, 30000)
    """
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データ挿入時に重複なら更新する ※upsert文
sql = """
    INSERT INTO test_table (item_cd, item_name, item_count, price)
    VALUES (5, 'HDMI cable', 3, 800)
    ON CONFLICT (item_cd)
    DO UPDATE SET item_count=3, price=800
    """
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

import sqlite3

#　---ファイルがなければ作成してdb接続---
db_file= "test.db" # 拡張子は".db"か".sqlite"
conn = sqlite3.connect(db_file) 
# SQLiteを操作するためのカーソルを作成
cur = conn.cursor()

#　---テーブルを作成---
# テーブルが既にあれば削除する
sql = "DROP TABLE IF EXISTS test_table"
cur.execute("DROP TABLE IF EXISTS test_table")
# item_cdを主キーにテーブルを新規作成
sql = """
    CREATE TABLE test_table(
    item_cd INTEGER PRIMARY KEY,
    item_name TEXT,
    item_count INTEGER,
    price INTEGER
    )
    """
cur.execute(sql)
conn.commit() # コミットしないと反映しない

# データを挿入 ※execute
sql = "INSERT INTO test_table (item_cd, item_name, item_count, price) VALUES (1, 'mouse', 1, 3000)"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# まとめてデータを挿入 ※executemany
sql = "INSERT INTO test_table (item_cd, item_name, item_count, price) VALUES (?,?,?,?)"
data = [(2, "keyboard", 1, 8000), (3, "monitor", 1, 15000), (4, "USB cable", 3, 300), (5, "HDMI cable", 1, 1000)]
cur.executemany(sql, data)
conn.commit()  # コミットしないと反映しない

# データベースからデータを取得
sql = "SELECT * FROM test_table"
_ = cur.execute(sql)
rows = cur.fetchall()
for row in rows:
    print(row)

# データを削除
sql = "DELETE FROM test_table WHERE item_cd=1"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データを更新
sql = "UPDATE test_table SET price=5000 WHERE item_name='keyboard'"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データ削除と挿入を同時にする
sql = "REPLACE INTO test_table (item_cd, item_name, item_count, price) VALUES (3, 'wide monitor', 1, 30000)"
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# データ挿入時に重複なら更新する ※upsert文
sql = """
    INSERT INTO test_table (item_cd, item_name, item_count, price)
    VALUES (5, 'HDMI cable', 3, 800)
    ON CONFLICT (item_cd)
    DO UPDATE SET item_count=3, price=800
    """
cur.execute(sql)
conn.commit()  # コミットしないと反映しない

# 処理結果を見るためにもう一度データを取得
sql = "SELECT * FROM test_table"
_ = cur.execute(sql)
for row in cur.fetchall():
    print(row)

WebDriverWait(webdriver, タイムアウトまでの上限秒数).until(expected_conditionsで設定する条件)

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, NoSuchElementException

driver = webdriver.Chrome()
driver.get('https://javeo.jp/practice_scraping/')
try:
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#hoge')))
    print('条件を満たしました')
except TimeoutException:
    print('条件を満たせませんでした')
driver.quit()

def presence_of_element_located(locator: tuple[str, str]) -> Callable[[WebDriverOrWebElement], WebElement]:
    def _predicate(driver: WebDriverOrWebElement):
        return driver.find_element(*locator)

    return _predicate

def presence_of_all_elements_located(locator: tuple[str, str]) -> Callable[[WebDriverOrWebElement], list[WebElement]]:
    def _predicate(driver: WebDriverOrWebElement):
        return driver.find_elements(*locator)

    return _predicate

def visibility_of_element_located(
    locator: tuple[str, str],
) -> Callable[[WebDriverOrWebElement], Union[Literal[False], WebElement]]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            return _element_if_visible(driver.find_element(*locator))
        except StaleElementReferenceException:
            return False

    return _predicate

def _element_if_visible(element: WebElement, visibility: bool = True) -> Union[Literal[False], WebElement]:
    return element if element.is_displayed() == visibility else False

def visibility_of(element: WebElement) -> Callable[[Any], Union[Literal[False], WebElement]]:
    def _predicate(_):
        return _element_if_visible(element)

    return _predicate

def visibility_of_all_elements_located(
    locator: tuple[str, str],
) -> Callable[[WebDriverOrWebElement], Union[list[WebElement], Literal[False]]]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            elements = driver.find_elements(*locator)
            for element in elements:
                if _element_if_visible(element, visibility=False):
                    return False
            return elements
        except StaleElementReferenceException:
            return False

    return _predicate

def visibility_of_any_elements_located(locator: tuple[str, str]) -> Callable[[WebDriverOrWebElement], list[WebElement]]:
    def _predicate(driver: WebDriverOrWebElement):
        return [element for element in driver.find_elements(*locator) if _element_if_visible(element)]

    return _predicate

def invisibility_of_element_located(
    locator: Union[WebElement, tuple[str, str]],
) -> Callable[[WebDriverOrWebElement], Union[WebElement, bool]]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            target = locator
            if not isinstance(target, WebElement):
                target = driver.find_element(*target)
            return _element_if_visible(target, visibility=False)
        except (NoSuchElementException, StaleElementReferenceException):
            # In the case of NoSuchElement, returns true because the element is
            # not present in DOM. The try block checks if the element is present
            # but is invisible.
            # In the case of StaleElementReference, returns true because stale
            # element reference implies that element is no longer visible.
            return True

    return _predicate

def invisibility_of_element(
    element: Union[WebElement, tuple[str, str]],
) -> Callable[[WebDriverOrWebElement], Union[WebElement, bool]]:
    return invisibility_of_element_located(element)

def element_attribute_to_include(locator: tuple[str, str], attribute_: str) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            element_attribute = driver.find_element(*locator).get_attribute(attribute_)
            return element_attribute is not None
        except StaleElementReferenceException:
            return False

    return _predicate

def element_located_selection_state_to_be(
    locator: tuple[str, str], is_selected: bool
) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            element = driver.find_element(*locator)
            return element.is_selected() == is_selected
        except StaleElementReferenceException:
            return False

    return _predicate

def element_located_to_be_selected(locator: tuple[str, str]) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        return driver.find_element(*locator).is_selected()

    return _predicate

def element_to_be_selected(element: WebElement) -> Callable[[Any], bool]:
    def _predicate(_):
        return element.is_selected()

    return _predicate

def element_selection_state_to_be(element: WebElement, is_selected: bool) -> Callable[[Any], bool]:
    def _predicate(_):
        return element.is_selected() == is_selected

    return _predicate

def element_to_be_clickable(
    mark: Union[WebElement, tuple[str, str]],
) -> Callable[[WebDriverOrWebElement], Union[Literal[False], WebElement]]:
    # renamed argument to 'mark', to indicate that both locator
    # and WebElement args are valid
    def _predicate(driver: WebDriverOrWebElement):
        target = mark
        if not isinstance(target, WebElement):  # if given locator instead of WebElement
            target = driver.find_element(*target)  # grab element at locator
        element = visibility_of(target)(driver)
        if element and element.is_enabled():
            return element
        return False

    return _predicate

def text_to_be_present_in_element(locator: tuple[str, str], text_: str) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            element_text = driver.find_element(*locator).text
            return text_ in element_text
        except StaleElementReferenceException:
            return False

    return _predicate

def text_to_be_present_in_element_value(
    locator: tuple[str, str], text_: str
) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            element_text = driver.find_element(*locator).get_attribute("value")
            if element_text is None:
                return False
            return text_ in element_text
        except StaleElementReferenceException:
            return False

    return _predicate

def text_to_be_present_in_element_attribute(
    locator: tuple[str, str], attribute_: str, text_: str
) -> Callable[[WebDriverOrWebElement], bool]:
    def _predicate(driver: WebDriverOrWebElement):
        try:
            element_text = driver.find_element(*locator).get_attribute(attribute_)
            if element_text is None:
                return False
            return text_ in element_text
        except StaleElementReferenceException:
            return False

    return _predicate

def title_is(title: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return driver.title == title

    return _predicate

def title_contains(title: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return title in driver.title

    return _predicate

def url_contains(url: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return url in driver.current_url

    return _predicate

def url_matches(pattern: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return re.search(pattern, driver.current_url) is not None

    return _predicate

def url_to_be(url: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return url == driver.current_url

    return _predicate

def url_changes(url: str) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return url != driver.current_url

    return _predicate

def number_of_windows_to_be(num_windows: int) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return len(driver.window_handles) == num_windows

    return _predicate

def new_window_is_opened(current_handles: list[str]) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        return len(driver.window_handles) > len(current_handles)

    return _predicate

def frame_to_be_available_and_switch_to_it(
    locator: Union[tuple[str, str], str, WebElement],
) -> Callable[[WebDriver], bool]:
    def _predicate(driver: WebDriver):
        try:
            if isinstance(locator, Iterable) and not isinstance(locator, str):
                driver.switch_to.frame(driver.find_element(*locator))
            else:
                driver.switch_to.frame(locator)
            return True
        except NoSuchFrameException:
            return False

    return _predicate

def staleness_of(element: WebElement) -> Callable[[Any], bool]:
    def _predicate(_):
        try:
            # Calling any method forces a staleness check
            element.is_enabled()
            return False
        except StaleElementReferenceException:
            return True

def alert_is_present() -> Callable[[WebDriver], Union[Alert, Literal[False]]]:
    def _predicate(driver: WebDriver):
        try:
            return driver.switch_to.alert
        except NoAlertPresentException:
            return False

    return _predicate

def any_of(*expected_conditions: Callable[[D], T]) -> Callable[[D], Union[Literal[False], T]]:
    def any_of_condition(driver: D):
        for expected_condition in expected_conditions:
            try:
                result = expected_condition(driver)
                if result:
                    return result
            except WebDriverException:
                pass
        return False

    return any_of_condition

def all_of(
    *expected_conditions: Callable[[D], Union[T, Literal[False]]],
) -> Callable[[D], Union[list[T], Literal[False]]]:
    def all_of_condition(driver: D):
        results: list[T] = []
        for expected_condition in expected_conditions:
            try:
                result = expected_condition(driver)
                if not result:
                    return False
                results.append(result)
            except WebDriverException:
                return False
        return results

    return all_of_condition

def none_of(*expected_conditions: Callable[[D], Any]) -> Callable[[D], bool]:
    def none_of_condition(driver: D):
        for expected_condition in expected_conditions:
            try:
                result = expected_condition(driver)
                if result:
                    return False
            except WebDriverException:
                pass
        return True

    return none_of_condition

from datetime import datetime
import re
import urllib.parse
from time import sleep

from bs4 import BeautifulSoup
from db_connector import xserver_keiba
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait


# ====================================================================================================
class data_class:
    def __init__(self, data_title: list) -> None:
        self.race_id = ''
        self.race_date = ''
        self.race_times = data_title[0]
        self.course_place = data_title[1]
        self.race_days = data_title[2]
        self.race_no = 0
        self.race_name = ''
        self.race_grade = ''
        self.race_time = ''
        self.coruse_type = ''
        self.course_distance = ''
        self.not_found = 0

    def upsert_sql(self):
        sql = f'''
            INSERT INTO race_mst(race_id,race_date,race_times,course_place,race_days,race_no,race_name,race_grade,race_time,coruse_type,course_distance,not_found)
            values ({self.race_id},'{self.race_date}','{self.race_times}','{self.course_place}','{self.race_days}',{self.race_no},'{self.race_name}','{self.race_grade}','{self.race_time}','{self.coruse_type}','{self.course_distance}',{self.not_found})
            ON DUPLICATE KEY UPDATE race_date='{self.race_date}',race_times='{self.race_times}',course_place='{self.course_place}',race_days='{self.race_days}',race_no={self.race_no},race_name='{self.race_name}',race_grade='{self.race_grade}',race_time='{self.race_time}',course_distance='{self.course_distance}',not_found='{self.not_found}'
        '''.replace("''", "Null")
        return sql


# ====================================================================================================
def grade_converter(grade_class) -> str:
    # クラス名からレースのグレードを判定して返す
    if 'Icon_GradeType1' in grade_class:
        return 'GⅠ'
    elif 'Icon_GradeType2' in grade_class:
        return 'GⅡ'
    elif 'Icon_GradeType3' in grade_class:
        return 'GⅢ'
    elif 'Icon_GradeType4' in grade_class:
        return '重賞'
    elif 'Icon_GradeType5' in grade_class:
        return 'OP'
    elif 'Icon_GradeType6' in grade_class:
        return '1600万下'
    elif 'Icon_GradeType7' in grade_class:
        return '1000万下'
    elif 'Icon_GradeType8' in grade_class:
        return '900万下'
    elif 'Icon_GradeType9' in grade_class:
        return '500万下'
    elif 'Icon_GradeType10' in grade_class:
        return 'JGⅠ'
    elif 'Icon_GradeType11' in grade_class:
        return 'JGⅡ'
    elif 'Icon_GradeType12' in grade_class:
        return 'JGⅢ'
    elif 'Icon_GradeType13' in grade_class:
        return 'WIN5'
    elif 'Icon_GradeType14' in grade_class:
        return '特選'
    elif 'Icon_GradeType15' in grade_class:
        return 'L'
    elif 'Icon_GradeType16' in grade_class:
        return '3勝'
    elif 'Icon_GradeType17' in grade_class:
        return '2勝'
    elif 'Icon_GradeType18' in grade_class:
        return '1勝'
    else:
        pass


# ====================================================================================================
def main():
    db = xserver_keiba()
    # データベース内の最新レース日取得する
    sql = '''
        SELECT
            MAX(race_date) AS last_get_date
        FROM
            race_mst
    '''
    ret = db.fetch(sql)
    # dbにあるレース開催日の最大値を最初の取得対象日にする
    # レースデータがない（≒初回）は'2014-01-05'で固定する
    target_date = datetime(2014, 1, 5) if ret[0]['last_get_date'] is None else ret[0]['last_get_date']
    options = Options()
    # 画像を読み込まない
    options.add_argument('--blink-settings=imagesEnabled=false')
    # シークレットモードで起動
    options.add_argument('--incognito')
    # Chromeを起動する
    driver = webdriver.Chrome(options=options)
    # urlに日付を設定すれば対象日のレース画面になる
    driver.get(f"https://race.netkeiba.com/top/race_list.html?&kaisai_date={datetime.strftime(target_date, '%Y%m%d')}")
    sleep(0.5)
    # 対象日付が未来日になるまでループする
    while target_date < datetime.today():
        next_date_tab = True
        while next_date_tab is True:
            next_date_tab = False
            # ページソースをBeautifulSoupに食わせる
            soup = BeautifulSoup(driver.page_source)
            # 上部の日付のliにを確認
            for race_date in soup.select('#date_list_sub > li[role="tab"]'):
                # 上部の日付のliにあるdate属性から対象の日付を取得して未来日になったら終わらせる
                if int(race_date.get('date')) >= int(datetime.now().strftime('%Y%m%d')):
                    break
                # 取得済みの日付ならスキップ・未取得ならクリックする
                sql = f'''
                    SELECT
                        *
                    FROM
                        race_mst
                    WHERE
                        race_date='{race_date.get('date')}'
                '''
                ret = db.fetch(sql)
                if len(ret) > 0:
                    continue
                else:
                    driver.find_element(By.CSS_SELECTOR, f'#date_list_sub > li2026/04/11').click()
                # ↑のクリックでソースが書き換わっているのでもう一度ページソースをBeautifulSoupに食わせる
                soup = BeautifulSoup(driver.page_source)
                # id="RaceTopRace"が複数ある可能性があるのでループさせる
                for RaceTopRace in soup.select('#RaceTopRace'):
                    # 今表示されているRaceTopRaceは上の階層の属性で判断する
                    if RaceTopRace.parent.get('aria-hidden') == 'true':
                        continue
                    # 会場別でdlが分かれているのでループする
                    for dl in RaceTopRace.select('dl.RaceList_DataList'):
                        # レースごとにliが分かれてるからループする
                        for li in dl.select('dd.RaceList_Data > ul > li.RaceList_DataItem'):
                            # --- ここから実際のデータ取得 ---
                            # リンクが複数あるから'result.html'を含んでいるかで正誤判定する
                            for a in li.select('a'):
                                if 'result.html' in a.get('href'):
                                    # 会場のヘッダー部から会場情報を取得する
                                    data = data_class(dl.select_one('dt.RaceList_DataHeader > div.RaceList_DataHeader_Top > p.RaceList_DataTitle').get_text(separator='/', strip=True).split('/'))
                                    # urlのクエリパラメータにレースIDがあるので分解する
                                    url = a.get('href')
                                    qs = urllib.parse.urlparse(url).query
                                    qs_d = urllib.parse.parse_qs(qs)
                                    data.race_id = qs_d['race_id'][0]
                                    # --- a配下にレース情報があるので取得する ---
                                    # レース番号
                                    data.race_no = a.select_one('div.Race_Num.Race_Fixed > span').get_text(strip=True).replace('R', '')
                                    # レース名
                                    data.race_name = a.select_one('div.RaceList_ItemContent > div.RaceList_ItemTitle > span.ItemTitle').get_text(strip=True)
                                    # レースのグレード設定があれば取得する
                                    if len(a.select('div.RaceList_ItemContent > div.RaceList_ItemTitle > span.Icon_GradeType')) > 0:
                                        data.race_grade = grade_converter(a.select_one('div.RaceList_ItemContent > div.RaceList_ItemTitle > span.Icon_GradeType').get('class'))
                                    # 出走時刻
                                    data.race_time = a.select_one('div.RaceList_ItemContent > div.RaceData > span.RaceList_Itemtime').get_text(strip=True)
                                    # 障害レースはクラス設定がないので分岐
                                    if len(a.select('div.RaceList_ItemContent > div.RaceData > span.RaceList_ItemLong')) > 0:
                                        # 芝・ダートはクラスが設定されているからセレクタ―で指定する
                                        data.coruse_type = a.select_one('div.RaceList_ItemContent > div.RaceData > span.RaceList_ItemLong').get_text(strip=True)[0]
                                        data.course_distance = re.findall(R'\d+', a.select_one('div.RaceList_ItemContent > div.RaceData > span.RaceList_ItemLong').get_text(strip=True))[0]
                                    else:
                                        # 障害はクラスが設定されていないから苦肉でindex指定する
                                        data.coruse_type = a.select('div.RaceList_ItemContent > div.RaceData > span')[1].get_text(strip=True)[0]
                                        data.course_distance = re.findall(R'\d+', a.select('div.RaceList_ItemContent > div.RaceData > span')[1].get_text(strip=True))[0]
                                    # レース日は変数から反映させる
                                    data.race_date = race_date.get('date')
                                    db.execute(data.upsert_sql())
                next_date_tab = True
                break

        # 次ボタンを押すと次開催日に移るのでクリックする
        try:
            WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, '#nextBtn > a')))
        except TimeoutException:
            # 次がボタンになっていない（≒次がない）時はループを抜ける（けど、過去データしか取得しないから基本的にありえない）
            break
        driver.find_element(By.CSS_SELECTOR, '#nextBtn > a').click()
        # 一瞬でもsleepしないと処理が早すぎてエラーになる可能性があるので0.5秒待機
        sleep(0.5)
        # クエリパラメータに開催日があるので日付型に変換する
        qs = urllib.parse.urlparse(driver.current_url).query
        qs_d = urllib.parse.parse_qs(qs)
        target_date = datetime.strptime(qs_d['kaisai_date'][0], '%Y%m%d')
    # 最後にChromedriverを落として終了
    driver.close()
    driver.quit()


# ====================================================================================================
if __name__ == '__main__':
    main()