Migrate from yapf to black

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.2.0
+  rev: v4.4.0
   hooks:
   - id: check-executables-have-shebangs
   - id: check-json
@@ -8,14 +8,13 @@ repos:
   - id: check-shebang-scripts-are-executable
   - id: check-toml
   - id: check-yaml
-  - id: double-quote-string-fixer
   - id: end-of-file-fixer
   - id: mixed-line-ending
     args: ['--fix=lf']
   - id: requirements-txt-fixer
   - id: trailing-whitespace
 - repo: https://github.com/myint/docformatter
-  rev: v1.4
+  rev: v1.7.5
   hooks:
   - id: docformatter
     args: ['--in-place']
@@ -23,14 +22,29 @@ repos:
   rev: 5.12.0
   hooks:
     - id: isort
+      args: ["--profile=black"]
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v0.991
+  rev: v1.5.1
   hooks:
     - id: mypy
       args: ['--ignore-missing-imports']
-      additional_dependencies: ['types-python-slugify', 'types-PyYAML']
-- repo: https://github.com/google/yapf
-  rev: v0.32.0
+      additional_dependencies: ['types-python-slugify', 'types-requests', 'types-PyYAML']
+- repo: https://github.com/psf/black
+  rev: 23.7.0
   hooks:
-  - id: yapf
-    args: ['--parallel', '--in-place']
+    - id: black
+      language_version: python3.10
+      args: ['--line-length=119']
+- repo: https://github.com/kynan/nbstripout
+  rev: 0.6.1
+  hooks:
+    - id: nbstripout
+      args: ['--extra-keys', 'metadata.interpreter metadata.kernelspec cell.metadata.pycharm']
+- repo: https://github.com/nbQA-dev/nbQA
+  rev: 1.7.0
+  hooks:
+    - id: nbqa-black
+    - id: nbqa-pyupgrade
+      args: ["--py37-plus"]
+    - id: nbqa-isort
+      args: ["--float-to-top"]

.vscode/settings.json

@@ -1,18 +1,21 @@
 {
-    "python.linting.enabled": true,
-    "python.linting.flake8Enabled": true,
-    "python.linting.pylintEnabled": false,
-    "python.linting.lintOnSave": true,
-    "python.formatting.provider": "yapf",
-    "python.formatting.yapfArgs": [
-        "--style={based_on_style: pep8, indent_width: 4, blank_line_before_nested_class_or_def: false, spaces_before_comment: 2, split_before_logical_operator: true}"
-    ],
     "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter",
         "editor.formatOnType": true,
         "editor.codeActionsOnSave": {
             "source.organizeImports": true
         }
     },
+    "black-formatter.args": [
+        "--line-length=119"
+    ],
+    "isort.args": ["--profile", "black"],
+    "flake8.args": [
+        "--max-line-length=119"
+    ],
+    "ruff.args": [
+        "--line-length=119"
+    ],
     "editor.formatOnSave": true,
     "files.insertFinalNewline": true
 }

app.py

@@ -4,127 +4,153 @@ from __future__ import annotations
 
 import gradio as gr
 
-from constants import (HARDWARE_CHOICES, OWNER_CHOICES, SDK_CHOICES,
-                       SLEEP_TIME_CHOICES, STATUS_CHOICES, VISIBILITY_CHOICES)
+from constants import (
+    HARDWARE_CHOICES,
+    OWNER_CHOICES,
+    SDK_CHOICES,
+    SLEEP_TIME_CHOICES,
+    STATUS_CHOICES,
+    VISIBILITY_CHOICES,
+)
 from demo_list import DemoList, get_df_from_yaml
 from restart_scheduler import RestartScheduler
 from settings import HF_TOKEN, INTERVAL_MINUTES, SPACE_ID
 
-demo_list = DemoList(get_df_from_yaml('list.yaml'))
+demo_list = DemoList(get_df_from_yaml("list.yaml"))
 
 if SPACE_ID is not None and INTERVAL_MINUTES > 0:
