more chunking renames

Author: Fallen-Breath

prime_backup/action/helpers/blob_pre_calc_result.py

@@ -1,6 +1,6 @@
 import dataclasses
 from pathlib import Path
-from typing import List, IO
+from typing import List, IO, Optional
 
 from prime_backup.types.chunk_method import ChunkMethod
 from prime_backup.types.chunker import PrettyChunk
@@ -16,20 +16,20 @@ class SizeMismatched(Exception):
 	size: int
 	hash: str
 	should_be_chunked: bool
-	chunks: List[PrettyChunk]
+	chunks: Optional[List[PrettyChunk]]
 
 	def simple_repr(self) -> str:
 		return misc_utils.represent(self, attrs={
 			'size': self.size,
 			'hash': self.hash,
 			'should_be_chunked': self.should_be_chunked,
-			'chunks_len': len(self.chunks),
+			'chunks_len': len(self.chunks) if self.chunks is not None else None,
 		})
 
 	@classmethod
 	def from_stream(cls, stream: IO[bytes], rel_path: Path, size: int) -> 'BlobPrecalculateResult':
 		chunk_method = ChunkMethod.get_for_file(rel_path, size)
-		chunks: List[PrettyChunk] = []
+		chunks: Optional[List[PrettyChunk]] = None
 		if chunk_method is not None:
 			chunker = chunk_method.create_stream_chunker(stream, need_entire_file_hash=True)
 			chunks = chunker.cut_all()
@@ -49,8 +49,8 @@ def from_stream(cls, stream: IO[bytes], rel_path: Path, size: int) -> 'BlobPreca
 	@classmethod
 	def from_file(cls, path: Path, rel_path: Path, size: int) -> 'BlobPrecalculateResult':
 		chunk_method = ChunkMethod.get_for_file(rel_path, size)
-		chunks: List[PrettyChunk] = []
-		if chunk_method is not None:
+		chunks: Optional[List[PrettyChunk]] = None
+		if chunk_method is not None and chunk_method.needs_precalculation():
 			chunker = chunk_method.create_file_chunker(path, need_entire_file_hash=True)
 			chunks = chunker.cut_all()
 			sah = SizeAndHash(chunker.get_read_file_size(), chunker.get_entire_file_hash())

prime_backup/types/chunk_method.py

@@ -3,21 +3,23 @@
 from typing import Optional, IO, TYPE_CHECKING
 
 from prime_backup.types.chunker import Chunker
-from prime_backup.types.chunker_definition import ChunkerDefinition, CDCChunkerDefinition, FixedSizeChunkerDefinition
+from prime_backup.types.chunker_definition import ChunkerDefinition, FastCDCChunkerDefinition, FixedSizeChunkerDefinition
 from prime_backup.utils.path_like import PathLike
 
 
 class ChunkMethod(enum.Enum):
-	# Content-Defined Chunking (CDC)
-	cdc_32k = CDCChunkerDefinition(avg_size=32 * 1024, min_size=8 * 1024, max_size=256 * 1024)
-	cdc_128k = CDCChunkerDefinition(avg_size=128 * 1024, min_size=64 * 1024, max_size=1024 * 1024)
-	cdc = cdc_32k
+	# Content-Defined Chunking with FastCDC
+	fastcdc_32k = FastCDCChunkerDefinition(avg_size=32 * 1024, min_size=8 * 1024, max_size=256 * 1024)
+	fastcdc_128k = FastCDCChunkerDefinition(avg_size=128 * 1024, min_size=64 * 1024, max_size=1024 * 1024)
 
 	# Fixed-Size Chunking
 	fixed_4k = FixedSizeChunkerDefinition(4 * 1024)
 	fixed_32k = FixedSizeChunkerDefinition(32 * 1024)
 	fixed_128k = FixedSizeChunkerDefinition(128 * 1024)
 
+	# Common Alias
+	cdc = fastcdc_32k
+
 	if TYPE_CHECKING:
 		value: ChunkerDefinition
 

prime_backup/types/chunker.py

@@ -82,17 +82,17 @@ def get_read_file_size(self) -> int:
 		return self.__file_size_sum
 
 
-# ======================== CDC Chunker ========================
+# ======================== FastCDC Chunker ========================
 
 @dataclasses.dataclass(frozen=True)
-class CDCChunkerConfig:
+class FastCDCChunkerConfig:
 	avg_size: int
 	min_size: int
 	max_size: int
 
 
 class _CDCChunker(Chunker, ABC):
-	def __init__(self, cfg: CDCChunkerConfig, need_entire_file_hash: bool):
+	def __init__(self, cfg: FastCDCChunkerConfig, need_entire_file_hash: bool):
 		super().__init__(need_entire_file_hash)
 		self.cfg = cfg
 
@@ -107,8 +107,8 @@ def _create_cdc_engine(self) -> 'pyfastcdc.FastCDC':
 		)
 
 
-class CDCFileChunker(_CDCChunker):
-	def __init__(self, cfg: CDCChunkerConfig, file_path: Path, need_entire_file_hash: bool = False):
+class FastCDCFileChunker(_CDCChunker):
+	def __init__(self, cfg: FastCDCChunkerConfig, file_path: Path, need_entire_file_hash: bool = False):
 		super().__init__(cfg, need_entire_file_hash)
 		self.file_path = file_path
 
@@ -119,8 +119,8 @@ def _iter_raw_chunks(self) -> Iterable[_RawChunk]:
 			yield _RawChunk(offset=c.offset, length=c.length, data=c.data)
 
 
-class CDCStreamChunker(_CDCChunker):
-	def __init__(self, cfg: CDCChunkerConfig, stream: 'pyfastcdc.BinaryStreamReader', need_entire_file_hash: bool = False):
+class FastCDCStreamChunker(_CDCChunker):
+	def __init__(self, cfg: FastCDCChunkerConfig, stream: 'pyfastcdc.BinaryStreamReader', need_entire_file_hash: bool = False):
 		super().__init__(cfg, need_entire_file_hash)
 		self.stream = stream
 

prime_backup/types/chunker_definition.py

@@ -5,7 +5,7 @@
 
 from typing_extensions import override
 
-from prime_backup.types.chunker import Chunker, CDCFileChunker, CDCStreamChunker, FixedSizeFileChunker, FixedSizeStreamChunker, CDCChunkerConfig
+from prime_backup.types.chunker import Chunker, FastCDCFileChunker, FastCDCStreamChunker, FixedSizeFileChunker, FixedSizeStreamChunker, FastCDCChunkerConfig
 
 
 class ChunkerDefinition(ABC):
@@ -19,22 +19,22 @@ def create_stream_chunker(self, stream, need_entire_file_hash: bool) -> Chunker:
 
 
 @dataclasses.dataclass(frozen=True)
-class CDCChunkerDefinition(ChunkerDefinition):
+class FastCDCChunkerDefinition(ChunkerDefinition):
 	avg_size: int
 	min_size: int
 	max_size: int
-	_config: CDCChunkerConfig = dataclasses.field(init=False, repr=False, compare=False)
+	_config: FastCDCChunkerConfig = dataclasses.field(init=False, repr=False, compare=False)
 
 	def __post_init__(self):
-		object.__setattr__(self, '_config', CDCChunkerConfig(self.avg_size, self.min_size, self.max_size))
+		object.__setattr__(self, '_config', FastCDCChunkerConfig(self.avg_size, self.min_size, self.max_size))
 
 	@override
 	def create_file_chunker(self, file_path: Path, need_entire_file_hash: bool) -> Chunker:
-		return CDCFileChunker(self._config, file_path, need_entire_file_hash)
+		return FastCDCFileChunker(self._config, file_path, need_entire_file_hash)
 
 	@override
 	def create_stream_chunker(self, stream: IO[bytes], need_entire_file_hash: bool) -> Chunker:
-		return CDCStreamChunker(self._config, stream, need_entire_file_hash)
+		return FastCDCStreamChunker(self._config, stream, need_entire_file_hash)
 
 
 @dataclasses.dataclass(frozen=True)