might work

app.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from tempfile import TemporaryDirectory
 
 import gradio as gr
 from huggingface_hub import HfApi, Repository
@@ -6,23 +7,25 @@ from huggingface_hub.utils import RepositoryNotFoundError
 
 from convert import convert
 
-REPO_PATH = Path("bloomz.cpp")
 
-repo = Repository(local_dir="bloomz.cpp", clone_from="https://github.com/NouamaneTazi/bloomz.cpp")
-
-
-def run(token: str, model_id: str, precision: str, quantization: bool) -> str:
+def run(
+    token: str, model_id: str, precision: str, quantization: bool, destination: str
+) -> str:
     if token == "" or model_id == "":
         return """
         ### Invalid input 🐞
         
         Please fill a token and model_id.
         """
+    if destination == "":
+        destination = model_id
 
     api = HfApi(token=token)
     try:
         # TODO: make a PR to bloomz.cpp to be able to pass a token
-        api.model_info(repo_id=model_id, token=False)  # only public repos are accessible
+        api.model_info(
+            repo_id=model_id, token=False
+        )  # only public repos are accessible
     except RepositoryNotFoundError:
         return f"""
         ### Error 😢😢😢
@@ -31,17 +34,29 @@ def run(token: str, model_id: str, precision: str, quantization: bool) -> str:
         """
 
     try:
-        model_path = convert(model_id=model_id, precision=precision, quantization=quantization)
-        print("[commit_info]", model_path)
+        with TemporaryDirectory() as cache_folder:
+            model_path = convert(
+                cache_folder=Path(cache_folder),
+                model_id=model_id,
+                precision=precision,
+                quantization=quantization,
+            )
+            print("[model_path]", model_path)
 
-        return f"""
-        ### Success 🔥
-        """
-        return f"""
-        ### Success 🔥
-        Yay! This model was successfully converted and a PR was open using your token, here:
-        # [{commit_info.pr_url}]({commit_info.pr_url})
-        """
+            commit_info = api.upload_file(
+                repo_id=destination,
+                path_or_fileobj=model_path,
+                path_in_repo=model_path.name,
+                create_pr=True,
+                commit_message=f"Add {model_path.name} from bloomz.cpp converter.",
+            )
+
+            return f"""
+            ### Success 🔥
+            Yay! This model was successfully converted and a PR was open using your token, here:
+            
+            # [{commit_info.pr_url}]({commit_info.pr_url})
+            """
     except Exception as e:
         return f"""
         ### Error 😢😢😢
@@ -52,11 +67,14 @@ def run(token: str, model_id: str, precision: str, quantization: bool) -> str:
 
 DESCRIPTION = """
 The steps are the following:
-- Paste a read-access token from hf.co/settings/tokens. Read access is enough given that we will open a PR against the source repo.
-- Input a model id from the Hub
-- Click "Submit"
-- That's it! You'll get feedback if it works or not, and if it worked, you'll get the URL of the opened PR 🔥
-⚠️ For now only `pytorch_model.bin` files are supported but we'll extend in the future.
+- Paste your HF token. You can create one in your [settings page](https://huggingface.co/settings/tokens).
+- Input a model id from the Hub. This model must be public.
+- Choose which precision you want to use (default to FP16).
+- (optional) Opt-in for 4-bit quantization.
+- (optional) By default a PR to the initial repo will be created. You can choose a different destination repo if you want. The destination repo must exist.
+- Click Submit:
+
+That's it! You'll get feedback if it works or not, and if it worked, you'll get the URL of the opened PR 🔥
 """
 
 demo = gr.Interface(
@@ -69,6 +87,7 @@ demo = gr.Interface(
         gr.Text(max_lines=1, label="model_id (e.g.: bigscience/bloomz-7b1)"),
         gr.Radio(choices=["FP16", "FP32"], label="Precision", value="FP16"),
         gr.Checkbox(value=False, label="4-bits quantization"),
+        gr.Text(max_lines=1, label="destination (e.g.: my-username/bloomz-7b1.cpp)"),
     ],
     outputs=[gr.Markdown(label="output")],
     fn=run,

convert.py

@@ -1,14 +1,18 @@
 from pathlib import Path
 from subprocess import run
 
+BLOOMZ_FOLDER = Path(__file__).parent / "bloomz.cpp"
 
-def convert(model_id:str, precision:str, quantization:bool)->Path:
+
+def convert(
+    cache_folder: Path, model_id: str, precision: str, quantization: bool
+) -> Path:
     # Conversion
     cmd = [
         "python",
-        "./bloomz.cpp/convert-hf-to-ggml.py",
-        model_id, # bigscience/bloomz-560m
-        "./bloomz.cpp/models",
+        str(BLOOMZ_FOLDER / "convert-hf-to-ggml.py"),
+        model_id,
+        str(cache_folder),
     ]
     if precision == "FP32":
         cmd.append("--use-fp32")
@@ -17,20 +21,23 @@ def convert(model_id:str, precision:str, quantization:bool)->Path:
     # Model file should exist
     f_suffix = "f32" if precision == "FP32" else "f16"
     _, model_name = model_id.split("/")
-    model_path = Path(f"./bloomz.cpp/models/ggml-model-{model_name}-{f_suffix}.bin")
+    model_path = cache_folder / f"ggml-model-{model_name}-{f_suffix}.bin"
     assert model_path.is_file()
 
     # Quantization
     if quantization:
+        q_model_path = model_path = (
+            cache_folder / f"ggml-model-{model_name}-{f_suffix}-q4_0.bin"
+        )
         cmd = [
             "./bloomz.cpp/quantize",
-            f"./bloomz.cpp/models/ggml-model-{model_name}-{f_suffix}.bin",
-            f"./bloomz.cpp/models/ggml-model-{model_name}-{f_suffix}-q4_0.bin",
+            str(model_path),
+            str(q_model_path),
             "2",
         ]
         run(cmd, check=True)
-        model_path = Path(f"./bloomz.cpp/models/ggml-model-{model_name}-{f_suffix}.bin")
-        assert model_path.is_file()
+        assert q_model_path.is_file()
+        model_path = q_model_path
 
     # Return
     return model_path