Space'inizi yönetin

Bu kılavuzda, huggingface_hub kullanarak Space çalışma zamanınızı (secrets, hardware ve hacimler) nasıl yöneteceğinizi göreceksiniz.

Spaces için arama yapın

Hub'da search_spaces() ile anlamsal arama kullanarak Spaces arayabilirsiniz. Bu, çok kelimeli sorgular için gömme tabanlı aramayı, tek kelimeli sorgular için ise tam metin aramayı kullanır.

>>> from huggingface_hub import search_spaces
>>> results = list(search_spaces("generate image"))
>>> results[0]
SpaceSearchResult(id='mrfakename/Z-Image-Turbo', title='Z Image Turbo', sdk='gradio', likes=2867, ...)

Sonuçları SDK veya etiketlere göre filtreleyebilirsiniz:

>>> results = search_spaces("chatbot", sdk="gradio", filter="mcp-server")

Veya CLI üzerinden:

>>> hf spaces search "generate image"
>>> hf spaces search "chatbot" --sdk gradio --limit 5

Basit bir örnek: gizli bilgileri ve donanımı yapılandırın.

Hub'da bir Space oluşturup yapılandırmak için uçtan uca bir örnek aşağıda verilmiştir.

Hub'da bir Space oluşturun

>>> from huggingface_hub import HfApi
>>> repo_id = "Wauplin/my-cool-training-space"
>>> api = HfApi()

# For example with a Gradio SDK
>>> api.create_repo(repo_id=repo_id, repo_type="space", space_sdk="gradio")

Statik Spaces herkes için ücretsizdir. Gradio ve Docker Spaces hesaplama üzerinde çalışır: ücretsiz cpu-basic donanımında bunlar bir abonelik gerektirir (kullanıcılar için PRO, kuruluşlar için Team veya Enterprise), ücretli donanımda ise yalnızca faturalama (bir ödeme yöntemi ve önceden ödenmiş krediler) yeterlidir. Abonelik olmadan, cpu-basic üzerinde bir Gradio veya Docker Space oluşturmak, çoğaltmak veya taşımak bir ödeme hatasıyla (HTTP 402) başarısız olur. Daha fazla ayrıntı için fiyatlandırma sayfasına bakın.

Bir şablon üzerinden Space oluşturun

