update source

.gitignore

@@ -0,0 +1 @@
+tmp

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/kaggle-utils.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="vlsp2023-tts-api" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="vlsp2023-tts-api" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/kaggle-utils.iml" filepath="$PROJECT_DIR$/.idea/kaggle-utils.iml" />
+    </modules>
+  </component>
+</project>

cli.py

@@ -0,0 +1,51 @@
+import os
+import json
+from types import SimpleNamespace
+
+from kaggle_service import KernelRerunService, NbJob
+import argparse
+from logger import sheet_logger
+
+
+def main(args):
+    if not os.path.exists(args.config):
+        print(f"Config folder not found: {os.path.abspath(args.config)}")
+        exit(1)
+
+    configs = []
+    if os.path.isdir(args.config):
+        files = os.listdir(args.config)
+        for file in files:
+            with open(os.path.join(args.config, file), "r") as f:
+                obj = json.loads(f.read())
+                configs.append(obj)
+                print(obj)
+    elif os.path.isfile(args.config):
+        with open(args.config, "r") as f:
+            obj = json.loads(f.read())
+            configs.append(obj)
+            print(obj)
+
+    service = KernelRerunService()
+    for config in configs:
+        service.add_job(NbJob.from_dict(config))
+
+    if args.option == "run":
+        service.run_all()
+    elif args.option == "validate":
+        service.validate_all()
+    elif args.option == "status":
+        service.status_all()
+    else:
+        print(f"Invalid option: {args.option}")
+
+
+if __name__ == "__main__":
+    # parser = argparse.ArgumentParser()
+    # parser.add_argument("option", type=str, default="run", choices=["run", "validate", "status"])
+    # parser.add_argument("--config", type=str, default="./config")
+    #
+    # args = parser.parse_args()
+    args = SimpleNamespace(option="validate", config='./config')
+
+    main(args)

config/aasist-train.json

@@ -0,0 +1,8 @@
+{
+  "accounts": {
+    "hahunavth": "fb3d65ea4d06f91a83cf571e9a39d40d",
+    "mrhakk": "26780db435523a697855d5d13355744d",
+    "havthust": "c54e96568075fcc277bd10ba0e0a52b9"
+  },
+  "slug": "hahunavth/vlsp-sv-2023-aasist-train"
+}

credentials.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "vlsp2023-tts-api",
+  "private_key_id": "411335f1452da99ac34dbaeaaea212dab3ff2400",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQClPtZ/kYuBkYrP\nzbfJ/ye2DmHm4xt2o0Fvdqnuddri63662YA0GmQ+3RpH/yMg4b9Kgcyl0GXJ6Q6r\nZZzdueg3Edx5B9DkBWgYkPaTLFFe5XXOj1w2vgzc8UBN5+oomzS/WaTCpKmrs/D1\nVi05jt7Uo9mrALUkPD8wr2D9vkXQdM1G4NNxuFWCDoAF0MoVKcS5Le3f6bH4OgpL\nl5BniW4sh/UCLcWrWfXS6tuzK+8z/L6AI1ezNUJHlt58AzLjLi5Q8fOdeXviJT60\nf4w22W4gtY5YHdVCG7b7frM7ig6V9bWyVvHjGWqVkmXjYepOCIWnwQHVqja6NpVg\nR45HForBAgMBAAECggEATeqhTamdNE0iPPXtcWvEl82UUEBKFNjJ4/r6CZy8xz7v\nlL81+ltvZUzwNX6SW9DWWBV4H79yH5CrABp7qvkcC8t6P/91ee8qtFq2SZMeEzbz\nI6DphE581jlTbuiputfkOU3VqInoDzRbq/Mkg/1gCLfxzPYac6mMyjIH892iIbYP\nhlexZiXhZWRLqGFu9J3JHQAjlAtCxjhb/vBXkxzxO2j1MXv7BNrp6t7MAgFvX57k\ngRfIg/rmWohHni/NxQgWWQqTydy2JvxEVUUdPr2hgWF7hHgMk4WFbb7hzy6wH/T3\nMcjd5OHMHZcBF/NgrnxMD9NRuhD1cSbSNETJVTt9WQKBgQDS9I3MGOz5/j+jkWY7\n4CdjbbLCgat9RvvyBAkSonogLhVap1/jfKK4XQz1+aDFFY9YWW4MX/hCxKWOM5Fw\nnvDka/m2yjxha66ismflDdxvpfcjAvAt6WNX6cbiPNxFBkpJXQRH55ug9a9PKjXY\nUtc7ZOM5R/NyxfsqPjNm01faVwKBgQDIh6X0ypwCKr0CF8GP7gYPfVeK1Zh22s21\neIOEyGLB40HWOsi+PQxQHkva8teVaGMPKqppdxjs+d26d3h4Lo1rSYQrF9x+BoGm\nUU+d+3vfp1aLOj3VHMIKHKrQVOF0JSy/VdYFkz6vu6nFy3n4WdLg0XXFIQTS4Z+d\nFAD81nhEpwKBgQCqI9WNa/kNM7MuACH9Xq9F8P7BA4ZFVw/yxLBwmBx5gdF1ORMM\nTcSLf3jpljjFW7suHYq1bl2ztBh2lT7TH03YXQGdHIUQaaIC1HMY+VH1tlyZn1AJ\nJ3gZOpJOe5mIDiex/dRrDfCmJCENb1TYMRAodhkRZOeDhQwqqNoaL5BmpwKBgQCM\nWMQB67v8mETorg++2GxNcwBOHugyZzkKBWqnCEh2QsPVWBcfbkKr4Ehe2Q+hdgm+\nl7HlVoGPeeGBnBQoqQw5Rp7GOlELsyoSaV47x8MO6WNc1kpoWVRFF4NFg+K3Ez2a\nPE0qYb/B5qoP0TVwaA17Y531dgKWRWsc2N9IFiLeiQKBgQDNc2ygLHTkAKmqltcF\nzcccEnUTabPHvFkt6qycmx6oOrF6IXr1/x9ODZnwo/2JD5H/Mbub47M2k3I+BDdW\nwb0ETSEW3rdrtk85yPx3eVDIVtHoEr/Zhr9a9EYK+V8uAku3UM0L0TrnHtgqbM0W\nyGvFQOUt1hYxgoydw/Lx7h+1dA==\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "102309854252079057442",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/hahunavth%40vlsp2023-tts-api.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

