コード例 #1
0
class Youtube:

    # ------------------------------------------------------------- Init ------------------------------------------------------------- #

    def __init__(self,
                 cookies_folder_path: str,
                 extensions_folder_path: str,
                 email: Optional[str] = None,
                 password: Optional[str] = None,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 screen_size: Optional[Tuple[int, int]] = None,
                 full_screen: bool = False,
                 disable_images: bool = False,
                 login_prompt_callback: Optional[Callable[[str],
                                                          None]] = None):
        self.browser = Firefox(cookies_folder_path,
                               extensions_folder_path,
                               host=host,
                               port=port,
                               screen_size=screen_size,
                               full_screen=full_screen,
                               disable_images=disable_images)
        self.channel_id = None

        try:
            self.__internal_channel_id = cookies_folder_path.strip('/').split(
                '/')[-1]
        except:
            self.__internal_channel_id = cookies_folder_path

        try:
            if self.browser.login_via_cookies(
                    YT_URL, LOGIN_INFO_COOKIE_NAME) or self.login(
                        email=email,
                        password=password,
                        login_prompt_callback=login_prompt_callback):
                time.sleep(0.5)
                self.browser.get(YT_URL)
                time.sleep(0.5)
                self.browser.save_cookies()
                time.sleep(0.5)
                self.channel_id = self.get_current_channel_id()
        except Exception as e:
            print(e)
            self.quit()

            raise

    # ------------------------------------------------------ Public properties ------------------------------------------------------- #

    @property
    def is_logged_in(self) -> bool:
        return self.browser.has_cookie(LOGIN_INFO_COOKIE_NAME)

    # -------------------------------------------------------- Public methods -------------------------------------------------------- #

    def login(
            self,
            email: Optional[str],
            password: Optional[str],
            login_prompt_callback: Optional[Callable[[str],
                                                     None]] = None) -> bool:
        org_url = self.browser.driver.current_url
        self.browser.get(YT_URL)
        time.sleep(0.5)

        logged_in = self.is_logged_in

        if not logged_in and email is not None and password is not None:
            logged_in = self.__login_auto(email, password)

        if not logged_in:
            print('Could not log you in automatically.')
            logged_in = self.__login_manual(
                login_prompt_callback=login_prompt_callback)

        if logged_in:
            time.sleep(0.5)
            self.browser.get(YT_URL)
            time.sleep(0.5)

            self.browser.save_cookies()

        time.sleep(0.5)
        self.browser.get(org_url)

        return logged_in

    def upload(
        self,
        video_path: str,
        title: str,
        description: str,
        tags: List[str],
        _timeout: Optional[int] = 60 * 3,  # 3 min
        extra_sleep_after_upload: Optional[int] = None,
        extra_sleep_before_publish: Optional[int] = None
    ) -> (bool, Optional[str]):
        if _timeout is not None:
            try:
                with timeout.timeout(_timeout):
                    return self.__upload(
                        video_path,
                        title,
                        description,
                        tags,
                        extra_sleep_after_upload=extra_sleep_after_upload,
                        extra_sleep_before_publish=extra_sleep_before_publish)
            except Exception as e:
                print('Upload', e)
                # self.browser.get(YT_URL)

                return False, None
        else:
            return self.__upload(
                video_path,
                title,
                description,
                tags,
                extra_sleep_after_upload=extra_sleep_after_upload,
                extra_sleep_before_publish=extra_sleep_before_publish)

    def get_current_channel_id(self) -> Optional[str]:
        self.browser.get(YT_URL)

        try:
            return json.loads(
                strings.between(self.browser.driver.page_source,
                                'var ytInitialGuideData = ', '};') +
                '}')['responseContext']['serviceTrackingParams'][2]['params'][
                    0]['value']
        except Exception as e:
            print('get_current_channel_id', e)

            return None

    def load_video(self, video_id: str):
        self.browser.get(self.__video_url(video_id))

    def comment_on_video(self,
                         video_id: str,
                         comment: str,
                         pinned: bool = False,
                         _timeout: Optional[int] = 15) -> (bool, bool):
        if _timeout is not None:
            try:
                with timeout.timeout(_timeout):
                    return self.__comment_on_video(video_id,
                                                   comment,
                                                   pinned=pinned)
            except Exception as e:
                print('Comment', e)
                # self.browser.get(YT_URL)

                return False, False
        else:
            return self.__comment_on_video(video_id, comment, pinned=pinned)

    def get_channel_video_ids(
            self,
            channel_id: Optional[str] = None,
            ignored_titles: Optional[List[str]] = None) -> List[str]:
        video_ids = []
        ignored_titles = ignored_titles or []

        channel_id = channel_id or self.channel_id

        try:
            self.browser.get(self.__channel_videos_url(channel_id))
            last_page_source = self.browser.driver.page_source

            while True:
                self.browser.scroll(1500)

                i = 0
                max_i = 100
                sleep_time = 0.1
                should_break = True

                while i < max_i:
                    i += 1
                    time.sleep(sleep_time)

                    if len(last_page_source) != len(
                            self.browser.driver.page_source):
                        last_page_source = self.browser.driver.page_source
                        should_break = False

                        break

                if should_break:
                    break

            soup = bs(self.browser.driver.page_source, 'lxml')
            elems = soup.find_all(
                'a', {
                    'id':
                    'video-title',
                    'class':
                    'yt-simple-endpoint style-scope ytd-grid-video-renderer'
                })

            for elem in elems:
                if 'title' in elem.attrs:
                    should_continue = False
                    title = elem['title'].strip().lower()

                    for ignored_title in ignored_titles:
                        if ignored_title.strip().lower() == title:
                            should_continue = True

                            break

                    if should_continue:
                        continue

                if 'href' in elem.attrs and '/watch?v=' in elem['href']:
                    vid_id = strings.between(elem['href'], '?v=', '&')

                    if vid_id is not None and vid_id not in video_ids:
                        video_ids.append(vid_id)
        except Exception as e:
            print(e)

        return video_ids

    def check_analytics(self) -> bool:
        self.browser.get(YT_STUDIO_URL)

        try:
            self.browser.get(
                self.browser.find(
                    By.XPATH, "//a[@id='menu-item-3']").get_attribute('href'))

            return True
        except Exception as e:
            print(e)

            return False

    def quit(self):
        self.browser.driver.quit()

    # ------------------------------------------------------- Private methods -------------------------------------------------------- #

    def __upload(
        self,
        video_path: str,
        title: str,
        description: str,
        tags: List[str],
        extra_sleep_after_upload: Optional[int] = None,
        extra_sleep_before_publish: Optional[int] = None
    ) -> (bool, Optional[str]):
        self.browser.get(YT_URL)
        time.sleep(1.5)

        try:
            self.browser.get(YT_UPLOAD_URL)
            time.sleep(1.5)
            self.browser.save_cookies()

            self.browser.find(By.XPATH,
                              "//input[@type='file']").send_keys(video_path)
            print('Upload: uploaded video')

            if extra_sleep_after_upload is not None and extra_sleep_after_upload > 0:
                time.sleep(extra_sleep_after_upload)

            title_field = self.browser.find_by('div', id_='textbox')
            time.sleep(0.5)
            title_field.send_keys(Keys.BACK_SPACE)
            time.sleep(0.5)
            title_field.send_keys(title[:MAX_TITLE_CHAR_LEN])
            print('Upload: added title')
            description_container = self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/ytcp-uploads-basics/ytcp-mention-textbox[2]"
            )
            description_field = self.browser.find(
                By.ID, "textbox", element=description_container)
            description_field.click()
            time.sleep(0.5)
            description_field.clear()
            time.sleep(0.5)
            description_field.send_keys(description[:MAX_DESCRIPTION_CHAR_LEN])

            print('Upload: added description')

            self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/div/ytcp-button/div"
            ).click()
            print("Upload: clicked more options")

            tags_container = self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/ytcp-uploads-advanced/ytcp-form-input-container/div[1]/div[2]/ytcp-free-text-chip-bar/ytcp-chip-bar/div"
            )
            tags_field = self.browser.find(By.ID, "text-input", tags_container)
            tags_field.send_keys(','.join(tags) + ',')
            print("Upload: added tags")

            kids_section = self.browser.find(By.NAME, "NOT_MADE_FOR_KIDS")
            self.browser.find(By.ID, "radioLabel", kids_section).click()
            print("Upload: did set NOT_MADE_FOR_KIDS")

            self.browser.find(By.ID, 'next-button').click()
            print('Upload: clicked first next')

            self.browser.find(By.ID, 'next-button').click()
            print('Upload: clicked second next')

            public_main_button = self.browser.find(By.NAME, "PUBLIC")
            self.browser.find(By.ID, 'radioLabel', public_main_button).click()
            print('Upload: set to public')

            try:
                video_url_container = self.browser.find(
                    By.XPATH,
                    "//span[@class='video-url-fadeable style-scope ytcp-video-info']",
                    timeout=2.5)
                video_url_element = self.browser.find(
                    By.XPATH,
                    "//a[@class='style-scope ytcp-video-info']",
                    element=video_url_container,
                    timeout=2.5)
                video_id = video_url_element.get_attribute('href').split(
                    '/')[-1]
            except Exception as e:
                print(e)
                video_id = None

            i = 0

            if extra_sleep_before_publish is not None and extra_sleep_before_publish > 0:
                time.sleep(extra_sleep_before_publish)

            while True:
                try:
                    progress_label = self.browser.find_by(
                        'span', {
                            'class':
                            'progress-label style-scope ytcp-video-upload-progress'
                        },
                        timeout=0.1
                    ) or self.browser.find_by('span', {
                        'class':
                        'progress-label-old style-scope ytcp-video-upload-progress'
                    },
                                              timeout=0.1)
                    progress_label_text = progress_label.text.lower()

                    if 'finished' in progress_label_text or 'process' in progress_label_text:
                        done_button = self.browser.find(By.ID, 'done-button')

                        if done_button.get_attribute(
                                'aria-disabled') == 'false':
                            done_button.click()

                            print('Upload: published')

                            time.sleep(3)
                            self.browser.get(YT_URL)

                            return True, video_id
                except Exception as e:
                    print(e)
                    i += 1

                    if i >= 20:
                        done_button = self.browser.find(By.ID, 'done-button')

                        if done_button.get_attribute(
                                'aria-disabled') == 'false':
                            done_button.click()

                            print('Upload: published')

                            time.sleep(3)
                            self.browser.get(YT_URL)

                            return True, video_id

                        raise

                time.sleep(1)
        except Exception as e:
            print(e)

            self.browser.get(YT_URL)

            return False, None

    # returns (commented_successfully, pinned_comment_successfully)
    def __comment_on_video(self,
                           video_id: str,
                           comment: str,
                           pinned: bool = False) -> (bool, bool):
        self.load_video(video_id)
        time.sleep(1)
        self.browser.scroll(150)
        time.sleep(1)
        self.browser.scroll(100)
        time.sleep(1)
        self.browser.scroll(100)

        try:
            header = self.browser.find_by('div',
                                          id_='masthead-container',
                                          class_='style-scope ytd-app')
            comment_field = self.browser.find(By.XPATH,
                                              "//div[@id='placeholder-area']",
                                              timeout=5)

            self.browser.scroll_to_element(comment_field,
                                           header_element=header)
            time.sleep(0.5)

            print('comment: clicking comment_field')
            comment_field.click()
            print('comment: sending keys')
            self.browser.find(By.XPATH,
                              "//div[@id='contenteditable-root']",
                              timeout=0.5).send_keys(comment)
            print('comment: clicking post_comment')
            self.browser.find(
                By.XPATH,
                "//ytd-button-renderer[@id='submit-button' and @class='style-scope ytd-commentbox style-primary size-default']",
                timeout=0.5).click()

            if not pinned:
                return True, False

            try:
                dropdown_menu_xpath = "//yt-sort-filter-sub-menu-renderer[@class='style-scope ytd-comments-header-renderer']"
                dropdown_menu = self.browser.find(By.XPATH,
                                                  dropdown_menu_xpath)
                self.browser.scroll_to_element(dropdown_menu,
                                               header_element=header)
                time.sleep(0.5)

                dropdown_trigger_xpath = "//paper-button[@id='label' and @class='dropdown-trigger style-scope yt-dropdown-menu']"

                print('comment: clicking dropdown_trigger (open)')
                self.browser.find(By.XPATH,
                                  dropdown_trigger_xpath,
                                  element=dropdown_menu,
                                  timeout=2.5).click()

                try:
                    dropdown_menu = self.browser.find(By.XPATH,
                                                      dropdown_menu_xpath)
                    dropdown_elements = [
                        elem for elem in self.browser.find_all(
                            By.XPATH,
                            "//a",
                            element=dropdown_menu,
                            timeout=2.5)
                        if 'yt-dropdown-menu' in elem.get_attribute('class')
                    ]

                    last_dropdown_element = dropdown_elements[-1]

                    if last_dropdown_element.get_attribute(
                            'aria-selected') == 'false':
                        time.sleep(0.25)
                        print('comment: clicking last_dropdown_element')
                        last_dropdown_element.click()
                    else:
                        print(
                            'comment: clicking dropdown_trigger (close) (did not click last_dropdown_element (did not find it))'
                        )
                        self.browser.find(By.XPATH,
                                          dropdown_trigger_xpath,
                                          element=dropdown_menu,
                                          timeout=2.5).click()
                except Exception as e:
                    print(e)
                    print(
                        'comment: clicking dropdown_trigger (close) (did not click last_dropdown_element (error occured))'
                    )
                    self.browser.find(By.XPATH,
                                      dropdown_trigger_xpath,
                                      element=dropdown_menu,
                                      timeout=2.5).click()
            except Exception as e:
                print(e)

            # self.browser.scroll(100)
            time.sleep(2.5)

            for comment_thread in self.browser.find_all(
                    By.XPATH,
                    "//ytd-comment-thread-renderer[@class='style-scope ytd-item-section-renderer']"
            ):
                pinned_element = self.browser.find(
                    By.XPATH,
                    "//yt-icon[@class='style-scope ytd-pinned-comment-badge-renderer']",
                    element=comment_thread,
                    timeout=0.5)
                pinned = pinned_element is not None and pinned_element.is_displayed(
                )

                if pinned:
                    continue

                try:
                    # button_3_dots
                    button_3_dots = self.browser.find(
                        By.XPATH,
                        "//yt-icon-button[@id='button' and @class='dropdown-trigger style-scope ytd-menu-renderer']",
                        element=comment_thread,
                        timeout=2.5)

                    self.browser.scroll_to_element(button_3_dots,
                                                   header_element=header)
                    time.sleep(0.5)
                    print('comment: clicking button_3_dots')
                    button_3_dots.click()

                    popup_renderer_3_dots = self.browser.find(
                        By.XPATH,
                        "//ytd-menu-popup-renderer[@class='style-scope ytd-popup-container']",
                        timeout=2)

                    # dropdown menu item (first)
                    print(
                        'comment: clicking button_3_dots-dropdown_menu_item (to pin it)'
                    )
                    self.browser.find(
                        By.XPATH,
                        "//a[@class='yt-simple-endpoint style-scope ytd-menu-navigation-item-renderer']",
                        element=popup_renderer_3_dots,
                        timeout=2.5).click()

                    confirm_button_container = self.browser.find(
                        By.XPATH,
                        "//yt-button-renderer[@id='confirm-button' and @class='style-scope yt-confirm-dialog-renderer style-primary size-default']",
                        timeout=5)

                    # confirm button
                    print('comment: clicking confirm_button')
                    self.browser.find(
                        By.XPATH,
                        "//a[@class='yt-simple-endpoint style-scope yt-button-renderer']",
                        element=confirm_button_container,
                        timeout=2.5).click()
                    time.sleep(2)

                    return True, True
                except Exception as e:
                    print(e)

                    return True, False

            # could not find new comment
            print('no_new_comments')
            return True, False
        except Exception as e:
            print(e)

            return False, False

    def __login_auto(self, email: str, password: str) -> bool:
        self.browser.get(YT_LOGIN_URL)
        time.sleep(0.5)

        try:
            with timeout.timeout(30):
                email_field = self.browser.find_by('input', {
                    'id': 'identifierId',
                    'type': 'email'
                })
                email_field.click()
                self.browser.send_keys_delay_random(email_field, email)
                time.sleep(1)
                self.browser.find_by('div', {
                    'jscontroller': 'VXdfxd',
                    'role': 'button'
                }).click()
                time.sleep(1)

                from selenium.webdriver.common.action_chains import ActionChains
                action = ActionChains(self.browser.driver)

                pass_container = self.browser.find_by('div', {
                    'id': 'password',
                    'jscontroller': 'pxq3x'
                })
                pass_field = self.browser.find_by('input',
                                                  {'type': 'password'},
                                                  in_element=pass_container)
                action.move_to_element(pass_field).perform()
                pass_field.click()
                self.browser.send_keys_delay_random(pass_field, password)
                time.sleep(1)
                self.browser.find_by('div', {
                    'jscontroller': 'VXdfxd',
                    'role': 'button'
                }).click()
                time.sleep(1)
        except Exception as e:
            print('__login_auto', e)

        self.browser.get(YT_URL)
        time.sleep(0.5)

        return self.is_logged_in

    def __login_manual(
            self,
            login_prompt_callback: Optional[Callable[[str],
                                                     None]] = None) -> bool:
        self.browser.get(YT_LOGIN_URL)
        time.sleep(0.5)

        try:
            if login_prompt_callback is not None:
                login_prompt_callback(self.__internal_channel_id +
                                      ' needs manual input to log in.')

            input('Log in then press return')
        except Exception as e:
            print('__login_manual', e)

        self.browser.get(YT_URL)
        time.sleep(0.5)

        return self.is_logged_in

    def __video_url(self, video_id: str) -> str:
        return YT_URL + '/watch?v=' + video_id

    def __channel_videos_url(self, channel_id: str) -> str:
        return YT_URL + '/channel/' + channel_id + '/videos?view=0&sort=da&flow=grid'


