rename methods

Author: almogdepaz

chia/_tests/plot_sync/test_plot_sync.py

@@ -193,7 +193,7 @@ async def plot_sync_callback(self, peer_id: bytes32, delta: Optional[Delta]) ->
             assert path in delta.valid.additions
             plot = harvester.plot_manager.plots.get(Path(path), None)
             assert plot is not None
-            assert plot.prover.get_filename_str() == delta.valid.additions[path].filename
+            assert plot.prover.get_filename() == delta.valid.additions[path].filename
             assert plot.prover.get_size() == delta.valid.additions[path].size
             assert plot.prover.get_id() == delta.valid.additions[path].plot_id
             assert plot.prover.get_compression_level() == delta.valid.additions[path].compression_level
@@ -254,7 +254,7 @@ async def run_sync_test(self) -> None:
             assert expected.duplicates_delta.empty()
             for path, plot_info in plot_manager.plots.items():
                 assert str(path) in receiver.plots()
-                assert plot_info.prover.get_filename_str() == receiver.plots()[str(path)].filename
+                assert plot_info.prover.get_filename() == receiver.plots()[str(path)].filename
                 assert plot_info.prover.get_size() == receiver.plots()[str(path)].size
                 assert plot_info.prover.get_id() == receiver.plots()[str(path)].plot_id
                 assert plot_info.prover.get_compression_level() == receiver.plots()[str(path)].compression_level

chia/_tests/plot_sync/test_sync_simulated.py

@@ -69,18 +69,18 @@ async def run(
         initial: bool,
     ) -> None:
         for plot_info in loaded:
-            assert plot_info.prover.get_filename() not in self.plots
+            assert plot_info.prover.get_filepath() not in self.plots
         for plot_info in removed:
-            assert plot_info.prover.get_filename() in self.plots
+            assert plot_info.prover.get_filepath() in self.plots
 
         self.invalid = invalid
         self.keys_missing = keys_missing
         self.duplicates = duplicates
 
-        removed_paths: list[Path] = [p.prover.get_filename() for p in removed] if removed is not None else []
-        invalid_dict: dict[Path, int] = {p.prover.get_filename(): 0 for p in self.invalid}
-        keys_missing_set: set[Path] = {p.prover.get_filename() for p in self.keys_missing}
-        duplicates_set: set[str] = {p.prover.get_filename_str() for p in self.duplicates}
+        removed_paths: list[Path] = [p.prover.get_filepath() for p in removed] if removed is not None else []
+        invalid_dict: dict[Path, int] = {p.prover.get_filepath(): 0 for p in self.invalid}
+        keys_missing_set: set[Path] = {p.prover.get_filepath() for p in self.keys_missing}
+        duplicates_set: set[str] = {p.prover.get_filename() for p in self.duplicates}
 
         # Inject invalid plots into `PlotManager` of the harvester so that the callback calls below can use them
         # to sync them to the farmer.
