lamin_cli 0.16.3__tar.gz → 0.17.1__tar.gz

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/PKG-INFO

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

lamin_cli-0.17.1/lamin_cli/__init__.py

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

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/lamin_cli/__main__.py

@@ -96,7 +96,7 @@ def main():
 
 
 @main.command()
-@click.argument("user", type=str)
+@click.argument("user", type=str, default=None, required=False)
 @click.option("--key", type=str, default=None, help="API key")
 def login(user: str, key: Optional[str]):
     """Log into LaminHub.
@@ -110,10 +110,26 @@ def login(user: str, key: Optional[str]):
     You'll find your API key in the top right corner under "Settings".
 
     After this, you can either use `lamin login myhandle` or `lamin login myemail@acme.com`
+
+    You can also use
+
+    ```
+    lamin login
+    ```
+
+    and type your beta API key in the terminal
     """
     from lamindb_setup._setup_user import login
 
-    return login(user, key=key)
+    if user is None:
+        if "LAMIN_API_KEY" in os.environ:
+            api_key = os.environ["LAMIN_API_KEY"]
+        else:
+            api_key = input("Your API key: ")
+    else:
+        api_key = None
+
+    return login(user, key=key, api_key=api_key)
 
 
 # fmt: off

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/lamin_cli/_get.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Tuple
 from lamin_utils import logger
 import lamindb_setup as ln_setup
+from pathlib import Path
 
 
 def decompose_url(url: str) -> Tuple[str, str, str]:
@@ -25,6 +26,7 @@ def get(url: str):
     ln_setup.settings.auto_connect = False
 
     import lamindb as ln
+    from lamindb._finish import script_to_notebook
 
     ln_setup.settings.auto_connect = auto_connect
     ln.connect(instance_slug)
@@ -32,12 +34,23 @@ def get(url: str):
 
     if entity == "transform":
         transform = ln.Transform.get(uid)
-        filepath_cache = transform._source_code_artifact.cache()
         target_filename = transform.key
-        if not target_filename.endswith(transform._source_code_artifact.suffix):
-            target_filename += transform._source_code_artifact.suffix
-        filepath_cache.rename(target_filename)
-        logger.success(f"cached source code of transform {uid} as {target_filename}")
+        if transform._source_code_artifact_id is not None:
+            # backward compat
+            filepath_cache = transform._source_code_artifact.cache()
+            if not target_filename.endswith(transform._source_code_artifact.suffix):
+                target_filename += transform._source_code_artifact.suffix
+            filepath_cache.rename(target_filename)
+        elif transform.source_code is not None:
+            if transform.key.endswith(".ipynb"):
+                script_to_notebook(transform, target_filename)
+            else:
+                Path(target_filename).write_text(transform.source_code)
+        else:
+            raise ValueError("No source code available for this transform.")
+        logger.success(
+            f"downloaded source code of transform {uid} as {target_filename}"
+        )
     elif entity == "artifact":
         artifact = ln.Artifact.get(uid)
         cache_path = artifact.cache()

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/lamin_cli/_save.py

@@ -90,13 +90,10 @@ def save_from_filepath_cli(
                     " in Transform registry. Did you run ln.context.track()?"
                 )
                 return "not-tracked-in-transform-registry"
-            # refactor this, save_context_core should not depend on transform_family
-            transform_family = transform.versions
         else:
-            # the corresponding transform family in the transform table
-            transform_family = ln.Transform.filter(uid__startswith=stem_uid).all()
-            # the specific version
-            transform = transform_family.get(version=transform_version)
+            transform = ln.Transform.get(
+                uid__startswith=stem_uid, version=transform_version
+            )
         # latest run of this transform by user
         run = ln.Run.filter(transform=transform).order_by("-started_at").first()
         if run.created_by.id != ln_setup.settings.user.id:
@@ -110,6 +107,5 @@ def save_from_filepath_cli(
             run=run,
             transform=transform,
             filepath=filepath,
-            transform_family=transform_family,
             from_cli=True,
         )

lamin_cli-0.17.1/tests/test_cli.py

@@ -0,0 +1,42 @@
+import os
+from datetime import datetime, timedelta, timezone
+from lamindb_setup.core._hub_client import connect_hub_with_auth
+from lamindb_setup.core._hub_core import create_api_key
+
+
+def test_entrypoint():
+    exit_status = os.system("lamin --help")
+    assert exit_status == 0
+
+
+def test_cli_login():
+    exit_status = os.system("lamin login testuser1")
+    assert exit_status == 0
+
+    exit_status = os.system(
+        "lamin login testuser1 --key cEvcwMJFX4OwbsYVaMt2Os6GxxGgDUlBGILs2RyS"
+    )
+    assert exit_status == 0
+
+
+def test_cli_login_api_key():
+    expires_at = datetime.now(tz=timezone.utc) + timedelta(days=1)
+    api_key = create_api_key(
+        {
+            "expires_at": expires_at.strftime("%Y-%m-%d"),
+            "description": "test_cli_login_api_key",
+        }
+    )
+
+    exit_status = os.system(f"echo {api_key} | lamin login")
+    assert exit_status == 0
+
+    os.environ["LAMIN_API_KEY"] = api_key
+    exit_status = os.system("lamin login")
+    assert exit_status == 0
+
+    hub = connect_hub_with_auth()
+    hub.table("api_key").delete().eq("description", "test_cli_login_api_key").execute()
+    hub.auth.sign_out({"scope": "local"})
+
+    os.system("lamin login testuser1@lamin.ai")

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/tests/test_save_notebooks.py

@@ -5,6 +5,7 @@ import nbproject_test
 import pytest
 from nbproject.dev import read_notebook, write_notebook
 from nbclient.exceptions import CellExecutionError
+import json
 import lamindb as ln
 
 notebook_dir = "./sub/lamin-cli/tests/notebooks/"
@@ -39,20 +40,22 @@ def test_save_non_consecutive():
         version="1",
         name="My test notebook (non-consecutive)",
         type="notebook",
-    )
-    transform.save()
-    run = ln.Run(transform=transform)
-    run.save()
-    result = subprocess.run(
-        f"lamin save {notebook_path}",  # noqa
+    ).save()
+    ln.Run(transform=transform).save()
+
+    process = subprocess.Popen(
+        f"lamin save {notebook_path}",
         shell=True,
-        capture_output=True,
         env=env,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
     )
-    print(result.stdout.decode())
-    print(result.stderr.decode())
-    assert result.returncode == 1
-    assert "were not run consecutively" in result.stdout.decode()
+    stdout, stderr = process.communicate("n")
+    assert "were not run consecutively" in stdout
+    assert "Do you still want to proceed with finishing?" in stdout
+    assert process.returncode == 1
 
 
 def test_save_consecutive():
@@ -62,6 +65,8 @@ def test_save_consecutive():
     env = os.environ
     env["LAMIN_TESTING"] = "true"
 
+    assert not Path("./with-title-and-initialized-consecutive.ipynb").exists()
+
     transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
     assert transform is None
 
@@ -92,47 +97,80 @@ def test_save_consecutive():
         capture_output=True,
         env=env,
     )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
     assert result.returncode == 0
 
     # now, we have the associated artifacts
     transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
     assert transform is not None
-    assert transform.latest_run.report.path.exists()
-    assert transform.latest_run.report.path == transform.latest_run.report.path
-    assert transform._source_code_artifact.hash == "EQrdZpS-fPaz5MKk_g02AA"
+    assert (
+        transform.source_code
+        == """# %% [markdown]
+# # transform.name
+
+# %%
+import lamindb as ln
+
+# %%
+ln.context.uid = "hlsFXswrJjtt0000"
+ln.context.track()
+
+# %%
+print("my consecutive cell")
+"""
+    )
+    assert transform.hash == "fHpHnC_pScmOl3ZR8x5cTQ"
+    # below is the test that we can use if store the run repot as `.ipynb`
+    # and not as html as we do right now
+    assert transform.latest_run.report.suffix == ".html"
+    # with open(transform.latest_run.report.path, "r") as f:
+    #     json_notebook = json.load(f)
+    # # test that title is stripped from notebook
+    # assert json_notebook["cells"][0] == {
+    #     "cell_type": "markdown",
+    #     "metadata": {},
+    #     "source": [],
+    # }
+    # testing for the hash of the report makes no sense because it contains timestamps
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact.path.exists()
+    assert transform._source_code_artifact is None
 
