mapFolding 0.4.2__tar.gz → 0.4.3__tar.gz

{mapfolding-0.4.2 → mapfolding-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.2
+Version: 0.4.3
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.4.2 → mapfolding-0.4.3}/mapFolding/__init__.py

@@ -11,6 +11,7 @@ from mapFolding.theSSOT import (
 
 # Datatype management
 from mapFolding.theSSOT import (
+	getDatatypeModule,
 	hackSSOTdatatype,
 	hackSSOTdtype,
 	setDatatypeElephino,
@@ -21,7 +22,7 @@ from mapFolding.theSSOT import (
 
 # Synthesize modules
 from mapFolding.theSSOT import (
-	formatModuleNameDEFAULT,
+	formatFilenameModuleDEFAULT,
 	getAlgorithmDispatcher,
 	getAlgorithmSource,
 	getPathJobRootDEFAULT,

{mapfolding-0.4.2 → mapfolding-0.4.3}/mapFolding/basecamp.py

@@ -17,7 +17,7 @@ def countFolds(listDimensions: Sequence[int]
 		computationDivisions (None):
 			Whether and how to divide the computational work. See notes for details.
 		CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
-		**keywordArguments: Datatype management.
+		**keywordArguments: Datatype management. See `outfitCountFolds` for details.
 	Returns:
 		foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
 

{mapfolding-0.4.2 → mapfolding-0.4.3}/mapFolding/beDRY.py

@@ -1,6 +1,7 @@
 """A relatively stable API for oft-needed functionality."""
 from mapFolding import (
 	computationState,
+	getDatatypeModule,
 	getPathJobRootDEFAULT,
 	hackSSOTdatatype,
 	hackSSOTdtype,
@@ -9,6 +10,7 @@ from mapFolding import (
 	setDatatypeElephino,
 	setDatatypeFoldsTotal,
 	setDatatypeLeavesTotal,
+	setDatatypeModule,
 )
 from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
@@ -21,23 +23,25 @@ import pathlib
 import sys
 
 def getFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]]) -> str:
-	"""Make a standardized filename for the computed value `foldsTotal`.
+	"""Imagine your computer has been counting folds for 70 hours, and when it tries to save your newly discovered value,
+	the filename is invalid. I bet you think this function is more important after that thought experiment.
+
+	Make a standardized filename for the computed value `foldsTotal`.
 
 	The filename takes into account
 		- the dimensions of the map, aka `mapShape`, aka `listDimensions`
 		- no spaces in the filename
-		- safe filesystem characters across platforms
+		- safe filesystem characters
 		- unique extension
-		- avoiding potential problems when Python is manipulating the filename, including
-			- treating the file stem as a valid Python identifier, such as
-				- not starting with a number
-				- not using reserved words
-				- no dashes or other special characters
-			- uh, I can't remember, but I found some frustrating edge limitations
-		- if 'p' is still the first character, I picked that because it was the original identifier for the map shape in Lunnan's code
+		- Python-safe strings:
+			- no starting with a number
+			- no reserved words
+			- no dashes or other special characters
+			- uh, I can't remember, but I found some other frustrating limitations
+		- if 'p' is still the first character of the filename, I picked that because it was the original identifier for the map shape in Lunnan's code
 
 	Parameters:
-		mapShape: A sequence of integers representing the dimensions of the map (e.g., [3, 2] for a 3x2 map)
+		mapShape: A sequence of integers representing the dimensions of the map.
 
 	Returns:
 		filenameFoldsTotal: A filename string in format 'pNxM.foldsTotal' where N,M are sorted dimensions
@@ -97,33 +101,36 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int],
 
 def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]) -> int:
 	"""
-	Determines whether or how to divide the computation into tasks.
+	Determines whether to divide the computation into tasks and how many divisions.
 
 	Parameters
 	----------
-	computationDivisions (None):
+	computationDivisions (None)
 		Specifies how to divide computations:
-		- None: no division of the computation into tasks; sets task divisions to 0
-		- int: direct set the number of task divisions; cannot exceed the map's total leaves
-		- "maximum": divides into `leavesTotal`-many `taskDivisions`
-		- "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
-		concurrencyLimit:
-			Maximum number of concurrent tasks allowed
-		CPUlimit: for error reporting
-		listDimensions: for error reporting
+		- `None`: no division of the computation into tasks; sets task divisions to 0.
+		- int: direct set the number of task divisions; cannot exceed the map's total leaves.
+		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
+		- `'cpu'`: limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`.
+	concurrencyLimit
+		Maximum number of concurrent tasks allowed.
+	CPUlimit
+		for error reporting.
+	listDimensions
+		for error reporting.
 
 	Returns
 	-------
-		taskDivisions:
+	taskDivisions
+		How many tasks must finish before the job can compute the total number of folds; `0` means no tasks, only job.
 
 	Raises
 	------
-		ValueError
-			If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves
+	ValueError
+		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves.
 
 	Notes
 	-----
-	Task divisions should not exceed total leaves to prevent duplicate counting of folds.
+	Task divisions should not exceed total leaves or the folds will be over-counted.
 	"""
 	taskDivisions = 0
 	leavesTotal = getLeavesTotal(listDimensions)
