mapFolding 0.11.2__py3-none-any.whl → 0.11.3__py3-none-any.whl

mapFolding/__init__.py

@@ -33,29 +33,16 @@ from mapFolding.datatypes import (
 from mapFolding.theSSOT import PackageSettings as PackageSettings, packageSettings as packageSettings
 
 from mapFolding.beDRY import (
-	ComputationState as ComputationState,
 	getConnectionGraph as getConnectionGraph,
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	makeDataContainer as makeDataContainer,
-	outfitCountFolds as outfitCountFolds,
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions,
 )
 
 from mapFolding.dataBaskets import MapFoldingState as MapFoldingState
 
-from mapFolding.infoBooth import (
-	PackageInformation as PackageInformation,
-	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
-	The as The,
-)
-
-from mapFolding.theDao import (
-	countInitialize as countInitialize,
-	doTheNeedful as doTheNeedful,
-)
-
 from mapFolding.filesystemToolkit import (
 	getFilenameFoldsTotal as getFilenameFoldsTotal,
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,

mapFolding/basecamp.py

@@ -12,10 +12,10 @@ appropriate algorithm implementation, and optional persistence of results.
 from collections.abc import Sequence
 from mapFolding import (
 	getPathFilenameFoldsTotal,
+	packageSettings,
 	saveFoldsTotal,
 	saveFoldsTotalFAILearly,
 	setProcessorLimit,
-	The,
 	validateListDimensions,
 )
 from os import PathLike
@@ -102,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)

mapFolding/beDRY.py

@@ -208,150 +208,6 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 	"""
 	return numpy.zeros(shape, dtype=datatype)
 
-
-@dataclasses.dataclass
-class ComputationState:
-	"""
-	Represents the complete state of a map folding computation.
-
-	This dataclass encapsulates all the information required to compute the number of possible ways to fold a map,
-	including the map dimensions, leaf connections, computation progress, and fold counting. It serves as the central
-	data structure that flows through the entire computational algorithm.
-
-	Fields are categorized into:
-	1. Input parameters (`mapShape`, `leavesTotal`, etc.).
-	2. Core computational structures (`connectionGraph`, etc.).
-	3. Tracking variables for the folding algorithm state.
-	4. Result accumulation fields (`foldsTotal`, `groupsOfFolds`).
-	"""
-	# NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` metadata needs to match the type
-	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
-	"""Dimensions of the map to be folded, as a tuple of integers."""
-
-	leavesTotal: DatatypeLeavesTotal
-	"""Total number of leaves (unit squares) in the map, equal to the product of all dimensions."""
-
-	taskDivisions: DatatypeLeavesTotal
-	"""Number of parallel tasks to divide the computation into. Zero means sequential computation."""
-
-	concurrencyLimit: DatatypeElephino
-	"""Maximum number of concurrent processes to use during computation."""
-
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
-	"""3D array encoding the connections between leaves in all dimensions."""
-
-	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
-	"""Total number of dimensions in the map shape."""
-
-	# I am using `dataclasses.field` metadata and `typeAlias.__args__[1].__args__[0]` to make the code more DRY. https://github.com/hunterhogan/mapFolding/issues/9
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks how many dimensions are gapped for each leaf."""
-
-	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Number of dimensions that are not constrained in the current folding state."""
-
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Starting index for the gap range for each leaf."""
-
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks where gaps occur in the folding pattern."""
-
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf above it in the folding pattern."""
-
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf below it in the folding pattern."""
-
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DFoldsTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Accumulator for fold groups across parallel tasks."""
-
-	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
-	"""The final computed total number of distinct folding patterns."""
-
-	gap1ndex: DatatypeElephino = DatatypeElephino(0)
-	"""Current index into gaps array during algorithm execution."""
-
-	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
-	"""Upper limit for gap index during the current algorithm phase."""
-
-	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
-	"""Accumulator for the number of fold groups found during computation."""
-
-	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current dimension being processed during algorithm execution."""
-
-	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current leaf index during iteration."""
-
-	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
-	"""Index used when filtering common gaps."""
-
-	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
-	"""Active leaf being processed in the folding algorithm. Starts at 1, not 0."""
-
-	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Leaf that is being connected to the active leaf."""
-
-	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Index of the current parallel task when using task divisions."""
-
-	def __post_init__(self) -> None:
-		from mapFolding.beDRY import getConnectionGraph, makeDataContainer
-		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
-		leavesTotalAsInt = int(self.leavesTotal)
-		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
-
-		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.foldGroups is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), self.__dataclass_fields__['foldGroups'].metadata['dtype'])
-			self.foldGroups[-1] = self.leavesTotal
-
-		# Dataclasses, Default factories, and arguments in `ComputationState` https://github.com/hunterhogan/mapFolding/issues/12
-		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		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]
-
-	# Automatic, or not, calculation in dataclass `ComputationState` https://github.com/hunterhogan/mapFolding/issues/14
-	def getFoldsTotal(self) -> None:
-		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
-
-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.
@@ -392,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/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/oeis.py

@@ -144,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/someAssemblyRequired/RecipeJob.py

@@ -1,106 +1,12 @@
-from mapFolding import ComputationState, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState
+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, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
-from mapFolding.someAssemblyRequired.toolkitNumba import theNumbaFlow
+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 RecipeJob:
-	state: ComputationState
-	# TODO create function to calculate `foldsTotalEstimated`
-	foldsTotalEstimated: int = 0
-	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
-
-	# ========================================
-	# Source
-	source_astModule = parsePathFilename2astModule(theNumbaFlow.pathFilenameSequential)
-	sourceCountCallable: ast_Identifier = theNumbaFlow.callableSequential
-
-	sourceLogicalPathModuleDataclass: str_nameDOTname = theNumbaFlow.logicalPathModuleDataclass
-	sourceDataclassIdentifier: ast_Identifier = theNumbaFlow.dataclassIdentifier
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
-
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
-
-	# ========================================
-	# Filesystem (names of physical objects)
-	pathPackage: PurePosixPath | None = None
-	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
-	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
-	fileExtension: str = theNumbaFlow.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)
-
-	# ========================================
-	# Fields you probably don't need =================================
-	# Dispatcher =================================
-	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
-	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
-	# Parallel counting =================================
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
-	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
-
 @dataclasses.dataclass
 class RecipeJobTheorem2Numba:
 	state: MapFoldingState
@@ -115,17 +21,17 @@ class RecipeJobTheorem2Numba:
 
 	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
 	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+	sourceDataclassInstance: ast_Identifier = packageInformation.dataclassInstance
 
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+	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 = theNumbaFlow.fileExtension
+	fileExtension: str = packageInformation.fileExtension
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 
 	# ========================================
@@ -181,16 +87,3 @@ class RecipeJobTheorem2Numba:
 
 		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)
-
-	# ========================================
-	# Fields you probably don't need =================================
-	# Dispatcher =================================
-	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
-	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
-	# Parallel counting =================================
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
-	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier

mapFolding/someAssemblyRequired/{Z0Z_makeSomeModules.py → Z0Z_makeAllModules.py}

@@ -1,28 +1,30 @@
 from collections.abc import Sequence
-from astToolkit import ClassIsAndAttribute, extractClassDef
-from mapFolding import raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
+from astToolkit import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
 	Be,
+	ClassIsAndAttribute,
 	DOT,
+	extractClassDef,
 	extractFunctionDef,
 	Grab,
-	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
-	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	removeUnusedParameters,
 	str_nameDOTname,
 	Then,
-	write_astModule,
+)
+from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from mapFolding.someAssemblyRequired import (
 	DeReConstructField2ast,
+	IfThis,
+	packageInformation,
+	raiseIfNoneGitHubIssueNumber3,
 	ShatteredDataclass,
 )
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
@@ -48,7 +50,7 @@ def makeInitializeGroupsOfFolds() -> None:
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	logicalPathSourceModule = '.'.join([packageInformation.packageName, algorithmSourceModule])
 
 	callableIdentifier = callableIdentifierHARDCODED
 	logicalPathInfix = logicalPathInfixHARDCODED