-    # now, assume the user modifies the notebook
+    # edit 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)
+    nb.cells.append(new_cell)  # duplicate last cell
     write_notebook(nb, notebook_path)
 
-    # try re-running - it fails
+    # attempt re-running - it fails
     with pytest.raises(CellExecutionError) as error:
         nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
     # print(error.exconly())
     assert "UpdateContext" 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(
+    # attempt re-saving - it works but the user needs to confirm overwriting
+    # source code and run report
+    process = subprocess.Popen(
         f"lamin save {notebook_path}",
         shell=True,
-        capture_output=True,
         env=env,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
     )
-    assert result.returncode == 0
+    stdout, stderr = process.communicate("y\ny")
+    assert "You are about to overwrite existing source code" in stdout
+    assert "You are about to overwrite an existing report" in stdout
+    assert process.returncode == 0
     # the source code is overwritten with the edits, reflected in a new hash
     transform = ln.Transform.get("hlsFXswrJjtt0000")
     assert transform.latest_run.report.path.exists()
     assert transform.latest_run.report.path == transform.latest_run.report.path
-    assert transform._source_code_artifact.hash == "DMVEHVQqmY3ektOg2KtKKA"
+    assert transform.hash == "b63gPnGqNWBE0G4G3pOghw"
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact.path.exists()
+    assert transform._source_code_artifact is None
 
     # get the the source code via command line
     result = subprocess.run(
@@ -142,6 +180,11 @@ def test_save_consecutive():
         capture_output=True,
     )
     # print(result.stderr.decode())
+    assert Path("./with-title-and-initialized-consecutive.ipynb").exists()
+    with open("./with-title-and-initialized-consecutive.ipynb", "r") as f:
+        json_notebook = json.load(f)
+    print(json_notebook["cells"][0])
+    assert json_notebook["cells"][0]["source"] == ["# My test notebook (consecutive)"]
     assert result.returncode == 0
 
     # now, assume the user renames the notebook

{lamin_cli-0.16.3 → lamin_cli-0.17.1}/tests/test_save_scripts.py

@@ -37,9 +37,9 @@ def test_run_save_cache():
     assert "created Run" in result.stdout.decode()
 
     transform = ln.Transform.get("m5uCHTTpJnjQ")
-    assert transform._source_code_artifact.hash == "Cwk0OPOyUH5nzTiU2ISlDQ"
+    assert transform.hash == "Cwk0OPOyUH5nzTiU2ISlDQ"
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact.path.exists()
+    assert transform._source_code_artifact is None
 
     # you can rerun the same script
     result = subprocess.run(
@@ -73,7 +73,7 @@ def test_run_save_cache():
     content = filepath.read_text() + "\n # edited"
     filepath.write_text(content)
 
-    # re-run the script without commiting
+    # re-run the script without committing
     result = subprocess.run(
         f"python {filepath}",
         shell=True,
@@ -101,10 +101,10 @@ def test_run_save_cache():
         capture_output=True,
         env=env,
     )
-    # print(result.stdout.decode())
-    # print(result.stderr.decode())
+    print(result.stdout.decode())
+    print(result.stderr.decode())
     assert result.returncode == 1
-    assert "Source code changed, bump version by setting" in result.stderr.decode()
+    assert "Source code changed, bump revision by setting" in result.stderr.decode()
 
     # try to get the the source code via command line
     result = subprocess.run(

lamin_cli-0.16.3/lamin_cli/__init__.py

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

lamin_cli-0.16.3/tests/test_cli.py

@@ -1,16 +0,0 @@
-import os
-
-
-def test_entrypoint():
-    exit_status = os.system("lamin --help")
-    assert exit_status == 0
-
-
-def test_login():
-    exit_status = os.system("lamin login testuser1")
-    assert exit_status == 0
-
-    exit_status = os.system(
-        "lamin login testuser1 --key cEvcwMJFX4OwbsYVaMt2Os6GxxGgDUlBGILs2RyS"
-    )
-    assert exit_status == 0