mapFolding 0.9.4__py3-none-any.whl → 0.10.0__py3-none-any.whl

mapfolding-0.10.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+mapFolding/__init__.py,sha256=vIUZ4w4Hr12xPhSXIrnoG7-jg59VeEl5KbaOfmMRjTA,5403
+mapFolding/basecamp.py,sha256=hs7hlTmbX7KTjI_eIRVU4xn7HR4l448SIpHk1cKDwRk,8071
+mapFolding/beDRY.py,sha256=JQ7T9v4aKzweGjvpzyghyq4N9l3Wf9HZco_K_DWoiW0,15368
+mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/dataBaskets.py,sha256=80ALoRqaOfNEgz8QTdDJPsyVBnm8MkWLtRHD3DPPoRw,5073
+mapFolding/datatypes.py,sha256=-TdXqAlEWEwUP_VUb9-X5pvaBBedbZOQbBuu5j1ZoTA,962
+mapFolding/oeis.py,sha256=zHk5Mygd7qpDj1NYXsvY_l3e8jg3tHDQ1Cpt6NrWiuc,17019
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=kc3rzTX3yts0PxgPCXFbgWvaqsBexsiU5ib2pzpvID0,10019
+mapFolding/theSSOT.py,sha256=rbv8esQeBG6uLWpFZu_ncMA4zIuQG3lj4FZNzC_6JGI,16138
+mapFolding/toolboxFilesystem.py,sha256=kVZoU-NBvfYSvI4R8mEpMXRUZee-1JV0fjtMFWPhk8Y,9818
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=6RD4F4Yde7K-Rz0F4IokQ62BVzRSx4vCCYY4H-Dfug4,10190
+mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py,sha256=ni7twaO2Pkrhg-BXuxysF-reNLb79_jcpQp6AcHJ98E,15770
+mapFolding/someAssemblyRequired/__init__.py,sha256=4PIwIa8iAX3h3O2_bdWjsfiFtHwnXCY85x6EdJrmh0g,3882
+mapFolding/someAssemblyRequired/_astTypes.py,sha256=EwLxEtbZwUtaRlt4tWwiTvaoeGR4_V3hdX8Xi3Z8w1E,7809
+mapFolding/someAssemblyRequired/_theTypes.py,sha256=8Ako7EVwciwdNoXLTpAQaOgMTgQv2HysXzPPYMwBv68,3107
+mapFolding/someAssemblyRequired/_toolBe.py,sha256=bT64xwj_lGJZZB6FyY46alFZENZ2LlJdb2kO47L643Q,16400
+mapFolding/someAssemblyRequired/_toolDOT.py,sha256=JpEpW0mZRFFYzlIhQQtD15rKSzEESXfzX6i0aH95YK0,12727
+mapFolding/someAssemblyRequired/_toolGrab.py,sha256=oMrTMVky5BIEo9GEXA3AVlElGtPd10gIR6jIEWWsFV8,25327
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=DsvXHvi27YGC8TZMm6WlV6YsK0ruVPVPQRip0wrpvlk,10223
+mapFolding/someAssemblyRequired/_toolMake.py,sha256=X54TBZysYEcVOmtBSTZoW80kmJJS-yYFwRvN_19uU_8,18282
+mapFolding/someAssemblyRequired/_toolThen.py,sha256=RFp1h8FQroBIR3F-TtXJo3j7wS_XKFAvLWly93PkZiE,2584
+mapFolding/someAssemblyRequired/_toolboxAST.py,sha256=-hlKH0gYCY4Srx1azL8SK2RLbYYRw0a0i3qaYcnx8L0,2376
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=5Y9-X-SyCkrxpn164PICvcimPE89Tgcnksm7N5wqOnU,30117
+mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=1K7IzqzmHNTaPA6qTo73GZYHCIQRYI2Rn8aYJ3VelqY,7873
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=5j3fLdiVHv7OlH-RR-fjeevRXnLrmUJpeXleHytDoF4,13830
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=9D0VLOAttfyTcf8GFko_QhRS5steSQo6FvWHD5xQLGc,15597
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=QIpYCf1IFfgrQ5GVA0ON0ymn324iBfkyHVSfBW5CqOY,8961
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=Kd_eVIgBHMdsZwOIe9hxST0x1JfqgCR26OyNBYjDSY0,29307
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/daoOfMapFolding.py,sha256=cfWPABtXyCxJ0BwPI7rhfLh_2UYV_XKAL8lJ4GLNXaQ,5896
+mapFolding/syntheticModules/dataPacking.py,sha256=J4WLJzQTOAm2d8itzWWSixTUcCGQl4KuEfqrzkb2tJQ,2294
+mapFolding/syntheticModules/initializeCount.py,sha256=nWSlJMMfIM3DvZxMn6ISQusUJqRYAjKQyLF5hwLEdBQ,3119
+mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUkYEEiHG--P1tQ,15525
+mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
+mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
+mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
+mapFolding/toolFactory/astFactory.py,sha256=3FJUx_O7L7rM9gyeUvYGB1rRm0gmqiTos4_CjboQ4KI,28777
+mapFolding/toolFactory/astFactory_annex.py,sha256=pTULZ8bJ4ioojK2VQ2636rvlHflT0GbSeHYjm2kooqE,5948
+mapFolding/toolFactory/astFactory_docstrings.py,sha256=aX2JR5cXMe2znIrvWxLeK74jQebMWwGX4U0sk-iexWQ,3406
+mapfolding-0.10.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
+tests/conftest.py,sha256=x8zMZQyTss3sn0GwHm_TSRwD9_LVlR8l_qF8r43Vxl4,14178
+tests/test_computations.py,sha256=5sg1PpSp6aeOrXZeO5NwWK5ipPAe49wVKC2J7yT5MFg,6524
+tests/test_filesystem.py,sha256=T2DkjBoI3lW6tCxd5BilPmUFrVukNKLjOOZVZxLM560,3004
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=UMlK4JPInalpOZuPvTnUrgXWCJOxAw-OsPs6CxMR254,3753
+tests/test_tasks.py,sha256=tOQc4uomKXGwWnENfbcThaVa1XofwXNCkGZbg4yS6VI,2833
+mapfolding-0.10.0.dist-info/METADATA,sha256=jcIwCSmk1EYzJDUvvQ3BE5-VYswynF9onfnMS7Humlg,7534
+mapfolding-0.10.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+mapfolding-0.10.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.10.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.10.0.dist-info/RECORD,,

{mapfolding-0.9.4.dist-info → mapfolding-0.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/test_computations.py

@@ -102,7 +102,7 @@ if __name__ == '__main__':
 def test_algorithmSourceParallel(mapShapeTestParallelization: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), countFolds, mapShapeTestParallelization, None, 'maximum', None)
 
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'theorem2', 'theorem2numba'])
+@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'theorem2', 'theorem2Trimmed', 'theorem2numba'])
 def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: Literal['daoOfMapFolding'] | Literal['theorem2'] | Literal['theorem2numba']) -> None:
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
 

mapFolding/Z0Z_flowControl.py

@@ -1,117 +0,0 @@
-from collections.abc import Sequence
-from mapFolding import (
-	ComputationState,
-	getPathFilenameFoldsTotal,
-	outfitCountFolds,
-	saveFoldsTotal,
-	saveFoldsTotalFAILearly,
-	setProcessorLimit,
-	The,
-	validateListDimensions,
-)
-from os import PathLike
-from pathlib import PurePath
-
-def countFolds(listDimensions: Sequence[int] | None = None
-				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
-				, computationDivisions: int | str | None = None
-				, CPUlimit: int | float | bool | None = None
-				# , * I need to improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
-				, mapShape: tuple[int, ...] | None = None
-				, oeisID: str | None = None
-				, oeis_n: int | None = None
-				, flow: str | None = None
-				) -> int:
-
-	# mapShape =====================================================================
-
-	if mapShape:
-		pass
-	else:
-		if oeisID and oeis_n:
-			from mapFolding.oeis import settingsOEIS
-			try:
-				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
-			except KeyError:
-				pass
-		if not mapShape and listDimensions:
-			mapShape = validateListDimensions(listDimensions)
-
-	if mapShape is None:
-		raise ValueError(f"""I received these values:
-	`{listDimensions = }`,
-	`{mapShape = }`,
-	`{oeisID = }` and `{oeis_n = }`,
-	but I was unable to select a map for which to count the folds.""")
-
-	# task division instructions ===============================================
-
-	if computationDivisions:
-		# NOTE `The.concurrencyPackage`
-		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
-		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
-		leavesTotal: int = getLeavesTotal(mapShape)
-		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
-		del leavesTotal
-	else:
-		concurrencyLimit = 1
-		taskDivisions = 0
-
-	# memorialization instructions ===========================================
-
-	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
-		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
-	else:
-		pathFilenameFoldsTotal = None
-
-	# Flow control until I can figure out a good way ===============================
-
-	if flow == 'daoOfMapFolding':
-		from mapFolding.dataBaskets import MapFoldingState
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.daoOfMapFolding import doTheNeedful
-		mapFoldingState = doTheNeedful(mapFoldingState)
-		foldsTotal = mapFoldingState.foldsTotal
-
-	elif flow == 'theorem2' and any((dimension > 2 for dimension in mapShape)):
-		from mapFolding.dataBaskets import MapFoldingState
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
-
-		from mapFolding.syntheticModules.theorem2 import count
-		mapFoldingState = count(mapFoldingState)
-
-		foldsTotal = mapFoldingState.foldsTotal
-
-	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any((dimension > 2 for dimension in mapShape)):
-		from mapFolding.dataBaskets import MapFoldingState
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
-		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
-
-		from mapFolding.syntheticModules.dataPacking import doTheNeedful
-		mapFoldingState = doTheNeedful(mapFoldingState)
-
-		foldsTotal = mapFoldingState.foldsTotal
-
-	# NOTE treat this as a default?
-	# flow based on `The` and `ComputationState` ====================================
-
-	else:
-		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
-		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
-
-		computationStateComplete.getFoldsTotal()
-		foldsTotal = computationStateComplete.foldsTotal
-
-	# Follow memorialization instructions ===========================================
-
-	if pathFilenameFoldsTotal is not None:
-		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
-
-	return foldsTotal

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -1,134 +0,0 @@
-"""
-AST Node Construction Utilities for Python Code Generation
-
-This module provides the Make class with static methods for creating AST nodes
-with sane defaults. It abstracts away the complexity of constructing AST nodes
-directly, making programmatic code generation more intuitive and less error-prone.
-
-The Make class serves as a factory for creating various types of AST nodes needed
-in code generation, transformation, and analysis workflows. Each method follows
-a consistent pattern that maps cleanly to Python's syntax while handling the
-details of AST node construction.
-"""
-
-from collections.abc import Sequence
-from mapFolding.someAssemblyRequired import (
-	ast_expr_Slice,
-	ast_Identifier,
-	intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone,
-	list_ast_type_paramORstr_orNone,
-	str_nameDOTname,
-)
-from typing import Any
-import ast
-
-class Make:
-	"""Almost all parameters described here are only accessible through a method's `**keywordArguments` parameter.
-
-	Parameters:
-		context (ast.Load()): Are you loading from, storing to, or deleting the identifier? The `context` (also, `ctx`) value is `ast.Load()`, `ast.Store()`, or `ast.Del()`.
-		col_offset (0): int Position information specifying the column where an AST node begins.
-		end_col_offset (None): int|None Position information specifying the column where an AST node ends.
-		end_lineno (None): int|None Position information specifying the line number where an AST node ends.
-		level (0): int Module import depth level that controls relative vs absolute imports. Default 0 indicates absolute import.
-		lineno: int Position information manually specifying the line number where an AST node begins.
-		kind (None): str|None Used for type annotations in limited cases.
-		type_comment (None): str|None "type_comment is an optional string with the type annotation as a comment." or `# type: ignore`.
-		type_params: list[ast.type_param] Type parameters for generic type definitions.
-
-	The `ast._Attributes`, lineno, col_offset, end_lineno, and end_col_offset, hold position information; however, they are, importantly, _not_ `ast._fields`.
-	"""
-	@staticmethod
-	def alias(name: ast_Identifier, asname: ast_Identifier | None = None) -> ast.alias:
-		return ast.alias(name, asname)
-
-	@staticmethod
-	def AnnAssign(target: ast.Attribute | ast.Name | ast.Subscript, annotation: ast.expr, value: ast.expr | None = None, **keywordArguments: int) -> ast.AnnAssign: # `simple: int`: uses a clever int-from-boolean to assign the correct value to the `simple` attribute. So, don't make it a method parameter.
-		return ast.AnnAssign(target, annotation, value, simple=int(isinstance(target, ast.Name)), **keywordArguments)
-
-	@staticmethod
-	def arg(identifier: ast_Identifier, annotation: ast.expr | None = None, **keywordArguments: intORstr_orNone) -> ast.arg:
-		return ast.arg(identifier, annotation, **keywordArguments)
-
-	@staticmethod
-	def argumentsSpecification(posonlyargs:list[ast.arg]=[], args:list[ast.arg]=[], vararg:ast.arg|None=None, kwonlyargs:list[ast.arg]=[], kw_defaults:list[ast.expr|None]=[None], kwarg:ast.arg|None=None, defaults:list[ast.expr]=[]) -> ast.arguments:
-		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
-
-	@staticmethod
-	def Assign(listTargets: list[ast.expr], value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
-		return ast.Assign(listTargets, value, **keywordArguments)
-
-	@staticmethod
-	def Attribute(value: ast.expr, *attribute: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Attribute:
-		""" If two `ast_Identifier` are joined by a dot `.`, they are _usually_ an `ast.Attribute`, but see `ast.ImportFrom`.
-		Parameters:
-			value: the part before the dot (e.g., `ast.Name`.)
-			attribute: an `ast_Identifier` after a dot `.`; you can pass multiple `attribute` and they will be chained together.
-		"""
-		def addDOTattribute(chain: ast.expr, identifier: ast_Identifier, context: ast.expr_context, **keywordArguments: int) -> ast.Attribute:
-			return ast.Attribute(value=chain, attr=identifier, ctx=context, **keywordArguments)
-		buffaloBuffalo = addDOTattribute(value, attribute[0], context, **keywordArguments)
-		for identifier in attribute[1:None]:
-			buffaloBuffalo = addDOTattribute(buffaloBuffalo, identifier, context, **keywordArguments)
-		return buffaloBuffalo
-
-	@staticmethod
-	def AugAssign(target: ast.Attribute | ast.Name | ast.Subscript, operator: ast.operator, value: ast.expr, **keywordArguments: int) -> ast.AugAssign:
-		return ast.AugAssign(target, operator, value, **keywordArguments)
-
-	@staticmethod
-	def Call(callee: ast.expr, listArguments: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None) -> ast.Call:
-		return ast.Call(func=callee, args=list(listArguments) if listArguments else [], keywords=list(list_astKeywords) if list_astKeywords else [])
-
-	@staticmethod
-	def ClassDef(name: ast_Identifier, listBases: list[ast.expr]=[], list_keyword: list[ast.keyword]=[], body: list[ast.stmt]=[], decorator_list: list[ast.expr]=[], **keywordArguments: list_ast_type_paramORstr_orNone) -> ast.ClassDef:
-		return ast.ClassDef(name, listBases, list_keyword, body, decorator_list, **keywordArguments)
-
-	@staticmethod
-	def Constant(value: Any, **keywordArguments: intORstr_orNone) -> ast.Constant:
-		return ast.Constant(value, **keywordArguments)
-
-	@staticmethod
-	def Expr(value: ast.expr, **keywordArguments: int) -> ast.Expr:
-		return ast.Expr(value, **keywordArguments)
-
-	@staticmethod
-	def FunctionDef(name: ast_Identifier, argumentsSpecification:ast.arguments=ast.arguments(), body:list[ast.stmt]=[], decorator_list:list[ast.expr]=[], returns:ast.expr|None=None, **keywordArguments: intORlist_ast_type_paramORstr_orNone) -> ast.FunctionDef:
-		return ast.FunctionDef(name, argumentsSpecification, body, decorator_list, returns, **keywordArguments)
-
-	@staticmethod
-	def Import(moduleWithLogicalPath: str_nameDOTname, asname: ast_Identifier | None = None, **keywordArguments: int) -> ast.Import:
-		return ast.Import(names=[Make.alias(moduleWithLogicalPath, asname)], **keywordArguments)
-
-	@staticmethod
-	def ImportFrom(moduleWithLogicalPath: str_nameDOTname, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
-		return ast.ImportFrom(moduleWithLogicalPath, list_astAlias, **keywordArguments)
-
-	@staticmethod
-	def keyword(keywordArgument: ast_Identifier, value: ast.expr, **keywordArguments: int) -> ast.keyword:
-		return ast.keyword(arg=keywordArgument, value=value, **keywordArguments)
-
-	@staticmethod
-	def Module(body: list[ast.stmt] = [], type_ignores: list[ast.TypeIgnore] = []) -> ast.Module:
-		return ast.Module(body, type_ignores)
-
-	@staticmethod
-	def Name(identifier: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Name:
-		return ast.Name(identifier, context, **keywordArguments)
-
-	@staticmethod
-	def Return(value: ast.expr | None = None, **keywordArguments: int) -> ast.Return:
-		return ast.Return(value, **keywordArguments)
-
-	@staticmethod
-	def Subscript(value: ast.expr, slice: ast_expr_Slice, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Subscript:
-		return ast.Subscript(value, slice, context, **keywordArguments)
-
-	@staticmethod
-	def Tuple(elements: Sequence[ast.expr] = [], context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Tuple:
-		return ast.Tuple(list(elements), context, **keywordArguments)
-
-	@staticmethod
-	def While(test: ast.expr, doThis: list[ast.stmt], orElse: list[ast.stmt] = [], **keywordArguments: int) -> ast.While:
-		return ast.While(test, doThis, orElse, **keywordArguments)

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -1,157 +0,0 @@
-"""
-AST Node Transformation Actions for Python Code Manipulation
-
-This module provides the Then class with static methods for generating callable
-action functions that specify what to do with AST nodes that match predicates.
-These action functions are used primarily with NodeChanger and NodeTourist to
-transform or extract information from AST nodes.
-
-The module also contains the grab class that provides functions for modifying
-specific attributes of AST nodes while preserving their structure, enabling
-fine-grained control when transforming AST structures.
-
-Together, these classes provide a complete system for manipulating AST nodes
-once they have been identified using predicate functions from ifThis.
-"""
-
-from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, ImaCallToName, NodeORattribute
-from typing import Any, overload
-import ast
-
-class grab:
-	"""
-	Modify specific attributes of AST nodes while preserving the node structure.
-
-	The grab class provides static methods that create transformation functions to modify
-	specific attributes of AST nodes. Unlike DOT which provides read-only access,
-	grab allows for targeted modifications of node attributes without replacing the
-	entire node.
-
-	Each method returns a function that takes a node, applies a transformation to a
-	specific attribute of that node, and returns the modified node. This enables fine-grained
-	control when transforming AST structures.
-	"""
-	@staticmethod
-	def andDoAllOf(listOfActions: list[Callable[[NodeORattribute], NodeORattribute]]) -> Callable[[NodeORattribute], NodeORattribute]:
-		def workhorse(node: NodeORattribute) -> NodeORattribute:
-			for action in listOfActions:
-				node = action(node)
-			return node
-		return workhorse
-
-	@staticmethod
-	def argAttribute(action: Callable[[ast_Identifier | None], ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.arg | ast.keyword]:
-		def workhorse(node: ast.arg | ast.keyword) -> ast.arg | ast.keyword:
-			node.arg = action(node.arg)
-			return node
-		return workhorse
-
-	@staticmethod
-	def attrAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Attribute], ast.Attribute]:
-		def workhorse(node: ast.Attribute) -> ast.Attribute:
-			node.attr = action(node.attr)
-			return node
-		return workhorse
-
-	@staticmethod
-	def comparatorsAttribute(action: Callable[[list[ast.expr]], list[ast.expr]]) -> Callable[[ast.Compare], ast.Compare]:
-		def workhorse(node: ast.Compare) -> ast.Compare:
-			node.comparators = action(node.comparators)
-			return node
-		return workhorse
-
-	@staticmethod
-	def funcAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Call], ast.Call]:
-		def workhorse(node: ast.Call) -> ast.Call:
-			node.func = action(node.func)
-			return node
-		return workhorse
-
-	@staticmethod
-	def funcDOTidAttribute(action: Callable[[ast_Identifier], Any]) -> Callable[[ImaCallToName], ImaCallToName]:
-		def workhorse(node: ImaCallToName) -> ImaCallToName:
-			node.func = grab.idAttribute(action)(node.func)
-			return node
-		return workhorse
-
-	@staticmethod
-	def idAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Name], ast.Name]:
-		def workhorse(node: ast.Name) -> ast.Name:
-			node.id = action(node.id)
-			return node
-		return workhorse
-
-	@staticmethod
-	def leftAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.BinOp | ast.Compare], ast.BinOp | ast.Compare]:
-		def workhorse(node: ast.BinOp | ast.Compare) -> ast.BinOp | ast.Compare:
-			node.left = action(node.left)
-			return node
-		return workhorse
-
-	@staticmethod
-	def opsAttribute(action: Callable[[list[ast.cmpop]], list[ast.cmpop]]) -> Callable[[ast.Compare], ast.Compare]:
-		def workhorse(node: ast.Compare) -> ast.Compare:
-			node.ops = action(node.ops)
-			return node
-		return workhorse
-
-	@staticmethod
-	def testAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Assert | ast.If | ast.IfExp | ast.While], ast.Assert | ast.If | ast.IfExp | ast.While]:
-		def workhorse(node: ast.Assert | ast.If | ast.IfExp | ast.While) -> ast.Assert | ast.If | ast.IfExp | ast.While:
-			node.test = action(node.test)
-			return node
-		return workhorse
-
-	@staticmethod
-	def valueAttribute(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
-		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
-			node.value = action(node.value)
-			return node
-		return workhorse
-
-class Then:
-	"""
-	Provide action functions that specify what to do with AST nodes that match predicates.
-
-	The Then class contains static methods that generate action functions used with
-	NodeChanger and NodeTourist to transform or extract information from AST nodes
-	that match specific predicates. These actions include node replacement, insertion,
-	extraction, and collection operations.
-
-	When paired with predicates from the ifThis class, Then methods complete the
-	pattern-matching-and-action workflow for AST manipulation.
-	"""
-	@staticmethod
-	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], ast.AST | ast_Identifier]:
-		def workhorse(node: ast.AST | ast_Identifier) -> ast.AST | ast_Identifier:
-			listOfAny.append(node)
-			return node
-		return workhorse
-
-	@staticmethod
-	def extractIt(node: NodeORattribute) -> NodeORattribute:
-		return node
-
-	@staticmethod
-	def insertThisAbove(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
-		return lambda aboveMe: [*list_astAST, aboveMe]
-
-	@staticmethod
-	def insertThisBelow(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
-		return lambda belowMe: [belowMe, *list_astAST]
-
-	@staticmethod
-	def removeIt(_removeMe: ast.AST) -> None:
-		return None
-
-	@staticmethod
-	def replaceWith(astAST: NodeORattribute) -> Callable[[NodeORattribute], NodeORattribute]:
-		return lambda _replaceMe: astAST
-
-	@staticmethod
-	def updateKeyValueIn(key: Callable[..., Any], value: Callable[..., Any], dictionary: dict[Any, Any]) -> Callable[[ast.AST], dict[Any, Any]]:
-		def workhorse(node: ast.AST) -> dict[Any, Any]:
-			dictionary.setdefault(key(node), value(node))
-			return dictionary
-		return workhorse