-    scheduler = RestartScheduler(space_id=SPACE_ID,
-                                 interval_minutes=INTERVAL_MINUTES,
-                                 hf_token=HF_TOKEN)
+    scheduler = RestartScheduler(space_id=SPACE_ID, interval_minutes=INTERVAL_MINUTES, hf_token=HF_TOKEN)
     scheduler.start()
 
 
 def update_status_checkboxes(choices: list[str]) -> list[str]:
-    if '(ALL)' in choices:
+    if "(ALL)" in choices:
         return STATUS_CHOICES
-    elif '(NONE)' in choices:
+    elif "(NONE)" in choices:
         return []
     else:
         return choices
 
 
 def update_hardware_checkboxes(choices: list[str]) -> list[str]:
-    if '(ALL)' in choices:
+    if "(ALL)" in choices:
         return HARDWARE_CHOICES
-    elif '(NONE)' in choices:
+    elif "(NONE)" in choices:
         return []
     else:
         return choices
 
 
 def update_sdk_checkboxes(choices: list[str]) -> list[str]:
-    if '(ALL)' in choices:
+    if "(ALL)" in choices:
         return SDK_CHOICES
-    elif '(NONE)' in choices:
+    elif "(NONE)" in choices:
         return []
     else:
         return choices
 
 
 def update_sleep_time_checkboxes(choices: list[str]) -> list[str]:
-    if '(ALL)' in choices:
+    if "(ALL)" in choices:
         return SLEEP_TIME_CHOICES
-    elif '(NONE)' in choices:
+    elif "(NONE)" in choices:
         return []
     else:
         return choices
 
 