@@ -133,9 +140,9 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 		taskDivisions = computationDivisions
 	elif isinstance(computationDivisions, str):
 		computationDivisions = computationDivisions.lower()
-		if computationDivisions == "maximum":
+		if computationDivisions == 'maximum':
 			taskDivisions = leavesTotal
-		elif computationDivisions == "cpu":
+		elif computationDivisions == 'cpu':
 			taskDivisions = min(concurrencyLimit, leavesTotal)
 	else:
 		raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
@@ -196,15 +203,21 @@ def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTy
 	Parameters:
 		shape: The shape of the array. Can be an integer for 1D arrays
 			or a tuple of integers for multi-dimensional arrays.
-		datatype: The desired data type for the array.
-			If None, defaults to dtypeLargeDEFAULT. Defaults to None.
+		datatype ('dtypeFoldsTotal'): The desired data type for the array.
+			If `None`, defaults to 'dtypeFoldsTotal'. Defaults to None.
 
 	Returns:
 		dataContainer: A new array of given shape and type, filled with zeros.
+
+	Notes:
+		If a version of the algorithm were to use something other than numpy, such as JAX or CUDA, because other
+		functions use this function, it would be much easier to change the datatype "ecosystem".
 	"""
-	if datatype is None:
-		datatype = hackSSOTdtype('dtypeFoldsTotal')
-	return numpy.zeros(shape, dtype=datatype)
+	numpyDtype = datatype or hackSSOTdtype('dtypeFoldsTotal')
+	if 'numpy' == getDatatypeModule():
+		return numpy.zeros(shape, dtype=numpyDtype)
+	else:
+		raise NotImplementedError("Somebody done broke it.")
 
 def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
 	"""
@@ -214,11 +227,12 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
 		listDimensions: The dimensions of the map to be folded
 		computationDivisions (None): see `getTaskDivisions`
 		CPUlimit (None): see `setCPUlimit`
-		**keywordArguments: Datatype management.
+		**keywordArguments: Datatype management, it's complicated: see the code below.
 
 	Returns:
 		stateInitialized: The initialized computation state
 	"""
+	# keywordArguments START
 	kwourGrapes = keywordArguments.get('sourGrapes', None)
 	if kwourGrapes:
 		sourGrapes = True
@@ -240,6 +254,13 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
 		ImaSetTheDatatype = str(ImaSetTheDatatype)
 		setDatatypeLeavesTotal(ImaSetTheDatatype, sourGrapes)
 
+	# NOTE well: this might be only hypothetical because as of this writing, `makeDataContainer` only makes numpy.zeros. But it's here in case things change.
+	ImaSetTheDatatype = keywordArguments.get('datatypeModule', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeModule(ImaSetTheDatatype, sourGrapes)
+	# keywordArguments END
+
 	my = makeDataContainer(len(indexMy), hackSSOTdtype('my'))
 
 	mapShape = tuple(sorted(validateListDimensions(listDimensions)))
@@ -265,16 +286,16 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
 
 def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
 	"""
-	Parse and validate dimensions are non-negative integers.
+	Parse and validate the dimensions are non-negative integers.
 
 	Parameters:
-		dimensions: Sequence of integers representing dimensions
-		parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
+		dimensions: Sequence of integers representing dimensions.
+		parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'.
 	Returns:
-		listNonNegative: List of validated non-negative integers
+		listNonNegative: List of validated non-negative integers.
 	Raises:
-		ValueError: If any dimension is negative or if the list is empty
-		TypeError: If any element cannot be converted to integer (raised by intInnit)
+		ValueError: If any dimension is negative or if the list is empty.
+		TypeError: If any element cannot be converted to integer (raised by `intInnit`).
 	"""
 	listValidated = intInnit(dimensions, parameterName)
 	listNonNegative = []
@@ -335,6 +356,7 @@ def setCPUlimit(CPUlimit: Optional[Any]) -> int:
 
 	concurrencyLimit = int(defineConcurrencyLimit(CPUlimit))
 	numba.set_num_threads(concurrencyLimit)
+	concurrencyLimit = numba.get_num_threads()
 
 	return concurrencyLimit
 
@@ -349,7 +371,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
 		dimensionsValidSorted: A list, with at least two elements, of only positive integers.
 
 	Raises:
-		ValueError: If the input listDimensions is None.
+		ValueError: If the input listDimensions is empty.
 		NotImplementedError: If the resulting list of positive dimensions has fewer than two elements.
 	"""
 	if not listDimensions:

{mapfolding-0.4.2 → mapfolding-0.4.3}/mapFolding/oeis.py

@@ -2,7 +2,7 @@
 _only_ things that implement _only_ the OEIS."""
 from datetime import datetime, timedelta
 from mapFolding import countFolds, getPathPackage
-from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING, Union
+from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -24,8 +24,8 @@ _pathCache = getPathPackage() / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	offset: int
 	getMapShape: Callable[[int], List[int]]
+	offset: int
 	valuesBenchmark: List[int]
 	valuesKnown: Dict[int, int]
 	valuesTestParallelization: List[int]
@@ -68,7 +68,7 @@ settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
 oeisIDsImplemented: Final[List[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
-def _validateOEISid(oeisIDcandidate: str) -> str:
+def validateOEISid(oeisIDcandidate: str) -> str:
 	"""
 	Validates an OEIS sequence ID against implemented sequences.
 
@@ -98,13 +98,14 @@ def _validateOEISid(oeisIDcandidate: str) -> str:
 				f"Available sequences:\n{_formatOEISsequenceInfo()}"
 			)
 
-def _getFilenameOEISbFile(oeisID: str) -> str:
-	oeisID = _validateOEISid(oeisID)
+def getFilenameOEISbFile(oeisID: str) -> str:
+	oeisID = validateOEISid(oeisID)
 	return f"b{oeisID[1:]}.txt"
 
 def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 	"""
 	Parses the content of an OEIS b-file for a given sequence ID.
+
 	This function processes a multiline string representing an OEIS b-file and
 	creates a dictionary mapping integer indices to their corresponding sequence
 	values. The first line of the b-file is expected to contain a comment that
@@ -133,7 +134,7 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 		OEISsequence[n] = aOFn
 	return OEISsequence
 
-def _getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
+def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 	cacheDays = 7
 	tryCache = False
 	if pathFilenameCache.exists():
@@ -158,7 +159,7 @@ def _getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 
 	return oeisInformation
 
-def _getOEISidValues(oeisID: str) -> Dict[int, int]:
+def getOEISidValues(oeisID: str) -> Dict[int, int]:
 	"""
 	Retrieves the specified OEIS sequence as a dictionary mapping integer indices
 	to their corresponding values.
@@ -177,21 +178,21 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
 		IOError: If there is an error reading from or writing to the local cache.
 	"""
 
-	pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
-	url = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
+	pathFilenameCache = _pathCache / getFilenameOEISbFile(oeisID)
+	url = f"https://oeis.org/{oeisID}/{getFilenameOEISbFile(oeisID)}"
 
-	oeisInformation = _getOEISofficial(pathFilenameCache, url)
+	oeisInformation = getOEISofficial(pathFilenameCache, url)
 
 	if oeisInformation:
 		return _parseBFileOEIS(oeisInformation, oeisID)
 	return {-1: -1}
 
-def _getOEISidInformation(oeisID: str) -> Tuple[str, int]:
-	oeisID = _validateOEISid(oeisID)
+def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
+	oeisID = validateOEISid(oeisID)
 	pathFilenameCache = _pathCache / f"{oeisID}.txt"
 	url = f"https://oeis.org/search?q=id:{oeisID}&fmt=text"
 
-	oeisInformation = _getOEISofficial(pathFilenameCache, url)
+	oeisInformation = getOEISofficial(pathFilenameCache, url)
 
 	if not oeisInformation:
 		return "Not found", -1
@@ -221,8 +222,8 @@ def _getOEISidInformation(oeisID: str) -> Tuple[str, int]:
 def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
 	settingsTarget = {}
 	for oeisID in oeisIDsImplemented:
-		valuesKnownSherpa = _getOEISidValues(oeisID)
-		descriptionSherpa, offsetSherpa = _getOEISidInformation(oeisID)
+		valuesKnownSherpa = getOEISidValues(oeisID)
+		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
 		settingsTarget[oeisID] = SettingsOEIS(
 			description=descriptionSherpa,
 			offset=offsetSherpa,
@@ -282,7 +283,7 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 		ValueError: If n is negative.
 		KeyError: If the OEIS sequence ID is not directly implemented.
 	"""
