mapFolding 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeCountingFunctions.py

@@ -1,7 +0,0 @@
-from mapFolding.someAssemblyRequired import IngredientsFunction, Make
-from typing import cast
-from types import ModuleType
-import ast
-
-def Z0Z_makeCountingFunction(callableTarget: str, sourceAlgorithm: ModuleType, inline: bool, dataclass: bool):
-	pass

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -1,91 +0,0 @@
-from collections.abc import Sequence
-from mapFolding.someAssemblyRequired.whatWillBe import LedgerOfImports, ParametersNumba, Z0Z_getDatatypeModuleScalar, parametersNumbaDEFAULT
-from mapFolding.someAssemblyRequired.whatWillBe import Z0Z_getDecoratorCallable
-from mapFolding.someAssemblyRequired import Make, ifThis
-from typing import Any, cast
-import ast
-
-def thisIsNumbaDotJit(Ima: ast.AST) -> bool:
-	return ifThis.isCallNamespace_Identifier(Z0Z_getDatatypeModuleScalar(), Z0Z_getDecoratorCallable())(Ima)
-
-def thisIsJit(Ima: ast.AST) -> bool:
-	return ifThis.isCall_Identifier(Z0Z_getDecoratorCallable())(Ima)
-
-def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
-	return thisIsNumbaDotJit(Ima) or thisIsJit(Ima)
-
-def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: LedgerOfImports, parametersNumba: ParametersNumba | None = None) -> tuple[ast.FunctionDef, LedgerOfImports]:
-	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
-		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
-		for decoratorItem in astCallable.decorator_list.copy():
-			import warnings
-			astCallable.decorator_list.remove(decoratorItem)
-			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
-		return astCallable
-
-	def make_arg4parameter(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None:
-		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
-			annotationShape: ast.expr = signatureElement.annotation.slice.elts[0]
-			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
-				shapeAsListSlices: list[ast.Slice] = [ast.Slice() for _axis in range(len(annotationShape.slice.elts))]
-				shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
-				shapeAST: ast.Slice | ast.Tuple = ast.Tuple(elts=list(shapeAsListSlices), ctx=ast.Load())
-			else:
-				shapeAST = ast.Slice(step=ast.Constant(value=1))
-
-			annotationDtype: ast.expr = signatureElement.annotation.slice.elts[1]
-			if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
-				datatypeAST = annotationDtype.slice.attr
-			else:
-				datatypeAST = None
-
-			ndarrayName = signatureElement.arg
-			Z0Z_hacky_dtype: str = ndarrayName
-			datatype_attr = datatypeAST or Z0Z_hacky_dtype
-			allImports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
-			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
-
-			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
-
-		elif isinstance(signatureElement.annotation, ast.Name):
-			return signatureElement.annotation
-		return None
-
-	datatypeModuleDecorator: str = Z0Z_getDatatypeModuleScalar()
-	list_argsDecorator: Sequence[ast.expr] = []
-
-	list_arg4signature_or_function: list[ast.expr] = []
-	for parameter in FunctionDefTarget.args.args:
-		signatureElement: ast.Subscript | ast.Name | None = make_arg4parameter(parameter)
-		if signatureElement:
-			list_arg4signature_or_function.append(signatureElement)
-
-	if FunctionDefTarget.returns and isinstance(FunctionDefTarget.returns, ast.Name):
-		theReturn: ast.Name = FunctionDefTarget.returns
-		list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
-							, args=list_arg4signature_or_function if list_arg4signature_or_function else [], keywords=[] ) )]
-	elif list_arg4signature_or_function:
-		list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
-
-	for decorator in FunctionDefTarget.decorator_list.copy():
-		if thisIsAnyNumbaJitDecorator(decorator):
-			decorator = cast(ast.Call, decorator)
-			if parametersNumba is None:
-				parametersNumbaSherpa: dict[str, Any] = Make.copy_astCallKeywords(decorator)
-				if (_HunterIsSureThereAreBetterWaysToDoThis := True):
-					if parametersNumbaSherpa:
-						parametersNumba = cast(ParametersNumba, parametersNumbaSherpa)
-		FunctionDefTarget.decorator_list.remove(decorator)
-
-	FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
-	if parametersNumba is None:
-		parametersNumba = parametersNumbaDEFAULT
-	listDecoratorKeywords: list[ast.keyword] = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
-
-	decoratorModule: str = Z0Z_getDatatypeModuleScalar()
-	decoratorCallable: str = Z0Z_getDecoratorCallable()
-	allImports.addImportFromStr(decoratorModule, decoratorCallable)
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-
-	FunctionDefTarget.decorator_list = [astDecorator]
-	return FunctionDefTarget, allImports

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -1,91 +0,0 @@
-# pyright: basic
-from os import PathLike
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-	from mapFolding.someAssemblyRequired.whatWillBe import ParametersSynthesizeNumbaCallable, listNumbaCallableDispatchees
-from mapFolding.theSSOT import theModuleOfSyntheticModules
-from mapFolding.theSSOT import getSourceAlgorithm
-import types
-
-def makeFlowNumbaOptimized(listCallablesInline: list[ParametersSynthesizeNumbaCallable] = listNumbaCallableDispatchees, callableDispatcher: bool = True, algorithmSource: types.ModuleType = getSourceAlgorithm(), relativePathWrite: str | PathLike[str] = theModuleOfSyntheticModules, filenameModuleWrite: str = 'filenameModuleSyntheticWrite', formatFilenameWrite: str = 'formatStrFilenameForCallableSynthetic'):
-	from mapFolding.someAssemblyRequired.whatWillBe import ParametersSynthesizeNumbaCallable, listNumbaCallableDispatchees
-	from mapFolding.someAssemblyRequired.whatWillBe import LedgerOfImports, Z0Z_autoflake_additional_imports
-	from mapFolding.theSSOT import FREAKOUT
-	from mapFolding.theSSOT import thePathPackage, getDatatypePackage
-	from mapFolding.someAssemblyRequired.whatWillBe import FunctionInliner, YouOughtaKnow, ast_Identifier
-	from pathlib import Path
-	from typing import cast
-	import ast
-	import autoflake
-	import inspect
-	import warnings
-	if relativePathWrite and Path(relativePathWrite).is_absolute():
-		raise ValueError("The path to write the module must be relative to the root of the package.")
-
-	listStuffYouOughtaKnow: list[YouOughtaKnow] = []
-
-	listFunctionDefs: list[ast.FunctionDef] = []
-	allImportsModule = LedgerOfImports()
-	for tupleParameters in listCallablesInline:
-		pythonSource: str = inspect.getsource(algorithmSource)
-		astModule: ast.Module = ast.parse(pythonSource)
-		if allImports is None:
-			allImports = LedgerOfImports(astModule)
-		else:
-			allImports.walkThis(astModule)
-
-		if inlineCallables:
-			dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
-			callableInlinerWorkhorse = FunctionInliner(dictionaryFunctionDef)
-			FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
-		else:
-			FunctionDefTarget = next((statement for statement in astModule.body if isinstance(statement, ast.FunctionDef) and statement.name == callableTarget), None)
-		if not FunctionDefTarget:
-			raise ValueError(f"Could not find function {callableTarget} in source code")
-
-		ast.fix_missing_locations(FunctionDefTarget)
-		listFunctionDefs.append(FunctionDefTarget)
-		allImportsModule.update(allImports)
-
-	listAstImports: list[ast.ImportFrom | ast.Import] = allImportsModule.makeListAst()
-	additional_imports: list[str] = Z0Z_autoflake_additional_imports
-	additional_imports.append(getDatatypePackage())
-
-	astModule = ast.Module(body=cast(list[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	if not pythonSource: raise FREAKOUT
-	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
-
-	pathWrite: Path = thePathPackage / relativePathWrite
-
-	if not filenameWrite:
-		if len(listCallableSynthesized) == 1:
-			callableTarget: str = listCallableSynthesized[0].callableTarget
-		else:
-			callableTarget = filenameWriteCallableTargetDEFAULT
-			# NOTE WARNING I think I broken this format string. See theSSOT.py
-		filenameWrite = formatFilenameWrite.format(callableTarget=callableTarget)
-	else:
-		if not filenameWrite.endswith('.py'):
-			warnings.warn(f"Filename {filenameWrite=} does not end with '.py'.")
-
-	pathFilename: Path = pathWrite / filenameWrite
-
-	pathFilename.write_text(pythonSource)
-
-	howIsThisStillAThing: Path = thePathPackage.parent
-	dumbassPythonNamespace: tuple[str, ...] = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
-	ImaModule: str = '.'.join(dumbassPythonNamespace)
-
-	for item in listCallableSynthesized:
-		callableTarget: str = item.callableTarget
-		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
-		stuff = YouOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
-		listStuffYouOughtaKnow.append(stuff)
-	listStuffYouOughtaKnow.extend(listStuff)
-
-	if callableDispatcher:
-		pass
-
-	return listStuffYouOughtaKnow

mapFolding/someAssemblyRequired/whatWillBe.py

@@ -1,357 +0,0 @@
-"""
-- Settings for synthesizing the modules used by the package (i.e., the flow for numba)
-- Settings for synthesizing modules that could be used by the package (e.g., the flow for JAX)
-- Therefore, an abstracted system for creating settings for the package
-- And with only a little more effort, an abstracted system for creating settings to synthesize arbitrary subsets of modules for arbitrary packages
-"""
-from mapFolding.someAssemblyRequired.transformationTools import (
-	ast_Identifier,
-	executeActionUnlessDescendantMatches,
-	extractClassDef,
-	extractFunctionDef,
-	ifThis,
-	Make,
-	NodeCollector,
-	NodeReplacer,
-	strDotStrCuzPyStoopid,
-	Then,
-)
-from mapFolding.filesystem import writeStringToHere
-from mapFolding.theSSOT import (
-	FREAKOUT,
-	getDatatypePackage,
-	getSourceAlgorithm,
-	theDataclassIdentifier,
-	theDataclassInstance,
-	theDispatcherCallable,
-	theFileExtension,
-	theFormatStrModuleForCallableSynthetic,
-	theFormatStrModuleSynthetic,
-	theLogicalPathModuleDataclass,
-	theLogicalPathModuleDispatcherSynthetic,
-	theModuleDispatcherSynthetic,
-	theModuleOfSyntheticModules,
-	thePackageName,
-	thePathPackage,
-	theSourceInitializeCallable,
-	theSourceParallelCallable,
-	theSourceSequentialCallable,
-)
-from autoflake import fix_code as autoflake_fix_code
-from collections import defaultdict
-from collections.abc import Sequence
-from inspect import getsource as inspect_getsource
-from mapFolding.someAssemblyRequired.ingredientsNumba import parametersNumbaDEFAULT, parametersNumbaSuperJit, parametersNumbaSuperJitParallel, ParametersNumba
-from pathlib import Path, PurePosixPath
-from types import ModuleType
-from typing import NamedTuple
-from Z0Z_tools import updateExtendPolishDictionaryLists
-import ast
-import dataclasses
-
-@dataclasses.dataclass
-class RecipeSynthesizeFlow:
-	"""Settings for synthesizing flow."""
-	# TODO consider `IngredientsFlow` or similar
-	# ========================================
-	# Source
-	sourceAlgorithm: ModuleType = getSourceAlgorithm()
-	sourcePython: str = inspect_getsource(sourceAlgorithm)
-	source_astModule: ast.Module = ast.parse(sourcePython)
-	# https://github.com/hunterhogan/mapFolding/issues/4
-	sourceDispatcherCallable: str = theDispatcherCallable
-	sourceSequentialCallable: str = theSourceSequentialCallable
-	sourceDataclassIdentifier: str = theDataclassIdentifier
-	# I still hate the OOP paradigm. But I like this dataclass stuff.
-
-	# ========================================
-	# Filesystem
-	pathPackage: PurePosixPath = PurePosixPath(thePathPackage)
-	fileExtension: str = theFileExtension
-
-	# ========================================
-	# Logical identifiers
-	# meta
-	formatStrModuleSynthetic: str = theFormatStrModuleSynthetic
-	formatStrModuleForCallableSynthetic: str = theFormatStrModuleForCallableSynthetic
-
-	# Package
-	packageName: ast_Identifier = thePackageName
-
-	# Module
-	# https://github.com/hunterhogan/mapFolding/issues/4
-	Z0Z_flowLogicalPathRoot: str = theModuleOfSyntheticModules
-	moduleDispatcher: str = theModuleDispatcherSynthetic
-	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
-	# https://github.com/hunterhogan/mapFolding/issues/4
-	# `theLogicalPathModuleDispatcherSynthetic` is a problem. It is defined in theSSOT, but it can also be calculated.
-	logicalPathModuleDispatcher: str = theLogicalPathModuleDispatcherSynthetic
-	dataConverterModule: str = 'dataNamespaceFlattened'
-
-	# Function
-	sequentialCallable: str = sourceSequentialCallable
-	dataclassIdentifier: str = sourceDataclassIdentifier
-	dataConverterCallable: str = 'unpackDataclassPackUp'
-	dispatcherCallable: str = sourceDispatcherCallable
-
-	# Variable
-	dataclassInstance: str = theDataclassInstance
-
-class LedgerOfImports:
-	def __init__(self, startWith: ast.AST | None = None) -> None:
-		self.dictionaryImportFrom: dict[str, list[tuple[str, str | None]]] = defaultdict(list)
-		self.listImport: list[str] = []
-
-		if startWith:
-			self.walkThis(startWith)
-
-	def addAst(self, astImport_: ast.Import | ast.ImportFrom) -> None:
-		if not isinstance(astImport_, (ast.Import, ast.ImportFrom)): # pyright: ignore[reportUnnecessaryIsInstance]
-			raise ValueError(f"Expected ast.Import or ast.ImportFrom, got {type(astImport_)}")
-		if isinstance(astImport_, ast.Import):
-			for alias in astImport_.names:
-				self.listImport.append(alias.name)
-		else:
-			if astImport_.module is not None:
-				for alias in astImport_.names:
-					self.dictionaryImportFrom[astImport_.module].append((alias.name, alias.asname))
-
-	def addImportStr(self, module: str) -> None:
-		self.listImport.append(module)
-
-	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
-		self.dictionaryImportFrom[module].append((name, asname))
-
-	def exportListModuleNames(self) -> list[str]:
-		listModuleNames: list[str] = list(self.dictionaryImportFrom.keys())
-		listModuleNames.extend(self.listImport)
-		return sorted(set(listModuleNames))
-
-	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
-		listAstImportFrom: list[ast.ImportFrom] = []
-
-		for module, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
-			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
-			listAlias: list[ast.alias] = []
-			for name, asname in listOfNameTuples:
-				listAlias.append(Make.astAlias(name, asname))
-			listAstImportFrom.append(Make.astImportFrom(module, listAlias))
-
-		listAstImport: list[ast.Import] = [Make.astImport(name) for name in sorted(set(self.listImport))]
-		return listAstImportFrom + listAstImport
-
-	def update(self, *fromLedger: 'LedgerOfImports') -> None:
-		"""
-		Update this ledger with imports from one or more other ledgers.
-
-		Parameters:
-			*fromTracker: One or more other `LedgerOfImports` objects from which to merge.
-		"""
-		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
-
-		for ledger in fromLedger:
-			self.listImport.extend(ledger.listImport)
-
-	def walkThis(self, walkThis: ast.AST) -> None:
-		for smurf in ast.walk(walkThis):
-			if isinstance(smurf, (ast.Import, ast.ImportFrom)):
-				self.addAst(smurf)
-
-@dataclasses.dataclass
-class Z0Z_IngredientsDataStructure:
-	"""Everything necessary to create a data structure should be here."""
-	dataclassDef: ast.ClassDef
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-
-@dataclasses.dataclass
-class IngredientsFunction:
-	"""Everything necessary to integrate a function into a module should be here."""
-	FunctionDef: ast.FunctionDef # hint `Make.astFunctionDef`
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-
-@dataclasses.dataclass
-class IngredientsModule:
-	"""Everything necessary to create one _logical_ `ast.Module` should be here.
-	Extrinsic qualities should be handled externally, such as with `RecipeModule`."""
-	# If an `ast.Module` had a logical name that would be reasonable, but Python is firmly opposed
-	# to a reasonable namespace, therefore, Hunter, you were silly to add a `name` field to this
-	# dataclass for building an `ast.Module`.
-	# name: ast_Identifier
-	# Hey, genius, note that this is dataclasses.InitVar
-	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
-
-	# `body` attribute of `ast.Module`
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	prologue: list[ast.stmt] = dataclasses.field(default_factory=list)
-	functions: list[ast.FunctionDef | ast.stmt] = dataclasses.field(default_factory=list)
-	epilogue: list[ast.stmt] = dataclasses.field(default_factory=list)
-	launcher: list[ast.stmt] = dataclasses.field(default_factory=list)
-
-	# parameter for `ast.Module` constructor
-	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
-
-	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
-		if ingredientsFunction is not None:
-			if isinstance(ingredientsFunction, IngredientsFunction):
-				self.addIngredientsFunction(ingredientsFunction)
-			else:
-				self.addIngredientsFunction(*ingredientsFunction)
-
-	def addIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
-		"""Add one or more `IngredientsFunction`. """
-		listLedgers: list[LedgerOfImports] = []
-		for definition in ingredientsFunction:
-			self.functions.append(definition.FunctionDef)
-			listLedgers.append(definition.imports)
-		self.imports.update(*listLedgers)
-
-	def _makeModuleBody(self) -> list[ast.stmt]:
-		body: list[ast.stmt] = []
-		body.extend(self.imports.makeListAst())
-		body.extend(self.prologue)
-		body.extend(self.functions)
-		body.extend(self.epilogue)
-		body.extend(self.launcher)
-		# TODO `launcher`, if it exists, must start with `if __name__ == '__main__':` and be indented
-		return body
-
-	def export(self) -> ast.Module:
-		"""Create a new `ast.Module` from the ingredients."""
-		return Make.astModule(self._makeModuleBody(), self.type_ignores)
-
-@dataclasses.dataclass
-class RecipeCountingFunction:
-	"""Settings for synthesizing counting functions."""
-	ingredients: IngredientsFunction
-
-@dataclasses.dataclass
-class RecipeDispatchFunction:
-	# A "dispatcher" must receive a dataclass instance and return a dataclass instance.
-	# computationStateComplete: ComputationState = dispatcher(computationStateInitialized)
-	# The most critical values in the returned dataclass are foldGroups[0:-1] and leavesTotal
-	# self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
-	# the function name is required by IngredientsFunction
-	ingredients: IngredientsFunction
-	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
-	dataclassIdentifier: str = theDataclassIdentifier
-	dataclassInstance: str = theDataclassInstance
-	Z0Z_unpackDataclass: bool = True
-	countDispatcher: bool = True
-	# is this the countDispatcher or what is the information for calling the countDispatcher: import or no? callable identifier? parameters? return type?
-	# countDispatcher lives in `theLogicalPathModuleDispatcherSynthetic`
-	# countDispatcher is named `theDispatcherCallable`
-	# post init
-	# addImportFromStr(self, module: str, name: str, asname: str | None = None)
-
-@dataclasses.dataclass
-class RecipeModule:
-	"""How to get one or more logical `ast.Module` on disk as one physical module."""
-	# Physical namespace
-	filenameStem: str
-	fileExtension: str = theFileExtension
-	pathPackage: PurePosixPath = PurePosixPath(thePathPackage)
-
-	# Physical and logical namespace
-	packageName: ast_Identifier | None= thePackageName
-	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = None # module names other than the module itself and the package name
-
-	def _getLogicalPathParent(self) -> str | None:
-		listModules: list[ast_Identifier] = []
-		if self.packageName:
-			listModules.append(self.packageName)
-		if self.logicalPathINFIX:
-			listModules.append(self.logicalPathINFIX)
-		if listModules:
-			return '.'.join(listModules)
-
-	def _getLogicalPathAbsolute(self) -> str:
-		listModules: list[ast_Identifier] = []
-		logicalPathParent: str | None = self._getLogicalPathParent()
-		if logicalPathParent:
-			listModules.append(logicalPathParent)
-		listModules.append(self.filenameStem)
-		return '.'.join(listModules)
-
-	@property
-	def pathFilename(self):
-		""" `PurePosixPath` ensures os-independent formatting of the `dataclass.field` value,
-		but you must convert to `Path` to perform filesystem operations."""
-		pathRoot: PurePosixPath = self.pathPackage
-		filename: str = self.filenameStem + self.fileExtension
-		if self.logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = self.logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		return pathRoot.joinpath(filename)
-
-	ingredients: IngredientsModule = IngredientsModule()
-
-	@property
-	def absoluteImport(self) -> ast.Import:
-		return Make.astImport(self._getLogicalPathAbsolute())
-
-	@property
-	def absoluteImportFrom(self) -> ast.ImportFrom:
-		""" `from . import theModule` """
-		logicalPathParent: str = self._getLogicalPathParent() or '.'
-		return Make.astImportFrom(logicalPathParent, [Make.astAlias(self.filenameStem)])
-
-	def writeModule(self) -> None:
-		astModule = self.ingredients.export()
-		ast.fix_missing_locations(astModule)
-		pythonSource: str = ast.unparse(astModule)
-		if not pythonSource: raise FREAKOUT
-		autoflake_additional_imports: list[str] = self.ingredients.imports.exportListModuleNames()
-		if self.packageName:
-			autoflake_additional_imports.append(self.packageName)
-		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
-		writeStringToHere(pythonSource, self.pathFilename)
-
-numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-
-# https://github.com/hunterhogan/mapFolding/issues/3
-sourceSequentialFunctionDef = extractFunctionDef(numbaFlow.sourceSequentialCallable, numbaFlow.source_astModule)
-if sourceSequentialFunctionDef is None: raise FREAKOUT
-
-numbaCountSequential = RecipeCountingFunction(IngredientsFunction(
-	FunctionDef=sourceSequentialFunctionDef,
-	imports=LedgerOfImports(numbaFlow.source_astModule)
-))
-
-numbaDispatcher = RecipeModule(filenameStem=numbaFlow.moduleDispatcher, fileExtension=numbaFlow.fileExtension, pathPackage=numbaFlow.pathPackage,
-								packageName=numbaFlow.packageName, logicalPathINFIX=numbaFlow.Z0Z_flowLogicalPathRoot)
-
-class ParametersSynthesizeNumbaCallable(NamedTuple):
-	callableTarget: str
-	parametersNumba: ParametersNumba | None = None
-	inlineCallables: bool = False
-
-listNumbaCallableDispatchees: list[ParametersSynthesizeNumbaCallable] = [
-	ParametersSynthesizeNumbaCallable('countParallel', parametersNumbaSuperJitParallel, True),
-	ParametersSynthesizeNumbaCallable('countSequential', parametersNumbaSuperJit, True),
-	ParametersSynthesizeNumbaCallable('countInitialize', parametersNumbaDEFAULT, True),
-]
-
-_datatypeModuleScalar = ''
-_decoratorCallable = ''
-
-# if numba
-_datatypeModuleScalar = 'numba'
-_decoratorCallable = 'jit'
-Z0Z_autoflake_additional_imports: list[str] = []
-Z0Z_autoflake_additional_imports.append('numba')
-
-def Z0Z_getDatatypeModuleScalar() -> str:
-	return _datatypeModuleScalar
-
-def Z0Z_setDatatypeModuleScalar(moduleName: str) -> str:
-	global _datatypeModuleScalar
-	_datatypeModuleScalar = moduleName
-	return _datatypeModuleScalar
-
-def Z0Z_getDecoratorCallable() -> str:
-	return _decoratorCallable
-
-def Z0Z_setDecoratorCallable(decoratorName: str) -> str:
-	global _decoratorCallable
-	_decoratorCallable = decoratorName
-	return _decoratorCallable

mapFolding/syntheticModules/dataNamespaceFlattened.py

@@ -1,30 +0,0 @@
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
-from mapFolding.syntheticModules.numbaCount_doTheNeedful import doTheNeedful
-from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
-
-def flattenData(state: ComputationState) -> ComputationState:
-    state = makeStateJob(state.mapShape, writeJob=False)
-    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-    taskDivisions: DatatypeLeavesTotal = state.taskDivisions
-    connectionGraph: Array3D = state.connectionGraph
-    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
-    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
-    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
-    gapRangeStart: Array1DElephino = state.gapRangeStart
-    gapsWhere: Array1DLeavesTotal = state.gapsWhere
-    leafAbove: Array1DLeavesTotal = state.leafAbove
-    leafBelow: Array1DLeavesTotal = state.leafBelow
-    foldGroups: Array1DFoldsTotal = state.foldGroups
-    foldsTotal: DatatypeFoldsTotal = state.foldsTotal
-    gap1ndex: DatatypeLeavesTotal = state.gap1ndex
-    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
-    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
-    indexDimension: DatatypeLeavesTotal = state.indexDimension
-    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
-    indexMiniGap: DatatypeElephino = state.indexMiniGap
-    leaf1ndex: DatatypeElephino = state.leaf1ndex
-    leafConnectee: DatatypeElephino = state.leafConnectee
-    taskIndex: DatatypeLeavesTotal = state.taskIndex
-    mapShape, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = doTheNeedful(mapShape, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
-    return ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, countDimensionsGapped=countDimensionsGapped, dimensionsUnconstrained=dimensionsUnconstrained, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, foldGroups=foldGroups, foldsTotal=foldsTotal, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, groupsOfFolds=groupsOfFolds, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, taskIndex=taskIndex)