পাইথন ast মডিউল: অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রি ম্যানিপুলেশন সহজবোধ্য

পাইথনের ast মডিউল পাইথন কোডের অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রি (AST) এর সাথে ইন্টারঅ্যাক্ট করার একটি শক্তিশালী উপায় সরবরাহ করে। একটি AST হল সোর্স কোডের সিনট্যাকটিক কাঠামোর একটি ট্রি-প্রতিনিধিত্ব, যা প্রোগ্রাম্যাটিকভাবে পাইথন কোড বিশ্লেষণ, পরিবর্তন এবং এমনকি তৈরি করা সম্ভব করে তোলে। এটি কোড বিশ্লেষণ সরঞ্জাম, স্বয়ংক্রিয় রিফ্যাক্টরিং, স্ট্যাটিক বিশ্লেষণ এবং কাস্টম ভাষা এক্সটেনশন সহ বিভিন্ন অ্যাপ্লিকেশনের দরজা খুলে দেয়। এই নিবন্ধটি আপনাকে ast মডিউলের মৌলিক বিষয়গুলির মাধ্যমে গাইড করবে, ব্যবহারিক উদাহরণ এবং এর ক্ষমতাগুলির অন্তর্দৃষ্টি প্রদান করবে।

অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রি (AST) কি?

ast মডিউলে প্রবেশ করার আগে, আসুন অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রি কি তা বুঝি। যখন একটি পাইথন ইন্টারপ্রেটার আপনার কোড এক্সিকিউট করে, তখন প্রথম ধাপ হল কোডটিকে একটি AST তে পার্স করা। এই ট্রি স্ট্রাকচার কোডের সিনট্যাকটিক উপাদানগুলিকে উপস্থাপন করে, যেমন ফাংশন, ক্লাস, লুপ, এক্সপ্রেশন এবং অপারেটর, তাদের সম্পর্ক সহ। AST হোয়াইটস্পেস এবং কমেন্টের মতো অপ্রাসঙ্গিক বিবরণ বাদ দেয়, অত্যাবশ্যক কাঠামোগত তথ্যের উপর ফোকাস করে। কোডকে এইভাবে উপস্থাপন করার মাধ্যমে, প্রোগ্রামগুলির পক্ষে কোডটিকে বিশ্লেষণ এবং ম্যানিপুলেট করা সম্ভব হয়, যা অনেক পরিস্থিতিতে অত্যন্ত উপযোগী।

ast মডিউল দিয়ে শুরু করা

ast মডিউলটি পাইথনের স্ট্যান্ডার্ড লাইব্রেরির অংশ, তাই আপনাকে কোনো অতিরিক্ত প্যাকেজ ইনস্টল করার প্রয়োজন নেই। এটি ব্যবহার শুরু করার জন্য কেবল এটি আমদানি করুন:

            import ast
            

              
                Copy
              
            
          

ast মডিউলের মূল ফাংশন হল ast.parse(), যা ইনপুট হিসাবে পাইথন কোডের একটি স্ট্রিং নেয় এবং একটি AST অবজেক্ট প্রদান করে।

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

এটি <_ast.Module object at 0x...> এর মতো কিছু আউটপুট দেবে। যদিও এই আউটপুটটি বিশেষভাবে তথ্যপূর্ণ নয়, এটি ইঙ্গিত দেয় যে কোডটি সফলভাবে একটি AST তে পার্স করা হয়েছে। ast_tree অবজেক্টটিতে এখন পার্স করা কোডের সম্পূর্ণ কাঠামো রয়েছে।

AST অন্বেষণ

AST এর কাঠামো বোঝার জন্য, আমরা ast.dump() ফাংশনটি ব্যবহার করতে পারি। এই ফাংশনটি রিকারসিভলি ট্রি-তে চলাচল করে এবং প্রতিটি নোডের একটি বিস্তারিত উপস্থাপনা প্রিন্ট করে।

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

আউটপুট হবে:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

এই আউটপুট কোডের হায়ারার্কিক্যাল কাঠামো দেখায়। আসুন এটি ভেঙে দেখি:

• Module: সম্পূর্ণ মডিউল প্রতিনিধিত্বকারী রুট নোড।
• body: মডিউলের মধ্যে থাকা স্টেটমেন্টগুলির একটি তালিকা।
• FunctionDef: একটি ফাংশন ডেফিনিশন প্রতিনিধিত্ব করে। এর বৈশিষ্ট্যগুলির মধ্যে রয়েছে:
• name: ফাংশনের নাম ('add')।
• args: ফাংশনের আর্গুমেন্ট।
• arguments: ফাংশনের আর্গুমেন্ট সম্পর্কিত তথ্য ধারণ করে।
• arg: একটি একক আর্গুমেন্ট (যেমন, 'x', 'y') প্রতিনিধিত্ব করে।
• body: ফাংশনের বডি (স্টেটমেন্টগুলির একটি তালিকা)।
• Return: একটি রিটার্ন স্টেটমেন্ট প্রতিনিধিত্ব করে।
• value: ফেরত দেওয়া মান।
• BinOp: একটি বাইনারি অপারেশন (যেমন, x + y) প্রতিনিধিত্ব করে।
• left: বাম অপারেন্ড (যেমন, 'x')।
• op: অপারেটর (যেমন, 'Add')।
• right: ডান অপারেন্ড (যেমন, 'y')।

AST ট্র্যাভার্সিং

ast মডিউল AST ট্র্যাভার্স করার জন্য ast.NodeVisitor ক্লাস সরবরাহ করে। ast.NodeVisitor কে সাবক্লাস করে এবং এর মেথডগুলি ওভাররাইড করে, আপনি ট্র্যাভার্সালের সময় নির্দিষ্ট নোড টাইপগুলি এনকাউন্টার করার সময় সেগুলি প্রক্রিয়া করতে পারেন। এটি কোড স্ট্রাকচার বিশ্লেষণ, নির্দিষ্ট প্যাটার্ন শনাক্তকরণ বা তথ্য বের করার জন্য দরকারী।

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']
            

              
                Copy
              
            
          

এই উদাহরণে, FunctionNameExtractor ast.NodeVisitor থেকে ইনহেরিট করে এবং visit_FunctionDef মেথডটি ওভাররাইড করে। এই মেথডটি AST তে প্রতিটি ফাংশন ডেফিনিশন নোডের জন্য কল করা হয়। মেথডটি ফাংশনের নাম function_names তালিকায় যুক্ত করে। visit() মেথডটি AST এর ট্র্যাভার্সাল শুরু করে।

উদাহরণ: সমস্ত ভ্যারিয়েবল অ্যাসাইনমেন্ট খুঁজে বের করা

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']
            

              
                Copy
              
            
          

এই উদাহরণটি কোডে সমস্ত ভ্যারিয়েবল অ্যাসাইনমেন্ট খুঁজে বের করে। visit_Assign মেথডটি প্রতিটি অ্যাসাইনমেন্ট স্টেটমেন্টের জন্য কল করা হয়। এটি অ্যাসাইনমেন্টের টার্গেটগুলির মাধ্যমে ইটারেট করে এবং, যদি একটি টার্গেট একটি সাধারণ নাম (ast.Name) হয়, তবে এটি assignments তালিকায় নামটি যুক্ত করে।

AST পরিবর্তন করা

ast মডিউল আপনাকে AST পরিবর্তন করার অনুমতি দেয়। আপনি বিদ্যমান নোড পরিবর্তন করতে পারেন, নতুন নোড যুক্ত করতে পারেন বা নোডগুলি সম্পূর্ণভাবে মুছে ফেলতে পারেন। AST পরিবর্তন করতে, আপনি ast.NodeTransformer ক্লাস ব্যবহার করেন। ast.NodeVisitor এর মতো, আপনি ast.NodeTransformer কে সাবক্লাস করেন এবং নির্দিষ্ট নোড টাইপগুলি পরিবর্তন করতে এর মেথডগুলি ওভাররাইড করেন। মূল পার্থক্য হল ast.NodeTransformer মেথডগুলি পরিবর্তিত নোড (বা এটিকে প্রতিস্থাপন করার জন্য একটি নতুন নোড) প্রদান করা উচিত। যদি একটি মেথড None প্রদান করে, তাহলে নোডটি AST থেকে মুছে ফেলা হয়।

AST পরিবর্তন করার পরে, আপনাকে compile() ফাংশন ব্যবহার করে এটিকে এক্সিকিউটেবল পাইথন কোডে কম্পাইল করতে হবে।

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21
            

              
                Copy
              
            
          

এই উদাহরণে, AddOneTransformer ast.NodeTransformer থেকে ইনহেরিট করে এবং visit_Num মেথডটি ওভাররাইড করে। এই মেথডটি প্রতিটি নিউমেরিক লিটারাল নোড (ast.Num) এর জন্য কল করা হয়। মেথডটি মান 1 যোগ করে একটি নতুন ast.Num নোড তৈরি করে। visit() মেথডটি পরিবর্তিত AST প্রদান করে।

compile() ফাংশন পরিবর্তিত AST, একটি ফাইলের নাম (এই ক্ষেত্রে <string>, যা নির্দেশ করে যে কোডটি একটি স্ট্রিং থেকে এসেছে) এবং একটি এক্সিকিউশন মোড (কোডের একটি ব্লক এক্সিকিউট করার জন্য 'exec') নেয়। এটি একটি কোড অবজেক্ট প্রদান করে যা exec() ফাংশন ব্যবহার করে এক্সিকিউট করা যেতে পারে।

উদাহরণ: একটি ভ্যারিয়েবল নাম প্রতিস্থাপন করা

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)
            

              
                Copy
              
            
          

এই উদাহরণটি 'number' ভ্যারিয়েবল নামের সমস্ত ঘটনাকে 'num' দিয়ে প্রতিস্থাপন করে। VariableNameReplacer পুরানো এবং নতুন নামগুলি আর্গুমেন্ট হিসাবে নেয়। visit_Name মেথডটি প্রতিটি নাম নোডের জন্য কল করা হয়। যদি নোডের আইডি পুরানো নামের সাথে মেলে, তবে এটি নতুন নাম এবং একই প্রসঙ্গ (node.ctx) সহ একটি নতুন ast.Name নোড তৈরি করে। প্রসঙ্গটি নির্দেশ করে যে নামটি কীভাবে ব্যবহার করা হচ্ছে (যেমন, লোডিং, স্টোরিং)।

AST থেকে কোড জেনারেট করা

compile() ফাংশন AST থেকে কোড এক্সিকিউট করতে সাহায্য করলেও, এটি কোডকে স্ট্রিং হিসেবে পাওয়ার কোনো উপায় সরবরাহ করে না। AST থেকে পাইথন কোড জেনারেট করতে, আপনি astunparse লাইব্রেরি ব্যবহার করতে পারেন। এই লাইব্রেরিটি স্ট্যান্ডার্ড লাইব্রেরির অংশ নয়, তাই আপনাকে এটি প্রথমে ইনস্টল করতে হবে:

            pip install astunparse
            

              
                Copy
              
            
          

তারপর, আপনি AST থেকে কোড জেনারেট করতে astunparse.unparse() ফাংশন ব্যবহার করতে পারেন।

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

আউটপুট হবে:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

দ্রষ্টব্য: (x + y) এর চারপাশের বন্ধনীগুলি astunparse দ্বারা যুক্ত করা হয়েছে যাতে সঠিক অপারেটর প্রেসিডেন্স নিশ্চিত করা যায়। এই বন্ধনীগুলি কঠোরভাবে প্রয়োজনীয় নাও হতে পারে, তবে তারা কোডের সঠিকতা নিশ্চিত করে।

উদাহরণ: একটি সহজ ক্লাস জেনারেট করা

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

এই উদাহরণটি নিম্নলিখিত পাইথন কোড তৈরি করে:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

এটি স্ক্র্যাচ থেকে একটি AST তৈরি করার এবং তারপরে এটি থেকে কোড জেনারেট করার পদ্ধতি প্রদর্শন করে। কোড জেনারেশন সরঞ্জাম এবং মেটাপ্রোগ্রামিংয়ের জন্য এই পদ্ধতিটি শক্তিশালী।

ast মডিউলের ব্যবহারিক প্রয়োগ

ast মডিউলের অসংখ্য ব্যবহারিক প্রয়োগ রয়েছে, যার মধ্যে রয়েছে:

• কোড বিশ্লেষণ: স্টাইল লঙ্ঘন, নিরাপত্তা দুর্বলতা বা পারফরম্যান্স বটলনেকের জন্য কোড বিশ্লেষণ। উদাহরণস্বরূপ, আপনি একটি বড় প্রকল্পে কোডিং স্ট্যান্ডার্ড প্রয়োগ করার জন্য একটি সরঞ্জাম লিখতে পারেন।
• স্বয়ংক্রিয় রিফ্যাক্টরিং: ভ্যারিয়েবলগুলির নাম পরিবর্তন করা, ফাংশন এক্সট্রাক্ট করা বা নতুন ভাষা বৈশিষ্ট্য ব্যবহার করার জন্য কোড রূপান্তর করার মতো কাজগুলি স্বয়ংক্রিয় করা। `rope`-এর মতো সরঞ্জামগুলি শক্তিশালী রিফ্যাক্টরিং ক্ষমতার জন্য AST ব্যবহার করে।
• স্ট্যাটিক বিশ্লেষণ: কোডটি আসলে না চালিয়ে সম্ভাব্য ত্রুটি বা বাগগুলি সনাক্ত করা। `pylint` এবং `flake8`-এর মতো সরঞ্জামগুলি সমস্যাগুলি সনাক্ত করতে AST বিশ্লেষণ ব্যবহার করে।
• কোড জেনারেশন: টেমপ্লেট বা স্পেসিফিকেশনগুলির উপর ভিত্তি করে স্বয়ংক্রিয়ভাবে কোড জেনারেট করা। এটি পুনরাবৃত্তিমূলক কোড তৈরি বা বিভিন্ন প্ল্যাটফর্মের জন্য কোড তৈরি করার জন্য দরকারী।
• ভাষা এক্সটেনশন: পাইথন কোডকে বিভিন্ন উপস্থাপনায় রূপান্তর করে কাস্টম ভাষা এক্সটেনশন বা ডোমেইন-স্পেসিফিক ল্যাঙ্গুয়েজ (DSLs) তৈরি করা।
• নিরাপত্তা নিরীক্ষা: সম্ভাব্য ক্ষতিকারক কনস্ট্রাক্ট বা দুর্বলতার জন্য কোড বিশ্লেষণ। এটি অনিরাপদ কোডিং অনুশীলন সনাক্ত করতে ব্যবহার করা যেতে পারে।

উদাহরণ: কোডিং স্টাইল প্রয়োগ করা

ধরুন আপনি আপনার প্রোজেক্টের সমস্ত ফাংশনের নামগুলি snake_case কনভেনশন (যেমন, myFunction এর পরিবর্তে my_function) অনুসরণ করে তা প্রয়োগ করতে চান। আপনি লঙ্ঘন পরীক্ষা করার জন্য ast মডিউল ব্যবহার করতে পারেন।

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")
            

              
                Copy
              
            
          

এই কোডটি একটি SnakeCaseChecker ক্লাস সংজ্ঞায়িত করে যা ast.NodeVisitor থেকে ইনহেরিট করে। visit_FunctionDef মেথডটি ফাংশনের নামটি snake_case রেগুলার এক্সপ্রেশনের সাথে মেলে কিনা তা পরীক্ষা করে। যদি না মেলে, তবে এটি errors তালিকায় একটি ত্রুটি বার্তা যুক্ত করে। check_code মেথডটি কোড পার্স করে, AST তে ট্র্যাভার্স করে এবং ত্রুটির তালিকা প্রদান করে।

ast মডিউল নিয়ে কাজ করার সময় সেরা অনুশীলন

