fpath -> path

Author: wangpatrick57

benchmark/job/cli.py

@@ -290,8 +290,8 @@ def _generate_job_workload(
         )
 
         for qname in query_names:
-            sql_fpath = fully_resolve_path(queries_parent_path / f"{qname}.sql")
-            f.write(f"Q{qname},{sql_fpath}\n")
+            sql_path = fully_resolve_path(queries_parent_path / f"{qname}.sql")
+            f.write(f"Q{qname},{sql_path}\n")
 
     workload_symlink_path = dbgym_workspace.link_result(workload_path)
     assert workload_symlink_path == expected_workload_symlink_path

benchmark/job/load_info.py

@@ -38,10 +38,10 @@ class JobLoadInfo(LoadInfoBaseClass):
     def __init__(self, dbgym_workspace: DBGymWorkspace):
         # Schema (directly in the codebase).
         job_codebase_path = dbgym_workspace.base_dbgym_repo_dpath / "benchmark" / "job"
-        self._schema_fpath = job_codebase_path / JOB_SCHEMA_FNAME
+        self._schema_path = job_codebase_path / JOB_SCHEMA_FNAME
         assert (
-            self._schema_fpath.exists()
-        ), f"self._schema_fpath ({self._schema_fpath}) does not exist"
+            self._schema_path.exists()
+        ), f"self._schema_path ({self._schema_path}) does not exist"
 
         # Tables
         tables_path = fully_resolve_path(
@@ -51,19 +51,19 @@ def __init__(self, dbgym_workspace: DBGymWorkspace):
         )
         self._tables_and_paths = []
         for table in JobLoadInfo.TABLES:
-            table_fpath = tables_path / f"{table}.csv"
-            self._tables_and_paths.append((table, table_fpath))
+            table_path = tables_path / f"{table}.csv"
+            self._tables_and_paths.append((table, table_path))
 
-    def get_schema_fpath(self) -> Path:
-        return self._schema_fpath
+    def get_schema_path(self) -> Path:
+        return self._schema_path
 
     def get_tables_and_paths(self) -> list[tuple[str, Path]]:
         return self._tables_and_paths
 
     def get_table_file_delimiter(self) -> str:
         return ","
 
-    def get_constraints_fpath(self) -> Optional[Path]:
+    def get_constraints_path(self) -> Optional[Path]:
         # JOB does not have any constraints. It does have indexes, but we don't want to create
         # those indexes so that the tuning agent can start from a clean slate.
         return None

benchmark/tpch/cli.py

@@ -233,11 +233,11 @@ def _generate_tpch_workload(
             )
 
             for qname in query_names:
-                sql_fpath = fully_resolve_path(queries_parent_path / f"{qname}.sql")
+                sql_path = fully_resolve_path(queries_parent_path / f"{qname}.sql")
                 assert is_fully_resolved(
-                    sql_fpath
+                    sql_path
                 ), "We should only write existent real absolute paths to a file"
-                f.write(f"S{seed}-Q{qname},{sql_fpath}\n")
+                f.write(f"S{seed}-Q{qname},{sql_path}\n")
 
     workload_symlink_path = dbgym_workspace.link_result(workload_path)
     assert workload_symlink_path == expected_workload_symlink_path

benchmark/tpch/load_info.py

@@ -27,14 +27,14 @@ def __init__(self, dbgym_workspace: DBGymWorkspace, scale_factor: float):
         tpch_codebase_path = (
             dbgym_workspace.base_dbgym_repo_dpath / "benchmark" / "tpch"
         )
-        self._schema_fpath = tpch_codebase_path / TPCH_SCHEMA_FNAME
+        self._schema_path = tpch_codebase_path / TPCH_SCHEMA_FNAME
         assert (
-            self._schema_fpath.exists()
-        ), f"self._schema_fpath ({self._schema_fpath}) does not exist"
-        self._constraints_fpath = tpch_codebase_path / TPCH_CONSTRAINTS_FNAME
+            self._schema_path.exists()
+        ), f"self._schema_path ({self._schema_path}) does not exist"
+        self._constraints_path = tpch_codebase_path / TPCH_CONSTRAINTS_FNAME
         assert (
-            self._constraints_fpath.exists()
-        ), f"self._constraints_fpath ({self._constraints_fpath}) does not exist"
+            self._constraints_path.exists()
+        ), f"self._constraints_path ({self._constraints_path}) does not exist"
 
         # Tables
         tables_path = fully_resolve_path(
@@ -47,14 +47,14 @@ def __init__(self, dbgym_workspace: DBGymWorkspace, scale_factor: float):
             table_path = tables_path / f"{table}.tbl"
             self._tables_and_paths.append((table, table_path))
 
-    def get_schema_fpath(self) -> Path:
-        return self._schema_fpath
+    def get_schema_path(self) -> Path:
+        return self._schema_path
 
     def get_tables_and_paths(self) -> list[tuple[str, Path]]:
         return self._tables_and_paths
 
     def get_table_file_delimiter(self) -> str:
         return "|"
 
-    def get_constraints_fpath(self) -> Optional[Path]:
-        return self._constraints_fpath
+    def get_constraints_path(self) -> Optional[Path]:
+        return self._constraints_path

dbms/load_info_base_class.py

@@ -9,7 +9,7 @@ class LoadInfoBaseClass:
       copy the comments or type annotations or else they might become out of sync.
     """
 
-    def get_schema_fpath(self) -> Path:
+    def get_schema_path(self) -> Path:
         raise NotImplementedError
 
     def get_tables_and_paths(self) -> list[tuple[str, Path]]:
@@ -21,5 +21,5 @@ def get_table_file_delimiter(self) -> str:
 
     # If the subclassing benchmark does not have constraints, you can return None here.
     # Constraints are also indexes.
-    def get_constraints_fpath(self) -> Optional[Path]:
+    def get_constraints_path(self) -> Optional[Path]:
         raise NotImplementedError

dbms/postgres/cli.py

@@ -301,14 +301,14 @@ def _load_into_dbdata(
     conn: sqlalchemy.Connection,
     load_info: LoadInfoBaseClass,
 ) -> None:
-    sql_file_execute(dbgym_workspace, conn, load_info.get_schema_fpath())
+    sql_file_execute(dbgym_workspace, conn, load_info.get_schema_path())
 
     # Truncate all tables first before even loading a single one.
     for table, _ in load_info.get_tables_and_paths():
         sqlalchemy_conn_execute(conn, f"TRUNCATE {table} CASCADE")
     # Then, load the tables.
-    for table, table_fpath in load_info.get_tables_and_paths():
-        with dbgym_workspace.open_and_save(table_fpath, "r") as table_csv:
+    for table, table_path in load_info.get_tables_and_paths():
+        with dbgym_workspace.open_and_save(table_path, "r") as table_csv:
             assert conn.connection.dbapi_connection is not None
             cur = conn.connection.dbapi_connection.cursor()
             try:
@@ -320,9 +320,9 @@ def _load_into_dbdata(
             finally:
                 cur.close()
 
-    constraints_fpath = load_info.get_constraints_fpath()
-    if constraints_fpath is not None:
-        sql_file_execute(dbgym_workspace, conn, constraints_fpath)
+    constraints_path = load_info.get_constraints_path()
+    if constraints_path is not None:
+        sql_file_execute(dbgym_workspace, conn, constraints_path)
 
 
 # The start and stop functions slightly duplicate functionality from pg_conn.py. However, I chose to do it this way

env/pg_conn.py

@@ -37,32 +37,32 @@ def __init__(
         self,
         dbgym_workspace: DBGymWorkspace,
         pgport: int,
-        pristine_dbdata_snapshot_fpath: Path,
+        pristine_dbdata_snapshot_path: Path,
         dbdata_parent_dpath: Path,
         pgbin_path: Union[str, Path],
         # Whether this is None determines whether Boot is enabled.
-        boot_config_fpath: Optional[Path],
+        boot_config_path: Optional[Path],
     ) -> None:
 
         self.dbgym_workspace = dbgym_workspace
         self.pgport = pgport
         self.pgbin_path = pgbin_path
-        self.boot_config_fpath = boot_config_fpath
+        self.boot_config_path = boot_config_path
         self.log_step = 0
 
         # All the paths related to dbdata
-        # pristine_dbdata_snapshot_fpath is the .tgz snapshot that represents the starting state
+        # pristine_dbdata_snapshot_path is the .tgz snapshot that represents the starting state
         #   of the database (with the default configuration). It is generated by a call to
         #   `python tune.py dbms postgres ...` and should not be overwritten.
-        self.pristine_dbdata_snapshot_fpath = pristine_dbdata_snapshot_fpath
-        # checkpoint_dbdata_snapshot_fpath is the .tgz snapshot that represents the current
+        self.pristine_dbdata_snapshot_path = pristine_dbdata_snapshot_path
+        # checkpoint_dbdata_snapshot_path is the .tgz snapshot that represents the current
         #   state of the database as it is being tuned. It is generated while tuning and is
         #   discarded once tuning is completed.
-        self.checkpoint_dbdata_snapshot_fpath = (
+        self.checkpoint_dbdata_snapshot_path = (
             dbgym_workspace.dbgym_tmp_path / "checkpoint_dbdata.tgz"
         )
         # dbdata_parent_dpath is the parent directory of the dbdata that is *actively being tuned*.
-        # It is *not* the parent directory of pristine_dbdata_snapshot_fpath.
+        # It is *not* the parent directory of pristine_dbdata_snapshot_path.
         #   Setting this lets us control the hardware device dbdata is built on (e.g. HDD vs. SSD).
         self.dbdata_parent_dpath = dbdata_parent_dpath
         # dbdata_dpath is the dbdata that is *actively being tuned*
@@ -102,16 +102,16 @@ def disconnect(self) -> None:
             self._conn = None
 
     def move_log(self) -> None:
-        pglog_fpath = (
+        pglog_path = (
             self.dbgym_workspace.cur_task_runs_artifacts_path(mkdir=True)
             / f"pg{self.pgport}.log"
         )
-        pglog_this_step_fpath = (
+        pglog_this_step_path = (
             self.dbgym_workspace.cur_task_runs_artifacts_path(mkdir=True)
             / f"pg{self.pgport}.log.{self.log_step}"
         )
-        if pglog_fpath.exists():
-            shutil.move(pglog_fpath, pglog_this_step_fpath)
+        if pglog_path.exists():
+            shutil.move(pglog_path, pglog_this_step_path)
             self.log_step += 1
 
     def force_statement_timeout(self, timeout: float) -> None:
@@ -273,7 +273,7 @@ def restart_with_changes(
                 "cf",
                 # We append .tmp so that if we fail in the *middle* of running tar, we
                 #   still have the previous checkpoint available to us
-                f"{self.checkpoint_dbdata_snapshot_fpath}.tmp",
+                f"{self.checkpoint_dbdata_snapshot_path}.tmp",
                 "-C",
                 parent_dpath_of_path(self.dbdata_dpath),
                 self.dbdata_dpath,
@@ -345,8 +345,8 @@ def restart_with_changes(
             )
 
         # Set up Boot if we're told to do so
-        if self.boot_config_fpath is not None:
-            with self.dbgym_workspace.open_and_save(self.boot_config_fpath) as f:
+        if self.boot_config_path is not None:
+            with self.dbgym_workspace.open_and_save(self.boot_config_path) as f:
                 boot_config = yaml.safe_load(f)
 
             self._set_up_boot(
@@ -483,10 +483,10 @@ def get_system_knobs(self) -> dict[str, str]:
         return knobs
 
     def restore_pristine_snapshot(self) -> bool:
-        return self._restore_snapshot(self.pristine_dbdata_snapshot_fpath)
+        return self._restore_snapshot(self.pristine_dbdata_snapshot_path)
 
     def restore_checkpointed_snapshot(self) -> bool:
-        return self._restore_snapshot(self.checkpoint_dbdata_snapshot_fpath)
+        return self._restore_snapshot(self.checkpoint_dbdata_snapshot_path)
 
     def _restore_snapshot(
         self,

env/tuning_artifacts.py

@@ -68,11 +68,11 @@ class DBMSConfigDelta:
     qknobs: QueryKnobsDelta
 
 
-def get_delta_at_step_fpath(tuning_artifacts_dpath: Path, step_num: int) -> Path:
+def get_delta_at_step_path(tuning_artifacts_dpath: Path, step_num: int) -> Path:
     return tuning_artifacts_dpath / f"step{step_num}_delta.json"
 
 
-def get_metadata_fpath(tuning_artifacts_dpath: Path) -> Path:
+def get_metadata_path(tuning_artifacts_dpath: Path) -> Path:
     return tuning_artifacts_dpath / "metadata.json"
 
 
@@ -88,7 +88,7 @@ def __init__(
         self.next_step_num = 0
 
         # Write metadata file
-        with get_metadata_fpath(self.tuning_artifacts_dpath).open("w") as f:
+        with get_metadata_path(self.tuning_artifacts_dpath).open("w") as f:
             json.dump(metadata.asdict(), f)
 
     def write_step(self, dbms_cfg_delta: DBMSConfigDelta) -> None:
@@ -97,7 +97,7 @@ def write_step(self, dbms_cfg_delta: DBMSConfigDelta) -> None:
         """
         curr_step_num = self.next_step_num
         self.next_step_num += 1
-        with get_delta_at_step_fpath(self.tuning_artifacts_dpath, curr_step_num).open(
+        with get_delta_at_step_path(self.tuning_artifacts_dpath, curr_step_num).open(
             "w"
         ) as f:
             json.dump(asdict(dbms_cfg_delta), f)
@@ -108,12 +108,12 @@ def __init__(self, tuning_artifacts_dpath: Path) -> None:
         self.tuning_artifacts_dpath = tuning_artifacts_dpath
         assert is_fully_resolved(self.tuning_artifacts_dpath)
         num_steps = 0
-        while get_delta_at_step_fpath(self.tuning_artifacts_dpath, num_steps).exists():
+        while get_delta_at_step_path(self.tuning_artifacts_dpath, num_steps).exists():
             num_steps += 1
         self.num_steps = num_steps
 
     def get_metadata(self) -> TuningMetadata:
-        with get_metadata_fpath(self.tuning_artifacts_dpath).open("r") as f:
+        with get_metadata_path(self.tuning_artifacts_dpath).open("r") as f:
             data = json.load(f)
             return TuningMetadata(
                 workload_path=Path(data["workload_path"]),
@@ -126,7 +126,7 @@ def get_metadata(self) -> TuningMetadata:
 
     def get_delta_at_step(self, step_num: int) -> DBMSConfigDelta:
         assert step_num >= 0 and step_num < self.num_steps
-        with get_delta_at_step_fpath(self.tuning_artifacts_dpath, step_num).open(
+        with get_delta_at_step_path(self.tuning_artifacts_dpath, step_num).open(
             "r"
         ) as f:
             data = json.load(f)

env/workload.py

@@ -10,12 +10,12 @@ def __init__(self, dbgym_workspace: DBGymWorkspace, workload_dpath: Path) -> Non
         assert is_fully_resolved(self.workload_dpath)
 
         self.queries: dict[str, str] = {}
-        order_fpath = self.workload_dpath / "order.txt"
+        order_path = self.workload_dpath / "order.txt"
         self.query_order: list[str] = []
 
-        assert order_fpath.exists()
+        assert order_path.exists()
 
-        with self.dbgym_workspace.open_and_save(order_fpath) as f:
+        with self.dbgym_workspace.open_and_save(order_path) as f:
             for line in f:
                 qid, qpath = line.strip().split(",")
                 qpath = Path(qpath)

manage/cli.py

@@ -101,14 +101,14 @@ def clean_workspace(
       any symlinks referenced in task_runs/run_*/ directories we have already decided to keep.
     """
     # This stack holds the symlinks that are left to be processed
-    symlink_fpaths_to_process: list[Path] = []
+    symlink_paths_to_process: list[Path] = []
     # This set holds the symlinks that have already been processed to avoid infinite loops
     processed_symlinks: set[Path] = set()
 
     # 1. Initialize paths to process
     if dbgym_workspace.dbgym_symlinks_path.exists():
         add_symlinks_in_dpath(
-            symlink_fpaths_to_process,
+            symlink_paths_to_process,
             dbgym_workspace.dbgym_symlinks_path,
             processed_symlinks,
         )
@@ -121,17 +121,17 @@ def clean_workspace(
     task_run_child_paths_to_keep = set()
 
     if dbgym_workspace.dbgym_runs_path.exists():
-        while symlink_fpaths_to_process:
-            symlink_fpath: Path = symlink_fpaths_to_process.pop()
-            assert symlink_fpath.is_symlink()
+        while symlink_paths_to_process:
+            symlink_path: Path = symlink_paths_to_process.pop()
+            assert symlink_path.is_symlink()
             # Path.resolve() resolves all layers of symlinks while os.readlink() only resolves one layer.
             # However, os.readlink() literally reads the string contents of the link. We need to do some
             #   processing on the result of os.readlink() to convert it to an absolute path
-            real_path = symlink_fpath.resolve()
-            one_layer_resolved_path = os.readlink(symlink_fpath)
+            real_path = symlink_path.resolve()
+            one_layer_resolved_path = os.readlink(symlink_path)
             assert str(real_path) == str(
-                os.readlink(symlink_fpath)
-            ), f"symlink_fpath ({symlink_fpath}) seems to point to *another* symlink. This is difficult to handle, so it is currently disallowed. Please resolve this situation manually."
+                os.readlink(symlink_path)
+            ), f"symlink_path ({symlink_path}) seems to point to *another* symlink. This is difficult to handle, so it is currently disallowed. Please resolve this situation manually."
 
             # If the file doesn't exist, we'll just ignore it.
             if not real_path.exists():
@@ -170,7 +170,7 @@ def clean_workspace(
             # If on safe mode, add symlinks inside the task_run_child_path to be processed
             if mode == "safe":
                 add_symlinks_in_dpath(
-                    symlink_fpaths_to_process,
+                    symlink_paths_to_process,
                     task_run_child_path,
                     processed_symlinks,
                 )