progress on Be

Author: hunterhogan

toolFactory/Z0Z_hardcoded.py

@@ -5,17 +5,11 @@
 ast_Identifier: typing_TypeAlias = str
 str_nameDOTname: typing_TypeAlias = str
 
+pythonVersionMinorMinimum: int = 10
 sys_version_infoMinimum: tuple[int, int] = (3, 10)
 sys_version_infoTarget: tuple[int, int] = (3, 13)
 
-listASTClassesPostPythonVersionMinimumHARDCODED: list[ast_Identifier] = ['astDOTParamSpec', 'astDOTTryStar', 'astDOTTypeAlias', 'astDOTTypeVar', 'astDOTTypeVarTuple', 'astDOTtype_param']
-listASTClassesPostPythonVersionMinimum = listASTClassesPostPythonVersionMinimumHARDCODED
-
-listASTSubclassesHARDCODED: list[str] = ['_Slice', 'AST', 'binaryop', 'boolop', 'cmpop', 'excepthandler', 'expr_context', 'expr', 'mod', 'operator', 'pattern', 'stmt', 'type_ignore', 'type_param', 'unaryop',]
-listASTSubclasses = listASTSubclassesHARDCODED
-
-class FREAKOUT(Exception):
-	pass
+class FREAKOUT(Exception): pass
 
 # filesystem and namespace ===============================================
 packageName: ast_Identifier = 'astToolkit'
@@ -30,131 +24,3 @@ class FREAKOUT(Exception):
 pathFilenameDatabaseAST = pathToolFactory / 'databaseAST.csv'
 
 fileExtension: str = '.py'
-
-# AST class and subclasses ==================================================
-listASTClasses = [ast.Add,
-ast.alias,
-ast.And,
-ast.AnnAssign,
-ast.arg,
-ast.arguments,
-ast.Assert,
-ast.Assign,
-ast.AST,
-ast.AsyncFor,
-ast.AsyncFunctionDef,
-ast.AsyncWith,
-ast.Attribute,
-ast.AugAssign,
-ast.Await,
-ast.BinOp,
-ast.BitAnd,
-ast.BitOr,
-ast.BitXor,
-ast.BoolOp,
-ast.boolop,
-ast.Break,
-ast.Call,
-ast.ClassDef,
-ast.cmpop,
-ast.Compare,
-ast.comprehension,
-ast.Constant,
-ast.Continue,
-ast.Del,
-ast.Delete,
-ast.Dict,
-ast.DictComp,
-ast.Div,
-ast.Eq,
-ast.ExceptHandler,
-ast.excepthandler,
-ast.expr_context,
-ast.Expr,
-ast.expr,
-ast.Expression,
-ast.FloorDiv,
-ast.For,
-ast.FormattedValue,
-ast.FunctionDef,
-ast.FunctionType,
-ast.GeneratorExp,
-ast.Global,
-ast.Gt,
-ast.GtE,
-ast.If,
-ast.IfExp,
-ast.Import,
-ast.ImportFrom,
-ast.In,
-ast.Interactive,
-ast.Invert,
-ast.Is,
-ast.IsNot,
-ast.JoinedStr,
-ast.keyword,
-ast.Lambda,
-ast.List,
-ast.ListComp,
-ast.Load,
-ast.LShift,
-ast.Lt,
-ast.LtE,
-ast.match_case,
-ast.Match,
-ast.MatchAs,
-ast.MatchClass,
-ast.MatchMapping,
-ast.MatchOr,
-ast.MatchSequence,
-ast.MatchSingleton,
-ast.MatchStar,
-ast.MatchValue,
-ast.MatMult,
-ast.Mod,
-ast.mod,
-ast.Module,
-ast.Mult,
-ast.Name,
-ast.NamedExpr,
-ast.Nonlocal,
-ast.Not,
-ast.NotEq,
-ast.NotIn,
-ast.operator,
-ast.Or,
-ast.ParamSpec,
-ast.Pass,
-ast.pattern,
-ast.Pow,
-ast.Raise,
-ast.Return,
-ast.RShift,
-ast.Set,
-ast.SetComp,
-ast.Slice,
-ast.Starred,
-ast.stmt,
-ast.Store,
-ast.Sub,
-ast.Subscript,
-ast.Try,
-ast.TryStar,
-ast.Tuple,
-ast.type_ignore,
-ast.type_param,
-ast.TypeAlias,
-ast.TypeIgnore,
-ast.TypeVar,
-ast.TypeVarTuple,
-ast.UAdd,
-ast.UnaryOp,
-ast.unaryop,
-ast.USub,
-ast.While,
-ast.With,
-ast.withitem,
-ast.Yield,
-ast.YieldFrom,
-]
-"""Python 3.13, not deprecated"""

toolFactory/__init__.py

@@ -2,18 +2,23 @@
 	ast_Identifier as ast_Identifier,
 	fileExtension as fileExtension,
 	FREAKOUT as FREAKOUT,
-	listASTClasses as listASTClasses,
-	listASTClassesPostPythonVersionMinimum as listASTClassesPostPythonVersionMinimum,
-	listASTSubclassesHARDCODED as listASTSubclassesHARDCODED,
+	keywordArgumentsIdentifier as keywordArgumentsIdentifier,
 	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.astFactory import makeTools as makeTools
 
 # from toolFactory.databaseAST import getDataframe as getDataframe

toolFactory/_snippets.py

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

toolFactory/astFactory.py

@@ -2,7 +2,7 @@
 from string import ascii_letters
 from toolFactory import ast_Identifier, fileExtension, listASTSubclassesHARDCODED, pathPackage, str_nameDOTname, sys_version_infoTarget
 from toolFactory.Z0Z_hardcoded import keywordArgumentsIdentifier, listASTClassesPostPythonVersionMinimum, moduleIdentifierPrefix
-from toolFactory._snippets import overloadName, staticmethodName, typing_TypeAliasName
+from toolFactory._snippets import astName_overload, astName_staticmethod, astName_typing_TypeAlias
 from toolFactory.astFactory_annex import (
 	astImportFromClassNewInPythonVersion,
 	FunctionDefMake_Attribute,
@@ -152,7 +152,7 @@ def writeModule(astModule: ast.Module, moduleIdentifier: ast_Identifier) -> None
 		ClassDefBe.body.append(ast.FunctionDef(name=ClassDefIdentifier
 			, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=ast.Name('ast.AST'))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 			, body=[ast.Return(value=ast.Call(func=ast.Name('isinstance'), args=[ast.Name('node'), ClassDef_astNameOrAttribute], keywords=[]))]
-			, decorator_list=[staticmethodName]
+			, decorator_list=[astName_staticmethod]
 			, returns=ast.Subscript(value=ast.Name('TypeGuard'), slice=ClassDef_astNameOrAttribute)))
 
 		# Start: cope with different arguments for Python versions. ==============================================================
@@ -210,7 +210,7 @@ def writeModule(astModule: ast.Module, moduleIdentifier: ast_Identifier) -> None
 		ClassDefMake.body.append(ast.FunctionDef(name=ClassDefIdentifier
 			, args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=keywordArguments_ast_arg, defaults=[])
 			, body=[ast.Return(value=ast.Call(ClassDef_astNameOrAttribute, args=[], keywords=[keywordArguments_ast_keyword] if keywordArguments_ast_keyword else []))]
-			, decorator_list=[staticmethodName]
+			, decorator_list=[astName_staticmethod]
 			, returns=ClassDef_astNameOrAttribute))
 
 		for attributeIdentifier in list_astDOTClassDefAttributeIdentifier:
@@ -401,10 +401,10 @@ def list2Sequence():
 				for ClassDefIdentifier in listClassDefIdentifier[1:]:
 					astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=dictionaryOf_astDOTclass[ClassDefIdentifier])
 			if len(attributeIdentifier2Str4TypeAlias2astAnnotationAndListClassDefIdentifier[attributeIdentifier]) == 1:
-				astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
+				astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, astName_typing_TypeAlias, astAnnAssignValue, 1))
 			else:
 				list_hasDOTNameTypeAliasAnnotations.append(ast.Name(hasDOTIdentifier + '_' + attributeAnnotationAsStr4TypeAliasIdentifier.replace('list', 'list_'), ast.Store()))
-				astTypesModule.body.append(ast.AnnAssign(list_hasDOTNameTypeAliasAnnotations[-1], typing_TypeAliasName, astAnnAssignValue, 1))
+				astTypesModule.body.append(ast.AnnAssign(list_hasDOTNameTypeAliasAnnotations[-1], astName_typing_TypeAlias, astAnnAssignValue, 1))
 				# overload definitions for `ClassIsAndAttribute` class
 				potentiallySuperComplicatedAnnotationORbool = ast.Name('bool')
 				buffaloBuffalo_workhorse_returnsAnnotation = ast.BinOp(ast.Subscript(ast.Name('TypeGuard'), list_hasDOTNameTypeAliasAnnotations[-1]), ast.BitOr(), ast.Name('bool'))
@@ -414,14 +414,14 @@ def list2Sequence():
 							, ast.arg('attributeCondition', annotation=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([attributeAnnotationAsAST]), potentiallySuperComplicatedAnnotationORbool])))
 						], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 					, body=[ast.Expr(value=ast.Constant(value=Ellipsis))]
-					, decorator_list=[staticmethodName, overloadName]
+					, decorator_list=[astName_staticmethod, astName_overload]
 					, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([ast.Attribute(ast.Name('ast'), attr='AST')]), buffaloBuffalo_workhorse_returnsAnnotation]))
 				))
 				# overload definitions for `DOT` class
 				ClassDefDOT.body.append(ast.FunctionDef(name=attributeIdentifier
 					, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=ast.Name(list_hasDOTNameTypeAliasAnnotations[-1].id))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 					, body=[ast.Expr(value=ast.Constant(value=Ellipsis))]
-					, decorator_list=[staticmethodName, overloadName]
+					, decorator_list=[astName_staticmethod, astName_overload]
 					, returns=attributeAnnotationAsAST
 				))
 
@@ -455,14 +455,14 @@ def list2Sequence():
 							, body=[ast.Return(workhorseReturnValue)]
 							, returns=buffaloBuffalo_workhorse_returnsAnnotation)
 						, ast.Return(ast.Name('workhorse'))]
-				, decorator_list=[staticmethodName]
+				, decorator_list=[astName_staticmethod]
 				, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([ast.Attribute(ast.Name('ast'), attr='AST')]), buffaloBuffalo_workhorse_returnsAnnotation]))
 			))
 
 		ClassDefDOT.body.append(ast.FunctionDef(name=attributeIdentifier
 				, args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='node', annotation=hasDOTName_Load)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[])
 				, body=[ast.Return(value=ast.Attribute(value=ast.Name('node'), attr=attributeIdentifier))]
-				, decorator_list=[staticmethodName]
+				, decorator_list=[astName_staticmethod]
 				, returns=attributeAnnotationUnifiedAsAST
 			))
 
@@ -471,7 +471,7 @@ def list2Sequence():
 			astAnnAssignValue = list_hasDOTNameTypeAliasAnnotations[0]
 			for index in range(1, len(list_hasDOTNameTypeAliasAnnotations)):
 				astAnnAssignValue = ast.BinOp(left=astAnnAssignValue, op=ast.BitOr(), right=list_hasDOTNameTypeAliasAnnotations[index])
-			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, typing_TypeAliasName, astAnnAssignValue, 1))
+			astTypesModule.body.append(ast.AnnAssign(hasDOTName_Store, astName_typing_TypeAlias, astAnnAssignValue, 1))
 		astAssignValue = ast.Call(ast.Name('action'), args=[ast.Attribute(ast.Name('node'), attr=attributeIdentifier)])
 		if (isinstance(attributeAnnotationUnifiedAsAST, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.value, ast.Name) and attributeAnnotationUnifiedAsAST.value.id == 'Sequence'
 		or isinstance(attributeAnnotationUnifiedAsAST, ast.BinOp) and isinstance(attributeAnnotationUnifiedAsAST.right, ast.Subscript) and isinstance(attributeAnnotationUnifiedAsAST.right.value, ast.Name) and attributeAnnotationUnifiedAsAST.right.value.id == 'Sequence'):
@@ -492,7 +492,7 @@ def list2Sequence():
 						, ast.Return(ast.Name('node'))],
 						returns=hasDOTName_Load),
 			ast.Return(ast.Name('workhorse'))]
-			, decorator_list=[staticmethodName], type_comment=None
+			, decorator_list=[astName_staticmethod], type_comment=None
 			, returns=ast.Subscript(ast.Name('Callable'), ast.Tuple([ast.List([hasDOTName_Load]), hasDOTName_Load]))))
 
 		del attributeAnnotationUnifiedAsAST

toolFactory/astFactory_annex.py

@@ -81,7 +81,8 @@ def workhorse(node: NodeORattribute) -> NodeORattribute:
 listPylanceErrors: list[str] = ['annotation', 'arg', 'args', 'body', 'keys', 'name', 'names', 'op', 'orelse', 'pattern', 'returns', 'target', 'value',]
 
 # ww='''
-# TypeGuard[ast.AnnAssign] | bool
+# if sys.version_info >= (3, 12):
+# 	"ImaBody"
 # '''
 
 # print(ast.dump(ast.parse(ww, type_comments=True), indent=4))