-with gr.Blocks(css='style.css') as demo:
-    with gr.Accordion(label='Filter', open=False):
-        status = gr.CheckboxGroup(label='Status',
-                                  choices=['(ALL)', '(NONE)'] + STATUS_CHOICES,
-                                  value=STATUS_CHOICES,
-                                  type='value')
-        hardware = gr.CheckboxGroup(label='Hardware',
-                                    choices=['(ALL)', '(NONE)'] +
-                                    HARDWARE_CHOICES,
-                                    value=HARDWARE_CHOICES,
-                                    type='value')
-        sleep_time = gr.CheckboxGroup(label='Sleep time',
-                                      choices=['(ALL)', '(NONE)'] +
-                                      SLEEP_TIME_CHOICES,
-                                      value=SLEEP_TIME_CHOICES,
-                                      type='value')
-        multiple_replicas = gr.Checkbox(label='Multiple replicas', value=False)
-        sdk = gr.CheckboxGroup(label='SDK',
-                               choices=['(ALL)', '(NONE)'] + SDK_CHOICES,
-                               value=SDK_CHOICES,
-                               type='value')
-        visibility = gr.CheckboxGroup(label='Visibility',
-                                      choices=VISIBILITY_CHOICES,
-                                      value=VISIBILITY_CHOICES,
-                                      type='value')
-        owner = gr.CheckboxGroup(label='Owner',
-                                 choices=OWNER_CHOICES,
-                                 value=OWNER_CHOICES,
-                                 type='value')
-        apply_button = gr.Button('Apply')
-    df = gr.Dataframe(value=demo_list.df_prettified,
-                      datatype=demo_list.column_datatype,
-                      type='pandas',
-                      interactive=False,
-                      row_count=(0, 'dynamic'))
-
-    status.change(fn=update_status_checkboxes,
-                  inputs=status,
-                  outputs=status,
-                  queue=False,
-                  show_progress=False,
-                  api_name=False)
-    hardware.change(fn=update_hardware_checkboxes,
-                    inputs=hardware,
-                    outputs=hardware,
-                    queue=False,
-                    show_progress=False,
-                    api_name=False)
-    sdk.change(fn=update_sdk_checkboxes,
-               inputs=sdk,
-               outputs=sdk,
-               queue=False,
-               show_progress=False,
-               api_name=False)
-    sleep_time.change(fn=update_sleep_time_checkboxes,
-                      inputs=sleep_time,
-                      outputs=sleep_time,
-                      queue=False,
-                      show_progress=False,
-                      api_name=False)
-    apply_button.click(fn=demo_list.filter,
-                       inputs=[
-                           status,
-                           hardware,
-                           sleep_time,
-                           multiple_replicas,
-                           sdk,
-                           visibility,
-                           owner,
-                       ],
-                       outputs=df,
-                       api_name=False)
+with gr.Blocks(css="style.css") as demo:
+    with gr.Accordion(label="Filter", open=False):
+        status = gr.CheckboxGroup(
+            label="Status",
+            choices=["(ALL)", "(NONE)"] + STATUS_CHOICES,
+            value=STATUS_CHOICES,
+            type="value",
+        )
+        hardware = gr.CheckboxGroup(
+            label="Hardware",
+            choices=["(ALL)", "(NONE)"] + HARDWARE_CHOICES,
+            value=HARDWARE_CHOICES,
+            type="value",
+        )
+        sleep_time = gr.CheckboxGroup(
+            label="Sleep time",
+            choices=["(ALL)", "(NONE)"] + SLEEP_TIME_CHOICES,
+            value=SLEEP_TIME_CHOICES,
+            type="value",
+        )
+        multiple_replicas = gr.Checkbox(label="Multiple replicas", value=False)
+        sdk = gr.CheckboxGroup(
+            label="SDK",
+            choices=["(ALL)", "(NONE)"] + SDK_CHOICES,
+            value=SDK_CHOICES,
+            type="value",
+        )
+        visibility = gr.CheckboxGroup(
+            label="Visibility",
+            choices=VISIBILITY_CHOICES,
+            value=VISIBILITY_CHOICES,
+            type="value",
+        )
+        owner = gr.CheckboxGroup(
+            label="Owner",
+            choices=OWNER_CHOICES,
+            value=OWNER_CHOICES,
+            type="value",
+        )
+        apply_button = gr.Button("Apply")
+    df = gr.Dataframe(
+        value=demo_list.df_prettified,
+        datatype=demo_list.column_datatype,
+        type="pandas",
+        interactive=False,
+        row_count=(0, "dynamic"),
+    )
+
+    status.change(
+        fn=update_status_checkboxes,
+        inputs=status,
+        outputs=status,
+        queue=False,
+        show_progress=False,
+        api_name=False,
+    )
+    hardware.change(
+        fn=update_hardware_checkboxes,
+        inputs=hardware,
+        outputs=hardware,
+        queue=False,
+        show_progress=False,
+        api_name=False,
+    )
+    sdk.change(
+        fn=update_sdk_checkboxes,
+        inputs=sdk,
+        outputs=sdk,
+        queue=False,
+        show_progress=False,
+        api_name=False,
+    )
+    sleep_time.change(
+        fn=update_sleep_time_checkboxes,
+        inputs=sleep_time,
+        outputs=sleep_time,
+        queue=False,
+        show_progress=False,
+        api_name=False,
+    )
+    apply_button.click(
+        fn=demo_list.filter,
+        inputs=[
+            status,
+            hardware,
+            sleep_time,
+            multiple_replicas,
+            sdk,
+            visibility,
+            owner,
+        ],
+        outputs=df,
+        api_name=False,
+    )
 demo.queue(api_open=False).launch()

constants.py

