mapFolding 0.11.0__tar.gz → 0.11.1__tar.gz

{mapfolding-0.11.0 → mapfolding-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.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

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/__init__.py

@@ -50,27 +50,10 @@ import sys
 yourPythonIsOld: TypeAlias = Any
 # ruff: noqa: E402
 
-# if sys.version_info >= (3, 12):
-# 	from ast import (
-# 		ParamSpec as astDOTParamSpec,
-# 		type_param as astDOTtype_param,
-# 		TypeAlias as astDOTTypeAlias,
-# 		TypeVar as astDOTTypeVar,
-# 		TypeVarTuple as astDOTTypeVarTuple,
-# 	)
-# else:
-# 	astDOTParamSpec: TypeAlias = yourPythonIsOld
-# 	astDOTtype_param: TypeAlias = yourPythonIsOld
-# 	astDOTTypeAlias: TypeAlias = yourPythonIsOld
-# 	astDOTTypeVar: TypeAlias = yourPythonIsOld
-# 	astDOTTypeVarTuple: TypeAlias = yourPythonIsOld
-
 if sys.version_info >= (3, 11):
-	# from ast import TryStar as astDOTTryStar
 	from typing import TypedDict as TypedDict
 	from typing import NotRequired as NotRequired
 else:
-	astDOTTryStar: TypeAlias = yourPythonIsOld
 	try:
 		from typing_extensions import TypedDict as TypedDict
 		from typing_extensions import NotRequired as NotRequired

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -9,23 +9,23 @@ from mapFolding.someAssemblyRequired import (
 	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	Then,
+	removeUnusedParameters,
 	str_nameDOTname,
+	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
-	inlineFunctionDef,
 	removeDataclassFromFunction,
-	removeUnusedParameters,
 	shatter_dataclassesDOTdataclass,
 	unpackDataclassCallFunctionRepackDataclass,
-	write_astModule,
 )
 from pathlib import PurePath
 import ast
@@ -168,7 +168,7 @@ def makeTheorem2() -> PurePath:
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/__init__.py

@@ -53,7 +53,6 @@ from astToolkit import (
 	extractClassDef as extractClassDef,
 	extractFunctionDef as extractFunctionDef,
 	Grab as Grab,
-	ImaCallToName as ImaCallToName,
 	importLogicalPath2Callable as importLogicalPath2Callable,
 	importPathFilename2Callable as importPathFilename2Callable,
 	IngredientsFunction as IngredientsFunction,
@@ -67,7 +66,13 @@ from astToolkit import (
 	parsePathFilename2astModule as parsePathFilename2astModule,
 	str_nameDOTname as str_nameDOTname,
 	Then as Then,
-	个 as 个,
+)
+
+from astToolkit.transformationTools import (
+	inlineFunctionDef as inlineFunctionDef,
+	removeUnusedParameters as removeUnusedParameters,
+	unparseFindReplace as unparseFindReplace,
+	write_astModule as write_astModule,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -51,3 +51,9 @@ class IfThis(astToolkit_IfThis):
 	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
 		return lambda node: (Be.While(node)
 					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isAttributeNamespace_IdentifierLessThanOrEqual0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (Be.Compare(node)
+					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and Be.LtE(node.ops[0]))

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -18,10 +18,9 @@ The containers work in conjunction with transformation tools that manipulate the
 specific optimizations and transformations.
 """
 
-from astToolkit import IngredientsFunction as IngredientsFunction, IngredientsModule as IngredientsModule, LedgerOfImports as LedgerOfImports
 from collections.abc import Callable
 from copy import deepcopy
-from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then
+from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then, LedgerOfImports
 from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3, The
 from pathlib import Path, PurePosixPath
 from typing import Any, cast
@@ -158,10 +157,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=dict)
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, ast.AnnAssign | ast.Assign]())
 	"""Maps field names to their corresponding AST call expressions."""
 
-	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict)
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]]())
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""
@@ -169,22 +168,22 @@ class ShatteredDataclass:
 	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	"""Import records for the dataclass and its constituent parts."""
 
-	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=lambda: list[ast.arg]())
 	"""Function argument nodes with annotations for parameter specification."""
 
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=lambda: list[ast.keyword]())
 	"""Keyword arguments for dataclass initialization with field=field format."""
 
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list)
+	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=lambda: list[ast.expr]())
 	"""Type annotations for each dataclass field."""
 
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=lambda: list[ast.Name]())
 	"""Name nodes for each dataclass field used as function parameters."""
 
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=lambda: list[ast.AnnAssign]())
 	"""Annotated assignment statements to extract fields from dataclass."""
 
-	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=dict)
+	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=lambda: dict[ast.AST, ast.Name]())
 	"""Maps AST expressions to Name nodes for find-replace operations."""
 
 	repack: ast.Assign = dummyAssign

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -12,10 +12,10 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
 from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import write_astModule
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from mapFolding.dataBaskets import MapFoldingState
 from pathlib import PurePosixPath

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -32,10 +32,11 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
 from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, makeInitializedComputationState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -17,8 +17,8 @@ performance improvements while preserving code semantics and correctness.
 
 from collections.abc import Callable, Sequence
 from mapFolding import NotRequired, TypedDict
-from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname
-from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow, write_astModule
+from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname, write_astModule
+from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final
 import ast

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,9 +18,7 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from astToolkit.transformationTools import ( inlineFunctionDef as inlineFunctionDef, removeUnusedParameters as removeUnusedParameters, write_astModule as write_astModule, )
-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,
@@ -33,16 +31,18 @@ from mapFolding.someAssemblyRequired import (
 	importLogicalPath2Callable,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	RecipeSynthesizeFlow,
+	removeUnusedParameters,
 	ShatteredDataclass,
 	str_nameDOTname,
 	Then,
-	个,
+	unparseFindReplace,
 )
 from mapFolding.theSSOT import ComputationState, The
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
@@ -230,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)
 
@@ -274,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:
@@ -294,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.unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
-
-		if ast.unparse(newTree) == ast.unparse(astTree):
-			keepGoing = False
-		else:
-			astTree = deepcopy(newTree)
-	return newTree

{mapfolding-0.11.0 → mapfolding-0.11.1}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.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

{mapfolding-0.11.0 → mapfolding-0.11.1}/pyproject.toml

@@ -75,7 +75,7 @@ readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/mapFolding", Repository = "https://github.com/hunterhogan/mapFolding.git", Issues = "https://github.com/hunterhogan/mapFolding/issues"}
-version = "0.11.0"
+version = "0.11.1"
 
 [tool.coverage]
 report = { exclude_lines = [