# ---------------------------------------------------------------------------------------------------------------------------------------- #
コード例 #2
0
class Youtube:

    # ------------------------------------------------------------- Init ------------------------------------------------------------- #

    def __init__(self,
                 cookies_folder_path: Optional[str] = None,
                 extensions_folder_path: Optional[str] = None,
                 email: Optional[str] = None,
                 password: Optional[str] = None,
                 host: Optional[str] = None,
                 port: Optional[int] = None,
                 screen_size: Optional[Tuple[int, int]] = None,
                 full_screen: bool = False,
                 disable_images: bool = False,
                 user_agent: Optional[str] = None,
                 login_prompt_callback: Optional[Callable[[str], None]] = None,
                 headless: bool = False):
        self.browser = Firefox(cookies_folder_path,
                               extensions_folder_path,
                               host=host,
                               port=port,
                               screen_size=screen_size,
                               user_agent=user_agent,
                               full_screen=full_screen,
                               disable_images=disable_images,
                               headless=headless)
        self.channel_id = None
        self.browser.get(YT_URL)
        self.__dismiss_alerts()

        try:
            self.__internal_channel_id = cookies_folder_path.strip('/').split(
                '/')[-1]
        except:
            self.__internal_channel_id = cookies_folder_path or self.browser.cookies_folder_path

        try:
            if self.browser.login_via_cookies(YT_URL, LOGIN_INFO_COOKIE_NAME):
                time.sleep(0.5)
                self.browser.get(YT_URL)
                time.sleep(0.5)
                self.browser.save_cookies()
                time.sleep(0.5)
                self.channel_id = self.get_current_channel_id()
            elif email and password:
                self.login(email=email,
                           password=password,
                           login_prompt_callback=login_prompt_callback)
        except Exception as e:
            print(e)
            self.quit()

            raise

    # ------------------------------------------------------ Public properties ------------------------------------------------------- #

    @property
    def is_logged_in(self) -> bool:
        return self.browser.has_cookie(LOGIN_INFO_COOKIE_NAME)

    # -------------------------------------------------------- Public methods -------------------------------------------------------- #

    def login(
            self,
            email: Optional[str],
            password: Optional[str],
            login_prompt_callback: Optional[Callable[[str],
                                                     None]] = None) -> bool:
        org_url = self.browser.driver.current_url
        self.browser.get(YT_URL)
        time.sleep(0.5)

        logged_in = self.is_logged_in

        if not logged_in and email is not None and password is not None:
            try:
                logged_in = self.__login_auto(email, password, timeout=30)
            except Exception as e:
                print('__login_auto', e)

                logged_in = False

        if not logged_in:
            print('Could not log you in automatically.')
            logged_in = self.__login_manual(
                login_prompt_callback=login_prompt_callback)

        if logged_in:
            time.sleep(0.5)
            self.browser.get(YT_URL)
            time.sleep(0.5)
            self.browser.save_cookies()
            time.sleep(0.5)
            self.channel_id = self.get_current_channel_id()

        time.sleep(0.5)
        self.browser.get(org_url)

        return logged_in

    def watch_video(
        self,
        video_id: str,
        percent_to_watch: float = -1,  # 0-100 # -1 means all
        like: bool = False
    ) -> Tuple[bool, bool]:  # watched, liked
        watched = False
        liked = False

        try:
            self.browser.get(YT_WATCH_VIDEO_URL + video_id)
            length_s = float(
                strings.between(self.browser.driver.page_source,
                                'detailpage\\\\u0026len=', '\\\\'))
            play_button = self.browser.find_by(
                'button',
                class_='ytp-large-play-button ytp-button',
                timeout=0.5)

            if play_button and play_button.is_displayed():
                play_button.click()
                time.sleep(1)

            while True:
                ad = self.browser.find_by('div',
                                          class_='video-ads ytp-ad-module',
                                          timeout=0.5)

                if not ad or not ad.is_displayed():
                    break

                time.sleep(0.1)

            watched = True
            seconds_to_watch = percent_to_watch / 100 * length_s if percent_to_watch >= 0 else length_s

            if seconds_to_watch > 0:
                print('Goinng to watch', seconds_to_watch)
                time.sleep(seconds_to_watch)

            return watched, self.like(
                video_id) if like and self.is_logged_in else False
        except Exception as e:
            print(e)

            return watched, liked

    def like(self, video_id: str) -> bool:
        self.browser.get(YT_WATCH_VIDEO_URL + video_id)

        try:
            buttons_container = self.browser.find_by(
                'div',
                id_='top-level-buttons',
                class_='style-scope ytd-menu-renderer',
                timeout=1.5)

            if buttons_container:
                button_container = self.browser.find_by(
                    'ytd-toggle-button-renderer',
                    class_=
                    'style-scope ytd-menu-renderer force-icon-button style-text',
                    timeout=0.5,
                    in_element=buttons_container)

                if button_container:
                    button = self.browser.find_by('button',
                                                  id_='button',
                                                  timeout=0.5,
                                                  in_element=button_container)

                    if button:
                        attr = button.get_attribute('aria-pressed')

                        if attr and attr == 'false':
                            button.click()

                        return True

            return False
        except Exception as e:
            print(e)

            return False

    def upload(
        self,
        video_path: str,
        title: str,
        description: str,
        tags: List[str],
        made_for_kids: bool = False,
        visibility: Visibility = Visibility.PUBLIC,
        thumbnail_image_path: Optional[str] = None,
        _timeout: Optional[int] = 60 * 3,  # 3 min
        extra_sleep_after_upload: Optional[int] = None,
        extra_sleep_before_publish: Optional[int] = None
    ) -> (bool, Optional[str]):
        res = self.__upload(
            video_path,
            title,
            description,
            tags,
            made_for_kids=made_for_kids,
            visibility=visibility,
            thumbnail_image_path=thumbnail_image_path,
            extra_sleep_after_upload=extra_sleep_after_upload,
            extra_sleep_before_publish=extra_sleep_before_publish,
            timeout=_timeout)

        if res == TIME_OUT_ERROR:
            print('Upload:', TIME_OUT_ERROR)

            return False, None

        return res

    def get_current_channel_id(self,
                               _click_avatar: bool = False,
                               _get_home_url: bool = False) -> Optional[str]:
        if _get_home_url:
            self.browser.get(YT_URL)

        try:
            if _click_avatar:
                avatar_button = self.browser.find_by('button',
                                                     id_='avatar-btn',
                                                     timeout=0.5)

                if avatar_button:
                    avatar_button.click()

            href_containers = self.browser.find_all_by(
                'a',
                class_=
                'yt-simple-endpoint style-scope ytd-compact-link-renderer',
                timeout=0.5)

            if href_containers:
                for href_container in href_containers:
                    href = href_container.get_attribute('href')

                    if href and 'channel/' in href:
                        return strings.between(href, 'channel/', '?')
        except Exception as e:
            print(e)

        if not _click_avatar:
            return self.get_current_channel_id(_click_avatar=True,
                                               _get_home_url=_get_home_url)
        elif not _get_home_url:
            return self.get_current_channel_id(_click_avatar=False,
                                               _get_home_url=True)

        return None

    def load_video(self, video_id: str):
        self.browser.get(self.__video_url(video_id))

    def comment_on_video(self,
                         video_id: str,
                         comment: str,
                         pinned: bool = False,
                         _timeout: Optional[int] = 15) -> (bool, bool):
        res = self.__comment_on_video(video_id,
                                      comment,
                                      pinned=pinned,
                                      timeout=_timeout)

        if res == TIME_OUT_ERROR:
            print('Comment:', TIME_OUT_ERROR)

            return False, False

        return res

    def get_channel_video_ids(
            self,
            channel_id: Optional[str] = None,
            ignored_titles: Optional[List[str]] = None) -> List[str]:
        video_ids = []
        ignored_titles = ignored_titles or []

        channel_id = channel_id or self.channel_id

        try:
            self.browser.get(self.__channel_videos_url(channel_id))
            last_page_source = self.browser.driver.page_source

            while True:
                self.browser.scroll(1500)

                i = 0
                max_i = 100
                sleep_time = 0.1
                should_break = True

                while i < max_i:
                    i += 1
                    time.sleep(sleep_time)

                    if len(last_page_source) != len(
                            self.browser.driver.page_source):
                        last_page_source = self.browser.driver.page_source
                        should_break = False

                        break

                if should_break:
                    break

            soup = bs(self.browser.driver.page_source, 'lxml')
            elems = soup.find_all(
                'a', {
                    'id':
                    'video-title',
                    'class':
                    'yt-simple-endpoint style-scope ytd-grid-video-renderer'
                })

            for elem in elems:
                if 'title' in elem.attrs:
                    should_continue = False
                    title = elem['title'].strip().lower()

                    for ignored_title in ignored_titles:
                        if ignored_title.strip().lower() == title:
                            should_continue = True

                            break

                    if should_continue:
                        continue

                if 'href' in elem.attrs and '/watch?v=' in elem['href']:
                    vid_id = strings.between(elem['href'], '?v=', '&')

                    if vid_id is not None and vid_id not in video_ids:
                        video_ids.append(vid_id)
        except Exception as e:
            print(e)

        return video_ids

    def check_analytics(
            self,
            tab: AnalyticsTab = AnalyticsTab.OVERVIEW,
            period: AnalyticsPeriod = AnalyticsPeriod.LAST_28_DAYS) -> bool:
        if not self.channel_id:
            print('No channel ID found')

            return False

        url = YT_STUDIO_URL.rstrip(
            '/'
        ) + '/channel/' + self.channel_id + '/analytics/tab-' + tab.value + '/period-' + period.value

        try:
            self.browser.get(url)

            return True
        except Exception as e:
            print(e)

            return False

    def get_violations(self) -> Tuple[bool, int]:  # has_warning, strikes
        self.browser.get(YT_STUDIO_URL)

        try:
            violations_container = self.browser.find_by(
                'div', class_='style-scope ytcd-strikes-item')

            if not violations_container:
                return False, 0

            violations_label = self.browser.find_by(
                'div',
                class_='label style-scope ytcp-badge',
                in_element=violations_container)

            if not violations_label:
                return False, 0

            violation_text = violations_label.text.strip().lower()
            violation_text_number = 0

            try:
                violation_text_number = int(violation_text)
            except:
                pass

            return True, violation_text_number
        except Exception as e:
            print(e)

            return False, 0

    def add_endscreen(self,
                      video_id: str,
                      max_wait_seconds_for_processing: float = 0) -> bool:
        self.browser.get(YT_STUDIO_VIDEO_URL.format(video_id))

        try:
            start_time = time.time()

            while True:
                attrs = self.browser.get_attributes(
                    self.browser.find_by('ytcp-text-dropdown-trigger',
                                         id_='endscreen-editor-link'))

                if not attrs or 'disabled' in attrs:
                    if time.time(
                    ) - start_time < max_wait_seconds_for_processing:
                        time.sleep(1)

                        continue

                    return False
                else:
                    break

            self.browser.find_by('ytcp-text-dropdown-trigger',
                                 id_='endscreen-editor-link').click()
            time.sleep(0.5)
            self.browser.find_all_by(
                'div',
                class_='card style-scope ytve-endscreen-template-picker'
            )[0].click()
            time.sleep(0.5)
            self.browser.find_by('ytcp-button', id_='save-button').click()

            time.sleep(2)

            return self.browser.find_by('ytve-endscreen-editor-options-panel',
                                        class_='style-scope ytve-editor',
                                        timeout=0.5) is None
        except Exception as e:
            print(e)

            return False

    def quit(self):
        try:
            self.browser.driver.quit()
        except:
            pass

    # ------------------------------------------------------- Private methods -------------------------------------------------------- #

    @stopit.signal_timeoutable(default=TIME_OUT_ERROR, timeout_param='timeout')
    def __upload(self,
                 video_path: str,
                 title: str,
                 description: str,
                 tags: List[str],
                 made_for_kids: bool = False,
                 visibility: Visibility = Visibility.PUBLIC,
                 thumbnail_image_path: Optional[str] = None,
                 extra_sleep_after_upload: Optional[int] = None,
                 extra_sleep_before_publish: Optional[int] = None,
                 timeout: Optional[int] = None) -> (bool, Optional[str]):
        self.browser.get(YT_URL)
        time.sleep(1.5)

        try:
            self.browser.get(YT_UPLOAD_URL)
            time.sleep(1.5)
            self.browser.save_cookies()

            self.browser.find(By.XPATH,
                              "//input[@type='file']").send_keys(video_path)
            print('Upload: uploaded video')

            if extra_sleep_after_upload is not None and extra_sleep_after_upload > 0:
                time.sleep(extra_sleep_after_upload)

            title_field = self.browser.find_by(
                'div', id_='textbox', timeout=2) or self.browser.find_by(
                    id_='textbox', timeout=2)
            time.sleep(0.5)
            title_field.send_keys(Keys.BACK_SPACE)

            try:
                time.sleep(0.5)
                title_field.send_keys(
                    Keys.COMMAND if platform == 'darwin' else Keys.CONTROL,
                    'a')
                time.sleep(0.5)
                title_field.send_keys(Keys.BACK_SPACE)
            except Exception as e:
                print(e)

            time.sleep(0.5)
            title_field.send_keys('a')
            time.sleep(0.5)
            title_field.send_keys(Keys.BACK_SPACE)

            time.sleep(0.5)
            title_field.send_keys(title[:MAX_TITLE_CHAR_LEN])
            print('Upload: added title')
            description_container = self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/ytcp-uploads-basics/ytcp-mention-textbox[2]"
            )
            description_field = self.browser.find(
                By.ID, "textbox", element=description_container)
            description_field.click()
            time.sleep(0.5)
            description_field.clear()
            time.sleep(0.5)
            description_field.send_keys(description[:MAX_DESCRIPTION_CHAR_LEN])
            print('Upload: added description')

            if thumbnail_image_path is not None:
                try:
                    self.browser.find(By.XPATH,
                                      "//input[@id='file-loader']").send_keys(
                                          thumbnail_image_path)
                    time.sleep(0.5)
                    print('Upload: added thumbnail')
                except Exception as e:
                    print('Upload: Thumbnail error: ', e)

            self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/div/ytcp-button/div"
            ).click()
            print("Upload: clicked more options")

            tags_container = self.browser.find(
                By.XPATH,
                "/html/body/ytcp-uploads-dialog/paper-dialog/div/ytcp-animatable[1]/ytcp-uploads-details/div/ytcp-uploads-advanced/ytcp-form-input-container/div[1]/div[2]/ytcp-free-text-chip-bar/ytcp-chip-bar/div"
            )
            tags_field = self.browser.find(By.ID, 'text-input', tags_container)
            tags_field.send_keys(','.join(
                [t for t in tags
                 if len(t) <= MAX_TAG_CHAR_LEN])[:MAX_TAGS_CHAR_LEN - 1] + ',')
            print("Upload: added tags")

            kids_selection_name = 'MADE_FOR_KIDS' if made_for_kids else 'NOT_MADE_FOR_KIDS'
            kids_section = self.browser.find(By.NAME, kids_selection_name)
            self.browser.find(By.ID, 'radioLabel', kids_section).click()
            print('Upload: did set', kids_selection_name)

            self.browser.find(By.ID, 'next-button').click()
            print('Upload: clicked first next')

            self.browser.find(By.ID, 'next-button').click()
            print('Upload: clicked second next')

            visibility_main_button = self.browser.find(By.NAME,
                                                       visibility.name)
            self.browser.find(By.ID, 'radioLabel',
                              visibility_main_button).click()
            print('Upload: set to', visibility.name)

            try:
                video_url_container = self.browser.find(
                    By.XPATH,
                    "//span[@class='video-url-fadeable style-scope ytcp-video-info']",
                    timeout=2.5)
                video_url_element = self.browser.find(
                    By.XPATH,
                    "//a[@class='style-scope ytcp-video-info']",
                    element=video_url_container,
                    timeout=2.5)
                video_id = video_url_element.get_attribute('href').split(
                    '/')[-1]
            except Exception as e:
                print(e)
                video_id = None

            i = 0

            if extra_sleep_before_publish is not None and extra_sleep_before_publish > 0:
                time.sleep(extra_sleep_before_publish)

            while True:
                try:
                    upload_progress_element = self.browser.find_by(
                        'ytcp-video-upload-progress',
                        class_='style-scope ytcp-uploads-dialog',
                        timeout=0.2)

                    upload_status = UploadStatus.get_status(
                        self.browser, upload_progress_element)

                    if upload_status in [
                            UploadStatus.PROCESSING_SD,
                            UploadStatus.PROCESSED_SD_PROCESSING_HD,
                            UploadStatus.PROCESSED_ALL
                    ]:
                        done_button = self.browser.find(By.ID, 'done-button')

                        if done_button.get_attribute(
                                'aria-disabled') == 'false':
                            done_button.click()

                            print('Upload: published')

                            time.sleep(3)
                            self.browser.get(YT_URL)

                            return True, video_id
                except Exception as e:
                    print(e)
                    i += 1

                    if i >= 20:
                        done_button = self.browser.find(By.ID, 'done-button')

                        if done_button.get_attribute(
                                'aria-disabled') == 'false':
                            done_button.click()

                            print('Upload: published')

                            time.sleep(3)
                            self.browser.get(YT_URL)

                            return True, video_id

                        raise

                time.sleep(1)
        except Exception as e:
            print(e)

            self.browser.get(YT_URL)

            return False, None

    def save_cookies(self) -> None:
        self.browser.get(YT_URL)
        self.browser.save_cookies()

    # returns (commented_successfully, pinned_comment_successfully)
    @stopit.signal_timeoutable(default=TIME_OUT_ERROR, timeout_param='timeout')
    def __comment_on_video(self,
                           video_id: str,
                           comment: str,
                           pinned: bool = False,
                           timeout: Optional[int] = None) -> (bool, bool):
        self.load_video(video_id)
        time.sleep(1)
        self.browser.scroll(150)
        time.sleep(1)
        self.browser.scroll(100)
        time.sleep(1)
        self.browser.scroll(100)

        try:
            # time.sleep(10000)
            header = self.browser.find_by('div',
                                          id_='masthead-container',
                                          class_='style-scope ytd-app')

            print('comment: looking for \'comment_placeholder_area\'')
            comment_placeholder_area = self.browser.find_by(
                'div', id_='placeholder-area', timeout=5)

            print('comment: scrollinng to \'comment_placeholder_area\'')
            self.browser.scroll_to_element(comment_placeholder_area,
                                           header_element=header)
            time.sleep(0.5)

            print('comment: getting focus')
            try:
                self.browser.find_by(
                    'div',
                    id_='simple-box',
                    class_='style-scope ytd-comments-header-renderer',
                    timeout=0.5).click()
                self.browser.find_by(
                    'ytd-comment-simplebox-renderer',
                    class_='style-scope ytd-comments-header-renderer',
                    timeout=0.5).click()
                # comment_placeholder_area.click()
                self.browser.find_by('div',
                                     id_='placeholder-area',
                                     timeout=0.5).click()
            except Exception as e:
                print(e)

            print('comment: sending keys')
            # self.browser.find_by('div', id_='contenteditable-root', timeout=0.5).click()
            self.browser.find_by('div',
                                 id_='contenteditable-root',
                                 timeout=0.5).send_keys(comment)

            print('comment: clicking post_comment')
            self.browser.find_by(
                'ytd-button-renderer',
                id_='submit-button',
                class_='style-scope ytd-commentbox style-primary size-default',
                timeout=0.5).click()

            # self.browser.find(By.XPATH, "//ytd-button-renderer[@id='submit-button' and @class='style-scope ytd-commentbox style-primary size-default']", timeout=0.5).click()

            if not pinned:
                return True, False

            try:
                try:
                    dropdown_menu = self.browser.find_by(
                        'yt-sort-filter-sub-menu-renderer',
                        class_='style-scope ytd-comments-header-renderer')
                    self.browser.scroll_to_element(dropdown_menu,
                                                   header_element=header)
                    time.sleep(0.5)

                    print('comment: clicking dropdown_trigger (open)')
                    self.browser.find_by(
                        'paper-button',
                        id_='label',
                        class_='dropdown-trigger style-scope yt-dropdown-menu',
                        in_element=dropdown_menu,
                        timeout=2.5).click()

                    try:
                        dropdown_menu = self.browser.find_by(
                            'paper-button',
                            id_='label',
                            class_=
                            'dropdown-trigger style-scope yt-dropdown-menu',
                            in_element=dropdown_menu,
                            timeout=2.5)
                        dropdown_elements = [
                            elem for elem in self.browser.find_all_by(
                                'a', in_element=dropdown_menu, timeout=2.5) if
                            'yt-dropdown-menu' in elem.get_attribute('class')
                        ]

                        last_dropdown_element = dropdown_elements[-1]

                        if last_dropdown_element.get_attribute(
                                'aria-selected') == 'false':
                            time.sleep(0.25)
                            print('comment: clicking last_dropdown_element')
                            last_dropdown_element.click()
                        else:
                            print(
                                'comment: clicking dropdown_trigger (close) (did not click last_dropdown_element (did not find it))'
                            )
                            self.browser.find_by(
                                'paper-button',
                                id_='label',
                                class_=
                                'dropdown-trigger style-scope yt-dropdown-menu',
                                in_element=dropdown_menu,
                                timeout=2.5).click()
                    except Exception as e:
                        print(e)
                        self.browser.find_by(
                            'paper-button',
                            id_='label',
                            class_=
                            'dropdown-trigger style-scope yt-dropdown-menu',
                            in_element=dropdown_menu,
                            timeout=2.5).click()
                except Exception as e:
                    print(e)

                # self.browser.scroll(100)
                time.sleep(2.5)

                for comment_thread in self.browser.find_all_by(
                        'ytd-comment-thread-renderer',
                        class_='style-scope ytd-item-section-renderer'):
                    pinned_element = self.browser.find_by(
                        'yt-icon',
                        class_='style-scope ytd-pinned-comment-badge-renderer',
                        in_element=comment_thread,
                        timeout=0.5)
                    pinned = pinned_element is not None and pinned_element.is_displayed(
                    )

                    if pinned:
                        continue

                    try:
                        # button_3_dots
                        button_3_dots = self.browser.find_by(
                            'yt-icon-button',
                            id_='button',
                            class_=
                            'dropdown-trigger style-scope ytd-menu-renderer',
                            in_element=comment_thread,
                            timeout=2.5)

                        self.browser.scroll_to_element(button_3_dots,
                                                       header_element=header)
                        time.sleep(0.5)
                        print('comment: clicking button_3_dots')
                        button_3_dots.click()

                        popup_renderer_3_dots = self.browser.find_by(
                            'ytd-menu-popup-renderer',
                            class_='ytd-menu-popup-renderer',
                            timeout=2)
                        time.sleep(1.5)

                        try:
                            self.browser.driver.execute_script(
                                "arguments[0].scrollIntoView();",
                                self.browser.find_by(
                                    'a',
                                    class_=
                                    'yt-simple-endpoint style-scope ytd-menu-navigation-item-renderer',
                                    in_element=popup_renderer_3_dots,
                                    timeout=2.5))

                            self.browser.find_by(
                                'a',
                                class_=
                                'yt-simple-endpoint style-scope ytd-menu-navigation-item-renderer',
                                in_element=popup_renderer_3_dots,
                                timeout=2.5).click()
                        except:
                            try:
                                self.browser.find_by(
                                    'ytd-menu-navigation-item-renderer',
                                    class_=
                                    'style-scope ytd-menu-popup-renderer',
                                    in_element=popup_renderer_3_dots,
                                    timeout=2.5).click()
                            except Exception as e:
                                try:
                                    self.browser.find_by(
                                        'paper-item',
                                        class_=
                                        'style-scope ytd-menu-navigation-item-renderer',
                                        in_element=popup_renderer_3_dots,
                                        timeout=2.5).click()
                                except Exception as e:
                                    pass

                        confirm_button_container = self.browser.find_by(
                            'yt-button-renderer',
                            id_='confirm-button',
                            class_=
                            'style-scope yt-confirm-dialog-renderer style-primary size-default',
                            timeout=5)

                        # confirm button
                        print('comment: clicking confirm_button')
                        self.browser.find_by(
                            'a',
                            class_=
                            'yt-simple-endpoint style-scope yt-button-renderer',
                            in_element=confirm_button_container,
                            timeout=2.5).click()
                        time.sleep(2)

                        return True, True
                    except Exception as e:
                        print(e)

                        return True, False
            except Exception as e:
                print(e)

                return True, False

            # could not find new comment
            print('no_new_comments')
            return True, False
        except Exception as e:
            print('comment error:', e)

            return False, False

    @stopit.signal_timeoutable(default=TIME_OUT_ERROR, timeout_param='timeout')
    def __login_auto(self,
                     email: str,
                     password: str,
                     timeout: Optional[float] = None) -> bool:
        self.browser.get(YT_LOGIN_URL)
        time.sleep(0.5)

        email_field = self.browser.find_by('input', {
            'id': 'identifierId',
            'type': 'email'
        })
        email_field.click()
        self.browser.send_keys_delay_random(email_field, email)
        time.sleep(1)
        self.browser.find_by('div', {
            'jscontroller': 'VXdfxd',
            'role': 'button'
        }).click()
        time.sleep(1)

        action = ActionChains(self.browser.driver)

        pass_container = self.browser.find_by('div', {
            'id': 'password',
            'jscontroller': 'pxq3x'
        })
        pass_field = self.browser.find_by('input', {'type': 'password'},
                                          in_element=pass_container)
        action.move_to_element(pass_field).perform()
        pass_field.click()
        self.browser.send_keys_delay_random(pass_field, password)
        time.sleep(1)
        self.browser.find_by('div', {
            'jscontroller': 'VXdfxd',
            'role': 'button'
        }).click()
        time.sleep(1)

        self.browser.get(YT_URL)
        time.sleep(0.5)

        return self.is_logged_in

    def __login_manual(
            self,
            login_prompt_callback: Optional[Callable[[str],
                                                     None]] = None) -> bool:
        self.browser.get(YT_LOGIN_URL)
        time.sleep(0.5)

        try:
            if login_prompt_callback is not None:
                login_prompt_callback(self.__internal_channel_id +
                                      ' needs manual input to log in.')

            input('Log in then press return')
        except Exception as e:
            print('__login_manual', e)

        self.browser.get(YT_URL)
        time.sleep(0.5)

        return self.is_logged_in

    def __dismiss_alerts(self):
        dismiss_button_container = self.browser.find_by('div',
                                                        id_='dismiss-button',
                                                        timeout=1.5)

        if dismiss_button_container:
            dismiss_button = self.browser.find_by(
                'paper-button',
                id_='button',
                timeout=0.5,
                in_element=dismiss_button_container)

            if dismiss_button:
                dismiss_button.click()

            iframe = self.browser.find_by(
                'iframe',
                class_='style-scope ytd-consent-bump-lightbox',
                timeout=2.5)

            if iframe:
                self.browser.driver.switch_to.frame(iframe)

            agree_button = self.browser.find_by('div',
                                                id_='introAgreeButton',
                                                timeout=2.5)

            if agree_button:
                agree_button.click()

            if iframe:
                self.browser.driver.switch_to.default_content()

    def __video_url(self, video_id: str) -> str:
        return YT_URL + '/watch?v=' + video_id

    def __channel_videos_url(self, channel_id: str) -> str:
        return YT_URL + '/channel/' + channel_id + '/videos?view=0&sort=da&flow=grid'


# ---------------------------------------------------------------------------------------------------------------------------------------- #s