@@ -1,48 +1,48 @@
 from huggingface_hub import HfApi
 
 STATUS_CHOICES = [
-    'RUNNING',
-    'PAUSED',
-    'STOPPED',
-    'RUNTIME_ERROR',
-    'BUILD_ERROR',
-    'CONFIG_ERROR',
-    'BUILDING',
-    'RUNNING_BUILDING',
-    'NO_APP_FILE',
+    "RUNNING",
+    "PAUSED",
+    "STOPPED",
+    "RUNTIME_ERROR",
+    "BUILD_ERROR",
+    "CONFIG_ERROR",
+    "BUILDING",
+    "RUNNING_BUILDING",
+    "NO_APP_FILE",
 ]
 HARDWARE_CHOICES = [
-    'cpu-basic',
-    'cpu-upgrade',
-    't4-small',
-    't4-medium',
-    'zero-a10g',
-    'a10g-small',
-    'a10g-large',
-    'a100-large',
+    "cpu-basic",
+    "cpu-upgrade",
+    "t4-small",
+    "t4-medium",
+    "zero-a10g",
+    "a10g-small",
+    "a10g-large",
+    "a100-large",
 ]
 SDK_CHOICES = [
-    'gradio',
-    'streamlit',
-    'docker',
+    "gradio",
+    "streamlit",
+    "docker",
 ]
 SLEEP_TIME_INT_TO_STR = {
-    0: 'null',
-    300: '5 minutes',
-    900: '15 minutes',
-    1800: '30 minutes',
-    3600: '1 hour',
-    36000: '10 hours',
-    86400: '24 hours',
-    172800: '48 hours',
-    259200: '72 hours',
-    604800: '1 week',
+    0: "null",
+    300: "5 minutes",
+    900: "15 minutes",
+    1800: "30 minutes",
+    3600: "1 hour",
+    36000: "10 hours",
+    86400: "24 hours",
+    172800: "48 hours",
+    259200: "72 hours",
+    604800: "1 week",
 }
 SLEEP_TIME_CHOICES = list(SLEEP_TIME_INT_TO_STR.values())
 SLEEP_TIME_STR_TO_INT = {v: k for k, v in SLEEP_TIME_INT_TO_STR.items()}
 
-VISIBILITY_CHOICES = ['public', 'private']
+VISIBILITY_CHOICES = ["public", "private"]
 
 api = HfApi()
-WHOAMI = api.whoami()['name']
-OWNER_CHOICES = [WHOAMI, 'other organizations']
+WHOAMI = api.whoami()["name"]
+OWNER_CHOICES = [WHOAMI, "other organizations"]

demo_list.py

@@ -8,8 +8,12 @@ import tqdm.auto
 import yaml
 from huggingface_hub import HfApi
 
-from constants import (OWNER_CHOICES, SLEEP_TIME_INT_TO_STR,
-                       SLEEP_TIME_STR_TO_INT, WHOAMI)
+from constants import (
+    OWNER_CHOICES,
+    SLEEP_TIME_INT_TO_STR,
+    SLEEP_TIME_STR_TO_INT,
+    WHOAMI,
+)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -28,50 +32,45 @@ class DemoInfo:
     private: bool
     hardware: str
     suggested_hardware: str
-    created: str = ''
+    created: str = ""
     arxiv: list[str] = dataclasses.field(default_factory=list)
     github: list[str] = dataclasses.field(default_factory=list)
     tags: list[str] = dataclasses.field(default_factory=list)
 
     def __post_init__(self):
-        object.__setattr__(self, 'last_modified',
-                           DemoInfo.convert_timestamp(self.last_modified))
-        object.__setattr__(self, 'created',
-                           DemoInfo.convert_timestamp(self.created))
+        object.__setattr__(self, "last_modified", DemoInfo.convert_timestamp(self.last_modified))
+        object.__setattr__(self, "created", DemoInfo.convert_timestamp(self.created))
 
     @staticmethod
     def convert_timestamp(timestamp: str) -> str:
         try:
-            return datetime.datetime.strptime(
-                timestamp,
-                '%Y-%m-%dT%H:%M:%S.%fZ').strftime('%Y/%m/%d %H:%M:%S')
+            return datetime.datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%fZ").strftime("%Y/%m/%d %H:%M:%S")
         except ValueError:
             return timestamp
 
     @classmethod
-    def from_space_id(cls, space_id: str) -> 'DemoInfo':
+    def from_space_id(cls, space_id: str) -> "DemoInfo":
         api = HfApi()
         space_info = api.space_info(repo_id=space_id)
         card = space_info.cardData
         runtime = space_info.runtime
-        resources = runtime['resources']
+        resources = runtime["resources"]
 
         return cls(
             space_id=space_id,
-            url=f'https://huggingface.co/spaces/{space_id}',
-            title=card['title'] if 'title' in card else '',
-            owner=space_id.split('/')[0],
-            sdk=card['sdk'],
-            sdk_version=card.get('sdk_version', ''),
+            url=f"https://huggingface.co/spaces/{space_id}",
+            title=card["title"] if "title" in card else "",
+            owner=space_id.split("/")[0],
+            sdk=card["sdk"],
+            sdk_version=card.get("sdk_version", ""),
             likes=space_info.likes,
-            status=runtime['stage'],
+            status=runtime["stage"],
             last_modified=space_info.lastModified,
-            sleep_time=runtime['gcTimeout'] or 0,
-            replicas=resources['replicas'] if resources is not None else 0,
+            sleep_time=runtime["gcTimeout"] or 0,
+            replicas=resources["replicas"] if resources is not None else 0,
             private=space_info.private,
-            hardware=runtime['hardware']['current']
-            or runtime['hardware']['requested'],
-            suggested_hardware=card.get('suggested_hardware', ''),
+            hardware=runtime["hardware"]["current"] or runtime["hardware"]["requested"],
+            suggested_hardware=card.get("suggested_hardware", ""),
         )
 
 
@@ -89,19 +88,17 @@ def get_df_from_yaml(path: pathlib.Path | str) -> pd.DataFrame:
 class Prettifier:
     @staticmethod
     def get_arxiv_link(links: list[str]) -> str:
-        links = [
-            Prettifier.create_link(link.split('/')[-1], link) for link in links
-        ]
-        return '\n'.join(links)
+        links = [Prettifier.create_link(link.split("/")[-1], link) for link in links]
+        return "\n".join(links)
 
     @staticmethod
     def get_github_link(links: list[str]) -> str:
-        links = [Prettifier.create_link('github', link) for link in links]
-        return '\n'.join(links)
+        links = [Prettifier.create_link("github", link) for link in links]
+        return "\n".join(links)
 
     @staticmethod
     def get_tag_list(tags: list[str]) -> str:
-        return ', '.join(tags)
+        return ", ".join(tags)
 
     @staticmethod
     def create_link(text: str, url: str) -> str:
@@ -110,53 +107,40 @@ class Prettifier:
     @staticmethod
     def to_div(text: str | None, category_name: str) -> str:
         if text is None:
-            text = ''
-        class_name = f'{category_name}-{text.lower()}'
+            text = ""
+        class_name = f"{category_name}-{text.lower()}"
         return f'<div class="{class_name}">{text}</div>'
 
     @staticmethod
     def add_div_tag_to_replicas(replicas: int) -> str:
         if replicas == 0:
-            return ''
+            return ""
         if replicas == 1:
-            return '1'
+            return "1"
         return f'<div class="multiple-replicas">{replicas}</div>'
 
     @staticmethod
     def add_div_tag_to_sleep_time(sleep_time_s: str, hardware: str) -> str:
-        if hardware == 'cpu-basic':
+        if hardware == "cpu-basic":
             return f'<div class="sleep-time-cpu-basic">{sleep_time_s}</div>'
