mapFolding 0.11.1__tar.gz → 0.11.3__tar.gz

{mapfolding-0.11.1 → mapfolding-0.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.1
+Version: 0.11.3
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,8 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: astToolkit
 Requires-Dist: autoflake
-Requires-Dist: cytoolz
-Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
@@ -42,7 +40,6 @@ Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: sympy
 Requires-Dist: tomli
-Requires-Dist: typeshed_client
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
@@ -67,12 +64,6 @@ Dynamic: license-file
 - You're interested in solving mathematical puzzles through code
 - You're learning about Numba and advanced Python optimization
 
-**This package is NOT for you if:**
-
-- You're looking for a general-purpose folding simulation tool
-- You need commercial-ready mapping software
-- You want simple visualization of folding patterns
-
 ## What Does This Package Actually Do?
 
 `mapFolding` solves a specific mathematical problem: counting the number of distinct ways to fold a rectangular map. While this may sound niche, it's a fascinating computational challenge that demonstrates:
@@ -87,7 +78,7 @@ The package has achieved new computational records, including first-ever calcula
 ```python
 # Compute the number of ways to fold a 5×5 grid:
 from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n('A001418', 5)  # Returns 186,086,600
+foldsTotal = oeisIDfor_n('A001418', 5)
 ```
 
 ## Key Benefits for Computational Enthusiasts
@@ -178,4 +169,18 @@ If you've read this far and are intrigued by computational puzzles, algorithm op
 
 Whether you use it to solve map folding problems or to study its optimization techniques, `mapFolding` offers a unique window into advanced Python programming approaches.
 
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

{mapfolding-0.11.1 → mapfolding-0.11.3}/README.md

@@ -11,12 +11,6 @@
 - You're interested in solving mathematical puzzles through code
 - You're learning about Numba and advanced Python optimization
 
-**This package is NOT for you if:**
-
-- You're looking for a general-purpose folding simulation tool
-- You need commercial-ready mapping software
-- You want simple visualization of folding patterns
-
 ## What Does This Package Actually Do?
 
 `mapFolding` solves a specific mathematical problem: counting the number of distinct ways to fold a rectangular map. While this may sound niche, it's a fascinating computational challenge that demonstrates:
@@ -31,7 +25,7 @@ The package has achieved new computational records, including first-ever calcula
 ```python
 # Compute the number of ways to fold a 5×5 grid:
 from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n('A001418', 5)  # Returns 186,086,600
+foldsTotal = oeisIDfor_n('A001418', 5)
 ```
 
 ## Key Benefits for Computational Enthusiasts
@@ -122,4 +116,18 @@ If you've read this far and are intrigued by computational puzzles, algorithm op
 
 Whether you use it to solve map folding problems or to study its optimization techniques, `mapFolding` offers a unique window into advanced Python programming approaches.
 
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.11.3/mapFolding/__init__.py

@@ -0,0 +1,62 @@
+from typing import Any, TypeAlias
+import sys
+
+yourPythonIsOld: TypeAlias = Any
+# ruff: noqa: E402
+
+if sys.version_info >= (3, 11):
+	from typing import TypedDict as TypedDict
+	from typing import NotRequired as NotRequired
+else:
+	try:
+		from typing_extensions import TypedDict as TypedDict
+		from typing_extensions import NotRequired as NotRequired
+	except Exception:
+		TypedDict = dict[yourPythonIsOld, yourPythonIsOld]
+		from collections.abc import Iterable
+		NotRequired: TypeAlias = Iterable
+
+from mapFolding.datatypes import (
+	Array1DElephino as Array1DElephino,
+	Array1DFoldsTotal as Array1DFoldsTotal,
+	Array1DLeavesTotal as Array1DLeavesTotal,
+	Array3D as Array3D,
+	DatatypeElephino as DatatypeElephino,
+	DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+)
+
+from mapFolding.theSSOT import PackageSettings as PackageSettings, packageSettings as packageSettings
+
+from mapFolding.beDRY import (
+	getConnectionGraph as getConnectionGraph,
+	getLeavesTotal as getLeavesTotal,
+	getTaskDivisions as getTaskDivisions,
+	makeDataContainer as makeDataContainer,
+	setProcessorLimit as setProcessorLimit,
+	validateListDimensions as validateListDimensions,
+)
+
+from mapFolding.dataBaskets import MapFoldingState as MapFoldingState
+
+from mapFolding.filesystemToolkit import (
+	getFilenameFoldsTotal as getFilenameFoldsTotal,
+	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
+	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
+	saveFoldsTotal as saveFoldsTotal,
+	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
+)
+
+from mapFolding.basecamp import countFolds as countFolds
+
+from mapFolding.oeis import (
+	clearOEIScache as clearOEIScache,
+	getFoldsTotalKnown as getFoldsTotalKnown,
+	getOEISids as getOEISids,
+	OEIS_for_n as OEIS_for_n,
+	oeisIDfor_n as oeisIDfor_n,
+)

{mapfolding-0.11.1 → mapfolding-0.11.3}/mapFolding/basecamp.py

@@ -11,13 +11,11 @@ appropriate algorithm implementation, and optional persistence of results.
 
 from collections.abc import Sequence
 from mapFolding import (
-	ComputationState,
 	getPathFilenameFoldsTotal,
-	outfitCountFolds,
+	packageSettings,
 	saveFoldsTotal,
 	saveFoldsTotalFAILearly,
 	setProcessorLimit,
-	The,
 	validateListDimensions,
 )
 from os import PathLike
@@ -104,8 +102,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	# task division instructions ===============================================
 
 	if computationDivisions:
-		# NOTE `The.concurrencyPackage`
-		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
+		concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
 		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
 		leavesTotal: int = getLeavesTotal(mapShape)
 		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
@@ -163,20 +160,25 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.dataPacking import doTheNeedful
-		mapFoldingState = doTheNeedful(mapFoldingState)
+		from mapFolding.syntheticModules.dataPacking import sequential
+		mapFoldingState = sequential(mapFoldingState)
 
 		foldsTotal = mapFoldingState.foldsTotal
 
-	# NOTE treat this as a default?
-	# flow based on `The` and `ComputationState` ====================================
+	elif taskDivisions > 1:
+		from mapFolding.dataBaskets import ParallelMapFoldingState
+		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
+
+		from mapFolding.syntheticModules.countParallel import doTheNeedful
+		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit)
 
 	else:
-		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
-		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		computationStateComplete.getFoldsTotal()
-		foldsTotal = computationStateComplete.foldsTotal
+		from mapFolding.syntheticModules.daoOfMapFolding import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
 
 	# Follow memorialization instructions ===========================================
 

{mapfolding-0.11.1 → mapfolding-0.11.3}/mapFolding/beDRY.py

@@ -18,12 +18,13 @@ These utilities form a stable internal API that other modules depend on, particu
 theDao (core algorithm), and the synthetic module generators that produce optimized implementations.
 """
 from collections.abc import Sequence
-from mapFolding import ComputationState, NumPyIntegerType
+from mapFolding import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, NumPyIntegerType
 from numpy import dtype as numpy_dtype, int64 as numpy_int64, ndarray
 from sys import maxsize as sysMaxsize
 from typing import Any
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numpy
+import dataclasses
 
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""
@@ -59,7 +60,6 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
-
 	Parameters
 	----------
 	computationDivisions: None
@@ -208,39 +208,6 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 	"""
 	return numpy.zeros(shape, dtype=datatype)
 
-def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
-	"""
-	Initialize a `ComputationState` with validated parameters for map folding calculation.
-
-	This function serves as the central initialization point for creating a properly configured `ComputationState`
-	object, ensuring consistent calculation of the fundamental parameters (`leavesTotal` and `taskDivisions`) across the
-	entire package.
-
-	Parameters
-	----------
-	mapShape
-		A tuple of integers representing the dimensions of the map.
-	computationDivisions: None
-		Controls how to divide the computation into parallel tasks. I know it is annoying, but please see
-		`countFolds` for details, so that you and I both know you have the most accurate information.
-	concurrencyLimit: 1
-		Maximum number of concurrent processes to use during computation.
-
-	Returns
-	-------
-	computationStateInitialized
-		A fully initialized `ComputationState` object that's ready for computation.
-
-	Notes
-	-----
-	This function maintains the Single Source of Truth principle for `leavesTotal` and `taskDivisions` calculation,
-	ensuring these values are derived consistently throughout the package.
-	"""
-	leavesTotal = getLeavesTotal(mapShape)
-	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
-	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions, concurrencyLimit)
-	return computationStateInitialized
-
 def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
 	"""
 	Whether and how to limit the CPU usage.
@@ -281,7 +248,8 @@ def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = Non
 
 	match concurrencyPackage:
 		case 'multiprocessing' | None:
-			# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+			# When to use multiprocessing.set_start_method
+			# https://github.com/hunterhogan/mapFolding/issues/6
 			concurrencyLimit: int = defineConcurrencyLimit(CPUlimit)
 		case 'numba':
 			from numba import get_num_threads, set_num_threads

{mapfolding-0.11.1 → mapfolding-0.11.3}/mapFolding/dataBaskets.py

@@ -1,5 +1,14 @@
-from mapFolding.beDRY import getConnectionGraph, getLeavesTotal, makeDataContainer
-from mapFolding.datatypes import Array3D, Array1DElephino, Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding import (
+	Array1DElephino,
+	Array1DLeavesTotal,
+	Array3D,
+	DatatypeElephino,
+	DatatypeFoldsTotal,
+	DatatypeLeavesTotal,
+	getConnectionGraph,
+	getLeavesTotal,
+	makeDataContainer,
+)
 import dataclasses
 
 @dataclasses.dataclass
@@ -48,6 +57,19 @@ class MapFoldingState:
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 
+@dataclasses.dataclass
+class ParallelMapFoldingState(MapFoldingState):
+	taskDivisions: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	"""Number of tasks into which to divide the computation. If the value is greater than `leavesTotal`, the computation will be wrong. Default is `leavesTotal`."""
+
+	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	"""Index of the current task when using task divisions."""
+
+	def __post_init__(self) -> None:
+		super().__post_init__()
+		if self.taskDivisions == 0:
+			self.taskDivisions = DatatypeLeavesTotal(int(self.leavesTotal))
+
 @dataclasses.dataclass
 class LeafSequenceState(MapFoldingState):
 	leafSequence: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]

{mapfolding-0.11.1 → mapfolding-0.11.3}/mapFolding/datatypes.py

@@ -1,9 +1,6 @@
 from numpy import dtype, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64, integer, ndarray
 from typing import Any, TypeAlias, TypeVar
 
-# =============================================================================
-# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
-
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 
 DatatypeLeavesTotal: TypeAlias = int

mapfolding-0.11.1/mapFolding/toolboxFilesystem.py → mapfolding-0.11.3/mapFolding/filesystemToolkit.py

@@ -21,7 +21,7 @@ The functions here adhere to a consistent approach to path handling:
 - Progressive fallback strategies for saving critical computation results.
 - Preemptive filesystem validation to detect issues before computation begins.
 """
-from mapFolding import The
+from mapFolding import packageSettings
 from os import PathLike
 from pathlib import Path, PurePath
 from sys import modules as sysModules
@@ -101,9 +101,9 @@ def getPathRootJobDEFAULT() -> Path:
 		- For Google Colab, uses a specific path in Google Drive.
 		- Creates the directory if it doesn't exist.
 	"""
-	pathJobDEFAULT = Path(platformdirs.user_data_dir(appname=The.packageName, appauthor=False, ensure_exists=True))
+	pathJobDEFAULT = Path(platformdirs.user_data_dir(appname=packageSettings.packageName, appauthor=False, ensure_exists=True))
 	if 'google.colab' in sysModules:
-		pathJobDEFAULT = Path("/content/drive/MyDrive") / The.packageName
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / packageSettings.packageName
 	pathJobDEFAULT.mkdir(parents=True, exist_ok=True)
 	return pathJobDEFAULT
 

{mapfolding-0.11.1 → mapfolding-0.11.3}/mapFolding/oeis.py

@@ -20,9 +20,10 @@ mathematical definition in OEIS and the computational implementation in the pack
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache
-from mapFolding import countFolds, The, TypedDict, writeStringToHere
+from mapFolding import countFolds, packageSettings, TypedDict
 from pathlib import Path
 from typing import Any, Final
+from Z0Z_tools import writeStringToHere
 import argparse
 import random
 import sys
@@ -33,7 +34,7 @@ import warnings
 
 cacheDays = 30
 
-pathCache: Path = The.pathPackage / ".cache"
+pathCache: Path = packageSettings.pathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
@@ -143,9 +144,6 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 		invalid.
 	"""
 	bFileLines: list[str] = OEISbFile.strip().splitlines()
-	# if not bFileLines.pop(0).startswith(f"# {oeisID}"):
-	# 	warnings.warn(f"Content does not match sequence {oeisID}")
-	# 	return {-1: -1}
 
 	OEISsequence: dict[int, int] = {}
 	for line in bFileLines:

mapfolding-0.11.3/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -0,0 +1,89 @@
+from astToolkit import ast_Identifier, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding import getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState
+from mapFolding import DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+from mapFolding.someAssemblyRequired import ShatteredDataclass, packageInformation
+from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
+from pathlib import Path, PurePosixPath
+from typing import TypeAlias
+import dataclasses
+
+@dataclasses.dataclass
+class RecipeJobTheorem2Numba:
+	state: MapFoldingState
+	# TODO create function to calculate `foldsTotalEstimated`
+	foldsTotalEstimated: int = 0
+	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Source
+	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')
+	sourceCountCallable: ast_Identifier = 'count'
+
+	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
+	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
+	sourceDataclassInstance: ast_Identifier = packageInformation.dataclassInstance
+
+	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageInformation.pathPackage)
+	sourcePackageIdentifier: ast_Identifier | None = packageInformation.packageName
+
+	# ========================================
+	# Filesystem (names of physical objects)
+	pathPackage: PurePosixPath | None = None
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	fileExtension: str = packageInformation.fileExtension
+	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	packageIdentifier: ast_Identifier | None = None
+	logicalPathRoot: str_nameDOTname | None = None
+	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	countCallable: ast_Identifier = sourceCountCallable
+	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
+	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
+	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
+
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
+	def _makePathFilename(self,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			filenameStem: str | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if filenameStem is None:
+			filenameStem = self.moduleIdentifier
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameModule(self) -> PurePosixPath:
+		if self.pathModule is None:
+			return self._makePathFilename()
+		else:
+			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
+
+	def __post_init__(self):
+		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
+
+		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = pathFilenameFoldsTotal.stem
+
+		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
+
+		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
+			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)