@@ -91,7 +91,7 @@ async def run(
         # Inject duplicated plots into `PlotManager` of the harvester so that the callback calls below can use them
         # to sync them to the farmer.
         for plot_info in loaded:
-            plot_path = Path(plot_info.prover.get_filename())
+            plot_path = Path(plot_info.prover.get_filepath())
             self.harvester.plot_manager.plot_filename_paths[plot_path.name] = (str(plot_path.parent), set())
         for duplicate in duplicates_set:
             plot_path = Path(duplicate)
@@ -123,39 +123,39 @@ async def sync_done() -> bool:
         await time_out_assert(60, sync_done)
 
         for plot_info in loaded:
-            self.plots[plot_info.prover.get_filename()] = plot_info
+            self.plots[plot_info.prover.get_filepath()] = plot_info
         for plot_info in removed:
-            del self.plots[plot_info.prover.get_filename()]
+            del self.plots[plot_info.prover.get_filepath()]
 
     def validate_plot_sync(self) -> None:
         assert len(self.plots) == len(self.plot_sync_receiver.plots())
         assert len(self.invalid) == len(self.plot_sync_receiver.invalid())
         assert len(self.keys_missing) == len(self.plot_sync_receiver.keys_missing())
         for _, plot_info in self.plots.items():
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.plots()
-            synced_plot = self.plot_sync_receiver.plots()[plot_info.prover.get_filename_str()]
-            assert plot_info.prover.get_filename_str() == synced_plot.filename
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename() in self.plot_sync_receiver.plots()
+            synced_plot = self.plot_sync_receiver.plots()[plot_info.prover.get_filename()]
+            assert plot_info.prover.get_filename() == synced_plot.filename
             assert plot_info.pool_public_key == synced_plot.pool_public_key
             assert plot_info.pool_contract_puzzle_hash == synced_plot.pool_contract_puzzle_hash
             assert plot_info.plot_public_key == synced_plot.plot_public_key
             assert plot_info.file_size == synced_plot.file_size
             assert uint64(int(plot_info.time_modified)) == synced_plot.time_modified
         for plot_info in self.invalid:
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.plots()
-            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.plots()
+            assert plot_info.prover.get_filename() in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.duplicates()
         for plot_info in self.keys_missing:
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.plots()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.plots()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename() in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.duplicates()
         for plot_info in self.duplicates:
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename() in self.plot_sync_receiver.duplicates()
 
 
 @dataclass
@@ -417,16 +417,16 @@ async def test_sync_reset_cases(
         # Inject some data into `PlotManager` of the harvester so that we can validate the reset worked and triggered a
         # fresh sync of all available data of the plot manager
         for plot_info in plots[0:10]:
-            test_data.plots[plot_info.prover.get_filename()] = plot_info
+            test_data.plots[plot_info.prover.get_filepath()] = plot_info
             plot_manager.plots = test_data.plots
         test_data.invalid = plots[10:20]
         test_data.keys_missing = plots[20:30]
         test_data.plot_sync_receiver.simulate_error = simulate_error  # type: ignore[attr-defined]
         sender: Sender = test_runner.test_data[0].plot_sync_sender
         started_sync_id: uint64 = uint64(0)
 
-        plot_manager.failed_to_open_filenames = {p.prover.get_filename(): 0 for p in test_data.invalid}
-        plot_manager.no_key_filenames = {p.prover.get_filename() for p in test_data.keys_missing}
+        plot_manager.failed_to_open_filenames = {p.prover.get_filepath(): 0 for p in test_data.invalid}
+        plot_manager.no_key_filenames = {p.prover.get_filepath() for p in test_data.keys_missing}
 
         async def wait_for_reset() -> bool:
             assert started_sync_id != 0

chia/_tests/plotting/test_plot_manager.py

@@ -115,7 +115,7 @@ def refresh_callback(self, event: PlotRefreshEvents, refresh_result: PlotRefresh
                     for value in actual_value:
                         if type(value) is PlotInfo:
                             for plot_info in expected_list:
-                                if plot_info.prover.get_filename() == value.prover.get_filename():
+                                if plot_info.prover.get_filename() == value.prover.get_filepath():
                                     values_found += 1
                                     continue
                         else:
@@ -507,7 +507,7 @@ async def test_plot_info_caching(environment, bt):
     await refresh_tester.run(expected_result)
     for path, plot_info in env.refresh_tester.plot_manager.plots.items():
         assert path in plot_manager.plots
-        assert plot_manager.plots[path].prover.get_filename() == plot_info.prover.get_filename()
+        assert plot_manager.plots[path].prover.get_filepath() == plot_info.prover.get_filepath()
         assert plot_manager.plots[path].prover.get_id() == plot_info.prover.get_id()
         assert plot_manager.plots[path].prover.get_memo() == plot_info.prover.get_memo()
         assert plot_manager.plots[path].prover.get_size() == plot_info.prover.get_size()

chia/_tests/plotting/test_prover.py

@@ -12,8 +12,8 @@ class TestProver:
     def test_v2_prover_init_with_nonexistent_file(self) -> None:
         prover = V2Prover("/nonexistent/path/test.plot2")
         assert prover.get_version() == PlotVersion.V2
-        assert prover.get_filename() == Path("/nonexistent/path/test.plot2")
-        assert prover.get_filename_str() == "/nonexistent/path/test.plot2"
+        assert prover.get_filepath() == Path("/nonexistent/path/test.plot2")
+        assert prover.get_filename() == "/nonexistent/path/test.plot2"
 
     def test_v2_prover_get_size_raises_error(self) -> None:
         prover = V2Prover("/nonexistent/path/test.plot2")

chia/plot_sync/sender.py

@@ -39,7 +39,7 @@ def _convert_plot_info_list(plot_infos: list[PlotInfo]) -> list[Plot]:
     for plot_info in plot_infos:
         converted.append(
             Plot(
-                filename=plot_info.prover.get_filename_str(),
+                filename=plot_info.prover.get_filename(),
                 size=plot_info.prover.get_size(),
                 plot_id=plot_info.prover.get_id(),
                 pool_public_key=plot_info.pool_public_key,

chia/plotting/manager.py

@@ -386,10 +386,10 @@ def process_file(file_path: Path) -> Optional[PlotInfo]:
                 with self.plot_filename_paths_lock:
                     paths: Optional[tuple[str, set[str]]] = self.plot_filename_paths.get(file_path.name)
                     if paths is None:
-                        paths = (str(Path(cache_entry.prover.get_filename()).parent), set())
+                        paths = (str(Path(cache_entry.prover.get_filepath()).parent), set())
                         self.plot_filename_paths[file_path.name] = paths
                     else:
-                        paths[1].add(str(Path(cache_entry.prover.get_filename()).parent))
+                        paths[1].add(str(Path(cache_entry.prover.get_filepath()).parent))
                         log.warning(f"Have multiple copies of the plot {file_path.name} in {[paths[0], *paths[1]]}.")
                         return None
 
@@ -423,7 +423,7 @@ def process_file(file_path: Path) -> Optional[PlotInfo]:
             plots_refreshed: dict[Path, PlotInfo] = {}
             for new_plot in executor.map(process_file, plot_paths):
                 if new_plot is not None:
-                    plots_refreshed[Path(new_plot.prover.get_filename())] = new_plot
+                    plots_refreshed[Path(new_plot.prover.get_filepath())] = new_plot
             self.plots.update(plots_refreshed)
 
         result.duration = time.time() - start_time

chia/plotting/prover.py

@@ -22,11 +22,11 @@ class PlotVersion(IntEnum):
 
 class ProverProtocol(ABC):
     @abstractmethod
-    def get_filename(self) -> Path:
+    def get_filepath(self) -> Path:
         """Returns the filename for the plot"""
 
     @abstractmethod
-    def get_filename_str(self) -> str:
+    def get_filename(self) -> str:
         """Returns the filename string for the plot"""
 
     @abstractmethod
@@ -73,10 +73,10 @@ class V2Prover(ProverProtocol):
     def __init__(self, filename: str):
         self._filename = filename
 
-    def get_filename(self) -> Path:
+    def get_filepath(self) -> Path:
         return Path(self._filename)
 
-    def get_filename_str(self) -> str:
+    def get_filename(self) -> str:
         return str(self._filename)
 
     def get_size(self) -> uint8:
@@ -122,10 +122,10 @@ class V1Prover(ProverProtocol):
     def __init__(self, disk_prover: DiskProver) -> None:
         self._disk_prover = disk_prover
 
-    def get_filename(self) -> Path:
+    def get_filepath(self) -> Path:
         return Path(self._disk_prover.get_filename())
 
-    def get_filename_str(self) -> str:
+    def get_filename(self) -> str:
         return str(self._disk_prover.get_filename())
 
     def get_size(self) -> uint8: