fix arguments mode in dataset and table

Author: tricktx

python-package/basedosdados/upload/dataset.py

@@ -36,36 +36,38 @@ def dataset_config(self) -> dict[str, Any]:
         """
         return self.backend.get_dataset_config(self.dataset_id)
 
-    def _loop_modes(self, mode: str = "all"):
+    def _loop_modes(self, project_gcp: str = "all"):
         """
         Loop modes.
         """
 
         def dataset_tag(m):
             return f"_{m}" if m == "staging" else ""
 
-        mode_ = ["prod", "staging"] if mode == "all" else [mode]
+        _project_gcp = (
+            ["prod", "staging"] if project_gcp == "all" else [project_gcp]
+        )
         return (
             {
                 "client": self.client[f"bigquery_{m}"],
                 "id": f"{self.client[f'bigquery_{m}'].project}.{self.dataset_id}{dataset_tag(m)}",
                 "mode": m,
             }
-            for m in mode_
+            for m in _project_gcp
         )
 
     def _setup_dataset_object(
         self,
         dataset_id: str,
         location: Optional[str] = None,
-        mode: str = "staging",
+        project_gcp: str = "staging",
     ) -> bigquery.Dataset:
         """
         Setup dataset object.
         """
 
         dataset = bigquery.Dataset(dataset_id)
-        if mode == "staging":
+        if project_gcp == "staging":
             dataset_path = dataset_id.replace("_staging", "")
             description = f"staging dataset for `{dataset_path}`"
             labels = {"staging": True}
@@ -89,19 +91,19 @@ def _setup_dataset_object(
         return dataset
 
     def publicize(
-        self, mode: str = "all", dataset_is_public: bool = True
+        self, project_gcp: str = "all", dataset_is_public: bool = True
     ) -> None:
         """
         Changes IAM configuration to turn BigQuery dataset public.
 
         Args:
-            mode: Which dataset to create [`prod`|`staging`|`all`].
+            project_gcp: Which dataset to create [`prod`|`staging`].
             dataset_is_public: Control if prod dataset is public or not. By
                 default, staging datasets like `dataset_id_staging` are not
                 public.
         """
 
-        for m in self._loop_modes(mode):
+        for m in self._loop_modes(project_gcp):
             dataset = m["client"].get_dataset(m["id"])
             entries = dataset.access_entries
             # TODO https://github.com/basedosdados/sdk/pull/1020
@@ -140,9 +142,9 @@ def publicize(
                 dataset.access_entries = entries
             m["client"].update_dataset(dataset, ["access_entries"])
             logger.success(
-                " {object} {object_id}_{mode} was {action}!",
+                " {object} {object_id}_{project_gcp} was {action}!",
                 object_id=self.dataset_id,
-                mode=m["mode"],
+                project_gcp=m["mode"],
                 object="Dataset",
                 action="publicized",
             )
@@ -176,13 +178,11 @@ def create(
 
         It can create two datasets:
 
-        * `<dataset_id>` (mode = `prod`)
-        * `<dataset_id>_staging` (mode = `staging`)
-
-        If `mode` is `all`, it creates both.
+        * `<dataset_id>` (project_gcp = `prod`)
+        * `<dataset_id>_staging` (project_gcp = `staging`)
 
         Args:
-            mode: Which dataset to create [`prod`|`staging`|`all`].
+            project_gcp: Which dataset to create [`prod`|`staging`].
             if_exists: What to do if dataset exists
                 * `raise`: Raises Conflict exception
                 * `replace`: Drop all tables and replace dataset
@@ -213,21 +213,24 @@ def create(
                 if not self.exists(project_gcp=m["mode"]):
                     # Construct a full Dataset object to send to the API.
                     dataset_obj = self._setup_dataset_object(
-                        dataset_id=m["id"], location=location, mode=m["mode"]
+                        dataset_id=m["id"],
+                        location=location,
+                        project_gcp=m["mode"],
                     )
                     m["client"].create_dataset(
                         dataset_obj
                     )  # Make an API request.
                     logger.success(
-                        " {object} {object_id}_{mode} was {action}!",
+                        " {object} {object_id}_{project_gcp} was {action}!",
                         object_id=self.dataset_id,
-                        mode=m["mode"],
+                        project_gcp=m["mode"],
                         object="Dataset",
                         action="created",
                     )
                     # Make prod dataset public
                     self.publicize(
-                        dataset_is_public=dataset_is_public, mode=m["mode"]
+                        dataset_is_public=dataset_is_public,
+                        project_gcp=m["mode"],
                     )
             except Conflict as e:
                 if if_exists == "pass":

python-package/basedosdados/upload/table.py

@@ -271,7 +271,7 @@ def _parser_blobs_to_partition_dict(self) -> Optional[dict[Any, Any]]:
         Extract the partition information from the blobs.
         """
 
