lamin_cli 0.12.3__tar.gz → 0.13.1__tar.gz

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamin_cli
-Version: 0.12.3
+Version: 0.13.1
 Summary: Lamin CLI.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown

lamin_cli-0.13.1/lamin_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Lamin CLI."""
+
+__version__ = "0.13.1"

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/lamin_cli/_get.py

@@ -30,7 +30,9 @@ def get(url: str):
     if entity == "transform":
         transform = ln.Transform.filter(uid=uid).one()
         filepath_cache = transform.source_code.cache()
-        target_filename = f"{transform.key}.ipynb"
+        target_filename = transform.key
+        if not target_filename.endswith(transform.source_code.suffix):
+            target_filename += transform.source_code.suffix
         filepath_cache.rename(target_filename)
         logger.success(f"cached source code of transform {uid} as {target_filename}")
     else:

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/lamin_cli/_save.py

@@ -3,6 +3,44 @@ from pathlib import Path
 from typing import Optional, Union
 import lamindb_setup as ln_setup
 from lamin_utils import logger
+import re
+
+
+def get_stem_uid_and_version_from_file(file_path: Path) -> tuple[str, str]:
+    # line-by-line matching might be faster, but let's go with this for now
+    with open(file_path) as file:
+        content = file.read()
+
+    if file_path.suffix == ".py":
+        stem_uid_pattern = re.compile(
+            r'\.transform\.stem_uid\s*=\s*["\']([^"\']+)["\']'
+        )
+        version_pattern = re.compile(r'\.transform\.version\s*=\s*["\']([^"\']+)["\']')
+    elif file_path.suffix == ".ipynb":
+        stem_uid_pattern = re.compile(
+            r'\.transform\.stem_uid\s*=\s*\\["\']([^"\']+)\\["\']'
+        )
+        version_pattern = re.compile(
+            r'\.transform\.version\s*=\s*\\["\']([^"\']+)\\["\']'
+        )
+    else:
+        raise ValueError("Only .py and .ipynb files are supported.")
+
+    # Search for matches in the entire file content
+    stem_uid_match = stem_uid_pattern.search(content)
+    version_match = version_pattern.search(content)
+
+    # Extract values if matches are found
+    stem_uid = stem_uid_match.group(1) if stem_uid_match else None
+    version = version_match.group(1) if version_match else None
+
+    if stem_uid is None or version is None:
+        raise SystemExit(
+            "ln.settings.transform.stem_uid and ln.settings.transform.version aren't"
+            f" set in {file_path}\nCall ln.track() and copy/paste the output into the"
+            " notebook"
+        )
+    return stem_uid, version
 
 
 def save_from_filepath_cli(
@@ -17,7 +55,6 @@ def save_from_filepath_cli(
     ln_setup.settings.auto_connect = True
 
     import lamindb as ln
-    from lamindb.core._run_context import get_stem_uid_and_version_from_file
     from lamindb._finish import save_run_context_core
 
     ln_setup.settings.auto_connect = auto_connect_state

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/tests/conftest.py

@@ -7,12 +7,13 @@ from lamin_utils import logger
 
 def pytest_sessionstart(session: pytest.Session):
     ln.setup.init(
-        storage="./default_storage",
-        name="lamindb-unit-tests",
+        storage="./default_storage_ci",
+        name="laminci-unit-tests",
     )
+    ln.setup.settings.auto_connect = True
 
 
 def pytest_sessionfinish(session: pytest.Session):
     logger.set_verbosity(1)
-    ln.setup.delete("lamindb-unit-tests", force=True)
-    shutil.rmtree("./default_storage")
+    shutil.rmtree("./default_storage_ci")
+    ln.setup.delete("laminci-unit-tests", force=True)

lamin_cli-0.13.1/tests/notebooks/with-title-and-initialized-consecutive.ipynb

@@ -0,0 +1,193 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# My test notebook (consecutive)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-04-30T02:45:28.590279Z",
+     "iopub.status.busy": "2024-04-30T02:45:28.590128Z",
+     "iopub.status.idle": "2024-04-30T02:45:29.921019Z",
+     "shell.execute_reply": "2024-04-30T02:45:29.920739Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💡 connected lamindb: testuser1/laminci-unit-tests\n"
+     ]
+    }
+   ],
+   "source": [
+    "import lamindb as ln"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-04-30T02:45:29.923093Z",
+     "iopub.status.busy": "2024-04-30T02:45:29.922808Z",
+     "iopub.status.idle": "2024-04-30T02:45:32.189053Z",
+     "shell.execute_reply": "2024-04-30T02:45:32.188627Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💡 notebook imports: lamindb==0.71.0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💡 saved: Transform(uid='hlsFXswrJjtt5zKv', name='My test notebook (consecutive)', key='with-title-and-initialized-consecutive', version='1', type='notebook', updated_at=2024-04-30 02:45:31 UTC, created_by_id=1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💡 saved: Run(uid='oX11QZyYk6dhucek9jNg', transform_id=1, created_by_id=1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ln.settings.transform.stem_uid = \"hlsFXswrJjtt\"\n",
+    "ln.settings.transform.version = \"1\"\n",
+    "ln.track()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-04-30T02:45:32.191144Z",
+     "iopub.status.busy": "2024-04-30T02:45:32.191016Z",
+     "iopub.status.idle": "2024-04-30T02:45:32.193262Z",
+     "shell.execute_reply": "2024-04-30T02:45:32.192907Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "my consecutive cell\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"my consecutive cell\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py39",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {
+     "31729cb39d074e8fb483120775f53731": {
+      "model_module": "ipylab",
+      "model_module_version": "^1.0.0",
+      "model_name": "SessionManagerModel",
+      "state": {
+       "_model_module": "ipylab",
+       "_model_module_version": "^1.0.0",
+       "_model_name": "SessionManagerModel",
+       "_view_count": null,
+       "_view_module": null,
+       "_view_module_version": "",
+       "_view_name": null,
+       "current_session": {},
+       "sessions": []
+      }
+     },
+     "6939d8a17fbb46b8877f987b20b56757": {
+      "model_module": "ipylab",
+      "model_module_version": "^1.0.0",
+      "model_name": "CommandRegistryModel",
+      "state": {
+       "_command_list": [],
+       "_commands": [],
+       "_model_module": "ipylab",
+       "_model_module_version": "^1.0.0",
+       "_model_name": "CommandRegistryModel",
+       "_view_count": null,
+       "_view_module": null,
+       "_view_module_version": "",
+       "_view_name": null
+      }
+     },
+     "82c3ccb5d1114b968e80e1605d528742": {
+      "model_module": "ipylab",
+      "model_module_version": "^1.0.0",
+      "model_name": "JupyterFrontEndModel",
+      "state": {
+       "_model_module": "ipylab",
+       "_model_module_version": "^1.0.0",
+       "_model_name": "JupyterFrontEndModel",
+       "_view_count": null,
+       "_view_module": null,
+       "_view_module_version": "",
+       "_view_name": null,
+       "commands": "IPY_MODEL_6939d8a17fbb46b8877f987b20b56757",
+       "sessions": "IPY_MODEL_31729cb39d074e8fb483120775f53731",
+       "shell": "IPY_MODEL_9f239e52e3794df9b2c06052072cad24",
+       "version": ""
+      }
+     },
+     "9f239e52e3794df9b2c06052072cad24": {
+      "model_module": "ipylab",
+      "model_module_version": "^1.0.0",
+      "model_name": "ShellModel",
+      "state": {
+       "_model_module": "ipylab",
+       "_model_module_version": "^1.0.0",
+       "_model_name": "ShellModel",
+       "_view_count": null,
+       "_view_module": null,
+       "_view_module_version": "",
+       "_view_name": null,
+       "_widgets": []
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/tests/notebooks/with-title-and-initialized-non-consecutive.ipynb

@@ -65,7 +65,6 @@
         }
       ],
       "source": [
-        "ln.connect(\"lamindb-unit-tests\")\n",
         "ln.settings.transform.stem_uid = \"HDMGkxN9rgFA\"\n",
         "ln.settings.transform.version = \"1\"\n",
         "ln.track()"

lamin_cli-0.13.1/tests/scripts/merely-import-lamindb.py

@@ -0,0 +1,4 @@
+import lamindb as ln  # noqa
+
+if __name__ == "__main__":
+    print("hello!")

lamin_cli-0.12.3/tests/scripts/initialized.py → lamin_cli-0.13.1/tests/scripts/run-track-and-finish-sync-git.py

@@ -1,7 +1,5 @@
 import lamindb as ln
 
-ln.connect("lamindb-unit-tests")
-
 ln.settings.sync_git_repo = "https://github.com/laminlabs/lamin-cli"
 ln.settings.transform.stem_uid = "m5uCHTTpJnjQ"
 ln.settings.transform.version = "1"
@@ -13,3 +11,5 @@ if __name__ == "__main__":
     ln.track(new_run=False)
 
     print("hello!")
+
+    ln.finish()

lamin_cli-0.12.3/tests/scripts/initialized-no-git-sync.py → lamin_cli-0.13.1/tests/scripts/run-track-and-finish.py

@@ -1,9 +1,14 @@
 import lamindb as ln
 
-ln.connect("lamindb-unit-tests")
+ln.settings.transform.stem_uid = "VFYCIuaw2GsX"
+ln.settings.transform.version = "1"
 
 if __name__ == "__main__":
     # we're using new_run here to mock the notebook situation
     # and cover the look up of an existing run in the tests
     # new_run = True is trivial
+    ln.track(new_run=False)
+
     print("hello!")
+
+    ln.finish()

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/tests/test_get.py

@@ -3,7 +3,7 @@ import subprocess
 
 
 def test_decompose_url():
-    url = "https://lamin.ai/laminlabs/arrayloader-benchmarks/core/transform/1GCKs8zLtkc85zKv"  # noqa
+    url = "https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv"  # noqa
     result = decompose_url(url)
     instance_slug, entity, uid = result
     assert instance_slug == "laminlabs/arrayloader-benchmarks"
@@ -14,7 +14,7 @@ def test_decompose_url():
 def test_get():
     result = subprocess.run(
         "lamin get"
-        " 'https://lamin.ai/laminlabs/arrayloader-benchmarks/core/transform/1GCKs8zLtkc85zKv'",  # noqa
+        " 'https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv'",  # noqa
         shell=True,
         capture_output=True,
     )

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/tests/test_multi_process.py

@@ -6,7 +6,7 @@ scripts_dir = Path(__file__).parent.resolve() / "scripts"
 
 
 def run_script():
-    filepath = scripts_dir / "initialized-no-git-sync.py"
+    filepath = scripts_dir / "merely-import-lamindb.py"
     result = subprocess.run(
         f"python {filepath}",
         shell=True,

{lamin_cli-0.12.3 → lamin_cli-0.13.1}/tests/test_save_notebooks.py

@@ -3,7 +3,9 @@ import subprocess
 from pathlib import Path
 import nbproject_test
 import pytest
+from nbproject.dev import read_notebook, write_notebook
 from nbclient.exceptions import CellExecutionError
+import lamindb as ln
 
 notebook_dir = "./sub/lamin-cli/tests/notebooks/"
 
@@ -30,9 +32,6 @@ def test_save_non_consecutive():
     notebook_path = Path(
         f"{notebook_dir}with-title-and-initialized-non-consecutive.ipynb"
     ).resolve()
-    import lamindb as ln
-
-    ln.connect("lamindb-unit-tests")
 
     # here, we're mimicking a non-consecutive run
     transform = ln.Transform(
@@ -63,11 +62,6 @@ def test_save_consecutive():
     env = os.environ
     env["LAMIN_TESTING"] = "true"
 
-    # let's inspect what got written to the database
-    import lamindb as ln
-
-    ln.connect("lamindb-unit-tests")
-
     transform = ln.Transform.filter(uid="hlsFXswrJjtt5zKv").one_or_none()
     assert transform is None
 
@@ -106,22 +100,26 @@ def test_save_consecutive():
     assert transform is not None
     assert transform.latest_report.path.exists()
     assert transform.latest_run.report.path == transform.latest_report.path
-    assert transform.source_code.hash == "AvZdpq4EHax5rNcnW-RACw"
+    assert transform.source_code.hash == "5nc_HMjPvT9n26OWrjq6uQ"
     assert transform.latest_run.environment.path.exists()
     assert transform.source_code.path.exists()
 
-    # now, assume the user modifies the notebook and saves
-    # it without changing stem uid or version
-    # outside of tests, this triggers a dialogue
-    # within tests, it automatically overwrites the source
-    from nbproject.dev import read_notebook, write_notebook
-
+    # now, assume the user modifies the notebook
     nb = read_notebook(notebook_path)
     # simulate editing the notebook (here, duplicate last cell)
     new_cell = nb.cells[-1].copy()
     new_cell["execution_count"] += 1
     nb.cells.append(new_cell)
     write_notebook(nb, notebook_path)
+
+    # try re-running - it fails
+    with pytest.raises(CellExecutionError) as error:
+        nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
+    print(error.exconly())
+    assert "UpdateTransformSettings" in error.exconly()
+
+    # try re-saving - it works but will issue an interactive warning dialogue
+    # that clarifies that the user is about to re-save the notebook
     result = subprocess.run(
         f"lamin save {notebook_path}",
         shell=True,
@@ -130,16 +128,24 @@ def test_save_consecutive():
     )
     assert result.returncode == 0
     assert "saved transform" in result.stdout.decode()
-
-    # now, the source code should be overwritten
-    transform = ln.Transform.filter(uid="hlsFXswrJjtt5zKv").one_or_none()
-    assert transform is not None
+    # the source code is overwritten with the edits, reflected in a new hash
+    transform = ln.Transform.get("hlsFXswrJjtt5zKv")
     assert transform.latest_report.path.exists()
     assert transform.latest_run.report.path == transform.latest_report.path
-    assert transform.source_code.hash == "-hK6xaIrA04vJFAY2wWAQQ"
+    assert transform.source_code.hash == "ocLybD0Hv_L3NhhXgTyQcw"
     assert transform.latest_run.environment.path.exists()
     assert transform.source_code.path.exists()
 
+    # get the the source code via command line
+    result = subprocess.run(
+        "lamin get"
+        f" https://lamin.ai/{ln.setup.settings.user.handle}/laminci-unit-tests/transform/hlsFXswrJjtt5zKv",  # noqa
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stderr.decode())
+    assert result.returncode == 0
+
     # now, assume the user renames the notebook
     new_path = notebook_path.with_name("new_name.ipynb")
     os.system(f"cp {notebook_path} {new_path}")

lamin_cli-0.13.1/tests/test_save_scripts.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+import subprocess
+import os
+import lamindb as ln
+from lamindb_setup import settings
+
+
+scripts_dir = Path(__file__).parent.resolve() / "scripts"
+
+
+def test_run_save_cache():
+    env = os.environ
+    env["LAMIN_TESTING"] = "true"
+    filepath = scripts_dir / "run-track-and-finish-sync-git.py"
+
+    # attempt to save the script without it yet being run
+    result = subprocess.run(
+        f"lamin save {filepath}",
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stderr.decode())
+    assert result.returncode == 1
+    assert "Did you run ln.track()" in result.stdout.decode()
+
+    # run the script
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
+    assert result.returncode == 0
+    assert "saved: Transform" in result.stdout.decode()
+    assert "m5uCHTTpJnjQ5zKv" in result.stdout.decode()
+    assert "saved: Run" in result.stdout.decode()
+
+    transform = ln.Transform.get("m5uCHTTpJnjQ")
+    assert transform.source_code.hash == "-QN2dVdC8T3xWG8vBl-wew"
+    assert transform.latest_run.environment.path.exists()
+    assert transform.source_code.path.exists()
+
+    # you can rerun the same script
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
+    assert result.returncode == 0
+    assert "loaded: Transform" in result.stdout.decode()
+    assert "m5uCHTTpJnjQ5zKv" in result.stdout.decode()
+    assert "loaded: Run" in result.stdout.decode()
+
+    # edit the script
+    content = filepath.read_text() + "\n # edited"
+    filepath.write_text(content)
+
+    # re-run the script
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
+    assert result.returncode == 1
+    assert "Did not find blob hash" in result.stderr.decode()
+
+    # edit the script to remove the git integration
+    content = filepath.read_text()
+    content_lines = content.split("\n")
+    content_lines.remove(
+        'ln.settings.sync_git_repo = "https://github.com/laminlabs/lamin-cli"'
+    )
+    content = "\n".join(content_lines)
+    filepath.write_text(content)
+
+    # re-run the script
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
+    assert result.returncode == 1
+    assert "Please update your transform settings as follows" in result.stderr.decode()
+
+    # try to get the the source code via command line
+    result = subprocess.run(
+        "lamin get"
+        f" https://lamin.ai/{settings.user.handle}/laminci-unit-tests/transform/m5uCHTTpJnjQ5zKv",  # noqa
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stderr.decode())
+    assert result.returncode == 0

lamin_cli-0.12.3/lamin_cli/__init__.py

@@ -1,3 +0,0 @@
-"""Lamin CLI."""
-
-__version__ = "0.12.3"

lamin_cli-0.12.3/tests/notebooks/with-title-and-initialized-consecutive.ipynb

@@ -1,218 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# My test notebook (consecutive)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2024-02-28T10:26:34.123001Z",
-          "iopub.status.busy": "2024-02-28T10:26:34.122692Z",
-          "iopub.status.idle": "2024-02-28T10:26:35.334278Z",
-          "shell.execute_reply": "2024-02-28T10:26:35.333942Z"
-        }
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "💡 lamindb instance: falexwolf/lamindb-setup-notebook-tests\n"
-          ]
-        }
-      ],
-      "source": [
-        "import lamindb as ln"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2024-02-28T10:26:35.351854Z",
-          "iopub.status.busy": "2024-02-28T10:26:35.351500Z",
-          "iopub.status.idle": "2024-02-28T10:26:37.516724Z",
-          "shell.execute_reply": "2024-02-28T10:26:37.516289Z"
-        }
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "💡 notebook imports: lamindb==0.67.3\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "💡 saved: Transform(uid='hlsFXswrJjtt5zKv', name='My test notebook (consecutive)', key='with-title-and-initialized-consecutive', version='1', type=notebook, updated_at=2024-02-28 10:26:36 UTC, created_by_id=1)\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "💡 saved: Run(uid='FyKeQx6bw3o1okN4khF7', started_at=2024-02-28 10:26:36 UTC, transform_id=1, created_by_id=1)\n"
-          ]
-        }
-      ],
-      "source": [
-        "ln.connect(\"lamindb-unit-tests\")\n",
-        "ln.settings.transform.stem_uid = \"hlsFXswrJjtt\"\n",
-        "ln.settings.transform.version = \"1\"\n",
-        "ln.track()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2024-02-28T10:26:37.518448Z",
-          "iopub.status.busy": "2024-02-28T10:26:37.518331Z",
-          "iopub.status.idle": "2024-02-28T10:26:37.520409Z",
-          "shell.execute_reply": "2024-02-28T10:26:37.520130Z"
-        }
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "my consecutive cell\n"
-          ]
-        }
-      ],
-      "source": [
-        "print(\"my consecutive cell\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 4,
-      "metadata": {
-        "execution": {
-          "iopub.execute_input": "2024-02-28T10:26:37.518448Z",
-          "iopub.status.busy": "2024-02-28T10:26:37.518331Z",
-          "iopub.status.idle": "2024-02-28T10:26:37.520409Z",
-          "shell.execute_reply": "2024-02-28T10:26:37.520130Z"
-        }
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "my consecutive cell\n"
-          ]
-        }
-      ],
-      "source": [
-        "print(\"my consecutive cell\")"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "py39",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.10.13"
-    },
-    "widgets": {
-      "application/vnd.jupyter.widget-state+json": {
-        "state": {
-          "444383c3d65b4d12a4f133df8dc72a9f": {
-            "model_module": "ipylab",
-            "model_module_version": "^1.0.0",
-            "model_name": "ShellModel",
-            "state": {
-              "_model_module": "ipylab",
-              "_model_module_version": "^1.0.0",
-              "_model_name": "ShellModel",
-              "_view_count": null,
-              "_view_module": null,
-              "_view_module_version": "",
-              "_view_name": null,
-              "_widgets": []
-            }
-          },
-          "b782fd14699442f5af38bfdaefae8b43": {
-            "model_module": "ipylab",
-            "model_module_version": "^1.0.0",
-            "model_name": "SessionManagerModel",
-            "state": {
-              "_model_module": "ipylab",
-              "_model_module_version": "^1.0.0",
-              "_model_name": "SessionManagerModel",
-              "_view_count": null,
-              "_view_module": null,
-              "_view_module_version": "",
-              "_view_name": null,
-              "current_session": {},
-              "sessions": []
-            }
-          },
-          "c5cf1ccc24ea4a49a6f6a8350c2cea24": {
-            "model_module": "ipylab",
-            "model_module_version": "^1.0.0",
-            "model_name": "CommandRegistryModel",
-            "state": {
-              "_command_list": [],
-              "_commands": [],
-              "_model_module": "ipylab",
-              "_model_module_version": "^1.0.0",
-              "_model_name": "CommandRegistryModel",
-              "_view_count": null,
-              "_view_module": null,
-              "_view_module_version": "",
-              "_view_name": null
-            }
-          },
-          "c63b8662332149d7a748445640768bf8": {
-            "model_module": "ipylab",
-            "model_module_version": "^1.0.0",
-            "model_name": "JupyterFrontEndModel",
-            "state": {
-              "_model_module": "ipylab",
-              "_model_module_version": "^1.0.0",
-              "_model_name": "JupyterFrontEndModel",
-              "_view_count": null,
-              "_view_module": null,
-              "_view_module_version": "",
-              "_view_name": null,
-              "commands": "IPY_MODEL_c5cf1ccc24ea4a49a6f6a8350c2cea24",
-              "sessions": "IPY_MODEL_b782fd14699442f5af38bfdaefae8b43",
-              "shell": "IPY_MODEL_444383c3d65b4d12a4f133df8dc72a9f",
-              "version": ""
-            }
-          }
-        },
-        "version_major": 2,
-        "version_minor": 0
-      }
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 2
-}

lamin_cli-0.12.3/tests/test_save_scripts.py

@@ -1,57 +0,0 @@
-from pathlib import Path
-import subprocess
-import os
-from lamindb_setup import settings
-
-
-scripts_dir = Path(__file__).parent.resolve() / "scripts"
-
-
-def test_run_save_cache():
-    env = os.environ
-    env["LAMIN_TESTING"] = "true"
-
-    filepath = scripts_dir / "initialized.py"
-    # attempt to save the script without it yet being run
-    # lamin save sub/lamin-cli/tests/scripts/initialized.py
-    result = subprocess.run(
-        f"lamin save {filepath}",
-        shell=True,
-        capture_output=True,
-    )
-    print(result.stderr.decode())
-    assert result.returncode == 1
-    assert "Did you run ln.track()" in result.stdout.decode()
-
-    # python sub/lamin-cli/tests/scripts/initialized.py
-    result = subprocess.run(
-        f"python {filepath}",
-        shell=True,
-        capture_output=True,
-    )
-    print(result.stdout.decode())
-    print(result.stderr.decode())
-    assert result.returncode == 0
-    assert "saved: Transform" in result.stdout.decode()
-    assert "saved: Run" in result.stdout.decode()
-
-    # python sub/lamin-cli/tests/scripts/initialized.py
-    # you can rerun the same script
-    result = subprocess.run(
-        f"python {filepath}",
-        shell=True,
-        capture_output=True,
-        env=env,
-    )
-    print(result.stdout.decode())
-    print(result.stderr.decode())
-    assert result.returncode == 0
-
-    result = subprocess.run(
-        "lamin get"
-        f" https://lamin.ai/{settings.user.handle}/lamindb-unit-tests/transform/m5uCHTTpJnjQ5zKv",  # noqa
-        shell=True,
-        capture_output=True,
-    )
-    print(result.stderr.decode())
-    assert result.returncode == 0