astToolkit 0.1.4__tar.gz → 0.2.1__tar.gz

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.4
+Version: 0.2.1
 Summary: A powerfully composable, type-safe toolkit for Python abstract syntax tree (AST) manipulation, analysis, transformation, and code generation with a layered architecture designed for building sophisticated code processing assembly-lines.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/__init__.py

@@ -13,6 +13,7 @@ from astToolkit._types import (
 	NodeORattribute as NodeORattribute,
 	str_nameDOTname as str_nameDOTname,
 	个 as 个,
+	个return as 个return,
 )
 
 from astToolkit._toolkitNodeVisitor import (

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/_toolBe.py

@@ -1,7 +1,7 @@
 """This file is generated automatically, so changes to this file will be lost."""
-from astToolkit import astDOTTryStar, astDOTParamSpec, astDOTtype_param, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple
 from typing import TypeGuard
 import ast
+import sys
 
 class Be:
     """
@@ -159,14 +159,14 @@ class Be:
     def Eq(node: ast.AST) -> TypeGuard[ast.Eq]:
         return isinstance(node, ast.Eq)
 
-    @staticmethod
-    def excepthandler(node: ast.AST) -> TypeGuard[ast.excepthandler]:
-        return isinstance(node, ast.excepthandler)
-
     @staticmethod
     def ExceptHandler(node: ast.AST) -> TypeGuard[ast.ExceptHandler]:
         return isinstance(node, ast.ExceptHandler)
 
+    @staticmethod
+    def excepthandler(node: ast.AST) -> TypeGuard[ast.excepthandler]:
+        return isinstance(node, ast.excepthandler)
+
     @staticmethod
     def Expr(node: ast.AST) -> TypeGuard[ast.Expr]:
         return isinstance(node, ast.Expr)
@@ -335,14 +335,14 @@ class Be:
     def MatMult(node: ast.AST) -> TypeGuard[ast.MatMult]:
         return isinstance(node, ast.MatMult)
 
-    @staticmethod
-    def mod(node: ast.AST) -> TypeGuard[ast.mod]:
-        return isinstance(node, ast.mod)
-
     @staticmethod
     def Mod(node: ast.AST) -> TypeGuard[ast.Mod]:
         return isinstance(node, ast.Mod)
 
+    @staticmethod
+    def mod(node: ast.AST) -> TypeGuard[ast.mod]:
+        return isinstance(node, ast.mod)
+
     @staticmethod
     def Module(node: ast.AST) -> TypeGuard[ast.Module]:
         return isinstance(node, ast.Module)
@@ -382,10 +382,11 @@ class Be:
     @staticmethod
     def Or(node: ast.AST) -> TypeGuard[ast.Or]:
         return isinstance(node, ast.Or)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def ParamSpec(node: ast.AST) -> TypeGuard[astDOTParamSpec]:
-        return isinstance(node, astDOTParamSpec)
+        @staticmethod
+        def ParamSpec(node: ast.AST) -> TypeGuard[ast.ParamSpec]:
+            return isinstance(node, ast.ParamSpec)
 
     @staticmethod
     def Pass(node: ast.AST) -> TypeGuard[ast.Pass]:
@@ -446,10 +447,11 @@ class Be:
     @staticmethod
     def Try(node: ast.AST) -> TypeGuard[ast.Try]:
         return isinstance(node, ast.Try)
+    if sys.version_info >= (3, 11):
 
-    @staticmethod
-    def TryStar(node: ast.AST) -> TypeGuard[astDOTTryStar]:
-        return isinstance(node, astDOTTryStar)
+        @staticmethod
+        def TryStar(node: ast.AST) -> TypeGuard[ast.TryStar]:
+            return isinstance(node, ast.TryStar)
 
     @staticmethod
     def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
@@ -458,26 +460,30 @@ class Be:
     @staticmethod
     def type_ignore(node: ast.AST) -> TypeGuard[ast.type_ignore]:
         return isinstance(node, ast.type_ignore)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def type_param(node: ast.AST) -> TypeGuard[astDOTtype_param]:
-        return isinstance(node, astDOTtype_param)
+        @staticmethod
+        def type_param(node: ast.AST) -> TypeGuard[ast.type_param]:
+            return isinstance(node, ast.type_param)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def TypeAlias(node: ast.AST) -> TypeGuard[astDOTTypeAlias]:
-        return isinstance(node, astDOTTypeAlias)
+        @staticmethod
+        def TypeAlias(node: ast.AST) -> TypeGuard[ast.TypeAlias]:
+            return isinstance(node, ast.TypeAlias)
 
     @staticmethod
     def TypeIgnore(node: ast.AST) -> TypeGuard[ast.TypeIgnore]:
         return isinstance(node, ast.TypeIgnore)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def TypeVar(node: ast.AST) -> TypeGuard[astDOTTypeVar]:
-        return isinstance(node, astDOTTypeVar)
+        @staticmethod
+        def TypeVar(node: ast.AST) -> TypeGuard[ast.TypeVar]:
+            return isinstance(node, ast.TypeVar)
+    if sys.version_info >= (3, 12):
 
-    @staticmethod
-    def TypeVarTuple(node: ast.AST) -> TypeGuard[astDOTTypeVarTuple]:
-        return isinstance(node, astDOTTypeVarTuple)
+        @staticmethod
+        def TypeVarTuple(node: ast.AST) -> TypeGuard[ast.TypeVarTuple]:
+            return isinstance(node, ast.TypeVarTuple)
 
     @staticmethod
     def UAdd(node: ast.AST) -> TypeGuard[ast.UAdd]:

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/_toolIfThis.py

@@ -44,12 +44,6 @@ class IfThis:
 		"""see also `isArgument_Identifier`"""
 		return lambda node: Be.keyword(node) and IfThis.isIdentifier(identifier)(DOT.arg(node))
 
-	@staticmethod
-	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return Be.AnnAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
 	@staticmethod
 	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
 		return lambda node: (Be.arg(node) or Be.keyword(node)) and IfThis.isIdentifier(identifier)(DOT.arg(node))
@@ -58,10 +52,6 @@ class IfThis:
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		""" `node` is `ast.Assign` and `node.targets[0]` matches `targets0Predicate`."""
 		return lambda node: Be.Assign(node) and targets0Predicate(node.targets[0])
-	@staticmethod
-	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
-		""" `node` is `ast.Assign` and `node.value` matches `valuePredicate`. """
-		return lambda node: Be.Assign(node) and valuePredicate(DOT.value(node))
 
 	@staticmethod
 	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
@@ -82,12 +72,6 @@ class IfThis:
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: IfThis.isAttributeName(node) and IfThis.isName_Identifier(namespace)(DOT.value(node)) and IfThis.isIdentifier(identifier)(DOT.attr(node))
 
-	@staticmethod
-	def isAugAssignAndTargetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
-			return Be.AugAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
 	@staticmethod
 	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/_toolkitNodeVisitor.py

@@ -15,12 +15,13 @@ structures, creating a complete workflow for code analysis and transformation.
 """
 
 from collections.abc import Callable
-from typing import Any
+from typing import Any, cast, Generic, TypeGuard, TypeVar
 import ast
+from astToolkit import NodeORattribute, 个, 个return
 
 # TODO Identify the logic that narrows the type and can help the user during static type checking.
 
-class NodeTourist(ast.NodeVisitor):
+class NodeTourist(ast.NodeVisitor, Generic[个, 个return]):
 	"""
 	Visit and extract information from AST nodes that match a predicate.
 
@@ -31,19 +32,18 @@ class NodeTourist(ast.NodeVisitor):
 	This class is particularly useful for analyzing AST structures, extracting specific nodes or node properties, and
 	gathering information about code patterns.
 	"""
-	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
+	def __init__(self, findThis: Callable[[ast.AST], TypeGuard[个] | bool], doThat: Callable[[个], 个return]) -> None:
 		self.findThis = findThis
 		self.doThat = doThat
-		self.nodeCaptured: Any | None = None
+		self.nodeCaptured: 个return | None = None
 
 	def visit(self, node: ast.AST) -> None:
 		if self.findThis(node):
-			nodeActionReturn = self.doThat(node)
-			if nodeActionReturn is not None:
-				self.nodeCaptured = nodeActionReturn
+			node = cast(个, node)
+			self.nodeCaptured = self.doThat(node)
 		self.generic_visit(node)
 
-	def captureLastMatch(self, node: ast.AST) -> Any | None:
+	def captureLastMatch(self, node: ast.AST) -> 个return | None:
 		self.nodeCaptured = None
 		self.visit(node)
 		return self.nodeCaptured

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/_types.py

@@ -4,12 +4,6 @@ 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.
-# To cover all cases, quantity of necessary classes = sum of (for each class: for each attribute: attribute * number of valid types). If an attribute has type ast.expr, for example, then there are 27 valid types just for that attribute. There would be thousands of subclasses like ImaCallToName.
-# 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
@@ -17,7 +11,8 @@ 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)
+个return = typing_TypeVar('个return', covariant = True)
+NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | 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
@@ -34,3 +29,9 @@ Ima_ast_type_param: typing_TypeAlias = astDOTtype_param | astDOTParamSpec | astD
 Ima_ast_unaryop: typing_TypeAlias = ast.unaryop | ast.Invert | ast.Not | ast.UAdd | ast.USub
 
 Ima_ast_orphan = ast.alias | ast.arg | ast.arguments | ast.comprehension | ast.keyword | ast.match_case | ast.withitem
+
+# NOTE Prototype of an old idea to subclass composable methods so that typing information
+# can extend beyond the top level of the ast node.
+# To cover all cases, quantity of necessary classes = sum of (for each class: for each attribute: attribute * number of valid types). If an attribute has type ast.expr, for example, then there are 27 valid types just for that attribute. There would be thousands of subclasses like ImaCallToName.
+# class ImaCallToName(ast.Call):
+# 	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit/transformationTools.py

@@ -1,6 +1,7 @@
 from astToolkit import (
 	ast_Identifier,
 	Be,
+	ClassIsAndAttribute,
 	DOT,
 	FREAKOUT,
 	Grab,
@@ -18,7 +19,7 @@ from collections.abc import Callable, Mapping
 from copy import deepcopy
 from os import PathLike
 from pathlib import PurePath
-from typing import Any, cast
+from typing import Any, cast, overload
 from Z0Z_tools import writeStringToHere
 import ast
 
@@ -65,7 +66,8 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
 
 	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName, doThat = Grab.funcAttribute(cast(Callable[[ast.expr], ast.expr], Grab.idAttribute(cast(Callable[[ast_Identifier], ast_Identifier], Then.appendTo(listIdentifiersCalledFunctions))))))
+	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName
+							, doThat = Grab.funcAttribute(cast(Callable[[ast.expr], ast.expr], Grab.idAttribute(cast(Callable[[ast_Identifier], ast_Identifier], Then.appendTo(listIdentifiersCalledFunctions))))))
 	findIdentifiersToInline.visit(FunctionDefToInline)
 
 	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
@@ -94,7 +96,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 						for astFunctionDef in dictionary4Inlining.values():
 							inliner.visit(astFunctionDef)
 					else:
-						inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
+						inliner = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
 						for astFunctionDef in dictionary4Inlining.values():
 							inliner.visit(astFunctionDef)
 
@@ -104,7 +106,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 			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 = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
 			inliner.visit(FunctionDefToInline)
 	ast.fix_missing_locations(FunctionDefToInline)
 	return FunctionDefToInline
@@ -189,6 +191,10 @@ def unparseFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, a
 			astTree = deepcopy(newTree)
 	return newTree
 
+# @overload
+# def write_astModule(astModule: ast.AST, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:...
+# @overload
+# def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:...
 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.
@@ -215,6 +221,8 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	Raises:
 		FREAKOUT: If the generated source code is empty.
 	"""
+	# if ingredients:
+	# 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	ast.fix_missing_locations(astModule)
 	pythonSource: str = ast.unparse(astModule)

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.1.4
+Version: 0.2.1
 Summary: A powerfully composable, type-safe toolkit for Python abstract syntax tree (AST) manipulation, analysis, transformation, and code generation with a layered architecture designed for building sophisticated code processing assembly-lines.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/astToolkit.egg-info/SOURCES.txt

@@ -27,8 +27,11 @@ tests/test_basic.py
 toolFactory/Z0Z_hardcoded.py
 toolFactory/Z0Z_makeAstTools.py
 toolFactory/__init__.py
+toolFactory/_snippets.py
 toolFactory/astFactory.py
-toolFactory/astFactory_annex.py
+toolFactory/databaseASTCreation.py
+toolFactory/datacenter.py
 toolFactory/docstrings.py
-toolFactory/py.typed
-toolFactory/startHere.py
+toolFactory/factory3.py
+toolFactory/factory_annex.py
+toolFactory/py.typed

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/pyproject.toml

@@ -36,7 +36,7 @@ optional-dependencies = { testing = [
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/astToolkit", Issues = "https://github.com/hunterhogan/astToolkit/issues", Repository = "https://github.com/hunterhogan/astToolkit.git" }
-version = "0.1.4"
+version = "0.2.1"
 
 [tool.coverage]
 report = { exclude_lines = [

{asttoolkit-0.1.4 → asttoolkit-0.2.1}/toolFactory/Z0Z_hardcoded.py

@@ -1,17 +1,26 @@
 from pathlib import Path
 from typing import TypeAlias as typing_TypeAlias
+import ast
 
 ast_Identifier: typing_TypeAlias = str
-fileExtension: str = '.py'
+str_nameDOTname: typing_TypeAlias = str
+
+pythonVersionMinorMinimum: int = 10
+sys_version_infoMinimum: tuple[int, int] = (3, 10)
+sys_version_infoTarget: tuple[int, int] = (3, 13)
+
+class FREAKOUT(Exception): pass
+
+# filesystem and namespace ===============================================
 packageName: ast_Identifier = 'astToolkit'
+moduleIdentifierPrefix: str = '_tool'
+keywordArgumentsIdentifier: ast_Identifier = 'keywordArguments'
+
 pathRoot = Path('/apps') / packageName
 pathPackage = pathRoot / packageName
+pathToolFactory = pathRoot / 'toolFactory'
 pathTypeshed = pathRoot / 'typeshed' / 'stdlib'
-str_nameDOTname: typing_TypeAlias = str
-sys_version_infoMinimum: tuple[int, int] = (3, 10)
-sys_version_infoTarget: tuple[int, int] = (3, 13)
 
-listASTSubclasses: list[str] = ['_Slice', 'AST', 'binaryop', 'boolop', 'cmpop', 'excepthandler', 'expr_context', 'expr', 'mod', 'operator', 'pattern', 'stmt', 'type_ignore', 'type_param', 'unaryop',]
+pathFilenameDatabaseAST = pathToolFactory / 'databaseAST.csv'
 
-class FREAKOUT(Exception):
-	pass
+fileExtension: str = '.py'

asttoolkit-0.2.1/toolFactory/Z0Z_makeAstTools.py

@@ -0,0 +1,42 @@
+from collections.abc import Callable, Sequence
+import typeshed_client.finder
+from toolFactory import FREAKOUT, pathTypeshed, makeTools
+from pathlib import Path
+from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
+import ast
+
+ast_expr_Slice: typing_TypeAlias = ast.expr
+ast_Identifier: typing_TypeAlias = str
+str_nameDOTname: typing_TypeAlias = str
+
+个 = 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)
+
+# TODO Some `DOT` methods return lists, notably DOT.targets, which is an attribute of ast.Assign.
+# But, none or almost none of the other functions and methods accept a list as input.
+# This is most obviously a problem in `ClassIsAndAttribute.targetsIs` because the user needs to pass
+# a function that can take list[ast.expr] as a parameter.
+# I don't know if the following works, but it is interesting.
+# ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscript_Identifier('foldGroups')(node) for node in list_expr]))
+
+class cleverName:
+    @staticmethod
+    def index(at: int) -> Callable[[Sequence[NodeORattribute]], NodeORattribute]:
+        def workhorse(zzz: Sequence[NodeORattribute]) -> NodeORattribute:
+            node = zzz[at]
+            return node
+        return workhorse
+
+if __name__ == "__main__":
+	search_context = typeshed_client.finder.get_search_context(typeshed=pathTypeshed if pathTypeshed.exists() else None)
+
+	# pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("_ast", search_context=search_context)
+	# if pathFilenameStubFile is None: raise FREAKOUT
+	# astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
+	# Z0Z_typesSpecial(astStubFile)
+
+	pathFilenameStubFile: Path | None = typeshed_client.finder.get_stub_file("ast", search_context=search_context)
+	if pathFilenameStubFile is None: raise FREAKOUT
+	astStubFile: ast.Module = ast.parse(pathFilenameStubFile.read_text())
+
+	makeTools(astStubFile)

asttoolkit-0.2.1/toolFactory/__init__.py

@@ -0,0 +1,27 @@
+from toolFactory.Z0Z_hardcoded import (
+	ast_Identifier as ast_Identifier,
+	fileExtension as fileExtension,
+	FREAKOUT as FREAKOUT,
+	keywordArgumentsIdentifier as keywordArgumentsIdentifier,
+	moduleIdentifierPrefix as moduleIdentifierPrefix,
+	packageName as packageName,
+	pathFilenameDatabaseAST as pathFilenameDatabaseAST,
+	pathPackage as pathPackage,
+	pathTypeshed as pathTypeshed,
+	pythonVersionMinorMinimum as pythonVersionMinorMinimum,
+	str_nameDOTname as str_nameDOTname,
+	sys_version_infoMinimum as sys_version_infoMinimum,
+	sys_version_infoTarget as sys_version_infoTarget,
+)
+
+from toolFactory._snippets import (
+	astName_overload as astName_overload,
+	astName_staticmethod as astName_staticmethod,
+	astName_typing_TypeAlias as	astName_typing_TypeAlias,
+)
+
+from toolFactory.datacenter import (
+	getElementsBe as getElementsBe,
+	)
+
+from toolFactory.astFactory import makeTools as makeTools

asttoolkit-0.2.1/toolFactory/_snippets.py

@@ -0,0 +1,6 @@
+from typing import cast
+import ast
+
+astName_overload = ast.Name('overload')
+astName_staticmethod = ast.Name('staticmethod')
+astName_typing_TypeAlias: ast.expr = cast(ast.expr, ast.Name('typing_TypeAlias'))