-	oeisID = _validateOEISid(oeisID)
+	oeisID = validateOEISid(oeisID)
 
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
@@ -328,7 +329,7 @@ def clearOEIScache() -> None:
 		return
 	for oeisID in settingsOEIS:
 		( _pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
-		( _pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
+		( _pathCache / getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
 	print(f"Cache cleared from {_pathCache}")
 
 def getOEISids() -> None:

{mapfolding-0.4.2 → mapfolding-0.4.3}/mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -9,10 +9,11 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 	# NOTE hack
 	constructorName = constructorName.replace('ndarray', 'array')
 	argData_dtype: numpy.dtype = arrayTarget.dtype
-	argData_dtypeName = arrayTarget.dtype.name
+	datatypeName = argData_dtype.name
+	dtypeAsName = f"{moduleConstructor}_{datatypeName}"
 
 	allImports.addImportFromStr(moduleConstructor, constructorName)
-	allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+	allImports.addImportFromStr(moduleConstructor, datatypeName, dtypeAsName)
 
 	def insertAssign(assignee: str, arraySlice: numpy.ndarray) -> None:
 		nonlocal FunctionDefTarget
@@ -20,7 +21,7 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 		astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
 		dataAst = astStatement.value
 
-		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
+		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=dtypeAsName, ctx=ast.Load()))])
 
 		assignment = ast.Assign(targets=[ast.Name(id=assignee, ctx=ast.Store())], value=arrayCall)#NOTE
 		FunctionDefTarget.body.insert(0, assignment)
@@ -33,7 +34,8 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 
 	return FunctionDefTarget, allImports
 
-def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str , arrayTarget: numpy.ndarray , allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+
 	arrayType = type(arrayTarget)
 	moduleConstructor = arrayType.__module__
 	constructorName = arrayType.__name__
@@ -41,47 +43,41 @@ def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: s
 	constructorName = constructorName.replace('ndarray', 'array')
 	allImports.addImportFromStr(moduleConstructor, constructorName)
 
-	for stmt in FunctionDefTarget.body.copy():
-		if isinstance(stmt, ast.Assign):
-			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-				astAssignee: ast.Name = stmt.targets[0]
-				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-				astSubscript: ast.Subscript = stmt.value
-				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
-					indexAs_astAttribute: ast.Attribute = astSubscript.slice
-					indexAsStr = ast.unparse(indexAs_astAttribute)
-					arraySlice = arrayTarget[eval(indexAsStr)]
+	for statement in FunctionDefTarget.body.copy():
+		if ifThis.isUnpackingAnArray(identifier)(statement):
+			datatypeName = hackSSOTdatatype(statement.targets[0].id) # type: ignore
+			dtypeAsName = f"{moduleConstructor}_{datatypeName}"
+			indexAsStr = ast.unparse(statement.value.slice) # type: ignore
+			arraySlice = arrayTarget[eval(indexAsStr)]
 
-					onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
-					astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
-					dataAst = astStatement.value
+			onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
+			astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
+			dataAst = astStatement.value
 
-					arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
+			arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=dtypeAsName, ctx=ast.Load()))])
 