Boş bir Space ile başlamak yerine, Hub'da sunulan resmi şablonlardan (ör. JupyterLab, bir Gradio sohbet botu, bir Streamlit uygulaması vb.) birini kullanarak yeni bir Space oluşturabilirsiniz. Kullanılabilir şablonları list_space_templates() ile listeleyin, ardından bir şablonun repo_id'sini (veya kısa name'sini) create_repo() fonksiyonuna space_template olarak iletin. space_sdk'nin hâlâ gerekli olduğunu unutmayın: şablon dosyaları oluştururken SDK kart meta verilerini ayarlar.

>>> from huggingface_hub import HfApi
>>> api = HfApi()

# List available templates
>>> for template in api.list_space_templates():
...     print(f"{template.name} ({template.repo_id})")
Streamlit (streamlit/streamlit-template-space)
JupyterLab (SpacesExamples/jupyterlab)
chatbot (gradio-templates/chatbot)
...

# Create a Space from a template, by repo id or by short name
>>> api.create_repo(repo_id=repo_id, repo_type="space", space_template="SpacesExamples/jupyterlab")
>>> api.create_repo(repo_id=repo_id, repo_type="space", space_template="JupyterLab")

Bazı şablonların özel olarak oluşturulması önerilir (ör. JupyterLab). Görünürlüğü açıkça belirtmezseniz, bu tür Spaces otomatik olarak özel olarak oluşturulur.

Komut satırı arayüzünden, aynı özellik hf spaces templates ve hf repos create --template üzerinden de kullanılabilir:

# List available templates
>>> hf spaces templates
NAME            REPO_ID                                        SDK    PREFERRED_PRIVATE
--------------- ---------------------------------------------- ------ -----------------
Streamlit       streamlit/streamlit-template-space             docker
JupyterLab      SpacesExamples/jupyterlab                      docker ✔
Argilla         argilla/argilla-template-space                 docker
Livebook        livebook-dev/livebook                          docker
...

# Create a Space from a template
>>> hf repos create my-jupyterlab --type space --template jupyterlab

Bir Uzayı Kopyala

Mevcut bir Space'ten başlayarak sıfırdan başlamak yerine üzerine inşa etmek istiyorsanız bu işe yarayabilir. Ayrıca, herkese açık bir Space'in yapılandırma/ayarları üzerinde kontrol sahibi olmak istiyorsanız da faydalıdır. Daha fazla ayrıntı için duplicate_repo() işlevine bakın.

>>> api.duplicate_repo("multimodalart/dreambooth-training", repo_type="space")

Kodunuzu tercih ettiğiniz çözümle yükleyin

Makinenizdeki src/ yerel klasörünü Space'inize yüklemek için bir örnek:

>>> api.upload_folder(repo_id=repo_id, repo_type="space", folder_path="src/")

Bu adımda, uygulamanız Hub üzerinde zaten çalışıyor olmalıdır. Ancak, gizli anahtarlar (secrets) ve yükseltilmiş donanım ile yapılandırmasını daha da özelleştirmek isteyebilirsiniz.

Gizli bilgileri ve değişkenleri yapılandır

Space'iniz çalışmak için bazı gizli anahtarlar, jetonlar veya değişkenler gerektirebilir. Daha fazla ayrıntı için belgeleri inceleyin. Örneğin, Space'inizden oluşturulduktan sonra bir görüntü veri setini Hub'a yüklemek için bir HF jetonu.

>>> api.add_space_secret(repo_id=repo_id, key="HF_TOKEN", value="hf_api_***")
>>> api.add_space_variable(repo_id=repo_id, key="MODEL_REPO_ID", value="user/repo")

Mevcut gizli anahtarları ve değişkenleri listeleyebilirsiniz. Gizli anahtar değerleri yalnızca yazılabilir olduğundan yalnızca anahtarlar, açıklamalar ve güncelleme zaman damgaları döndürülür:

>>> api.get_space_secrets(repo_id=repo_id)
{'HF_TOKEN': SpaceSecret(key='HF_TOKEN', description=None, updated_at=datetime.datetime(...))}
>>> api.get_space_variables(repo_id=repo_id)
{'MODEL_REPO_ID': SpaceVariable(key='MODEL_REPO_ID', value='user/repo', description=None, updated_at=...)}

Gizli bilgiler ve değişkenler de silinebilir:

>>> api.delete_space_secret(repo_id=repo_id, key="HF_TOKEN")
>>> api.delete_space_variable(repo_id=repo_id, key="MODEL_REPO_ID")

Space'inizden eriştiğinizde, gizli bilgiler ortam değişkenleri olarak kullanılabilir (Streamlit kullanıyorsanız Streamlit Secrets Management). API üzerinden getirmenize gerek yok!

Space yapılandırmanızdaki herhangi bir değişiklik (gizli anahtarlar veya donanım), uygulamanızın yeniden başlatılmasına neden olur.

Bonus: Space oluştururken veya kopyalarken gizli bilgileri ve değişkenleri ayarlayın!

Gizli bilgiler ve değişkenler, bir alan oluşturulurken veya kopyalanırken ayarlanabilir:

>>> api.create_repo(
...     repo_id=repo_id,
...     repo_type="space",
...     space_sdk="gradio",
...     space_secrets=[{"key": "HF_TOKEN", "value": "hf_api_***"}, ...],
...     space_variables=[{"key": "MODEL_REPO_ID", "value": "user/repo"}, ...],
... )

>>> api.duplicate_repo(
...     from_id=repo_id,
...     repo_type="space",
...     space_secrets=[{"key": "HF_TOKEN", "value": "hf_api_***"}, ...],
...     space_variables=[{"key": "MODEL_REPO_ID", "value": "user/repo"}, ...],
... )

Donanımı yapılandırın

Varsayılan olarak Space'iniz ücretsiz cpu-basic donanımında çalışır (Gradio ve Docker Spaces için abonelik gerektirir, bkz. yukarıdaki bölüm). GPU'larda çalıştırmak için donanımı yükseltebilirsiniz. Space'inizi yükseltmek için bir ödeme yöntemi ve ön ödemeli krediler (veya bir topluluk hibesi) gereklidir. Daha fazla ayrıntı için belgeleri inceleyin.

# Use `SpaceHardware` enum
>>> from huggingface_hub import SpaceHardware
>>> api.request_space_hardware(repo_id=repo_id, hardware=SpaceHardware.T4_MEDIUM)

# Or simply pass a string value
>>> api.request_space_hardware(repo_id=repo_id, hardware="t4-medium")

Donanım güncellemeleri anında yapılmaz, çünkü Space'iniz sunucularımızda yeniden yüklenmelidir. İstediğiniz donanım talebinin karşılanıp karşılanmadığını görmek için Space'inizin hangi donanımda çalıştığını her zaman kontrol edebilirsiniz.

>>> runtime = api.get_space_runtime(repo_id=repo_id)
>>> runtime.stage
"RUNNING_BUILDING"
>>> runtime.hardware
"cpu-basic"
>>> runtime.requested_hardware
"t4-medium"

Artık tamamen yapılandırılmış bir Space'iniz var. Kullanımınız bittiğinde Space'inizi cpu-basic seviyesine geri düşürdüğünüzden emin olun.

Bonus: Space oluştururken veya kopyalarken donanım iste!

Yükseltilmiş donanım, Space'iniz oluşturulduğunda otomatik olarak atayacaktır.

>>> api.create_repo(
...     repo_id=repo_id,
...     repo_type="space",
...     space_sdk="gradio",
...     space_hardware="cpu-upgrade",
...     space_sleep_time="7200", # 2 hours in secs
... )

>>> api.duplicate_repo(
...     from_id=repo_id,
...     repo_type="space",
...     space_hardware="cpu-upgrade",
...     space_sleep_time="7200", # 2 hours in secs
... )

ZeroGPU kotaınızı izleyin

ZeroGPU Spaces, talep üzerine tahsis edilen paylaşımlı GPU'lar üzerinde çalışır. Bir ZeroGPU Space'i her kullandığınızda (arayüzden veya API'si üzerinden), kişisel kotanızdan belirli bir GPU süresi düşülür ve bu kota periyodik olarak sıfırlanır. ZeroGPU Spaces üzerine bir uygulama, ajan veya MCP sunucusu geliştiriyorsanız, kullanımınızı get_zero_gpu_quota() ile takip edebilirsiniz. Değerler GPU-saniye cinsinden ifade edilir.

>>> quota = api.get_zero_gpu_quota()
>>> quota
ZeroGpuQuota(base=2400, remaining=1810, resets_at=datetime.datetime(2026, 9, 30, 9, 12, 3, tzinfo=datetime.timezone.utc), overquota_used=0)
>>> if quota.remaining < 60:
...     print(f"Less than 1 minute of ZeroGPU left. Quota resets at {quota.resets_at}.")

resets_at, son sıfırlamadan beri ZeroGPU kullanmadıysanız None değerini alır. İnce tanecikli bir token kullanıyorsanız, bu tokenın “Billing > Read billing usage and payment method status” iznine sahip olması gerekir. Aynı bilgi, CLI üzerinden hf spaces zero-gpu quota komutuyla da alınabilir.

Kota tükendiğinde PRO, Team ve Enterprise kullanıcıları, ön ödemeli kredileri kullanarak ZeroGPU Spaces’i kullanmaya devam edebilir. Kredileri faturalandırma ayarlarınızdan satın alabilirsiniz. Daha fazla ayrıntı için Kredilerle kotayı uzatma bölümüne bakın.

Space'inizi duraklatın ve yeniden başlatın

Varsayılan olarak Space'iniz yükseltilmiş bir donanımda çalışıyorsa asla durdurulmaz. Ancak faturalandırılmayı önlemek için, kullanmadığınızda duraklatmak isteyebilirsiniz. Bu, pause_space() kullanılarak yapılabilir. Duraklatılmış bir Space, Space'in sahibi onu arayüz üzerinden veya restart_space() kullanarak API aracılığıyla yeniden başlatana kadar pasif kalır. Duraklatılmış mod hakkında daha fazla ayrıntı için lütfen bu bölüme bakın.

# Pause your Space to avoid getting billed
>>> api.pause_space(repo_id=repo_id)
# (...)
# Restart it when you need it
>>> api.restart_space(repo_id=repo_id)

Bir diğer olasılık, Space'iniz için bir zaman aşımı belirlemektir. Space'iniz, zaman aşımı süresinden daha uzun süre pasif kalırsa uykuya geçer. Space'inize gelen herhangi bir ziyaretçi onu yeniden başlatır. set_space_sleep_time() kullanarak bir zaman aşımı belirleyebilirsiniz. Uyku modu hakkında daha fazla ayrıntı için lütfen bu bölüme bakın.

# Put your Space to sleep after 1h of inactivity
>>> api.set_space_sleep_time(repo_id=repo_id, sleep_time=3600)

Not: ‘cpu-basic’ donanımı kullanıyorsanız özel bir uyku süresi yapılandıramazsınız. Space'iniz 48 saat hareketsizlikten sonra otomatik olarak duraklatılır.

Bonus: donanım isterken uyku süresi belirleyin

Yükseltilmiş donanım, Space'iniz oluşturulduğunda otomatik olarak atayacaktır.

>>> api.request_space_hardware(repo_id=repo_id, hardware=SpaceHardware.T4_MEDIUM, sleep_time=3600)

Bonus: Space oluştururken veya kopyalarken bir uyku süresi ayarlayın!

>>> api.create_repo(
...     repo_id=repo_id,
...     repo_type="space",
...     space_sdk="gradio",
...     space_hardware="t4-medium",
...     space_sleep_time="3600",
... )

>>> api.duplicate_repo(
...     from_id=repo_id,
...     repo_type="space",
...     space_hardware="t4-medium",
...     space_sleep_time="3600",
... )

Hata veren bir Space'i günlüklerini okuyarak hata ayıklama

Bir Space derlenemezse veya çalışma zamanında çökerse, tarayıcıda görüntülediğiniz günlükler programatik olarak da fetch_space_logs() üzerinden erişilebilir. Bu, tarayıcı açmanın mümkün olmadığı betiklerde veya ajan tabanlı iş akışlarında özellikle faydalıdır.

# Drain the currently available run logs and return immediately (like `docker logs`)
>>> for line in api.fetch_space_logs(repo_id=repo_id):
...     print(line, end="")

# Read the container build logs instead (useful when the Space is stuck in BUILD_ERROR)
>>> for line in api.fetch_space_logs(repo_id=repo_id, build=True):
...     print(line, end="")

# Stream run logs in real time until the server closes the stream (Ctrl-C to stop)
>>> for line in api.fetch_space_logs(repo_id=repo_id, follow=True):
...     print(line, end="")

Aynı işlevsellik CLI'den de kullanılabilir:

hf spaces logs username/my-space             # drain run logs
hf spaces logs username/my-space --build     # read build logs
hf spaces logs username/my-space -f          # stream in real time
hf spaces logs username/my-space -n 50       # last 50 lines only

Bir Space'e SSH ile bağlanın (Geliştirme Modu)

Dev Mode, çalışan bir Space konteynerine canlı hata ayıklama ve geliştirme için SSH ile bağlanmanızı sağlar. Oturumu doğrudan terminalden açmak için hf spaces ssh komutunu kullanın. Dev Mode henüz Space üzerinde etkinleştirilmediyse, CLI bunu etkinleştirmenizi ister (istemi atlamak için --auto parametresini geçebilirsiniz).

SSH genel anahtarınız ayarlarınızda kayıtlı olmalıdır.

# SSH into a Space (enables Dev Mode if needed)
hf spaces ssh username/my-space

# Auto-enable Dev Mode without prompting
hf spaces ssh username/my-space --auto

# Print the SSH command without running it
hf spaces ssh username/my-space --dry-run

# Use a specific SSH key
hf spaces ssh username/my-space -i ~/.ssh/id_ed25519

SSH kullanmadan hf spaces dev-mode ile Dev Mode'u da etkinleştirebilirsiniz; bu komut SSH, VS Code, Cursor ve Windsurf için bağlantı talimatlarını görüntüler:

hf spaces dev-mode username/my-space

Dev Modunun etkinleştirilmesi PRO veya Team & Enterprise planı gerektirir. Dev Modu açıkken aboneliğinizin süresi dolduysa gibi durumlarda devre dışı bırakılmasına her zaman izin verilir:

hf spaces dev-mode username/my-space --stop

Space'inizde hacim bağlayın

Hub kaynaklarını (modeller, veri kümeleri veya depolama varlıkları) Space konteynerinizde birimler olarak bağlayabilirsiniz. Bu, kodunuzda indirmede bulunmadan Space'inize bu kaynaklara doğrudan dosya sistemi erişimi sağlar. Birimler, bir Space oluşturulurken veya kopyalanırken doğrudan ayarlanabilir:

>>> from huggingface_hub import Volume
>>> api.create_repo(
...     repo_id=repo_id,
...     repo_type="space",
...     space_sdk="gradio",
...     space_volumes=[
...         Volume(type="model", source="username/my-model", mount_path="/models", read_only=True),
...         Volume(type="bucket", source="username/my-bucket", mount_path="/data"),
...     ],
... )

>>> api.duplicate_repo(
...     from_id=repo_id,
...     repo_type="space",
...     space_volumes=[
...         Volume(type="model", source="username/my-model", mount_path="/models", read_only=True),
...         Volume(type="bucket", source="username/my-bucket", mount_path="/data"),
...     ],
... )

Space çalışma zamanı üzerinden şu anda bağlı olan birimlerin hangileri olduğunu kontrol edebilirsiniz:

>>> runtime = api.get_space_runtime(repo_id=repo_id)
>>> runtime.volumes
[Volume(type='model', source='username/my-model', mount_path='/models', read_only=True), ...]

Mevcut bir Space'te hacimleri güncellemeniz gerekiyorsa set_space_volumes() kullanın. Bunun, daha önce bağlanmış tüm hacimleri değiştirdiğini unutmayın.

>>> api.set_space_volumes(
...     repo_id=repo_id,
...     volumes=[
...         Volume(type="model", source="username/my-model", mount_path="/models", read_only=True),
...         Volume(type="dataset", source="username/my-dataset", mount_path="/data", read_only=True),
...         Volume(type="bucket", source="username/my-bucket", mount_path="/output"),
...     ],
... )

Space'inizden tüm hacimleri kaldırmak için:

>>> api.delete_space_volumes(repo_id=repo_id)

Modeller, veri kümeleri ve Spaces her zaman salt okunur olarak bağlanır. Yalnızca depolama varilleri salt okunur-yazılabilir bağlamaları destekler.

Hacimlerin ayarlanması, daha önce bağlanmış hacimleri değiştirir. Mevcut bir listeye hacim eklemek için, önce mevcut hacimleri çalışma zamanından okuyun ve bunları yeni listeye dahil edin.

Tüm hacim işlemleri CLI'den de kullanılabilir:

# List current volumes
hf spaces volumes ls username/my-space

# Set (replace) volumes
hf spaces volumes set username/my-space \
    -v hf://models/username/my-model:/models \
    -v hf://buckets/username/my-bucket:/data

# Remove all volumes
hf spaces volumes delete username/my-space

Daha ileri düzey: Space'inizi geçici olarak yükseltin!

Spaces birçok farklı kullanım senaryosuna olanak tanır. Bazen bir Space'i belirli bir donanımda geçici olarak çalıştırıp bir işlem gerçekleştirdikten sonra kapatmak isteyebilirsiniz. Bu bölümde, bir modeli talep üzerine ince ayarlamak için Spaces'ten nasıl faydalanabileceğinizi inceleyeceğiz. Bu, bu özel sorunu çözmenin yalnızca bir yoludur. Bir öneri olarak ele alınmalı ve kullanım senarinize göre uyarlanmalıdır.

Bir modelin ince ayarını yapmak için bir Space'imize sahip olduğumuzu varsayalım. Bu, girdi olarak bir model kimliği ve bir veri seti kimliği alan bir Gradio uygulamasıdır. İş akışı şu şekildedir:

0. (Kullanıcıdan bir model ve bir veri seti isteyin)
1. Modeli Hub'dan yükleyin.
2. Veri setini Hub'dan yükleyin.
3. Modeli veri setinde ince ayarlayın.
4. Yeni modeli Hub'a yükleyin.

Adım 3. özel bir donanım gerektirir ancak Space'inizin sürekli olarak ücretli bir GPU üzerinde çalışmasını istemiyorsunuz. Çözüm, eğitim için donanımı dinamik olarak talep etmek ve sonrasında kapatmaktır. Donanım talebi Space'inizi yeniden başlattığından, uygulamanızın o an gerçekleştirdiği görevi bir şekilde “hatırlaması” gerekir. Bunun birden fazla yolu vardır. Bu kılavuzda, bir Dataset'i “görev zamanlayıcı” olarak kullanan bir çözümü inceleyeceğiz.

Uygulama iskeleti

Uygulamanızın görünümü aşağıdaki gibidir. Başlangıçta bir görevin planlanıp planlanmadığını kontrol edin ve evetse, onu doğru donanımda çalıştırın. İşlem tamamlandığında, donanımı boşta olan cpu-basic CPU'ya geri ayarlayın ve kullanıcıdan yeni bir görev isteyin.

Bu tür bir iş akışı, normal demolar gibi eşzamanlı erişimi desteklemez. Özellikle, eğitim gerçekleşirken arayüz devre dışı bırakılır. Sadece sizin kullanıcı olduğunuzdan emin olmak için repoyu özel olarak ayarlamak tercih edilir.

# Space will need your token to request hardware: set it as a Secret !
HF_TOKEN = os.environ.get("HF_TOKEN")

# Space own repo_id
TRAINING_SPACE_ID = "Wauplin/dreambooth-training"

from huggingface_hub import HfApi, SpaceHardware
api = HfApi(token=HF_TOKEN)

# On Space startup, check if a task is scheduled. If yes, finetune the model. If not,
# display an interface to request a new task.
task = get_task()
if task is None:
    # Start Gradio app
    def gradio_fn(task):
        # On user request, add task and request hardware
        add_task(task)
        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.T4_MEDIUM)

    gr.Interface(fn=gradio_fn, ...).launch()
else:
    runtime = api.get_space_runtime(repo_id=TRAINING_SPACE_ID)
    # Check if Space is loaded with a GPU.
    if runtime.hardware == SpaceHardware.T4_MEDIUM:
        # If yes, finetune base model on dataset !
        train_and_upload(task)

        # Then, mark the task as "DONE"
        mark_as_done(task)

        # DO NOT FORGET: set back CPU hardware
        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.CPU_BASIC)
    else:
        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.T4_MEDIUM)