google_sheet.py

@@ -0,0 +1,61 @@
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+from typing import Dict
+
+class SheetCRUDRepository:
+    def __init__(self, worksheet):
+        self.worksheet = worksheet
+        self.titles = self.worksheet.row_values(1)  # Assuming titles are in the first row
+        assert len(set(self.titles)) == len(self.titles), f"Failed to init {SheetCRUDRepository.__class__}, titles: {self.titles} contain duplicated values!"
+
+    def create(self, data: Dict):
+        values = [data.get(title, '') for title in self.titles]
+        self.worksheet.append_row(values)
+
+    def read(self, row_index: int) -> Dict:
+        """
+        return {} if empty
+        """
+        values = self.worksheet.row_values(row_index)
+        return {title: value for title, value in zip(self.titles, values)}
+
+    def update(self, row_index: int, data: Dict):
+        values = [data.get(title, '') for title in self.titles]
+        self.worksheet.update(f"A{row_index}:Z{row_index}", [values])
+
+    def delete(self, row_index: int):
+        self.worksheet.delete_row(row_index)
+
+    def find(self, search_dict):
+        for col_title, value in search_dict.items():
+            if col_title in self.titles:
+                col_index = self.titles.index(col_title) + 1  # Adding 1 to match gspread indexing
+                cell = self.worksheet.find(value, in_column=col_index)
+                if cell is None:
+                    break
+                row_number = cell.row
+                return row_number, self.read(row_number)
+        return None
+
+def create_repositories():
+    scope = [
+        'https://www.googleapis.com/auth/spreadsheets',
+        'https://www.googleapis.com/auth/drive'
+    ]
+    creds = ServiceAccountCredentials.from_json_keyfile_name('credentials.json', scope)
+    client = gspread.authorize(creds)
+    # sheet_url = "https://docs.google.com/spreadsheets/d/17OxKF0iP_aJJ0HCgJkwFsH762EUrtcEIYcPmyiiKnaM"
+    sheet_url = "https://docs.google.com/spreadsheets/d/1KzUYgWwbvYXGfyehOTyZCCQf0udZiwVXxaxpmkXEe3E/edit?usp=sharing"
+    sheet = client.open_by_url(sheet_url)
+
+    config_repository = SheetCRUDRepository(sheet.get_worksheet(0))
+    log_repository = SheetCRUDRepository(sheet.get_worksheet(1))
+    return config_repository, log_repository
+
+
+conf_repo, log_repo = create_repositories()
+
+
+if __name__ == "__main__":
+    a = create_repositories()
+    print(a)

kaggle_service.py