• AST কাঠামো বোঝা: AST ম্যানিপুলেট করার চেষ্টা করার আগে, ast.dump() ব্যবহার করে এর কাঠামো বোঝার জন্য সময় নিন। এটি আপনাকে কোন নোডগুলির সাথে কাজ করতে হবে তা শনাক্ত করতে সহায়তা করবে।
• ast.NodeVisitor এবং ast.NodeTransformer ব্যবহার করুন: এই ক্লাসগুলি ম্যানুয়ালি ট্রি নেভিগেট না করে AST ট্র্যাভার্স এবং পরিবর্তন করার একটি সুবিধাজনক উপায় সরবরাহ করে।
• পুঙ্খানুপুঙ্খভাবে পরীক্ষা করুন: AST পরিবর্তন করার সময়, পরিবর্তনগুলি সঠিক কিনা এবং কোনো ত্রুটি তৈরি করে না তা নিশ্চিত করার জন্য আপনার কোড পুঙ্খানুপুঙ্খভাবে পরীক্ষা করুন।
• কোড জেনারেশনের জন্য astunparse বিবেচনা করুন: যদিও compile() পরিবর্তিত কোড এক্সিকিউট করার জন্য দরকারী, astunparse AST থেকে পঠনযোগ্য পাইথন কোড জেনারেট করার একটি উপায় সরবরাহ করে।
• টাইপ হিন্ট ব্যবহার করুন: বিশেষ করে জটিল AST কাঠামোর সাথে কাজ করার সময়, টাইপ হিন্টগুলি আপনার কোডের পঠনযোগ্যতা এবং রক্ষণাবেক্ষণকে উল্লেখযোগ্যভাবে উন্নত করতে পারে।
• আপনার কোড ডকুমেন্ট করুন: কাস্টম AST ভিজিটর বা ট্রান্সফর্মার তৈরি করার সময়, প্রতিটি মেথডের উদ্দেশ্য এবং এটি AST তে কী পরিবর্তন করে তা ব্যাখ্যা করার জন্য আপনার কোডটি স্পষ্টভাবে ডকুমেন্ট করুন।

চ্যালেঞ্জ এবং বিবেচনা

• জটিলতা: AST নিয়ে কাজ করা জটিল হতে পারে, বিশেষ করে বড় কোডবেসের জন্য। বিভিন্ন নোড টাইপ এবং তাদের সম্পর্ক বোঝা চ্যালেঞ্জিং হতে পারে।
• রক্ষণাবেক্ষণ: পাইথন সংস্করণের মধ্যে AST কাঠামো পরিবর্তিত হতে পারে। সামঞ্জস্যতা নিশ্চিত করার জন্য বিভিন্ন পাইথন সংস্করণের সাথে আপনার কোড পরীক্ষা করুন।
• পারফরম্যান্স: বড় ASTs ট্র্যাভার্সিং এবং পরিবর্তন করা ধীর হতে পারে। কর্মক্ষমতা উন্নত করতে আপনার কোড অপ্টিমাইজ করার কথা বিবেচনা করুন। প্রায়শই অ্যাক্সেস করা নোডগুলির ক্যাশিং বা আরও কার্যকর অ্যালগরিদম ব্যবহার করে এটি সাহায্য করতে পারে।
• ত্রুটি পরিচালনা: AST পার্সিং বা ম্যানিপুলেট করার সময় ত্রুটিগুলি সুন্দরভাবে পরিচালনা করুন। ব্যবহারকারীকে তথ্যপূর্ণ ত্রুটি বার্তা সরবরাহ করুন।
• নিরাপত্তা: AST থেকে জেনারেট করা কোড এক্সিকিউট করার সময় সতর্ক থাকুন, বিশেষ করে যদি AST ব্যবহারকারীর ইনপুটের উপর ভিত্তি করে হয়। কোড ইনজেকশন আক্রমণ প্রতিরোধ করার জন্য ইনপুট স্যানিটাইজ করুন।

উপসংহার

পাইথন ast মডিউল পাইথন কোডের অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রির সাথে ইন্টারঅ্যাক্ট করার একটি শক্তিশালী এবং নমনীয় উপায় সরবরাহ করে। AST কাঠামো বুঝে এবং ast.NodeVisitor এবং ast.NodeTransformer ক্লাস ব্যবহার করে, আপনি প্রোগ্রাম্যাটিকভাবে পাইথন কোড বিশ্লেষণ, পরিবর্তন এবং তৈরি করতে পারেন। এটি কোড বিশ্লেষণ সরঞ্জাম থেকে স্বয়ংক্রিয় রিফ্যাক্টরিং এবং এমনকি কাস্টম ভাষা এক্সটেনশন পর্যন্ত বিস্তৃত অ্যাপ্লিকেশনের জন্য দরজা খুলে দেয়। AST নিয়ে কাজ করা জটিল হতে পারে, তবে প্রোগ্রাম্যাটিকভাবে কোড ম্যানিপুলেট করার ক্ষমতা গুরুত্বপূর্ণ সুবিধা প্রদান করে। আপনার পাইথন প্রকল্পগুলিতে নতুন সম্ভাবনা উন্মোচন করতে ast মডিউলের শক্তিকে আলিঙ্গন করুন।