@@ -70,16 +72,16 @@ def makeInitializeGroupsOfFolds() -> None:
 
 	ingredientsModule = IngredientsModule(countInitializeIngredients)
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = PurePath(packageInformation.pathPackage, logicalPathInfix, moduleIdentifier + packageInformation.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 def makeDaoOfMapFolding() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	logicalPathSourceModule = '.'.join([packageInformation.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = moduleIdentifierHARDCODED
@@ -119,7 +121,7 @@ def makeDaoOfMapFolding() -> PurePath:
 
 	daoOfMapFolding = decorateCallableWithNumba(daoOfMapFolding, parametersNumbaLight)
 
-	sourceCallableIdentifier = The.sourceCallableDispatcher
+	sourceCallableIdentifier = packageInformation.sourceCallableDispatcher
 
 	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
 	doTheNeedful.imports.update(shatteredDataclass.imports)
@@ -138,9 +140,9 @@ def makeDaoOfMapFolding() -> PurePath:
 	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = PurePath(packageInformation.pathPackage, logicalPathInfix, moduleIdentifier + packageInformation.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 	return pathFilename
 
@@ -149,7 +151,7 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	logicalPathSourceModule = '.'.join([packageInformation.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = moduleIdentifierHARDCODED
@@ -242,7 +244,7 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
 	# Start unpack/repack the dataclass function ================================================
-	sourceCallableIdentifier = The.sourceCallableDispatcher
+	sourceCallableIdentifier = packageInformation.sourceCallableDispatcher
 
 	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
 	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclass_IdentifierParallel
@@ -293,9 +295,9 @@ def makeDaoOfMapFoldingParallel() -> PurePath:
 	)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = PurePath(packageInformation.pathPackage, logicalPathInfix, moduleIdentifier + packageInformation.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 	return pathFilename
 
 def makeTheorem2() -> PurePath:
@@ -303,7 +305,7 @@ def makeTheorem2() -> PurePath:
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	logicalPathSourceModule = '.'.join([packageInformation.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = moduleIdentifierHARDCODED
@@ -342,9 +344,9 @@ def makeTheorem2() -> PurePath:
 
 	ingredientsModule = IngredientsModule(countTheorem2)
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = PurePath(packageInformation.pathPackage, logicalPathInfix, moduleIdentifier + packageInformation.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 	return pathFilename
 
@@ -365,11 +367,11 @@ def trimTheorem2(pathFilenameSource: PurePath) -> PurePath:
 
 	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Trimmed')
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
+	if packageInformation.packageName:
+		logicalPath.append(packageInformation.packageName)
 	if logicalPathInfix:
 		logicalPath.append(logicalPathInfix)
 	logicalPath.append(pathFilename.stem)
@@ -413,11 +415,11 @@ def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 
 	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 	logicalPath: list[str] = []
-	if The.packageName:
-		logicalPath.append(The.packageName)
+	if packageInformation.packageName:
+		logicalPath.append(packageInformation.packageName)
 	if logicalPathInfix:
 		logicalPath.append(logicalPathInfix)
 	logicalPath.append(pathFilename.stem)
@@ -431,8 +433,8 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	callableIdentifierHARDCODED: ast_Identifier = 'sequential'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
-	sourceCallableIdentifier = The.sourceCallableDispatcher
-	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+	sourceCallableIdentifier = packageInformation.sourceCallableDispatcher
+	logicalPathSourceModule = '.'.join([packageInformation.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = dataPackingModuleIdentifierHARDCODED
@@ -476,9 +478,9 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+	pathFilename = PurePath(packageInformation.pathPackage, logicalPathInfix, moduleIdentifier + packageInformation.fileExtension)
 
-	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, packageInformation.packageName)
 
 if __name__ == '__main__':
 	makeInitializeGroupsOfFolds()

mapFolding/someAssemblyRequired/__init__.py

@@ -44,41 +44,15 @@ optimizations - while maintaining the ability to verify correctness at each tran
 test suite.
 """
 
-from astToolkit import (
-	ast_expr_Slice as ast_expr_Slice,
-	ast_Identifier as ast_Identifier,
-	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
-	Be as Be,
-	DOT as DOT,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-	Grab as Grab,
-	IngredientsFunction as IngredientsFunction,
-	IngredientsModule as IngredientsModule,
-	LedgerOfImports as LedgerOfImports,
-	Make as Make,
-	NodeChanger as NodeChanger,
-	NodeORattribute as NodeORattribute,
-	NodeTourist as NodeTourist,
-	parseLogicalPath2astModule as parseLogicalPath2astModule,
-	parsePathFilename2astModule as parsePathFilename2astModule,
-	str_nameDOTname as str_nameDOTname,
-	Then as Then,
-)
-
-from Z0Z_tools import importLogicalPath2Callable as importLogicalPath2Callable, importPathFilename2Callable as importPathFilename2Callable
-
-from astToolkit.transformationTools import (
-	inlineFunctionDef as inlineFunctionDef,
-	removeUnusedParameters as removeUnusedParameters,
-	unparseFindReplace as unparseFindReplace,
-	write_astModule as write_astModule,
+from mapFolding.someAssemblyRequired.infoBooth import (
+	PackageInformation as PackageInformation,
+	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
+	packageInformation as packageInformation,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
 
 from mapFolding.someAssemblyRequired._toolkitContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
-	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -19,9 +19,8 @@ they implement a declarative approach to AST manipulation that separates node id
 (be), and data access (DOT).
 """
 
-from astToolkit import IfThis as astToolkit_IfThis
+from astToolkit import ast_Identifier, Be, DOT, IfThis as astToolkit_IfThis
 from collections.abc import Callable
-from mapFolding.someAssemblyRequired import ast_Identifier, Be, DOT
 from typing import TypeGuard
 import ast