-        if not self.table_exists(mode="staging"):
+        if not self.table_exists(project_gcp="staging"):
             return
         blobs = (
             self.client["storage_staging"]
@@ -417,7 +417,7 @@ def table_exists(self, project_gcp: str = "staging") -> bool:
         Check if table exists in BigQuery.
 
         Args:
-            mode: Which dataset to check [`prod`|`staging`].
+            project_gcp: Which dataset to check [`prod`|`staging`].
         """
 
         try:
@@ -436,7 +436,7 @@ def _get_biglake_connection(
         Get or create BigLake connection and set permissions if needed.
         """
         connection = Connection(
-            name="biglake", location=location, mode="staging"
+            name="biglake", location=location, project_gcp="staging"
         )
         if not connection.exists:
             try:
@@ -727,47 +727,47 @@ def create(
             ) from exc
 
         logger.success(
-            "{object} {object_id} was {action} in {mode}!",
+            "{object} {object_id} was {action} in {project_gcp}!",
             object_id=self.table_id,
-            mode="staging",
+            project_gcp="staging",
             object="Table",
             action="created",
         )
         # return None
 
     def update(
         self,
-        mode: str = "prod",
+        project_gcp: str = "prod",
         custom_schema: Optional[list[dict[str, str]]] = None,
     ) -> None:
         """
         Updates BigQuery schema and description.
 
         Args:
-            mode: Table of which table to update [`prod`].
+            project_gcp: Table of which table to update [`prod`].
             not_found_ok: What to do if table is not found.
         """
 
-        table = self._get_table_obj("prod")
+        table = self._get_table_obj(project_gcp="prod")
 
         table.description = self._get_table_description()
 
         # when mode is staging the table schema already exists
-        if mode == "prod" and custom_schema is None:
+        if project_gcp == "prod" and custom_schema is None:
             table.schema = self._load_schema_from_json(
                 columns=self._get_cross_columns_from_bq_api()
             )
-        if mode == "prod" and custom_schema is not None:
+        if project_gcp == "prod" and custom_schema is not None:
             table.schema = self._load_schema_from_json(custom_schema)
 
         fields = ["description", "schema"]
 
         self.client["bigquery_prod"].update_table(table, fields=fields)
 
         logger.success(
-            " {object} {object_id} was {action} in {mode}!",
+            " {object} {object_id} was {action} in {project_gcp}!",
             object_id=self.table_id,
-            mode=mode,
+            project_gcp=project_gcp,
             object="Table",
             action="updated",
         )
@@ -798,15 +798,15 @@ def publish(
         """
         # TODO: review this method. Check if all required fields are filled
 
-        if if_exists == "replace" and self.table_exists(mode="prod"):
-            self.delete(mode="prod")
+        if if_exists == "replace" and self.table_exists(project_gcp="prod"):
+            self.delete(project_gcp="prod")
 
         publish_sql = self._make_publish_sql()
 
         # create view using API metadata
         if custom_publish_sql is None:
             self.client["bigquery_prod"].query(publish_sql).result()
-            self.update(mode="prod")
+            self.update(project_gcp="prod")
 
         # create view using custon query
         if custom_publish_sql is not None: