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

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,129 +18,40 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from autoflake import fix_code as autoflake_fix_code
-from collections.abc import Callable, Mapping
-from copy import deepcopy
+from collections.abc import Callable
 from mapFolding.beDRY import outfitCountFolds
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
 	Be,
 	DeReConstructField2ast,
-	DOT,
 	extractClassDef,
 	Grab,
 	IfThis,
 	importLogicalPath2Callable,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	RecipeSynthesizeFlow,
+	removeUnusedParameters,
 	ShatteredDataclass,
 	str_nameDOTname,
 	Then,
-	个,
+	unparseFindReplace,
 )
-from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
+from mapFolding.theSSOT import ComputationState, The
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
 import ast
 import dataclasses
 import pickle
-import python_minifier
-
-def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
-	"""
-	Create a dictionary mapping function names to their AST definitions.
-
-	This function creates a dictionary that maps function names to their AST function
-	definition nodes for all functions defined in the given module.
-
-	Parameters:
-		module: The AST module to extract function definitions from.
-
-	Returns:
-		A dictionary mapping function identifiers to their AST function definition nodes.
-	"""
-	dictionaryIdentifier2FunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
-	NodeTourist(Be.FunctionDef, Then.updateKeyValueIn(DOT.name, Then.extractIt, dictionaryIdentifier2FunctionDef)).visit(module)
-	return dictionaryIdentifier2FunctionDef
-
-def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) -> ast.FunctionDef:
-	"""
-	Inline function calls within a function definition to create a self-contained function.
-
-	This function takes a function identifier and a module, finds the function definition,
-	and then recursively inlines all function calls within that function with their
-	implementation bodies. This produces a fully inlined function that doesn't depend
-	on other function definitions from the module.
-
-	Parameters:
-		identifierToInline: The name of the function to inline.
-		module: The AST module containing the function and its dependencies.
-
-	Returns:
-		A modified function definition with all function calls inlined.
-
-	Raises:
-		ValueError: If the function to inline is not found in the module.
-	"""
-	dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = makeDictionaryFunctionDef(module)
-	try:
-		FunctionDefToInline = dictionaryFunctionDef[identifierToInline]
-	except KeyError as ERRORmessage:
-		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
-
-	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName, doThat = Grab.funcDOTidAttribute(Then.appendTo(listIdentifiersCalledFunctions)))
-	findIdentifiersToInline.visit(FunctionDefToInline)
-
-	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
-	for identifier in sorted(set(listIdentifiersCalledFunctions).intersection(dictionaryFunctionDef.keys())):
-		if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-			dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
-
-	keepGoing = True
-	while keepGoing:
-		keepGoing = False
-		listIdentifiersCalledFunctions.clear()
-		findIdentifiersToInline.visit(Make.Module(list(dictionary4Inlining.values())))
-
-		listIdentifiersCalledFunctions = sorted((set(listIdentifiersCalledFunctions).difference(dictionary4Inlining.keys())).intersection(dictionaryFunctionDef.keys()))
-		if len(listIdentifiersCalledFunctions) > 0:
-			keepGoing = True
-			for identifier in listIdentifiersCalledFunctions:
-				if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-					FunctionDefTarget = dictionaryFunctionDef[identifier]
-					if len(FunctionDefTarget.body) == 1:
-						replacement = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-
-						findThis = IfThis.isCall_Identifier(identifier)
-						doThat = Then.replaceWith(replacement)
-						inliner = NodeChanger(findThis, doThat)
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-					else:
-						inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-
-	for identifier, FunctionDefTarget in dictionary4Inlining.items():
-		if len(FunctionDefTarget.body) == 1:
-			replacement = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-			inliner = NodeChanger(IfThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
-			inliner.visit(FunctionDefToInline)
-		else:
-			inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-			inliner.visit(FunctionDefToInline)
-	ast.fix_missing_locations(FunctionDefToInline)
-	return FunctionDefToInline
 
 @overload
 def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
@@ -248,91 +159,7 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 
 	return shatteredDataclass
 
-def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:
-	"""
-	Convert an IngredientsModule to Python source code and write it to a file.
-
-	This function renders an IngredientsModule into executable Python code,
-	applies code quality improvements like import organization via autoflake,
-	and writes the result to the specified file path.
-
-	The function performs several key steps:
-	1. Converts the AST module structure to a valid Python AST
-	2. Fixes location attributes in the AST for proper formatting
-	3. Converts the AST to Python source code
-	4. Optimizes imports using autoflake
-	5. Writes the final source code to the specified file location
-
-	This is typically the final step in the code generation assembly line,
-	producing optimized Python modules ready for execution.
-
-	Parameters:
-		ingredients: The IngredientsModule containing the module definition.
-		pathFilename: The file path where the module should be written.
-		packageName: Optional package name to preserve in import optimization.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the generated source code is empty.
-	"""
-	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
-	autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleIdentifiers()
-	if packageName:
-		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	# pythonSource = python_minifier.minify(pythonSource, remove_annotations=False, hoist_literals=False)
-	writeStringToHere(pythonSource, pathFilename)
-
 # END of acceptable classes and functions ======================================================
-def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
-	"""
-	Removes unused parameters from a function's AST definition, return statement, and annotation.
-
-	This function analyzes the Abstract Syntax Tree (AST) of a given function and removes
-	any parameters that are not referenced within the function body. It updates the
-	function signature, the return statement (if it's a tuple containing unused variables),
-	and the return type annotation accordingly.
-
-	Parameters
-	----------
-	ingredientsFunction : IngredientsFunction
-		An object containing the AST representation of a function to be processed.
-
-	Returns
-	-------
-	IngredientsFunction
-		The modified IngredientsFunction object with unused parameters and corresponding
-		return elements/annotations removed from its AST.
-
-	The modification is done in-place on the original AST nodes within the IngredientsFunction object.
-	"""
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	fauxFunctionDef = deepcopy(ingredientsFunction.astFunctionDef)
-	NodeChanger(Be.Return, Then.removeIt).visit(fauxFunctionDef)
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(fauxFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-	for arg_Identifier in list_IdentifiersNotUsed:
-		remove_arg = NodeChanger(IfThis.is_arg_Identifier(arg_Identifier), Then.removeIt)
-		remove_arg.visit(ingredientsFunction.astFunctionDef)
-
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-
-	listName: list[ast.Name] = [Make.Name(ast_arg.arg) for ast_arg in list_argCuzMyBrainRefusesToThink]
-	replaceReturn = NodeChanger(Be.Return, Then.replaceWith(Make.Return(Make.Tuple(listName))))
-	replaceReturn.visit(ingredientsFunction.astFunctionDef)
-
-	list_annotation: list[ast.expr] = [ast_arg.annotation for ast_arg in list_argCuzMyBrainRefusesToThink if ast_arg.annotation is not None]
-	ingredientsFunction.astFunctionDef.returns = Make.Subscript(Make.Name('tuple'), Make.Tuple(list_annotation))
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-
-	return ingredientsFunction
-
 def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 	listAllIngredientsFunctions = [
@@ -374,7 +201,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	for ingredients in listAllIngredientsFunctions:
 		for source_Identifier, recipe_Identifier in listFindReplace:
 			updateName = NodeChanger(IfThis.isName_Identifier(source_Identifier) , Grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier))) # type: ignore
+			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier)))
 			updateName.visit(ingredients.astFunctionDef)
 			update_arg.visit(ingredients.astFunctionDef)
 
@@ -403,7 +230,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	if recipeFlow.removeDataclassParallel:
 		ingredientsParallel.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 
-		ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+		ingredientsParallel.astFunctionDef = unparseFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 
 		ingredientsParallel = removeUnusedParameters(ingredientsParallel)
 
@@ -447,7 +274,7 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
 	changeReturnCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
 	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
-	ingredientsTarget.astFunctionDef = Z0Z_lameFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+	ingredientsTarget.astFunctionDef = unparseFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 	return ingredientsTarget
 
 def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: ast_Identifier, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
@@ -467,37 +294,3 @@ dictionaryEstimates: dict[tuple[int, ...], int] = {
 	(3,3,3,3): 85109616000000000000000000000000,
 	(8,8): 791274195985524900,
 }
-
-# END of marginal classes and functions ======================================================
-def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 个:
-	"""
-	Recursively replace AST nodes based on a mapping of find-replace pairs.
-
-	This function applies brute-force node replacement throughout an AST tree
-	by comparing textual representations of nodes. While not the most efficient
-	approach, it provides a reliable way to replace complex nested structures
-	when more precise targeting methods are difficult to implement.
-
-	The function continues replacing nodes until no more changes are detected
-	in the AST's textual representation, ensuring complete replacement throughout
-	the tree structure.
-
-	Parameters:
-		astTree: The AST structure to modify.
-		mappingFindReplaceNodes: A mapping from source nodes to replacement nodes.
-
-	Returns:
-		The modified AST structure with all matching nodes replaced.
-	"""
-	keepGoing = True
-	newTree = deepcopy(astTree)
-
-	while keepGoing:
-		for nodeFind, nodeReplace in mappingFindReplaceNodes.items():
-			NodeChanger(IfThis.Z0Z_unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
-
-		if ast.unparse(newTree) == ast.unparse(astTree):
-			keepGoing = False
-		else:
-			astTree = deepcopy(newTree)
-	return newTree

{mapfolding-0.10.0.dist-info → mapfolding-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.10.0
+Version: 0.11.1
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -31,6 +31,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: astToolkit
 Requires-Dist: autoflake
 Requires-Dist: cytoolz
 Requires-Dist: more_itertools

{mapfolding-0.10.0.dist-info → mapfolding-0.11.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mapFolding/__init__.py,sha256=vIUZ4w4Hr12xPhSXIrnoG7-jg59VeEl5KbaOfmMRjTA,5403
+mapFolding/__init__.py,sha256=P2guQYFN19PSAl8yd9NQjIapMvZnZlasPOvKJ1KUGvA,4883
 mapFolding/basecamp.py,sha256=hs7hlTmbX7KTjI_eIRVU4xn7HR4l448SIpHk1cKDwRk,8071
 mapFolding/beDRY.py,sha256=JQ7T9v4aKzweGjvpzyghyq4N9l3Wf9HZco_K_DWoiW0,15368
 mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
@@ -22,24 +22,15 @@ mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5Dv
 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/Z0Z_makeSomeModules.py,sha256=Ss9YlFAAodsydiYWz9TrcTneeYn_IUR2iQfEPjFf3IY,15805
+mapFolding/someAssemblyRequired/__init__.py,sha256=p2mbSsdEefBu0Hnwuis91cnSr0i49ZV9_bhfncGLxls,3571
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=Ey6byfbpzRmgrnuOVIA9M068Lo7S1Jk6wzNgBMPci3A,3140
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=DZDFfCcRsCY0wFlkoZ9l8Ozw7bsT5OA3qMcG2KnABGI,16003
 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/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=zZFfHhNG0VWaCigeHID-eAWQBRbYmo_59JycdstxJTc,13784
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=4ZwOQA4FWrILYe5eiawTZgeTiJ7RRUUCpI0Th5Mezso,15668
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=LZdosArlkNzFUwy8BMhswivW5xfhREAPyx2ApNOuse8,8961
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=o4gORDvDuTnTPofeDLwfZItW5MFJljNcHagVprJeBU4,18966
 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
@@ -48,10 +39,7 @@ mapFolding/syntheticModules/numbaCount.py,sha256=zM-bp07c9tEDdvidwzZ_bJTd0JC0VUk
 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
+mapfolding-0.11.1.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
@@ -59,8 +47,8 @@ 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.11.1.dist-info/METADATA,sha256=z1Z2MfDiXFSxbortwiHbjCex9X3zD9RvC7qWYs4l50g,7560
+mapfolding-0.11.1.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+mapfolding-0.11.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.11.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.11.1.dist-info/RECORD,,

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

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

mapFolding/someAssemblyRequired/_astTypes.py

@@ -1,117 +0,0 @@
-"""This file is generated automatically, so changes to this file will be lost."""
-from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
-from typing import Any, TypeAlias as typing_TypeAlias
-import ast
-intORstr: typing_TypeAlias = Any
-intORstrORtype_params: typing_TypeAlias = Any
-intORtype_params: typing_TypeAlias = Any
-hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
-hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
-hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone
-hasDOTarg_Identifier: typing_TypeAlias = ast.arg
-hasDOTarg_IdentifierOrNone: typing_TypeAlias = ast.keyword
-hasDOTarg: typing_TypeAlias = hasDOTarg_Identifier | hasDOTarg_IdentifierOrNone
-hasDOTargs_arguments: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
-hasDOTargs_list_expr: typing_TypeAlias = ast.Call
-hasDOTargs_list_arg: typing_TypeAlias = ast.arguments
-hasDOTargs: typing_TypeAlias = hasDOTargs_arguments | hasDOTargs_list_expr | hasDOTargs_list_arg
-hasDOTargtypes: typing_TypeAlias = ast.FunctionType
-hasDOTasname: typing_TypeAlias = ast.alias
-hasDOTattr: typing_TypeAlias = ast.Attribute
-hasDOTbases: typing_TypeAlias = ast.ClassDef
-hasDOTbody_list_stmt: typing_TypeAlias = ast.Module | ast.Interactive | ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.For | ast.AsyncFor | ast.While | ast.If | ast.With | ast.AsyncWith | ast.Try | ast.ExceptHandler | astDOTTryStar | ast.match_case
-hasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.Lambda | ast.IfExp
-hasDOTbody: typing_TypeAlias = hasDOTbody_list_stmt | hasDOTbody_expr
-hasDOTbound: typing_TypeAlias = astDOTTypeVar
-hasDOTcases: typing_TypeAlias = ast.Match
-hasDOTcause: typing_TypeAlias = ast.Raise
-hasDOTcls: typing_TypeAlias = ast.MatchClass
-hasDOTcomparators: typing_TypeAlias = ast.Compare
-hasDOTcontext_expr: typing_TypeAlias = ast.withitem
-hasDOTconversion: typing_TypeAlias = ast.FormattedValue
-hasDOTctx: typing_TypeAlias = ast.Attribute | ast.Subscript | ast.Starred | ast.Name | ast.List | ast.Tuple
-hasDOTdecorator_list: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
-hasDOTdefault_value: typing_TypeAlias = astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
-hasDOTdefaults: typing_TypeAlias = ast.arguments
-hasDOTelt: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.GeneratorExp
-hasDOTelts: typing_TypeAlias = ast.Set | ast.List | ast.Tuple
-hasDOTexc: typing_TypeAlias = ast.Raise
-hasDOTfinalbody: typing_TypeAlias = ast.Try | astDOTTryStar
-hasDOTformat_spec: typing_TypeAlias = ast.FormattedValue
-hasDOTfunc: typing_TypeAlias = ast.Call
-hasDOTgenerators: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp
-hasDOTguard: typing_TypeAlias = ast.match_case
-hasDOThandlers: typing_TypeAlias = ast.Try | astDOTTryStar
-hasDOTid: typing_TypeAlias = ast.Name
-hasDOTifs: typing_TypeAlias = ast.comprehension
-hasDOTis_async: typing_TypeAlias = ast.comprehension
-hasDOTitems: typing_TypeAlias = ast.With | ast.AsyncWith
-hasDOTiter: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
-hasDOTkey: typing_TypeAlias = ast.DictComp
-hasDOTkeys_list_exprOrNone: typing_TypeAlias = ast.Dict
-hasDOTkeys_list_expr: typing_TypeAlias = ast.MatchMapping
-hasDOTkeys: typing_TypeAlias = hasDOTkeys_list_exprOrNone | hasDOTkeys_list_expr
-hasDOTkeywords: typing_TypeAlias = ast.ClassDef | ast.Call
-hasDOTkind: typing_TypeAlias = ast.Constant
-hasDOTkw_defaults: typing_TypeAlias = ast.arguments
-hasDOTkwarg: typing_TypeAlias = ast.arguments
-hasDOTkwd_attrs: typing_TypeAlias = ast.MatchClass
-hasDOTkwd_patterns: typing_TypeAlias = ast.MatchClass
-hasDOTkwonlyargs: typing_TypeAlias = ast.arguments
-hasDOTleft: typing_TypeAlias = ast.BinOp | ast.Compare
-hasDOTlevel: typing_TypeAlias = ast.ImportFrom
-hasDOTlineno: typing_TypeAlias = ast.TypeIgnore
-hasDOTlower: typing_TypeAlias = ast.Slice
-hasDOTmodule: typing_TypeAlias = ast.ImportFrom
-hasDOTmsg: typing_TypeAlias = ast.Assert
-hasDOTname_Identifier: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
-hasDOTname_IdentifierOrNone: typing_TypeAlias = ast.ExceptHandler | ast.MatchStar | ast.MatchAs
-hasDOTname_str: typing_TypeAlias = ast.alias
-hasDOTname_Name: typing_TypeAlias = astDOTTypeAlias
-hasDOTname: typing_TypeAlias = hasDOTname_Identifier | hasDOTname_IdentifierOrNone | hasDOTname_str | hasDOTname_Name
-hasDOTnames_list_alias: typing_TypeAlias = ast.Import | ast.ImportFrom
-hasDOTnames_list_Identifier: typing_TypeAlias = ast.Global | ast.Nonlocal
-hasDOTnames: typing_TypeAlias = hasDOTnames_list_alias | hasDOTnames_list_Identifier
-hasDOTop_operator: typing_TypeAlias = ast.AugAssign | ast.BinOp
-hasDOTop_boolop: typing_TypeAlias = ast.BoolOp
-hasDOTop_unaryop: typing_TypeAlias = ast.UnaryOp
-hasDOTop: typing_TypeAlias = hasDOTop_operator | hasDOTop_boolop | hasDOTop_unaryop
-hasDOToperand: typing_TypeAlias = ast.UnaryOp
-hasDOTops: typing_TypeAlias = ast.Compare
-hasDOToptional_vars: typing_TypeAlias = ast.withitem
-hasDOTorelse_list_stmt: typing_TypeAlias = ast.For | ast.AsyncFor | ast.While | ast.If | ast.Try | astDOTTryStar
-hasDOTorelse_expr: typing_TypeAlias = ast.IfExp
-hasDOTorelse: typing_TypeAlias = hasDOTorelse_list_stmt | hasDOTorelse_expr
-hasDOTpattern_pattern: typing_TypeAlias = ast.match_case
-hasDOTpattern_patternOrNone: typing_TypeAlias = ast.MatchAs
-hasDOTpattern: typing_TypeAlias = hasDOTpattern_pattern | hasDOTpattern_patternOrNone
-hasDOTpatterns: typing_TypeAlias = ast.MatchSequence | ast.MatchMapping | ast.MatchClass | ast.MatchOr
-hasDOTposonlyargs: typing_TypeAlias = ast.arguments
-hasDOTrest: typing_TypeAlias = ast.MatchMapping
-hasDOTreturns_expr: typing_TypeAlias = ast.FunctionType
-hasDOTreturns_exprOrNone: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef
-hasDOTreturns: typing_TypeAlias = hasDOTreturns_expr | hasDOTreturns_exprOrNone
-hasDOTright: typing_TypeAlias = ast.BinOp
-hasDOTsimple: typing_TypeAlias = ast.AnnAssign
-hasDOTslice: typing_TypeAlias = ast.Subscript
-hasDOTstep: typing_TypeAlias = ast.Slice
-hasDOTsubject: typing_TypeAlias = ast.Match
-hasDOTtag: typing_TypeAlias = ast.TypeIgnore
-hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AugAssign | ast.AnnAssign
-hasDOTtarget_expr: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
-hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
-hasDOTtarget: typing_TypeAlias = hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr | hasDOTtarget_Name
-hasDOTtargets: typing_TypeAlias = ast.Delete | ast.Assign
-hasDOTtest: typing_TypeAlias = ast.While | ast.If | ast.Assert | ast.IfExp
-hasDOTtype: typing_TypeAlias = ast.ExceptHandler
-hasDOTtype_comment: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Assign | ast.For | ast.AsyncFor | ast.With | ast.AsyncWith | ast.arg
-hasDOTtype_ignores: typing_TypeAlias = ast.Module
-hasDOTtype_params: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeAlias
-hasDOTupper: typing_TypeAlias = ast.Slice
-hasDOTvalue_exprOrNone: typing_TypeAlias = ast.Return | ast.AnnAssign | ast.Yield
-hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.AugAssign | ast.Expr | ast.NamedExpr | ast.DictComp | ast.Await | ast.YieldFrom | ast.FormattedValue | ast.Attribute | ast.Subscript | ast.Starred | ast.keyword | astDOTTypeAlias | ast.MatchValue
-hasDOTvalue_Any: typing_TypeAlias = ast.Constant
-hasDOTvalue_LiteralTrueFalseOrNone: typing_TypeAlias = ast.MatchSingleton
-hasDOTvalue: typing_TypeAlias = hasDOTvalue_exprOrNone | hasDOTvalue_expr | hasDOTvalue_Any | hasDOTvalue_LiteralTrueFalseOrNone
-hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
-hasDOTvararg: typing_TypeAlias = ast.arguments

mapFolding/someAssemblyRequired/_theTypes.py

@@ -1,34 +0,0 @@
-from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTtype_param, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple
-from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
-import ast
-
-# TODO understand typing.
-
-# NOTE Prototype of an idea to subclass composable methods so that typing information
-# can extend beyond the top level of the ast node.
-class ImaCallToName(ast.Call):
-	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]
-
-# Type hints through TypeAlias or type "hints" through the identifier name.
-ast_expr_Slice: typing_TypeAlias = ast.expr
-ast_Identifier: typing_TypeAlias = str
-str_nameDOTname: typing_TypeAlias = str
-
-# Limited success with TypeVar.
-个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
-NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
-
-# For my reference, all ast classes by subgroup:
-Ima_ast_boolop: typing_TypeAlias = ast.boolop | ast.And | ast.Or
-Ima_ast_cmpop: typing_TypeAlias = ast.cmpop | ast.Eq | ast.NotEq | ast.Lt | ast.LtE | ast.Gt | ast.GtE | ast.Is | ast.IsNot | ast.In | ast.NotIn
-Ima_ast_excepthandler: typing_TypeAlias = ast.excepthandler | ast.ExceptHandler
-Ima_ast_expr_context: typing_TypeAlias = ast.expr_context | ast.Load | ast.Store | ast.Del
-Ima_ast_expr: typing_TypeAlias = ast.expr | ast.Attribute | ast.Await | ast.BinOp | ast.BoolOp | ast.Call | ast.Compare | ast.Constant | ast.Dict | ast.DictComp | ast.FormattedValue | ast.GeneratorExp | ast.IfExp | ast.JoinedStr | ast.Lambda | ast.List | ast.ListComp | ast.Name | ast.NamedExpr | ast.Set | ast.SetComp | ast.Slice | ast.Starred | ast.Subscript | ast.Tuple | ast.UnaryOp | ast.Yield | ast.YieldFrom
-Ima_ast_mod: typing_TypeAlias = ast.mod | ast.Expression | ast.FunctionType | ast.Interactive | ast.Module
-Ima_ast_operator: typing_TypeAlias = ast.operator | ast.Add | ast.Sub | ast.Mult | ast.MatMult | ast.Div | ast.Mod | ast.Pow | ast.LShift | ast.RShift | ast.BitOr | ast.BitXor | ast.BitAnd | ast.FloorDiv
-Ima_ast_orphan = ast.alias | ast.arg | ast.arguments | ast.comprehension | ast.keyword | ast.match_case | ast.withitem
-iMa_ast_pattern: typing_TypeAlias = ast.pattern | ast.MatchAs | ast.MatchClass | ast.MatchMapping | ast.MatchOr | ast.MatchSequence | ast.MatchSingleton | ast.MatchStar | ast.MatchValue
-Ima_ast_stmt: typing_TypeAlias = ast.stmt | ast.AnnAssign | ast.Assert | ast.Assign | ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.AugAssign | ast.Break | ast.ClassDef | ast.Continue | ast.Delete | ast.Expr | ast.For | ast.FunctionDef | ast.Global | ast.If | ast.Import | ast.ImportFrom | ast.Match | ast.Nonlocal | ast.Pass | ast.Raise | ast.Return | ast.Try | astDOTTryStar | astDOTTypeAlias | ast.While | ast.With
-Ima_ast_type_ignore: typing_TypeAlias = ast.type_ignore | ast.TypeIgnore
-Ima_ast_type_param: typing_TypeAlias = astDOTtype_param | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
-Ima_ast_unaryop: typing_TypeAlias = ast.unaryop | ast.Invert | ast.Not | ast.UAdd | ast.USub