@@ -0,0 +1,460 @@
+import json
+import os
+from typing import Callable, List, Union, Dict
+
+# fake default account to use kaggle.api.kaggle_api_extended
+os.environ['KAGGLE_USERNAME']=''
+os.environ['KAGGLE_KEY']=''
+
+from kaggle.api.kaggle_api_extended import KaggleApi
+from kaggle.rest import ApiException
+import shutil
+import time
+import threading
+import copy
+from logger import sheet_logger
+
+
+def get_api():
+    api = KaggleApi()
+    api.authenticate()
+    return api
+
+
+class KaggleApiWrapper(KaggleApi):
+    """
+    Override KaggleApi.read_config_environment to use username and secret without environment variables
+    """
+
+    def __init__(self, username, secret):
+        super().__init__()
+        self.username = username
+        self.secret = secret
+
+    def read_config_environment(self, config_data=None, quiet=False):
+        config = super().read_config_environment(config_data, quiet)
+        config['username'] = self.username
+        config['key'] = self.secret
+        config['proxy'] = "http://proxy.server:3128"
+
+        return config_data
+
+    def __del__(self):
+        # todo: fix bug when delete api
+        pass
+
+
+class KaggleNotebook:
+    def __init__(self, api: KaggleApi, kernel_slug: str, container_path: str = "./tmp"):
+        """
+        :param api: KaggleApi
+        :param kernel_slug: Notebook id, you can find it in the url of the notebook.
+                            For example, `username/notebook-name-123456`
+        :param container_path: Path to the local folder where the notebook will be downloaded
+        """
+        self.api = api
+        self.kernel_slug = kernel_slug
+        self.container_path = container_path
+
+    def status(self) -> str or None:
+        """
+        :return:
+            "running"
+            "cancelAcknowledged"
+            "queued": waiting for run
+            "error": when raise exception in notebook
+        Throw exception when failed
+        """
+        res = self.api.kernels_status(self.kernel_slug)
+        print(f"Status: {res}")
+        if res is None:
+            return None
+        return res['status']
+
+    def _get_local_nb_path(self) -> str:
+        return os.path.join(self.container_path, self.kernel_slug)
+
+    def pull(self, path=None) -> str or None:
+        """
+
+        :param path:
+        :return:
+        :raises: ApiException if notebook not found or not share to user
+        """
+        self._clean()
+        path = path or self._get_local_nb_path()
+        metadata_path = os.path.join(path, "kernel-metadata.json")
+        res = self.api.kernels_pull(self.kernel_slug, path=path, metadata=True, quiet=False)
+        if not os.path.exists(metadata_path):
+            print(f"Warn: Not found {metadata_path}. Clean {path}")
+            self._clean()
+            return None
+        return res
+
+    def push(self, path=None) -> str or None:
+        status = self.status()
+        if status in ['queued', 'running']:
+            print("Warn: Notebook is " + status + ". Skip push notebook!")
+            return None
+
+        self.api.kernels_push(path or self._get_local_nb_path())
+        time.sleep(1)
+        status = self.status()
+        return status
+
+    def _clean(self) -> None:
+        if os.path.exists(self._get_local_nb_path()):
+            shutil.rmtree(self._get_local_nb_path())
+
+    def get_metadata(self, path=None):
+        path = path or self._get_local_nb_path()
+        metadata_path = os.path.join(path, "kernel-metadata.json")
+        if not os.path.exists(metadata_path):
+            return None
+        return json.loads(open(metadata_path).read())
+
+    def check_nb_permission(self) -> Union[tuple[bool], tuple[bool, None]]:
+        try:
+            status = self.status()
+            if status is None:
+                return False, status
+            return True, status
+        except ApiException as e:
+            print(f"Error: {e.status} {e.reason} with notebook {self.kernel_slug}")
+            return False, None
+
+    def check_datasets_permission(self) -> bool:
+        meta = self.get_metadata()
+        if meta is None:
+            print("Warn: cannot get metadata. Pull and try again?")
+        dataset_sources = meta['dataset_sources']
+        for dataset in dataset_sources:
+            try:
+                self.api.dataset_status(dataset)
+            except ApiException as e:
+                print(f"Error: {e.status} {e.reason} with dataset {dataset} in notebook {self.kernel_slug}")
+                return False
+        return True
+
+
+class AccountTransactionManager:
+    def __init__(self, acc_secret_dict: dict=None):
+        """
+        :param acc_secret_dict: {username: secret}
+        """
+        self.acc_secret_dict = acc_secret_dict
+        if self.acc_secret_dict is None:
+            self.acc_secret_dict = {}
+        # self.api_dict = {username: KaggleApiWrapper(username, secret) for username, secret in acc_secret_dict.items()}
+        # lock for each account to avoid concurrent use api
+        self.lock_dict = {username: False for username in self.acc_secret_dict.keys()}
+        self.state_lock = threading.Lock()
+
+    def _get_api(self, username: str) -> KaggleApiWrapper:
+        # return self.api_dict[username]
+        return KaggleApiWrapper(username, self.acc_secret_dict[username])
+
+    def _get_lock(self, username: str) -> bool:
+        return self.lock_dict[username]
+
+    def _set_lock(self, username: str, lock: bool) -> None:
+        self.lock_dict[username] = lock
+
+    def add_account(self, username, secret):
+        if username not in self.acc_secret_dict.keys():
+            self.state_lock.acquire()
+            self.acc_secret_dict[username] = secret
+            self.lock_dict[username] = False
+            self.state_lock.release()
+
+    def remove_account(self, username):
+        if username in self.acc_secret_dict.keys():
+            self.state_lock.acquire()
+            del self.acc_secret_dict[username]
+            del self.lock_dict[username]
+            self.state_lock.release()
+        else:
+            print(f"Warn: try to remove account not in the list: {username}, list: {self.acc_secret_dict.keys()}")
+
+    def get_unlocked_api_unblocking(self, username_list: List[str]) -> tuple[KaggleApiWrapper, Callable[[], None]]:
+        """
+        :param username_list: list of username
+        :return: (api, release) where release is a function to release api
+        """
+        while True:
+            print("get_unlocked_api_unblocking" + str(username_list))
+            for username in username_list:
+                self.state_lock.acquire()
+                if not self._get_lock(username):
+                    self._set_lock(username, True)
+                    api = self._get_api(username)
+
+                    def release():
+                        self.state_lock.acquire()
+                        self._set_lock(username, False)
+                        api.__del__()
+                        self.state_lock.release()
+
+                    self.state_lock.release()
+                    return api, release
+                self.state_lock.release()
+            time.sleep(1)
+
+
+class NbJob:
+    def __init__(self, acc_dict: dict, nb_slug: str, rerun_stt: List[str] = None, not_rerun_stt: List[str] = None):
+        """
+
+        :param acc_dict:
+        :param nb_slug:
+        :param rerun_stt:
+        :param not_rerun_stt: If notebook status in this list, do not rerun it. (Note: do not add "queued", "running")
+        """
+        self.rerun_stt = rerun_stt
+        if self.rerun_stt is None:
+            self.rerun_stt = ['complete']
+        self.not_rerun_stt = not_rerun_stt
+
+        if self.not_rerun_stt is None:
+            self.not_rerun_stt = ['queued', 'running', 'cancelAcknowledged']
+        assert "queued" in self.not_rerun_stt
+        assert "running" in self.not_rerun_stt
+
+        self.acc_dict = acc_dict
+        self.nb_slug = nb_slug
+
+    def get_acc_dict(self):
+        return self.acc_dict
+
+    def get_username_list(self):
+        return list(self.acc_dict.keys())
+
+    def is_valid_with_acc(self, api):
+        notebook = KaggleNotebook(api, self.nb_slug)
+        try:
+            notebook.pull()
+        except ApiException as e:
+            return False
+        stt, _ = notebook.check_nb_permission()
+        if not stt:
+            return False
+        stt = notebook.check_datasets_permission()
+        if not stt:
+            return False
+        return True
+
+    def is_valid(self):
+        for username in self.acc_dict.keys():
+            secrets = self.acc_dict[username]
+            api = KaggleApiWrapper(username=username, secret=secrets)
+            api.authenticate()
+            if not self.is_valid_with_acc(api):
+                return False
+        return True
+
+    def acc_check_and_rerun_if_need(self, api: KaggleApi) -> bool:
+        """
+        :return:
+            True if rerun success or notebook is running
+            False user does not have enough gpu quotas
+        :raises
+            Exception if setup error
+        """
+        notebook = KaggleNotebook(api, self.nb_slug, "./tmp")  # todo: change hardcode container_path here
+
+        notebook.pull()
+        assert notebook.check_datasets_permission(), f"User {api} does not have permission on datasets of notebook {self.nb_slug}"
+        success, status1 = notebook.check_nb_permission()
+        assert success, f"User {api} does not have permission on notebook {self.nb_slug}"  # todo: using api.username
+
+        if status1 in self.rerun_stt:
+            status2 = notebook.push()
+            time.sleep(10)
+            status3 = notebook.status()
+
+            # if 3 times same stt -> acc out of quota
+            if status1 == status2 == status3:
+                sheet_logger.log(username=api.username, nb=self.nb_slug, log="Try but no effect. Seem account to be out of quota")
+                return False
+            if status3 in self.not_rerun_stt:
+                sheet_logger.log(username=api.username, nb=self.nb_slug, log=f"Notebook is in ignore status list {self.not_rerun_stt}, do nothing!")
+                return True
+            if status3 not in ["queued", "running"]:
+                # return False # todo: check when user is out of quota
+                print(f"Error: status is {status3}")
+                raise Exception("Setup exception")
+            sheet_logger.log(username=api.username, nb=self.nb_slug,
+                             log=f"Schedule notebook successfully. Current status is '{status3}'")
+            return True
+
+        sheet_logger.log(username=api.username, nb=self.nb_slug, log=f"Notebook status is '{status1}' is not in {self.rerun_stt}, do nothing!")
+        return True
+
+    @staticmethod
+    def from_dict(obj: dict):
+        return NbJob(acc_dict=obj['accounts'], nb_slug=obj['slug'], rerun_stt=obj.get('rerun_status'), not_rerun_stt=obj.get('not_rerun_stt'))
+
+
+class KernelRerunService:
+    def __init__(self):
+        self.jobs: Dict[str, NbJob] = {}
+        self.acc_manager = AccountTransactionManager()
+        self.username2jobid = {}
+        self.jobid2username = {}
+
+    def add_job(self, nb_job: NbJob):
+        if nb_job.nb_slug in self.jobs.keys():
+            print("Warn: nb_job already in job list")
+            return
+        self.jobs[nb_job.nb_slug] = nb_job
+        self.jobid2username[nb_job.nb_slug] = nb_job.get_username_list()
+        for username in nb_job.get_username_list():
+            if username not in self.username2jobid.keys():
+                self.username2jobid[username] = []
+                self.acc_manager.add_account(username, nb_job.acc_dict[username])
+            self.username2jobid[username].append(nb_job.nb_slug)
+
+    def remove_job(self, nb_job):
+        if nb_job.nb_slug not in self.jobs.keys():
+            print("Warn: try to remove nb_job not in list")
+            return
+        username_list = self.jobid2username[nb_job.nb_slug]
+        username_list = [username for username in username_list if len(self.username2jobid[username]) == 1]
+
+        for username in username_list:
+            del self.username2jobid[username]
+            self.acc_manager.remove_account(username)
+        del self.jobs[nb_job.nb_slug]
+        del self.jobid2username[nb_job.nb_slug]
+
+    def validate_all(self):
+        for username in self.acc_manager.acc_secret_dict.keys():
+            api, release = self.acc_manager.get_unlocked_api_unblocking([username])
+            api.authenticate()
+            print(f"Using username: {api.username}")
+
+            for job in self.jobs.values():
+                if username in job.get_username_list():
+                    print(f"Validate user: {username}, job: {job.nb_slug}")
+                    if not job.is_valid_with_acc(api):
+                        print(f"Error: not valid")
+                        a = f"Setup error: {username} does not have permission on notebook {job.nb_slug} or related datasets"
+                        raise Exception(a)
+            release()
+        return True
+
+    def status_all(self):
+        for job in self.jobs.values():
+            print(f"Job: {job.nb_slug}")
+            api, release = self.acc_manager.get_unlocked_api_unblocking(job.get_username_list())
+            api.authenticate()
+            print(f"Using username: {api.username}")
+            notebook = KaggleNotebook(api, job.nb_slug)
+            print(f"Notebook: {notebook.kernel_slug}")
+            print(notebook.status())
+            release()
+
+    def run(self, nb_job: NbJob):
+        username_list = copy.copy(nb_job.get_username_list())
+        while len(username_list) > 0:
+            api, release = self.acc_manager.get_unlocked_api_unblocking(username_list)
+            api.authenticate()
+            print(f"Using username: {api.username}")
+
+            try:
+                result = nb_job.acc_check_and_rerun_if_need(api)
+                if result:
+                    return True
+            except Exception as e:
+                print(e)
+                release()
+                break
+
+            if api.username in username_list:
+                username_list.remove(api.username)
+                release()
+            else:
+                release()
+                raise Exception("")
+        return False
+
+    def run_all(self):
+        for job in self.jobs.values():
+            success = self.run(job)
+            print(f"Job: {job.nb_slug} {success}")
+
+
+if __name__ == "__main__":
+    service = KernelRerunService()
+    files = os.listdir("./config")
+    for file in files:
+        if '.example' not in file:
+            with open(os.path.join("./config", file), "r") as f:
+                obj = json.loads(f.read())
+                print(obj)
+                service.add_job(NbJob.from_dict(obj))
+    service.run_all()
+
+    # try:
+    #     acc_secret_dict = {
+    #         "hahunavth": "secret",
+    #         "hahunavth2": "secret",
+    #         "hahunavth3": "secret",
+    #         "hahunavth4": "secret",
+    #         "hahunavth5": "secret",
+    #     }
+    #     acc_manager = AccountTransactionManager(acc_secret_dict)
+    #
+    #
+    #     def test1():
+    #         username_list = ["hahunavth", "hahunavth2", "hahunavth3", "hahunavth4", "hahunavth5"]
+    #         while len(username_list) > 0:
+    #             api, release = acc_manager.get_unlocked_api_unblocking(username_list)
+    #             print("test1 is using " + api.username)
+    #             time.sleep(1)
+    #             release()
+    #             if api.username in username_list:
+    #                 username_list.remove(api.username)
+    #             else:
+    #                 raise Exception("")
+    #             print("test1 release " + api.username)
+    #
+    #
+    #     def test2():
+    #         username_list = ["hahunavth2", "hahunavth3", "hahunavth5"]
+    #         while len(username_list) > 0:
+    #             api, release = acc_manager.get_unlocked_api_unblocking(username_list)
+    #             print("test2 is using " + api.username)
+    #             time.sleep(3)
+    #             release()
+    #             if api.username in username_list:
+    #                 username_list.remove(api.username)
+    #             else:
+    #                 raise Exception("")
+    #             print("test2 release " + api.username)
+    #
+    #
+    #     t1 = threading.Thread(target=test1)
+    #     t2 = threading.Thread(target=test2)
+    #     t1.start()
+    #     t2.start()
+    #     t1.join()
+    #     t2.join()
+    #
+    #     # kgapi = KaggleApiWrapper("hahunavth", "fb3d65ea4d06f91a83cf571e9a39d40d")
+    #     # kgapi.authenticate()
+    #     # # kgapi = get_api()
+    #     # notebook = KaggleNotebook(kgapi, "hahunavth/ess-vlsp2023-denoising", "./tmp")
+    #     # # print(notebook.pull())
+    #     # # print(notebook.check_datasets_permission())
+    #     # print(notebook.check_nb_permission())
+    #     # # print(notebook.status())
+    #     # # notebook.push()
+    #     # # print(notebook.status())
+    # except ApiException as e:
+    #     print(e.status)
+    #     print(e.reason)
+    #     raise e
+    #     # 403 when nb not exists or not share to acc
+    #     # 404 when push to unknow kenel_slug.username
+    #     # 401 when invalid username, pass

logger.py

@@ -0,0 +1,40 @@
+import platform,socket,re,uuid,json,psutil,logging
+from datetime import datetime as dt
+from google_sheet import log_repo
+
+
+version="v1.0.0"
+
+
+def get_sys_info():
+    try:
+        info={}
+        info['platform']=platform.system()
+        info['platform-release']=platform.release()
+        info['platform-version']=platform.version()
+        info['architecture']=platform.machine()
+        info['hostname']=socket.gethostname()
+        info['ip-address']=socket.gethostbyname(socket.gethostname())
+        info['mac-address']=':'.join(re.findall('..', '%012x' % uuid.getnode()))
+        info['processor']=platform.processor()
+        info['ram']=str(round(psutil.virtual_memory().total / (1024.0 **3)))+" GB"
+        return json.dumps(info)
+    except Exception as e:
+        logging.exception(e)
+
+
+class SheetLogger:
+    def __init__(self, log_repo):
+        self.log_repo = log_repo
+
+    def log(self, log='', nb='', username=''):
+        self.log_repo.create({
+            "time": str(dt.now()),
+            "notebook_name": nb,
+            "kaggle_username": username,
+            "log": log,
+            "device": str(get_sys_info()),
+            "version": version
+        })
+
+sheet_logger = SheetLogger(log_repo)