-        s = sleep_time_s.replace(' ', '-')
+        s = sleep_time_s.replace(" ", "-")
         return f'<div class="sleep-time-{s}">{sleep_time_s}</div>'
 
     def __call__(self, df: pd.DataFrame) -> pd.DataFrame:
         new_rows = []
         for _, row in df.iterrows():
             new_row = dict(row) | {
-                'status':
-                self.to_div(row.status, 'status'),
-                'hardware':
-                self.to_div(row.hardware, 'hardware'),
-                'suggested_hardware':
-                self.to_div(row.suggested_hardware, 'hardware'),
-                'title':
-                self.create_link(row.title, row.url),
-                'owner':
-                self.create_link(row.owner,
-                                 f'https://huggingface.co/{row.owner}'),
-                'sdk':
-                self.to_div(row.sdk, 'sdk'),
-                'sleep_time':
-                self.add_div_tag_to_sleep_time(
-                    SLEEP_TIME_INT_TO_STR[row.sleep_time], row.hardware),
-                'replicas':
-                self.add_div_tag_to_replicas(row.replicas),
-                'arxiv':
-                self.get_arxiv_link(row.arxiv),
-                'github':
-                self.get_github_link(row.github),
-                'tags':
-                self.get_tag_list(row.tags),
+                "status": self.to_div(row.status, "status"),
+                "hardware": self.to_div(row.hardware, "hardware"),
+                "suggested_hardware": self.to_div(row.suggested_hardware, "hardware"),
+                "title": self.create_link(row.title, row.url),
+                "owner": self.create_link(row.owner, f"https://huggingface.co/{row.owner}"),
+                "sdk": self.to_div(row.sdk, "sdk"),
+                "sleep_time": self.add_div_tag_to_sleep_time(SLEEP_TIME_INT_TO_STR[row.sleep_time], row.hardware),
+                "replicas": self.add_div_tag_to_replicas(row.replicas),
+                "arxiv": self.get_arxiv_link(row.arxiv),
+                "github": self.get_github_link(row.github),
+                "tags": self.get_tag_list(row.tags),
             }
             new_rows.append(new_row)
         return pd.DataFrame(new_rows, columns=df.columns)
@@ -164,22 +148,22 @@ class Prettifier:
 
 class DemoList:
     COLUMN_INFO = [
-        ['status', 'markdown'],
-        ['hardware', 'markdown'],
-        ['title', 'markdown'],
-        ['owner', 'markdown'],
-        ['arxiv', 'markdown'],
-        ['github', 'markdown'],
-        ['likes', 'number'],
-        ['tags', 'str'],
-        ['last_modified', 'str'],
-        ['created', 'str'],
-        ['sdk', 'markdown'],
-        ['sdk_version', 'str'],
-        ['suggested_hardware', 'markdown'],
-        ['sleep_time', 'markdown'],
-        ['replicas', 'markdown'],
-        ['private', 'bool'],
+        ["status", "markdown"],
+        ["hardware", "markdown"],
+        ["title", "markdown"],
+        ["owner", "markdown"],
+        ["arxiv", "markdown"],
+        ["github", "markdown"],
+        ["likes", "number"],
+        ["tags", "str"],
+        ["last_modified", "str"],
+        ["created", "str"],
+        ["sdk", "markdown"],
+        ["sdk_version", "str"],
+        ["suggested_hardware", "markdown"],
+        ["sleep_time", "markdown"],
+        ["replicas", "markdown"],
+        ["private", "bool"],
     ]
 
     def __init__(self, df: pd.DataFrame):
@@ -210,14 +194,14 @@ class DemoList:
         if multiple_replicas:
             df = df[self.df_raw.replicas > 1]
 
-        if visibility == ['public']:
+        if visibility == ["public"]:
             df = df[~self.df_raw.private]
-        elif visibility == ['private']:
+        elif visibility == ["private"]:
             df = df[self.df_raw.private]
 
-        df = df[(self.df_raw.status.isin(status))
-                & (self.df_raw.hardware.isin(hardware))
-                & (self.df_raw.sdk.isin(sdk))]
+        df = df[
+            (self.df_raw.status.isin(status)) & (self.df_raw.hardware.isin(hardware)) & (self.df_raw.sdk.isin(sdk))
+        ]
 
         sleep_time_int = [SLEEP_TIME_STR_TO_INT[s] for s in sleep_time]
         df = df[self.df_raw.sleep_time.isin(sleep_time_int)]

