astToolkit 0.3.7__tar.gz → 0.5.0__tar.gz

{asttoolkit-0.3.7 → asttoolkit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astToolkit
-Version: 0.3.7
+Version: 0.5.0
 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
@@ -30,12 +30,14 @@ Requires-Dist: Z0Z_tools
 Requires-Dist: autoflake
 Requires-Dist: python_minifier
 Requires-Dist: tomli
+Requires-Dist: typing-extensions
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: setuptools-scm; extra == "testing"
 Requires-Dist: trove_classifiers; extra == "testing"
 Dynamic: license-file
 

{asttoolkit-0.3.7 → asttoolkit-0.5.0}/astToolkit/__init__.py

@@ -2,7 +2,7 @@
 AST Toolkit for Python - A comprehensive utility library for AST manipulation and transformation
 
 The astToolkit package provides a powerful set of tools for working with Python's Abstract Syntax Tree (AST),
-enabling sophisticated code analysis, transformation, and generation. The toolkit is designed around a 
+enabling sophisticated code analysis, transformation, and generation. The toolkit is designed around a
 composable architecture with specialized modules for different aspects of AST manipulation:
 
 Core Components:
@@ -41,21 +41,6 @@ from astToolkit._toolClassIsAndAttribute import ClassIsAndAttribute as ClassIsAn
 from astToolkit._toolDOT import DOT as DOT
 from astToolkit._toolGrab import Grab as Grab
 from astToolkit._toolMake import Make as Make
-from astToolkit._joinClassmethod import (
-    Add as Add,
-    BitAnd as BitAnd,
-    BitOr as BitOr,
-    BitXor as BitXor,
-    Div as Div,
-    FloorDiv as FloorDiv,
-    LShift as LShift,
-    MatMult as MatMult,
-    Mod as Mod,
-	Mult as Mult,
-    Pow as Pow,
-    RShift as RShift,
-    Sub as Sub,
-)
 
 from astToolkit._toolIfThis import IfThis as IfThis
 from astToolkit._toolThen import Then as Then

{asttoolkit-0.3.7 → asttoolkit-0.5.0}/astToolkit/_astTypes.py

@@ -51,8 +51,9 @@ hasDOTcontext_expr: typing_TypeAlias = ast.withitem
 hasDOTconversion: typing_TypeAlias = ast.FormattedValue
 hasDOTctx: typing_TypeAlias = ast.Attribute | ast.List | ast.Name | ast.Starred | ast.Subscript | ast.Tuple
 hasDOTdecorator_list: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef
-if sys.version_info >= (3, 13):
-    hasDOTdefault_value: typing_TypeAlias = ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
+match sys.version_info:
+    case version if version >= (3, 13):
+        hasDOTdefault_value: typing_TypeAlias = ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
 hasDOTdefaults: typing_TypeAlias = ast.arguments
 hasDOTelt: typing_TypeAlias = ast.GeneratorExp | ast.ListComp | ast.SetComp
 hasDOTelts: typing_TypeAlias = ast.List | ast.Set | ast.Tuple
@@ -117,10 +118,10 @@ hasDOTslice: typing_TypeAlias = ast.Subscript
 hasDOTstep: typing_TypeAlias = ast.Slice
 hasDOTsubject: typing_TypeAlias = ast.Match
 hasDOTtag: typing_TypeAlias = ast.TypeIgnore
+hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
 hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
 hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
-hasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
-hasDOTtarget: typing_TypeAlias = hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr
+hasDOTtarget: typing_TypeAlias = hasDOTtarget_expr | hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript
 hasDOTtargets: typing_TypeAlias = ast.Assign | ast.Delete
 hasDOTtest: typing_TypeAlias = ast.Assert | ast.If | ast.IfExp | ast.While
 hasDOTtype: typing_TypeAlias = ast.ExceptHandler
@@ -128,10 +129,10 @@ hasDOTtype_comment: typing_TypeAlias = ast.arg | ast.Assign | ast.AsyncFor | ast
 hasDOTtype_ignores: typing_TypeAlias = ast.Module
 hasDOTtype_params: typing_TypeAlias = ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.TypeAlias
 hasDOTupper: typing_TypeAlias = ast.Slice
-hasDOTvalue_ConstantValueType: typing_TypeAlias = ast.Constant
 hasDOTvalue_boolOrNone: typing_TypeAlias = ast.MatchSingleton
+hasDOTvalue_ConstantValueType: typing_TypeAlias = ast.Constant
 hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Starred | ast.Subscript | ast.TypeAlias | ast.YieldFrom
 hasDOTvalue_exprOrNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-hasDOTvalue: typing_TypeAlias = hasDOTvalue_ConstantValueType | hasDOTvalue_boolOrNone | hasDOTvalue_expr | hasDOTvalue_exprOrNone
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_boolOrNone | hasDOTvalue_ConstantValueType | hasDOTvalue_expr | hasDOTvalue_exprOrNone
 hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
 hasDOTvararg: typing_TypeAlias = ast.arguments

{asttoolkit-0.3.7 → asttoolkit-0.5.0}/astToolkit/_toolClassIsAndAttribute.py

@@ -72,7 +72,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[Sequence[ast.expr]], bool] | Callable[[list[ast.arg]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
+    def argsIs(astClass: type[hasDOTargs], attributeCondition: Callable[[ast.arguments], bool] | Callable[[list[ast.arg]], bool] | Callable[[Sequence[ast.expr]], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTargs] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTargs] | bool:
             return isinstance(node, astClass) and attributeCondition(node.args)
@@ -626,7 +626,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.Name], bool] | Callable[[ast.expr], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
+    def targetIs(astClass: type[hasDOTtarget], attributeCondition: Callable[[ast.expr], bool] | Callable[[ast.Name], bool] | Callable[[ast.Name | ast.Attribute | ast.Subscript], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTtarget] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTtarget] | bool:
             return isinstance(node, astClass) and attributeCondition(node.target)
@@ -702,7 +702,7 @@ class ClassIsAndAttribute:
         ...
 
     @staticmethod
-    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[ConstantValueType], bool] | Callable[[bool], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
+    def valueIs(astClass: type[hasDOTvalue], attributeCondition: Callable[[ast.expr], bool] | Callable[[bool], bool] | Callable[[ConstantValueType], bool]) -> Callable[[ast.AST], TypeGuard[hasDOTvalue] | bool]:
 
         def workhorse(node: ast.AST) -> TypeGuard[hasDOTvalue] | bool:
             return isinstance(node, astClass) and node.value is not None and attributeCondition(node.value)

{asttoolkit-0.3.7 → asttoolkit-0.5.0}/astToolkit/_toolDOT.py

@@ -1,3 +1,4 @@
+# pyright: reportReturnType=false
 # ruff: noqa: F403, F405
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit._astTypes import *
@@ -30,7 +31,7 @@ class DOT:
 
     @staticmethod
     def annotation(node: hasDOTannotation) -> ast.expr:
-        return node.annotation # pyright: ignore[reportReturnType]
+        return node.annotation
 
     @staticmethod
     @overload
@@ -44,7 +45,7 @@ class DOT:
 
     @staticmethod
     def arg(node: hasDOTarg) -> str:
-        return node.arg # pyright: ignore[reportReturnType]
+        return node.arg
 
     @staticmethod
     @overload
@@ -62,7 +63,7 @@ class DOT:
         ...
 
     @staticmethod
-    def args(node: hasDOTargs) -> ast.arguments | Sequence[ast.expr] | list[ast.arg]:
+    def args(node: hasDOTargs) -> ast.arguments | list[ast.arg] | Sequence[ast.expr]:
         return node.args
 
     @staticmethod
@@ -71,7 +72,7 @@ class DOT:
 
     @staticmethod
     def asname(node: hasDOTasname) -> str:
-        return node.asname # pyright: ignore[reportReturnType]
+        return node.asname
 
     @staticmethod
     def attr(node: hasDOTattr) -> str:
@@ -97,7 +98,7 @@ class DOT:
 
     @staticmethod
     def bound(node: hasDOTbound) -> ast.expr:
-        return node.bound # pyright: ignore[reportReturnType]
+        return node.bound
 
     @staticmethod
     def cases(node: hasDOTcases) -> Sequence[ast.match_case]:
@@ -105,7 +106,7 @@ class DOT:
 
     @staticmethod
     def cause(node: hasDOTcause) -> ast.expr:
-        return node.cause # pyright: ignore[reportReturnType]
+        return node.cause
 
     @staticmethod
     def cls(node: hasDOTcls) -> ast.expr:
@@ -134,7 +135,7 @@ class DOT:
 
         @staticmethod
         def default_value(node: hasDOTdefault_value) -> ast.expr:
-            return node.default_value # pyright: ignore[reportReturnType]
+            return node.default_value
 
     @staticmethod
     def defaults(node: hasDOTdefaults) -> Sequence[ast.expr]:
@@ -150,7 +151,7 @@ class DOT:
 
     @staticmethod
     def exc(node: hasDOTexc) -> ast.expr:
-        return node.exc # pyright: ignore[reportReturnType]
+        return node.exc
 
     @staticmethod
     def finalbody(node: hasDOTfinalbody) -> Sequence[ast.stmt]:
@@ -158,7 +159,7 @@ class DOT:
 
     @staticmethod
     def format_spec(node: hasDOTformat_spec) -> ast.expr:
-        return node.format_spec # pyright: ignore[reportReturnType]
+        return node.format_spec
 
     @staticmethod
     def func(node: hasDOTfunc) -> ast.expr:
@@ -170,7 +171,7 @@ class DOT:
 
     @staticmethod
     def guard(node: hasDOTguard) -> ast.expr:
-        return node.guard # pyright: ignore[reportReturnType]
+        return node.guard
 
     @staticmethod
     def handlers(node: hasDOThandlers) -> list[ast.ExceptHandler]:
@@ -212,7 +213,7 @@ class DOT:
 
     @staticmethod
     def keys(node: hasDOTkeys) -> Sequence[ast.expr]:
-        return node.keys # pyright: ignore[reportReturnType]
+        return node.keys
 
     @staticmethod
     def keywords(node: hasDOTkeywords) -> Sequence[ast.keyword]:
@@ -220,22 +221,22 @@ class DOT:
 
     @staticmethod
     def kind(node: hasDOTkind) -> str:
-        return node.kind # pyright: ignore[reportReturnType]
+        return node.kind
 
     @staticmethod
     def kw_defaults(node: hasDOTkw_defaults) -> Sequence[ast.expr]:
-        return node.kw_defaults # pyright: ignore[reportReturnType]
+        return node.kw_defaults
 
     @staticmethod
     def kwarg(node: hasDOTkwarg) -> ast.arg:
-        return node.kwarg # pyright: ignore[reportReturnType]
+        return node.kwarg
 
     @staticmethod
     def kwd_attrs(node: hasDOTkwd_attrs) -> list[str]:
         return node.kwd_attrs
 
     @staticmethod
-    def kwd_patterns(node: hasDOTkwd_patterns) -> list[ast.pattern]:
+    def kwd_patterns(node: hasDOTkwd_patterns) -> Sequence[ast.pattern]:
         return node.kwd_patterns
 
     @staticmethod
@@ -256,15 +257,15 @@ class DOT:
 
     @staticmethod
     def lower(node: hasDOTlower) -> ast.expr:
-        return node.lower # pyright: ignore[reportReturnType]
+        return node.lower
 
     @staticmethod
     def module(node: hasDOTmodule) -> str:
-        return node.module # pyright: ignore[reportReturnType]
+        return node.module
 
     @staticmethod
     def msg(node: hasDOTmsg) -> ast.expr:
-        return node.msg # pyright: ignore[reportReturnType]
+        return node.msg
 
     @staticmethod
     @overload
@@ -283,7 +284,7 @@ class DOT:
 
     @staticmethod
     def name(node: hasDOTname) -> ast.Name | str:
-        return node.name # pyright: ignore[reportReturnType]
+        return node.name
 
     @staticmethod
     @overload
@@ -328,7 +329,7 @@ class DOT:
 
     @staticmethod
     def optional_vars(node: hasDOToptional_vars) -> ast.expr:
-        return node.optional_vars # pyright: ignore[reportReturnType]
+        return node.optional_vars
 
     @staticmethod
     @overload
@@ -356,7 +357,7 @@ class DOT:
 
     @staticmethod
     def pattern(node: hasDOTpattern) -> ast.pattern:
-        return node.pattern # pyright: ignore[reportReturnType]
+        return node.pattern
 
     @staticmethod
     def patterns(node: hasDOTpatterns) -> Sequence[ast.pattern]:
@@ -368,7 +369,7 @@ class DOT:
 
     @staticmethod
     def rest(node: hasDOTrest) -> str:
-        return node.rest # pyright: ignore[reportReturnType]
+        return node.rest
 
     @staticmethod
     @overload
@@ -382,7 +383,7 @@ class DOT:
 
     @staticmethod
     def returns(node: hasDOTreturns) -> ast.expr:
-        return node.returns # pyright: ignore[reportReturnType]
+        return node.returns
 
     @staticmethod
     def right(node: hasDOTright) -> ast.expr:
@@ -398,7 +399,7 @@ class DOT:
 
     @staticmethod
     def step(node: hasDOTstep) -> ast.expr:
-        return node.step # pyright: ignore[reportReturnType]
+        return node.step
 
     @staticmethod
     def subject(node: hasDOTsubject) -> ast.expr:
@@ -424,7 +425,7 @@ class DOT:
         ...
 
     @staticmethod
-    def target(node: hasDOTtarget) -> ast.Name | ast.expr | (ast.Name | ast.Attribute | ast.Subscript):
+    def target(node: hasDOTtarget) -> ast.expr | ast.Name | (ast.Name | ast.Attribute | ast.Subscript):
         return node.target
 
     @staticmethod
@@ -437,11 +438,11 @@ class DOT:
 
     @staticmethod
     def type(node: hasDOTtype) -> ast.expr:
-        return node.type # pyright: ignore[reportReturnType]
+        return node.type
 
     @staticmethod
     def type_comment(node: hasDOTtype_comment) -> str:
-        return node.type_comment # pyright: ignore[reportReturnType]
+        return node.type_comment
 
     @staticmethod
     def type_ignores(node: hasDOTtype_ignores) -> list[ast.TypeIgnore]:
@@ -453,7 +454,7 @@ class DOT:
 
     @staticmethod
     def upper(node: hasDOTupper) -> ast.expr:
-        return node.upper # pyright: ignore[reportReturnType]
+        return node.upper
 
     @staticmethod
     @overload
@@ -476,7 +477,7 @@ class DOT:
         ...
 
     @staticmethod
-    def value(node: hasDOTvalue) -> ast.expr | ConstantValueType | bool:
+    def value(node: hasDOTvalue) -> ast.expr | bool | ConstantValueType:
         return node.value
 
     @staticmethod
@@ -485,4 +486,4 @@ class DOT:
 
     @staticmethod
     def vararg(node: hasDOTvararg) -> ast.arg:
-        return node.vararg # pyright: ignore[reportReturnType]
+        return node.vararg