-					assignment = ast.Assign(targets=[astAssignee], value=arrayCall)
-					FunctionDefTarget.body.insert(0, assignment)
-					FunctionDefTarget.body.remove(stmt)
+			assignment = ast.Assign(targets=[statement.targets[0]], value=arrayCall) # type: ignore
+			FunctionDefTarget.body.insert(0, assignment)
+			FunctionDefTarget.body.remove(statement)
+			allImports.addImportFromStr(moduleConstructor, datatypeName, dtypeAsName)
 	return FunctionDefTarget, allImports
 
 def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	moduleConstructor = Z0Z_getDatatypeModuleScalar()
-	for stmt in FunctionDefTarget.body.copy():
-		if isinstance(stmt, ast.Assign):
-			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-				astAssignee: ast.Name = stmt.targets[0]
-				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-				astSubscript: ast.Subscript = stmt.value
-				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
-					indexAs_astAttribute: ast.Attribute = astSubscript.slice
-					indexAsStr = ast.unparse(indexAs_astAttribute)
-					argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
-					astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[ast.Constant(value=argDataSlice)], keywords=[])
-					assignment = ast.Assign(targets=[astAssignee], value=astCall)
-					if astAssignee.id not in Z0Z_listChaff:
-						FunctionDefTarget.body.insert(0, assignment)
-					FunctionDefTarget.body.remove(stmt)
+	for statement in FunctionDefTarget.body.copy():
+		if ifThis.isUnpackingAnArray(identifier)(statement):
+			astSubscript: ast.Subscript = statement.value # type: ignore
+			astAssignee: ast.Name = statement.targets[0] # type: ignore
+			argData_dtypeName = hackSSOTdatatype(astAssignee.id)
+			allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+			indexAs_astAttribute: ast.Attribute = astSubscript.slice # type: ignore
+			indexAsStr = ast.unparse(indexAs_astAttribute)
+			argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
+			astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[ast.Constant(value=argDataSlice)], keywords=[])
+			assignment = ast.Assign(targets=[astAssignee], value=astCall)
+			if astAssignee.id not in Z0Z_listChaff:
+				FunctionDefTarget.body.insert(0, assignment)
+			FunctionDefTarget.body.remove(statement)
 	return FunctionDefTarget, allImports
 
 def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: str) -> ast.FunctionDef:
@@ -136,13 +132,10 @@ def findThingyReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, obj
 	return newFunction
 
 def findAstNameReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
-	def findName(node: ast.AST) -> bool:
-		return isinstance(node, ast.Name) and node.id == name
-
 	def replaceWithConstant(node: ast.AST) -> ast.AST:
 		return ast.copy_location(ast.Constant(value=value), node)
 
-	return cast(ast.FunctionDef, NodeReplacer(findName, replaceWithConstant).visit(FunctionDefTarget))
+	return cast(ast.FunctionDef, NodeReplacer(ifThis.nameIs(name), replaceWithConstant).visit(FunctionDefTarget))
 
 def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	"""Add multiplication and return statement to function, properly constructing AST nodes."""
@@ -155,6 +148,8 @@ def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget
 
 	returnStatement = ast.Return(value=multiplyOperation)
 
+	datatype = hackSSOTdatatype(Z0Z_identifierCountFolds)
+	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
 	datatypeModuleScalar = Z0Z_getDatatypeModuleScalar()
 	allImports.addImportFromStr(datatypeModuleScalar, datatype)
 
@@ -240,9 +235,7 @@ if __name__ == '__main__':
 """
 	return ast.parse(linesLaunch)
 
-def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False , unpackArrays: Optional[bool]=False , allImports: Optional[UniversalImportTracker]=None ) -> str:
-	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
-
+def makeFunctionDef(astModule: ast.Module, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False, unpackArrays: Optional[bool]=False, allImports: Optional[UniversalImportTracker]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	if allImports is None:
 		allImports = UniversalImportTracker()
 	for statement in astModule.body:
@@ -253,6 +246,7 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 		dictionaryFunctionDef = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
 		callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
 		# NOTE the inliner assumes each function is not called more than once
+		# TODO change the inliner to handle multiple calls to the same function
 		FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
 	else:
 		FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
@@ -270,9 +264,7 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 			FunctionDefTarget = cast(ast.FunctionDef, unpacker.visit(FunctionDefTarget))
 			ast.fix_missing_locations(FunctionDefTarget)
 
-	astModule = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
-	ast.fix_missing_locations(astModule)
-	return ast.unparse(astModule)
+	return FunctionDefTarget, allImports
 
 def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef: