# astToolkit
## Do You Want This Package?
astToolkit provides a powerfully composable system for manipulating Python Abstract Syntax Trees. Use it when:
- You need to programmatically analyze, transform, or generate Python code.
- You want type-safe operations that help prevent AST manipulation errors.
- You prefer working with a consistent, fluent API rather than raw AST nodes.
- You desire the ability to compose complex AST transformations from simple, reusable parts.
Don't use it for simple text-based code manipulation—use regex or string operations instead.
## Architecture
astToolkit implements a layered architecture designed for composability and type safety:
1. **Core "Atomic" Classes** - The foundation of the system:
- `Be`: Type guards that return `TypeIs[ast.NodeType]` for safe type narrowing.
- `DOT`: Read-only accessors that retrieve node attributes with proper typing.
- `Grab`: Transformation functions that modify specific attributes while preserving node structure.
- `Make`: Factory methods that create properly configured AST nodes with consistent interfaces.
2. **Traversal and Transformation** - Built on the visitor pattern:
- `NodeTourist`: Extends `ast.NodeVisitor` to extract information from nodes that match the antecedent (sometimes called "predicate").
- `NodeChanger`: Extends `ast.NodeTransformer` to selectively transform nodes that match antecedents.
3. **Composable APIs** - The antecedent-action pattern:
- `ClassIsAndAttribute`: A powerful antecedent constructor: it confirms the class type of `node`, then applies whatever condition check you want to an attribute of `node`. As long as you listen to your type checker, you won't accidentally pair an attribute to a class that doesn't have that attribute. Furthermore, your IDE's hover type hints will tell you which classes are valid for the attribute you are checking.
- `IfThis`: Generates predicate functions that identify nodes based on structure, content, or relationships.
- `Then`: Creates action functions that specify what to do with matched nodes (extract, replace, modify).
4. **Higher-level Tools** - Built from the core components:
- `_toolkitAST.py`: Functions for common operations like extracting function definitions or importing modules.
- `transformationTools.py`: Advanced utilities like function inlining and code generation.
- `IngredientsFunction` and `IngredientsModule`: Containers for holding AST components and their dependencies.
5. **Type System** - Over 120 specialized types for AST components:
- Custom type annotations for AST node attributes.
- Union types that accurately model Python's AST structure.
- Type guards that enable static type checkers to understand dynamic type narrowing.
### Easy-to-use Tools for Annoying Tasks
- extractClassDef
- extractFunctionDef
- parseLogicalPath2astModule
- parsePathFilename2astModule
### Easy-to-use Tools for More Complicated Tasks
- removeUnusedParameters
- write_astModule
### The `toolFactory`
Hypothetically, you could customize every aspect of the classes `Be`, `DOT`, `GRAB`, and `Make` and more than 100 `TypeAlias` in the toolFactory directory/package.
## Usage
astToolkit provides a comprehensive set of tools for AST manipulation, organized in a layered architecture for composability and type safety. The following examples demonstrate how to use these tools in real-world scenarios.
### Core Pattern: Layered AST Manipulation
The astToolkit approach follows a layered pattern:
1. **Create/Access/Check** - Use `Make`, `DOT`, and `Be` to work with AST nodes
2. **Locate** - Use `IfThis` predicates to identify nodes of interest
3. **Transform** - Use `NodeChanger` and `Then` to modify nodes
4. **Extract** - Use `NodeTourist` to collect information from the AST
### Example 1: Extracting Information from AST
This example shows how to extract information from a function's parameters:
```python
from astToolkit import Be, DOT, NodeTourist, Then
import ast
# Parse some Python code into an AST
code = """
def process_data(state: DataClass):
result = state.value * 2
return result
"""
tree = ast.parse(code)
# Extract the parameter name from the function
function_def = tree.body[0]
param_name = NodeTourist(
Be.arg, # Look for function parameters
Then.extractIt(DOT.arg) # Extract the parameter name
).captureLastMatch(function_def)
print(f"Function parameter name: {param_name}") # Outputs: state
# Extract the parameter's type annotation
annotation = NodeTourist(
Be.arg, # Look for function parameters
Then.extractIt(DOT.annotation) # Extract the type annotation
).captureLastMatch(function_def)
if annotation and Be.Name(annotation):
annotation_name = DOT.id(annotation)
print(f"Parameter type: {annotation_name}") # Outputs: DataClass
```
### Example 2: Transforming AST Nodes
This example demonstrates how to transform a specific node in the AST:
```python
from astToolkit import Be, IfThis, Make, NodeChanger, Then
import ast
# Parse some Python code into an AST
code = """
def double(x):
return x * 2
"""
tree = ast.parse(code)
# Define a predicate to find the multiplication operation
find_mult = Be.Mult
# Define a transformation to change multiplication to addition
change_to_add = Then.replaceWith(ast.Add())
# Apply the transformation
NodeChanger(find_mult, change_to_add).visit(tree)
# Now the code is equivalent to:
# def double(x):
# return x + x
print(ast.unparse(tree))
```
### Example 3: Advanced AST Transformation with Custom Predicates
This example shows a more complex transformation inspired by the mapFolding package:
```python
from astToolkit import str, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then
import ast
# Define custom predicates by extending IfThis
class IfThis(astToolkit_IfThis):
@staticmethod
def isAttributeNamespaceIdentifierGreaterThan0(
namespace: str,
identifier: str
) -> Callable[[ast.AST], TypeIs[ast.Compare] | bool]:
return lambda node: (
Be.Compare(node)
and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))
and Be.Gt(node.ops[0])
and IfThis.isConstant_value(0)(node.comparators[0]))
@staticmethod
def isWhileAttributeNamespaceIdentifierGreaterThan0(
namespace: str,
identifier: str
) -> Callable[[ast.AST], TypeIs[ast.While] | bool]:
return lambda node: (
Be.While(node)
and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
# Parse some code
code = """
while claude.counter > 0:
result += counter
counter -= 1
"""
tree = ast.parse(code)
# Find the while loop with our custom predicate
find_while_loop = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0("claude", "counter")
# Replace counter > 0 with counter > 1
change_condition = Grab.testAttribute(
Grab.comparatorsAttribute(
Then.replaceWith([Make.Constant(1)])
)
)
# Apply the transformation
NodeChanger(find_while_loop, change_condition).visit(tree)
print(ast.unparse(tree))
# Now outputs:
# while counter > 1:
# result += counter
# counter -= 1
```
### Example 4: Building Code Generation Systems
The following example shows how to set up a foundation for code generation and transformation systems:
```python
from astToolkit import (
Be, DOT, IngredientsFunction, IngredientsModule, LedgerOfImports,
Make, NodeTourist, Then, parseLogicalPath2astModule, write_astModule
)
import ast
# Parse a module to extract a function
module_ast = parseLogicalPath2astModule("my_package.source_module")
# Extract a function and track its imports
function_name = "target_function"
function_def = NodeTourist(
IfThis.isFunctionDefIdentifier(function_name),
Then.extractIt
).captureLastMatch(module_ast)
if function_def:
# Create a self-contained function with tracked imports
ingredients = IngredientsFunction(
function_def,
LedgerOfImports(module_ast)
)
# Rename the function
ingredients.astFunctionDef.name = "optimized_" + function_name
# Add a decorator
decorator = Make.Call(
Make.Name("jit"),
[],
[Make.keyword("cache", Make.Constant(True))]
)
ingredients.astFunctionDef.decorator_list.append(decorator)
# Add required import
ingredients.imports.addImportFrom_asStr("numba", "jit")
# Create a module and write it to disk
module = IngredientsModule(ingredients)
write_astModule(module, "path/to/generated_code.py", "my_package")
```
### Example 5: Extending Core Classes
To create specialized patterns for your codebase, extend the core classes:
```python
from astToolkit import str, Be, IfThis as astToolkit_IfThis
from collections.abc import Callable
from typing import TypeIs
import ast
class IfThis(astToolkit_IfThis):
@staticmethod
def isAttributeNamespaceIdentifierGreaterThan0(
namespace: str,
identifier: str
) -> Callable[[ast.AST], TypeIs[ast.Compare] | bool]:
"""Find comparisons like 'state.counter > 0'"""
return lambda node: (
Be.Compare(node)
and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(node.left)
and Be.Gt(node.ops[0])
and IfThis.isConstant_value(0)(node.comparators[0])
)
@staticmethod
def isWhileAttributeNamespaceIdentifierGreaterThan0(
namespace: str,
identifier: str
) -> Callable[[ast.AST], TypeIs[ast.While] | bool]:
"""Find while loops like 'while state.counter > 0:'"""
return lambda node: (
Be.While(node)
and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(node.test)
)
```
### Real-world Application: Code Transformation Assembly-line
In the [mapFolding](https://github.com/hunterhogan/mapFolding) project, astToolkit is used to build a complete transformation assembly-line that:
1. Extracts algorithms from source modules
2. Transforms them into optimized variants
3. Applies numerical computing decorators
4. Handles dataclass management and type systems
5. Generates complete modules with proper imports
This pattern enables the separation of readable algorithm implementations from their high-performance variants while ensuring they remain functionally equivalent.
For deeper examples, see the [mapFolding/someAssemblyRequired](https://github.com/hunterhogan/mapFolding/tree/main/mapFolding/someAssemblyRequired/) directory.
## Installation
```bash
pip install astToolkit
```
## My Recovery
[](https://HunterThinks.com/support)
[](https://www.youtube.com/@HunterHogan)
## How to code
Coding One Step at a Time:
0. WRITE CODE.
1. Don't write stupid code that's hard to revise.
2. Write good code.
3. When revising, write better code.
[](https://creativecommons.org/licenses/by-nc/4.0/)
Raw data
{
"_id": null,
"home_page": null,
"name": "astToolkit",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.12",
"maintainer_email": null,
"keywords": "abstract syntax tree, ast, ast-analysis, ast-manipulation, ast-predicate, ast-traversal, ast-visitor, code generation, code transformation, code-analysis, code-refactoring, composable-apis, function-inlining, metaprogramming, python-ast, source-code-generation, static-analysis, type-safe, typed-ast, visitor-pattern",
"author": null,
"author_email": "Hunter Hogan <HunterHogan@pm.me>",
"download_url": "https://files.pythonhosted.org/packages/f8/e1/4416d3c676df1c85427d388eeee729d4f89feedb5f2bf6e940ec8852b6f2/asttoolkit-0.6.0.tar.gz",
"platform": null,
"description": "# astToolkit\n\n## Do You Want This Package?\n\nastToolkit provides a powerfully composable system for manipulating Python Abstract Syntax Trees. Use it when:\n\n- You need to programmatically analyze, transform, or generate Python code.\n- You want type-safe operations that help prevent AST manipulation errors.\n- You prefer working with a consistent, fluent API rather than raw AST nodes.\n- You desire the ability to compose complex AST transformations from simple, reusable parts.\n\nDon't use it for simple text-based code manipulation\u2014use regex or string operations instead.\n\n## Architecture\n\nastToolkit implements a layered architecture designed for composability and type safety:\n\n1. **Core \"Atomic\" Classes** - The foundation of the system:\n - `Be`: Type guards that return `TypeIs[ast.NodeType]` for safe type narrowing.\n - `DOT`: Read-only accessors that retrieve node attributes with proper typing.\n - `Grab`: Transformation functions that modify specific attributes while preserving node structure.\n - `Make`: Factory methods that create properly configured AST nodes with consistent interfaces.\n\n2. **Traversal and Transformation** - Built on the visitor pattern:\n - `NodeTourist`: Extends `ast.NodeVisitor` to extract information from nodes that match the antecedent (sometimes called \"predicate\").\n - `NodeChanger`: Extends `ast.NodeTransformer` to selectively transform nodes that match antecedents.\n\n3. **Composable APIs** - The antecedent-action pattern:\n - `ClassIsAndAttribute`: A powerful antecedent constructor: it confirms the class type of `node`, then applies whatever condition check you want to an attribute of `node`. As long as you listen to your type checker, you won't accidentally pair an attribute to a class that doesn't have that attribute. Furthermore, your IDE's hover type hints will tell you which classes are valid for the attribute you are checking.\n - `IfThis`: Generates predicate functions that identify nodes based on structure, content, or relationships.\n - `Then`: Creates action functions that specify what to do with matched nodes (extract, replace, modify).\n\n4. **Higher-level Tools** - Built from the core components:\n - `_toolkitAST.py`: Functions for common operations like extracting function definitions or importing modules.\n - `transformationTools.py`: Advanced utilities like function inlining and code generation.\n - `IngredientsFunction` and `IngredientsModule`: Containers for holding AST components and their dependencies.\n\n5. **Type System** - Over 120 specialized types for AST components:\n - Custom type annotations for AST node attributes.\n - Union types that accurately model Python's AST structure.\n - Type guards that enable static type checkers to understand dynamic type narrowing.\n\n### Easy-to-use Tools for Annoying Tasks\n\n- extractClassDef\n- extractFunctionDef\n- parseLogicalPath2astModule\n- parsePathFilename2astModule\n\n### Easy-to-use Tools for More Complicated Tasks\n\n- removeUnusedParameters\n- write_astModule\n\n### The `toolFactory`\n\nHypothetically, you could customize every aspect of the classes `Be`, `DOT`, `GRAB`, and `Make` and more than 100 `TypeAlias` in the toolFactory directory/package.\n\n## Usage\n\nastToolkit provides a comprehensive set of tools for AST manipulation, organized in a layered architecture for composability and type safety. The following examples demonstrate how to use these tools in real-world scenarios.\n\n### Core Pattern: Layered AST Manipulation\n\nThe astToolkit approach follows a layered pattern:\n\n1. **Create/Access/Check** - Use `Make`, `DOT`, and `Be` to work with AST nodes\n2. **Locate** - Use `IfThis` predicates to identify nodes of interest\n3. **Transform** - Use `NodeChanger` and `Then` to modify nodes\n4. **Extract** - Use `NodeTourist` to collect information from the AST\n\n### Example 1: Extracting Information from AST\n\nThis example shows how to extract information from a function's parameters:\n\n```python\nfrom astToolkit import Be, DOT, NodeTourist, Then\nimport ast\n\n# Parse some Python code into an AST\ncode = \"\"\"\ndef process_data(state: DataClass):\n result = state.value * 2\n return result\n\"\"\"\ntree = ast.parse(code)\n\n# Extract the parameter name from the function\nfunction_def = tree.body[0]\nparam_name = NodeTourist(\n Be.arg, # Look for function parameters\n Then.extractIt(DOT.arg) # Extract the parameter name\n).captureLastMatch(function_def)\n\nprint(f\"Function parameter name: {param_name}\") # Outputs: state\n\n# Extract the parameter's type annotation\nannotation = NodeTourist(\n Be.arg, # Look for function parameters\n Then.extractIt(DOT.annotation) # Extract the type annotation\n).captureLastMatch(function_def)\n\nif annotation and Be.Name(annotation):\n annotation_name = DOT.id(annotation)\n print(f\"Parameter type: {annotation_name}\") # Outputs: DataClass\n```\n\n### Example 2: Transforming AST Nodes\n\nThis example demonstrates how to transform a specific node in the AST:\n\n```python\nfrom astToolkit import Be, IfThis, Make, NodeChanger, Then\nimport ast\n\n# Parse some Python code into an AST\ncode = \"\"\"\ndef double(x):\n return x * 2\n\"\"\"\ntree = ast.parse(code)\n\n# Define a predicate to find the multiplication operation\nfind_mult = Be.Mult\n\n# Define a transformation to change multiplication to addition\nchange_to_add = Then.replaceWith(ast.Add())\n\n# Apply the transformation\nNodeChanger(find_mult, change_to_add).visit(tree)\n\n# Now the code is equivalent to:\n# def double(x):\n# return x + x\nprint(ast.unparse(tree))\n```\n\n### Example 3: Advanced AST Transformation with Custom Predicates\n\nThis example shows a more complex transformation inspired by the mapFolding package:\n\n```python\nfrom astToolkit import str, Be, DOT, Grab, IfThis as astToolkit_IfThis, Make, NodeChanger, Then\nimport ast\n\n# Define custom predicates by extending IfThis\nclass IfThis(astToolkit_IfThis):\n @staticmethod\n def isAttributeNamespaceIdentifierGreaterThan0(\n namespace: str,\n identifier: str\n ) -> Callable[[ast.AST], TypeIs[ast.Compare] | bool]:\n\n return lambda node: (\n Be.Compare(node)\n and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))\n and Be.Gt(node.ops[0])\n and IfThis.isConstant_value(0)(node.comparators[0]))\n\n @staticmethod\n def isWhileAttributeNamespaceIdentifierGreaterThan0(\n namespace: str,\n identifier: str\n ) -> Callable[[ast.AST], TypeIs[ast.While] | bool]:\n\n return lambda node: (\n Be.While(node)\n and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))\n\n# Parse some code\ncode = \"\"\"\nwhile claude.counter > 0:\n result += counter\n counter -= 1\n\"\"\"\ntree = ast.parse(code)\n\n# Find the while loop with our custom predicate\nfind_while_loop = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(\"claude\", \"counter\")\n\n# Replace counter > 0 with counter > 1\nchange_condition = Grab.testAttribute(\n Grab.comparatorsAttribute(\n Then.replaceWith([Make.Constant(1)])\n )\n)\n\n# Apply the transformation\nNodeChanger(find_while_loop, change_condition).visit(tree)\n\nprint(ast.unparse(tree))\n# Now outputs:\n# while counter > 1:\n# result += counter\n# counter -= 1\n```\n\n### Example 4: Building Code Generation Systems\n\nThe following example shows how to set up a foundation for code generation and transformation systems:\n\n```python\nfrom astToolkit import (\n Be, DOT, IngredientsFunction, IngredientsModule, LedgerOfImports,\n Make, NodeTourist, Then, parseLogicalPath2astModule, write_astModule\n)\nimport ast\n\n# Parse a module to extract a function\nmodule_ast = parseLogicalPath2astModule(\"my_package.source_module\")\n\n# Extract a function and track its imports\nfunction_name = \"target_function\"\nfunction_def = NodeTourist(\n IfThis.isFunctionDefIdentifier(function_name),\n Then.extractIt\n).captureLastMatch(module_ast)\n\nif function_def:\n # Create a self-contained function with tracked imports\n ingredients = IngredientsFunction(\n function_def,\n LedgerOfImports(module_ast)\n )\n\n # Rename the function\n ingredients.astFunctionDef.name = \"optimized_\" + function_name\n\n # Add a decorator\n decorator = Make.Call(\n Make.Name(\"jit\"),\n [],\n [Make.keyword(\"cache\", Make.Constant(True))]\n )\n ingredients.astFunctionDef.decorator_list.append(decorator)\n\n # Add required import\n ingredients.imports.addImportFrom_asStr(\"numba\", \"jit\")\n\n # Create a module and write it to disk\n module = IngredientsModule(ingredients)\n write_astModule(module, \"path/to/generated_code.py\", \"my_package\")\n```\n\n### Example 5: Extending Core Classes\n\nTo create specialized patterns for your codebase, extend the core classes:\n\n```python\nfrom astToolkit import str, Be, IfThis as astToolkit_IfThis\nfrom collections.abc import Callable\nfrom typing import TypeIs\nimport ast\n\nclass IfThis(astToolkit_IfThis):\n @staticmethod\n def isAttributeNamespaceIdentifierGreaterThan0(\n namespace: str,\n identifier: str\n ) -> Callable[[ast.AST], TypeIs[ast.Compare] | bool]:\n \"\"\"Find comparisons like 'state.counter > 0'\"\"\"\n return lambda node: (\n Be.Compare(node)\n and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(node.left)\n and Be.Gt(node.ops[0])\n and IfThis.isConstant_value(0)(node.comparators[0])\n )\n\n @staticmethod\n def isWhileAttributeNamespaceIdentifierGreaterThan0(\n namespace: str,\n identifier: str\n ) -> Callable[[ast.AST], TypeIs[ast.While] | bool]:\n \"\"\"Find while loops like 'while state.counter > 0:'\"\"\"\n return lambda node: (\n Be.While(node)\n and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(node.test)\n )\n```\n\n### Real-world Application: Code Transformation Assembly-line\n\nIn the [mapFolding](https://github.com/hunterhogan/mapFolding) project, astToolkit is used to build a complete transformation assembly-line that:\n\n1. Extracts algorithms from source modules\n2. Transforms them into optimized variants\n3. Applies numerical computing decorators\n4. Handles dataclass management and type systems\n5. Generates complete modules with proper imports\n\nThis pattern enables the separation of readable algorithm implementations from their high-performance variants while ensuring they remain functionally equivalent.\n\nFor deeper examples, see the [mapFolding/someAssemblyRequired](https://github.com/hunterhogan/mapFolding/tree/main/mapFolding/someAssemblyRequired/) directory.\n\n## Installation\n\n```bash\npip install astToolkit\n```\n\n## My Recovery\n\n[](https://HunterThinks.com/support)\n[](https://www.youtube.com/@HunterHogan)\n\n## How to code\n\nCoding One Step at a Time:\n\n0. WRITE CODE.\n1. Don't write stupid code that's hard to revise.\n2. Write good code.\n3. When revising, write better code.\n\n[](https://creativecommons.org/licenses/by-nc/4.0/)\n",
"bugtrack_url": null,
"license": "CC-BY-NC-4.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.",
"version": "0.6.0",
"project_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"
},
"split_keywords": [
"abstract syntax tree",
" ast",
" ast-analysis",
" ast-manipulation",
" ast-predicate",
" ast-traversal",
" ast-visitor",
" code generation",
" code transformation",
" code-analysis",
" code-refactoring",
" composable-apis",
" function-inlining",
" metaprogramming",
" python-ast",
" source-code-generation",
" static-analysis",
" type-safe",
" typed-ast",
" visitor-pattern"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "3067cb6e804dd80a8d1edf454229e7090ef7d71f9ddbb102e371cdd36e7a77f5",
"md5": "453c6c9b9a8da5c93aa5451e4f393710",
"sha256": "14414d81280764930fb989959db9d5cd19c12a48598a29112b57790ff814536b"
},
"downloads": -1,
"filename": "asttoolkit-0.6.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "453c6c9b9a8da5c93aa5451e4f393710",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.12",
"size": 108808,
"upload_time": "2025-07-08T16:43:59",
"upload_time_iso_8601": "2025-07-08T16:43:59.229038Z",
"url": "https://files.pythonhosted.org/packages/30/67/cb6e804dd80a8d1edf454229e7090ef7d71f9ddbb102e371cdd36e7a77f5/asttoolkit-0.6.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "f8e14416d3c676df1c85427d388eeee729d4f89feedb5f2bf6e940ec8852b6f2",
"md5": "97632991c5bdf07243727f3934b83e45",
"sha256": "25b4e88563f0226442fa67716025b379f348f1602342d9556af88c973e58ebeb"
},
"downloads": -1,
"filename": "asttoolkit-0.6.0.tar.gz",
"has_sig": false,
"md5_digest": "97632991c5bdf07243727f3934b83e45",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.12",
"size": 104757,
"upload_time": "2025-07-08T16:44:00",
"upload_time_iso_8601": "2025-07-08T16:44:00.899752Z",
"url": "https://files.pythonhosted.org/packages/f8/e1/4416d3c676df1c85427d388eeee729d4f89feedb5f2bf6e940ec8852b6f2/asttoolkit-0.6.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-08 16:44:00",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "hunterhogan",
"github_project": "astToolkit",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "asttoolkit"
}
JSON
