Rename dataset_name to name

src/datachain/cli/__init__.py

@@ -161,7 +161,7 @@ def handle_dataset_command(args, catalog):
             all=args.all,
             team=args.team,
             latest_only=not args.versions,
-            dataset_name=args.dataset_name,
+            name=args.name,
         ),
         "rm": lambda: rm_dataset(
             catalog,

src/datachain/cli/commands/datasets.py

@@ -33,18 +33,16 @@ def list_datasets(
     all: bool = True,
     team: Optional[str] = None,
     latest_only: bool = True,
-    dataset_name: Optional[str] = None,
+    name: Optional[str] = None,
 ):
     token = Config().read().get("studio", {}).get("token")
     all, local, studio = determine_flavors(studio, local, all, token)
-    if dataset_name:
+    if name:
         latest_only = False
 
-    local_datasets = (
-        set(list_datasets_local(catalog, dataset_name)) if all or local else set()
-    )
+    local_datasets = set(list_datasets_local(catalog, name)) if all or local else set()
     studio_datasets = (
-        set(list_datasets_studio(team=team, dataset_name=dataset_name))
+        set(list_datasets_studio(team=team, name=name))
         if (all or studio) and token
         else set()
     )
@@ -59,23 +57,23 @@ def list_datasets(
     datasets = []
     if latest_only:
         # For each dataset name, get the latest version from each source (if available).
-        for name in all_dataset_names:
-            datasets.append((name, (local_grouped.get(name), studio_grouped.get(name))))
+        for n in all_dataset_names:
+            datasets.append((n, (local_grouped.get(n), studio_grouped.get(n))))
     else:
         # For each dataset name, merge all versions from both sources.
-        for name in all_dataset_names:
-            local_versions = local_grouped.get(name, [])
-            studio_versions = studio_grouped.get(name, [])
+        for n in all_dataset_names:
+            local_versions = local_grouped.get(n, [])
+            studio_versions = studio_grouped.get(n, [])
 
             # If neither source has any versions, record it as (None, None).
             if not local_versions and not studio_versions:
-                datasets.append((name, (None, None)))
+                datasets.append((n, (None, None)))
             else:
                 # For each unique version from either source, record its presence.
                 for version in sorted(set(local_versions) | set(studio_versions)):
                     datasets.append(
                         (
-                            name,
+                            n,
                             (
                                 version if version in local_versions else None,
                                 version if version in studio_versions else None,
@@ -85,31 +83,31 @@ def list_datasets(
 
     rows = [
         _datasets_tabulate_row(
-            name=name,
+            name=n,
             both=(all or (local and studio)) and token,
             local_version=local_version,
             studio_version=studio_version,
         )
-        for name, (local_version, studio_version) in datasets
+        for n, (local_version, studio_version) in datasets
     ]
 
     print(tabulate(rows, headers="keys"))
 
 
-def list_datasets_local(catalog: "Catalog", dataset_name: Optional[str] = None):
-    if dataset_name:
-        yield from list_datasets_local_versions(catalog, dataset_name)
+def list_datasets_local(catalog: "Catalog", name: Optional[str] = None):
+    if name:
+        yield from list_datasets_local_versions(catalog, name)
         return
 
     for d in catalog.ls_datasets():
         for v in d.versions:
             yield (d.name, v.version)
 
 
-def list_datasets_local_versions(catalog: "Catalog", dataset_name: str):
-    ds = catalog.get_dataset(dataset_name)
+def list_datasets_local_versions(catalog: "Catalog", name: str):
+    ds = catalog.get_dataset(name)
     for v in ds.versions:
-        yield (dataset_name, v.version)
+        yield (name, v.version)
 
 
 def _datasets_tabulate_row(name, both, local_version, studio_version):

src/datachain/cli/parser/__init__.py

@@ -255,7 +255,7 @@ def get_parser() -> ArgumentParser:  # noqa: PLR0915
         formatter_class=CustomHelpFormatter,
     )
     datasets_ls_parser.add_argument(
-        "dataset_name", action="store", help="Name of the dataset to list", nargs="?"
+        "name", action="store", help="Name of the dataset to list", nargs="?"
     )
     datasets_ls_parser.add_argument(
         "--versions",

src/datachain/studio.py

@@ -140,9 +140,9 @@ def token():
     print(token)
 
 
-def list_datasets(team: Optional[str] = None, dataset_name: Optional[str] = None):
-    if dataset_name:
-        yield from list_dataset_versions(team, dataset_name)
+def list_datasets(team: Optional[str] = None, name: Optional[str] = None):
+    if name:
+        yield from list_dataset_versions(team, name)
         return
 
     client = StudioClient(team=team)
@@ -165,10 +165,10 @@ def list_datasets(team: Optional[str] = None, dataset_name: Optional[str] = None
             yield (name, version)
 
 
-def list_dataset_versions(team: Optional[str] = None, dataset_name: str = ""):
+def list_dataset_versions(team: Optional[str] = None, name: str = ""):
     client = StudioClient(team=team)
 
-    response = client.dataset_info(dataset_name)
+    response = client.dataset_info(name)
 
     if not response.ok:
         raise_remote_error(response.message)
@@ -178,7 +178,7 @@ def list_dataset_versions(team: Optional[str] = None, dataset_name: str = ""):
 
     for v in response.data.get("versions", []):
         version = v.get("version")
-        yield (dataset_name, version)
+        yield (name, version)
 
 
 def edit_studio_dataset(