main.py

@@ -0,0 +1,31 @@
+from google_sheet import conf_repo
+import json
+
+from kaggle_service import KernelRerunService, NbJob
+from logger import sheet_logger
+
+
+# if __name__ == "__main__":
+configs = []
+try:
+    for i in range(2, 1000):
+        rs = conf_repo.read(i)
+        if not rs:
+            break
+        cfg = json.loads(rs['config'])
+        configs.append(cfg)
+        print(cfg)
+except Exception as e:
+    sheet_logger.log(log="Get config failed!!")
+
+service = KernelRerunService()
+for config in configs:
+    service.add_job(NbJob.from_dict(config))
+
+try:
+    service.validate_all()
+    service.status_all()
+    service.run_all()
+except Exception as e:
+    sheet_logger.log(log=str(e))
+

merged_file.py

@@ -0,0 +1,516 @@
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+from typing import Dict
+
+
+class SheetCRUDRepository:
+    def __init__(self, worksheet):
+        self.worksheet = worksheet
+        self.titles = self.worksheet.row_values(1)  # Assuming titles are in the first row
+        assert len(set(self.titles)) == len(self.titles), f"Failed to init {SheetCRUDRepository.__class__}, titles: {self.titles} contain duplicated values!"
+
+    def create(self, data: Dict):
+        values = [data.get(title, '') for title in self.titles]
+        self.worksheet.append_row(values)
+
+    def read(self, row_index: int) -> Dict:
+        """
+        return {} if empty
+        """
+        values = self.worksheet.row_values(row_index)
+        return {title: value for title, value in zip(self.titles, values)}
+
+    def update(self, row_index: int, data: Dict):
+        values = [data.get(title, '') for title in self.titles]
+        self.worksheet.update(f"A{row_index}:Z{row_index}", [values])
+
+    def delete(self, row_index: int):
+        self.worksheet.delete_row(row_index)
+
+    def find(self, search_dict):
+        for col_title, value in search_dict.items():
+            if col_title in self.titles:
+                col_index = self.titles.index(col_title) + 1  # Adding 1 to match gspread indexing
+                cell = self.worksheet.find(value, in_column=col_index)
+                if cell is None:
+                    break
+                row_number = cell.row
+                return row_number, self.read(row_number)
+        return None
+
+def create_repositories():
+    scope = [
+        'https://www.googleapis.com/auth/spreadsheets',
+        'https://www.googleapis.com/auth/drive'
+    ]
+    creds = ServiceAccountCredentials.from_json_keyfile_name('credentials.json', scope)
+    client = gspread.authorize(creds)
+    # sheet_url = "https://docs.google.com/spreadsheets/d/17OxKF0iP_aJJ0HCgJkwFsH762EUrtcEIYcPmyiiKnaM"
+    sheet_url = "https://docs.google.com/spreadsheets/d/1KzUYgWwbvYXGfyehOTyZCCQf0udZiwVXxaxpmkXEe3E/edit?usp=sharing"
+    sheet = client.open_by_url(sheet_url)
+
+    config_repository = SheetCRUDRepository(sheet.get_worksheet(0))
+    log_repository = SheetCRUDRepository(sheet.get_worksheet(1))
+    return config_repository, log_repository
+
+
+conf_repo, log_repo = create_repositories()
+
+
+import platform,socket,re,uuid,json,psutil,logging
+from datetime import datetime as dt
+from google_sheet import log_repo
+
+
+version="v1.0.0"
+
+
+def get_sys_info():
+    try:
+        info={}
+        info['platform']=platform.system()
+        info['platform-release']=platform.release()
+        info['platform-version']=platform.version()
+        info['architecture']=platform.machine()
+        info['hostname']=socket.gethostname()
+        info['ip-address']=socket.gethostbyname(socket.gethostname())
+        info['mac-address']=':'.join(re.findall('..', '%012x' % uuid.getnode()))
+        info['processor']=platform.processor()
+        info['ram']=str(round(psutil.virtual_memory().total / (1024.0 **3)))+" GB"
+        return json.dumps(info)
+    except Exception as e:
+        logging.exception(e)
+
+
+class SheetLogger:
+    def __init__(self, log_repo):
+        self.log_repo = log_repo
+
+    def log(self, log='', nb='', username=''):
+        self.log_repo.create({
+            "time": str(dt.now()),
+            "notebook_name": nb,
+            "kaggle_username": username,
+            "log": log,
+            "device": str(get_sys_info()),
+            "version": version
+        })
+
+sheet_logger = SheetLogger(log_repo)
+
+import json
+import os
+from typing import Callable, List, Union, Dict
+
+# fake default account to use kaggle.api.kaggle_api_extended
+os.environ['KAGGLE_USERNAME']=''
+os.environ['KAGGLE_KEY']=''
+
+from kaggle.api.kaggle_api_extended import KaggleApi
+from kaggle.rest import ApiException
+import shutil
+import time
+import threading
+import copy
+from logger import sheet_logger
+
+
+def get_api():
+    api = KaggleApi()
+    api.authenticate()
+    return api
+
+
+class KaggleApiWrapper(KaggleApi):
+    """
+    Override KaggleApi.read_config_environment to use username and secret without environment variables
+    """
+
+    def __init__(self, username, secret):
+        super().__init__()
+        self.username = username
+        self.secret = secret
+
+    def read_config_environment(self, config_data=None, quiet=False):
+        config = super().read_config_environment(config_data, quiet)
+        config['username'] = self.username
+        config['key'] = self.secret
+
+        return config_data
+
+    def __del__(self):
+        # todo: fix bug when delete api
+        pass
+
+
+class KaggleNotebook:
+    def __init__(self, api: KaggleApi, kernel_slug: str, container_path: str = "./tmp"):
+        """
+        :param api: KaggleApi
+        :param kernel_slug: Notebook id, you can find it in the url of the notebook.
+                            For example, `username/notebook-name-123456`
+        :param container_path: Path to the local folder where the notebook will be downloaded
+        """
+        self.api = api
+        self.kernel_slug = kernel_slug
+        self.container_path = container_path
+
+    def status(self) -> str or None:
+        """
+        :return:
+            "running"
+            "cancelAcknowledged"
+            "queued": waiting for run
+            "error": when raise exception in notebook
+        Throw exception when failed
+        """
+        res = self.api.kernels_status(self.kernel_slug)
+        print(f"Status: {res}")
+        if res is None:
+            return None
+        return res['status']
+
+    def _get_local_nb_path(self) -> str:
+        return os.path.join(self.container_path, self.kernel_slug)
+
+    def pull(self, path=None) -> str or None:
+        """
+
+        :param path:
+        :return:
+        :raises: ApiException if notebook not found or not share to user
+        """
+        self._clean()
+        path = path or self._get_local_nb_path()
+        metadata_path = os.path.join(path, "kernel-metadata.json")
+        res = self.api.kernels_pull(self.kernel_slug, path=path, metadata=True, quiet=False)
+        if not os.path.exists(metadata_path):
+            print(f"Warn: Not found {metadata_path}. Clean {path}")
+            self._clean()
+            return None
+        return res
+
+    def push(self, path=None) -> str or None:
+        status = self.status()
+        if status in ['queued', 'running']:
+            print("Warn: Notebook is " + status + ". Skip push notebook!")
+            return None
+
+        self.api.kernels_push(path or self._get_local_nb_path())
+        time.sleep(1)
+        status = self.status()
+        return status
+
+    def _clean(self) -> None:
+        if os.path.exists(self._get_local_nb_path()):
+            shutil.rmtree(self._get_local_nb_path())
+
+    def get_metadata(self, path=None):
+        path = path or self._get_local_nb_path()
+        metadata_path = os.path.join(path, "kernel-metadata.json")
+        if not os.path.exists(metadata_path):
+            return None
+        return json.loads(open(metadata_path).read())
+
+    def check_nb_permission(self) -> Union[tuple[bool], tuple[bool, None]]:
+        try:
+            status = self.status()
+            if status is None:
+                return False, status
+            return True, status
+        except ApiException as e:
+            print(f"Error: {e.status} {e.reason} with notebook {self.kernel_slug}")
+            return False, None
+
+    def check_datasets_permission(self) -> bool:
+        meta = self.get_metadata()
+        if meta is None:
+            print("Warn: cannot get metadata. Pull and try again?")
+        dataset_sources = meta['dataset_sources']
+        for dataset in dataset_sources:
+            try:
+                self.api.dataset_status(dataset)
+            except ApiException as e:
+                print(f"Error: {e.status} {e.reason} with dataset {dataset} in notebook {self.kernel_slug}")
+                return False
+        return True
+
+
+class AccountTransactionManager:
+    def __init__(self, acc_secret_dict: dict=None):
+        """
+        :param acc_secret_dict: {username: secret}
+        """
+        self.acc_secret_dict = acc_secret_dict
+        if self.acc_secret_dict is None:
+            self.acc_secret_dict = {}
+        # self.api_dict = {username: KaggleApiWrapper(username, secret) for username, secret in acc_secret_dict.items()}
+        # lock for each account to avoid concurrent use api
+        self.lock_dict = {username: False for username in self.acc_secret_dict.keys()}
+        self.state_lock = threading.Lock()
+
+    def _get_api(self, username: str) -> KaggleApiWrapper:
+        # return self.api_dict[username]
+        return KaggleApiWrapper(username, self.acc_secret_dict[username])
+
+    def _get_lock(self, username: str) -> bool:
+        return self.lock_dict[username]
+
+    def _set_lock(self, username: str, lock: bool) -> None:
+        self.lock_dict[username] = lock
+
+    def add_account(self, username, secret):
+        if username not in self.acc_secret_dict.keys():
+            self.state_lock.acquire()
+            self.acc_secret_dict[username] = secret
+            self.lock_dict[username] = False
+            self.state_lock.release()
+
+    def remove_account(self, username):
+        if username in self.acc_secret_dict.keys():
+            self.state_lock.acquire()
+            del self.acc_secret_dict[username]
+            del self.lock_dict[username]
+            self.state_lock.release()
+        else:
+            print(f"Warn: try to remove account not in the list: {username}, list: {self.acc_secret_dict.keys()}")
+
+    def get_unlocked_api_unblocking(self, username_list: List[str]) -> tuple[KaggleApiWrapper, Callable[[], None]]:
+        """
+        :param username_list: list of username
+        :return: (api, release) where release is a function to release api
+        """
+        while True:
+            print("get_unlocked_api_unblocking" + str(username_list))
+            for username in username_list:
+                self.state_lock.acquire()
+                if not self._get_lock(username):
+                    self._set_lock(username, True)
+                    api = self._get_api(username)
+
+                    def release():
+                        self.state_lock.acquire()
+                        self._set_lock(username, False)
+                        api.__del__()
+                        self.state_lock.release()
+
+                    self.state_lock.release()
+                    return api, release
+                self.state_lock.release()
+            time.sleep(1)
+
+
+class NbJob:
+    def __init__(self, acc_dict: dict, nb_slug: str, rerun_stt: List[str] = None, not_rerun_stt: List[str] = None):
+        """
+
+        :param acc_dict:
+        :param nb_slug:
+        :param rerun_stt:
+        :param not_rerun_stt: If notebook status in this list, do not rerun it. (Note: do not add "queued", "running")
+        """
+        self.rerun_stt = rerun_stt
+        if self.rerun_stt is None:
+            self.rerun_stt = ['complete']
+        self.not_rerun_stt = not_rerun_stt
+
+        if self.not_rerun_stt is None:
+            self.not_rerun_stt = ['queued', 'running', 'cancelAcknowledged']
+        assert "queued" in self.not_rerun_stt
+        assert "running" in self.not_rerun_stt
+
+        self.acc_dict = acc_dict
+        self.nb_slug = nb_slug
+
+    def get_acc_dict(self):
+        return self.acc_dict
+
+    def get_username_list(self):
+        return list(self.acc_dict.keys())
+
+    def is_valid_with_acc(self, api):
+        notebook = KaggleNotebook(api, self.nb_slug)
+        try:
+            notebook.pull()
+        except ApiException as e:
+            return False
+        stt, _ = notebook.check_nb_permission()
+        if not stt:
+            return False
+        stt = notebook.check_datasets_permission()
+        if not stt:
+            return False
+        return True
+
+    def is_valid(self):
+        for username in self.acc_dict.keys():
+            secrets = self.acc_dict[username]
+            api = KaggleApiWrapper(username=username, secret=secrets)
+            api.authenticate()
+            if not self.is_valid_with_acc(api):
+                return False
+        return True
+
+    def acc_check_and_rerun_if_need(self, api: KaggleApi) -> bool:
+        """
+        :return:
+            True if rerun success or notebook is running
+            False user does not have enough gpu quotas
+        :raises
+            Exception if setup error
+        """
+        notebook = KaggleNotebook(api, self.nb_slug, "./tmp")  # todo: change hardcode container_path here
+
+        notebook.pull()
+        assert notebook.check_datasets_permission(), f"User {api} does not have permission on datasets of notebook {self.nb_slug}"
+        success, status1 = notebook.check_nb_permission()
+        assert success, f"User {api} does not have permission on notebook {self.nb_slug}"  # todo: using api.username
+
+        if status1 in self.rerun_stt:
+            status2 = notebook.push()
+            time.sleep(10)
+            status3 = notebook.status()
+
+            # if 3 times same stt -> acc out of quota
+            if status1 == status2 == status3:
+                sheet_logger.log(username=api.username, nb=self.nb_slug, log="Try but no effect. Seem account to be out of quota")
+                return False
+            if status3 in self.not_rerun_stt:
+                sheet_logger.log(username=api.username, nb=self.nb_slug, log=f"Notebook is in ignore status list {self.not_rerun_stt}, do nothing!")
+                return True
+            if status3 not in ["queued", "running"]:
+                # return False # todo: check when user is out of quota
+                print(f"Error: status is {status3}")
+                raise Exception("Setup exception")
+            sheet_logger.log(username=api.username, nb=self.nb_slug,
+                             log=f"Schedule notebook successfully. Current status is '{status3}'")
+            return True
+
+        sheet_logger.log(username=api.username, nb=self.nb_slug, log=f"Notebook status is '{status1}' is not in {self.rerun_stt}, do nothing!")
+        return True
+
+    @staticmethod
+    def from_dict(obj: dict):
+        return NbJob(acc_dict=obj['accounts'], nb_slug=obj['slug'], rerun_stt=obj.get('rerun_status'), not_rerun_stt=obj.get('not_rerun_stt'))
+
+
+class KernelRerunService:
+    def __init__(self):
+        self.jobs: Dict[str, NbJob] = {}
+        self.acc_manager = AccountTransactionManager()
+        self.username2jobid = {}
+        self.jobid2username = {}
+
+    def add_job(self, nb_job: NbJob):
+        if nb_job.nb_slug in self.jobs.keys():
+            print("Warn: nb_job already in job list")
+            return
+        self.jobs[nb_job.nb_slug] = nb_job
+        self.jobid2username[nb_job.nb_slug] = nb_job.get_username_list()
+        for username in nb_job.get_username_list():
+            if username not in self.username2jobid.keys():
+                self.username2jobid[username] = []
+                self.acc_manager.add_account(username, nb_job.acc_dict[username])
+            self.username2jobid[username].append(nb_job.nb_slug)
+
+    def remove_job(self, nb_job):
+        if nb_job.nb_slug not in self.jobs.keys():
+            print("Warn: try to remove nb_job not in list")
+            return
+        username_list = self.jobid2username[nb_job.nb_slug]
+        username_list = [username for username in username_list if len(self.username2jobid[username]) == 1]
+
+        for username in username_list:
+            del self.username2jobid[username]
+            self.acc_manager.remove_account(username)
+        del self.jobs[nb_job.nb_slug]
+        del self.jobid2username[nb_job.nb_slug]
+
+    def validate_all(self):
+        for username in self.acc_manager.acc_secret_dict.keys():
+            api, release = self.acc_manager.get_unlocked_api_unblocking([username])
+            api.authenticate()
+            print(f"Using username: {api.username}")
+
+            for job in self.jobs.values():
+                if username in job.get_username_list():
+                    print(f"Validate user: {username}, job: {job.nb_slug}")
+                    if not job.is_valid_with_acc(api):
+                        print(f"Error: not valid")
+                        a = f"Setup error: {username} does not have permission on notebook {job.nb_slug} or related datasets"
+                        raise Exception(a)
+            release()
+        return True
+
+    def status_all(self):
+        for job in self.jobs.values():
+            print(f"Job: {job.nb_slug}")
+            api, release = self.acc_manager.get_unlocked_api_unblocking(job.get_username_list())
+            api.authenticate()
+            print(f"Using username: {api.username}")
+            notebook = KaggleNotebook(api, job.nb_slug)
+            print(f"Notebook: {notebook.kernel_slug}")
+            print(notebook.status())
+            release()
+
+    def run(self, nb_job: NbJob):
+        username_list = copy.copy(nb_job.get_username_list())
+        while len(username_list) > 0:
+            api, release = self.acc_manager.get_unlocked_api_unblocking(username_list)
+            api.authenticate()
+            print(f"Using username: {api.username}")
+
+            try:
+                result = nb_job.acc_check_and_rerun_if_need(api)
+                if result:
+                    return True
+            except Exception as e:
+                print(e)
+                release()
+                break
+
+            if api.username in username_list:
+                username_list.remove(api.username)
+                release()
+            else:
+                release()
+                raise Exception("")
+        return False
+
+    def run_all(self):
+        for job in self.jobs.values():
+            success = self.run(job)
+            print(f"Job: {job.nb_slug} {success}")
+
+
+
+import json
+
+from kaggle_service import KernelRerunService, NbJob
+from logger import sheet_logger
+
+
+if __name__ == "__main__":
+    configs = []
+    try:
+        for i in range(2, 1000):
+            rs = conf_repo.read(i)
+            if not rs:
+                break
+            cfg = json.loads(rs['config'])
+            configs.append(cfg)
+            print(cfg)
+    except Exception as e:
+        sheet_logger.log(log="Get config failed!!")
+
+    service = KernelRerunService()
+    for config in configs:
+        service.add_job(NbJob.from_dict(config))
+
+    try:
+        service.validate_all()
+        service.status_all()
+        service.run_all()
+    except Exception as e:
+        sheet_logger.log(log=str(e))
+