restart_scheduler.py

@@ -4,22 +4,21 @@ from huggingface_hub.utils import RepositoryNotFoundError
 
 
 class RestartScheduler:
-    def __init__(self, space_id: str, interval_minutes: int,
-                 hf_token: str | None):
+    def __init__(self, space_id: str, interval_minutes: int, hf_token: str | None):
         api = HfApi(token=hf_token)
-        if api.get_token_permission() != 'write':
-            raise ValueError('The HF token must have write permission.')
+        if api.get_token_permission() != "write":
+            raise ValueError("The HF token must have write permission.")
         try:
             api.space_info(repo_id=space_id)
         except RepositoryNotFoundError:
-            raise ValueError('The Space ID does not exist.')
+            raise ValueError("The Space ID does not exist.")
         if interval_minutes <= 0:
-            raise ValueError('The interval must be positive.')
+            raise ValueError("The interval must be positive.")
 
         self.scheduler = BackgroundScheduler()
-        self.scheduler.add_job(func=lambda: api.restart_space(space_id),
-                               trigger='interval',
-                               seconds=60 * interval_minutes)
+        self.scheduler.add_job(
+            func=lambda: api.restart_space(space_id), trigger="interval", seconds=60 * interval_minutes
+        )
 
     def start(self):
         self.scheduler.start()

settings.py

@@ -1,5 +1,5 @@
 import os
 
-HF_TOKEN = os.getenv('HUGGING_FACE_HUB_TOKEN')
-SPACE_ID = os.getenv('SPACE_ID')
-INTERVAL_MINUTES = int(os.getenv('INTERVAL_MINUTES', '30'))
+HF_TOKEN = os.getenv("HUGGING_FACE_HUB_TOKEN")
+SPACE_ID = os.getenv("SPACE_ID")
+INTERVAL_MINUTES = int(os.getenv("INTERVAL_MINUTES", "30"))

tools/add_creation_timestamps.py

@@ -10,7 +10,7 @@ import tqdm.auto
 import yaml
 
 repo_dir = pathlib.Path(__file__).parents[1]
-yaml_path = repo_dir / 'list.yaml'
+yaml_path = repo_dir / "list.yaml"
 
 
 def add_creation_timestamps() -> None:
@@ -20,18 +20,18 @@ def add_creation_timestamps() -> None:
     space_ids = list(data.keys())
     for space_id in tqdm.auto.tqdm(space_ids):
         info = data[space_id]
-        if 'created' in info:
+        if "created" in info:
             continue
         with tempfile.TemporaryDirectory() as temp_dir:
-            url = f'https://huggingface.co/spaces/{space_id}'
+            url = f"https://huggingface.co/spaces/{space_id}"
             repo = git.Repo.clone_from(url, temp_dir)
             commits = list(repo.iter_commits())
             initial_commit = commits[-1]
             date = initial_commit.authored_datetime
-            date_str = date.strftime('%Y-%m-%dT%H:%M:%S.000Z')
-            info['created'] = date_str
+            date_str = date.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+            info["created"] = date_str
 
-    with open(yaml_path, 'w') as f:
+    with open(yaml_path, "w") as f:
         yaml.dump(data, f)
 
 
@@ -39,15 +39,15 @@ def sort_by_creation_date() -> None:
     with open(yaml_path) as f:
         data = yaml.safe_load(f)
 
-    keys = sorted(data.keys(), key=lambda x: data[x]['created'])
+    keys = sorted(data.keys(), key=lambda x: data[x]["created"])
     sorted_data = dict()
     for key in keys[::-1]:
         sorted_data[key] = data[key]
 
-    with open(yaml_path, 'w') as f:
+    with open(yaml_path, "w") as f:
         yaml.dump(sorted_data, f, sort_keys=False)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     add_creation_timestamps()
     sort_by_creation_date()