Görev zamanlayıcı

Görevlerin zamanlaması birçok şekilde yapılabilir. Aşağıda, bir Dataset olarak saklanan basit bir CSV kullanılarak bunun nasıl yapılabileceğine dair bir örnek verilmiştir.

# Dataset ID in which a `tasks.csv` file contains the tasks to perform.
# Here is a basic example for `tasks.csv` containing inputs (base model and dataset)
# and status (PENDING or DONE).
#     multimodalart/sd-fine-tunable,Wauplin/concept-1,DONE
#     multimodalart/sd-fine-tunable,Wauplin/concept-2,PENDING
TASK_DATASET_ID = "Wauplin/dreambooth-task-scheduler"

def _get_csv_file():
    return hf_hub_download(repo_id=TASK_DATASET_ID, filename="tasks.csv", repo_type="dataset", token=HF_TOKEN)

def get_task():
    with open(_get_csv_file()) as csv_file:
        csv_reader = csv.reader(csv_file, delimiter=',')
        for row in csv_reader:
            if row[2] == "PENDING":
                return row[0], row[1] # model_id, dataset_id

def add_task(task):
    model_id, dataset_id = task
    with open(_get_csv_file()) as csv_file:
        with open(csv_file, "r") as f:
            tasks = f.read()

    api.upload_file(
        repo_id=repo_id,
        repo_type=repo_type,
        path_in_repo="tasks.csv",
        # Quick and dirty way to add a task
        path_or_fileobj=(tasks + f"\n{model_id},{dataset_id},PENDING").encode()
    )

def mark_as_done(task):
    model_id, dataset_id = task
    with open(_get_csv_file()) as csv_file:
        with open(csv_file, "r") as f:
            tasks = f.read()

    api.upload_file(
        repo_id=repo_id,
        repo_type=repo_type,
        path_in_repo="tasks.csv",
        # Quick and dirty way to set the task as DONE
        path_or_fileobj=tasks.replace(
            f"{model_id},{dataset_id},PENDING",
            f"{model_id},{dataset_id},DONE"
        ).encode()
    )