requirements.txt

@@ -0,0 +1,3 @@
+kaggle
+gspread
+oauth2client

test.ipynb

@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2023-11-05T00:47:48.131663100Z",
+     "start_time": "2023-11-05T00:47:35.527891600Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting kaggle\r\n",
+      "  Downloading kaggle-1.5.16.tar.gz (83 kB)\r\n",
+      "\u001B[2K     \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m83.6/83.6 kB\u001B[0m \u001B[31m444.7 kB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0m0:01\u001B[0m00:01\u001B[0m\r\n",
+      "\u001B[?25h  Preparing metadata (setup.py) ... \u001B[?25ldone\r\n",
+      "\u001B[?25hRequirement already satisfied: six>=1.10 in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (1.16.0)\r\n",
+      "Requirement already satisfied: certifi in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (2023.7.22)\r\n",
+      "Requirement already satisfied: python-dateutil in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (2.8.2)\r\n",
+      "Requirement already satisfied: requests in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (2.31.0)\r\n",
+      "Collecting tqdm (from kaggle)\r\n",
+      "  Downloading tqdm-4.66.1-py3-none-any.whl.metadata (57 kB)\r\n",
+      "\u001B[2K     \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m57.6/57.6 kB\u001B[0m \u001B[31m332.3 kB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0m \u001B[36m0:00:01\u001B[0m\r\n",
+      "\u001B[?25hCollecting python-slugify (from kaggle)\r\n",
+      "  Downloading python_slugify-8.0.1-py2.py3-none-any.whl (9.7 kB)\r\n",
+      "Requirement already satisfied: urllib3 in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (2.0.7)\r\n",
+      "Requirement already satisfied: bleach in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from kaggle) (6.1.0)\r\n",
+      "Requirement already satisfied: webencodings in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from bleach->kaggle) (0.5.1)\r\n",
+      "Collecting text-unidecode>=1.3 (from python-slugify->kaggle)\r\n",
+      "  Downloading text_unidecode-1.3-py2.py3-none-any.whl (78 kB)\r\n",
+      "\u001B[2K     \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m78.2/78.2 kB\u001B[0m \u001B[31m944.9 kB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0ma \u001B[36m0:00:01\u001B[0m\r\n",
+      "\u001B[?25hRequirement already satisfied: charset-normalizer<4,>=2 in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from requests->kaggle) (3.3.1)\r\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /home/kryo/miniconda3/envs/vlsp2023-tts-api/lib/python3.10/site-packages (from requests->kaggle) (3.4)\r\n",
+      "Downloading tqdm-4.66.1-py3-none-any.whl (78 kB)\r\n",
+      "\u001B[2K   \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m78.3/78.3 kB\u001B[0m \u001B[31m748.5 kB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0m \u001B[36m0:00:01\u001B[0m\r\n",
+      "\u001B[?25hBuilding wheels for collected packages: kaggle\r\n",
+      "  Building wheel for kaggle (setup.py) ... \u001B[?25ldone\r\n",
+      "\u001B[?25h  Created wheel for kaggle: filename=kaggle-1.5.16-py3-none-any.whl size=110683 sha256=fbd426d35c51820adb030ee423c20d997221fd1cdb7093a4b6af3afa94d170f3\r\n",
+      "  Stored in directory: /home/kryo/.cache/pip/wheels/43/4b/fb/736478af5e8004810081a06259f9aa2f7c3329fc5d03c2c412\r\n",
+      "Successfully built kaggle\r\n",
+      "Installing collected packages: text-unidecode, tqdm, python-slugify, kaggle\r\n",
+      "Successfully installed kaggle-1.5.16 python-slugify-8.0.1 text-unidecode-1.3 tqdm-4.66.1\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install kaggle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   },
+   "id": "55f5e4a1d2ec2ecc"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001B[31mERROR: Could not find a version that satisfies the requirement kaggle_api_extended (from versions: none)\u001B[0m\u001B[31m\r\n",
+      "\u001B[0m\u001B[31mERROR: No matching distribution found for kaggle_api_extended\u001B[0m\u001B[31m\r\n",
+      "\u001B[0m"
+     ]
+    }
+   ],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-11-05T00:51:45.918622100Z",
+     "start_time": "2023-11-05T00:51:45.022051100Z"
+    }
+   },
+   "id": "28cea8fd0c172fff"
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## merge files"
+   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "id": "fd44ed9dee4275cf"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files merged successfully!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import shutil\n",
+    "from pathlib import Path\n",
+    "try:\n",
+    "    with open(Path('merged_file.py'), 'wb') as destination_file:\n",
+    "        with open(Path('google_sheet.py'), 'rb') as file1:\n",
+    "            shutil.copyfileobj(file1, destination_file)\n",
+    "        with open(Path('logger.py'), 'rb') as file2:\n",
+    "            shutil.copyfileobj(file2, destination_file)\n",
+    "        with open(Path('kaggle_service.py'), 'rb') as file3:\n",
+    "            shutil.copyfileobj(file3, destination_file)\n",
+    "        with open(Path('main.py'), 'rb') as file4:\n",
+    "            shutil.copyfileobj(file4, destination_file)\n",
+    "    print(\"Files merged successfully!\")\n",
+    "except :\n",
+    "    raise Exception(\"Cannot merge files!\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-11-05T02:15:34.843461500Z",
+     "start_time": "2023-11-05T02:15:34.781001200Z"
+    }
+   },
+   "id": "2568f49413e2057c"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}