zrb 1.0.0b8__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

zrb/util/codemod/append_param_to_function_call.py

@@ -1,39 +0,0 @@
-import libcst as cst
-
-
-class FunctionCallParamAdder(cst.CSTTransformer):
-    def __init__(self, func_name: str, new_param: str):
-        self.func_name = func_name
-        # Parse the new parameter to ensure it’s a valid CST node
-        self.new_param = cst.parse_expression(new_param)
-        self.param_added = False
-
-    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
-        # Check if the function call name matches the target function
-        if (
-            isinstance(original_node.func, cst.Name)
-            and original_node.func.value == self.func_name
-        ):  # noqa
-            # Add the new parameter to the function call arguments
-            new_args = updated_node.args + (cst.Arg(value=self.new_param),)
-            self.param_added = True
-            return updated_node.with_changes(args=new_args)
-        return updated_node
-
-
-def append_param_to_function_call(
-    original_code: str, func_name: str, new_param: str
-) -> str:
-    # Parse the original code into a module
-    module = cst.parse_module(original_code)
-    # Initialize the transformer with the necessary information
-    transformer = FunctionCallParamAdder(func_name, new_param)
-    # Apply the transformation
-    modified_module = module.visit(transformer)
-    # Error handling: raise an error if the function call is not found
-    if not transformer.param_added:
-        raise ValueError(
-            f"Function call to {func_name} not found in the provided code."
-        )
-    # Return the modified code
-    return modified_module.code

zrb/util/codemod/prepend_parent_to_class.py

@@ -1,38 +0,0 @@
-import libcst as cst
-
-
-class ParentClassAdder(cst.CSTTransformer):
-    def __init__(self, class_name: str, parent_class_name: str):
-        self.class_name = class_name
-        self.parent_class_name = parent_class_name
-        self.class_found = False
-
-    def leave_ClassDef(
-        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
-    ) -> cst.ClassDef:
-        # Check if this is the target class
-        if original_node.name.value == self.class_name:
-            self.class_found = True
-            # Add the parent class to the existing bases
-            new_bases = (
-                cst.Arg(value=cst.Name(self.parent_class_name)),
-                *updated_node.bases,
-            )
-            return updated_node.with_changes(bases=new_bases)
-        return updated_node
-
-
-def prepend_parent_class(
-    original_code: str, class_name: str, parent_class_name: str
-) -> str:
-    # Parse the original code into a module
-    module = cst.parse_module(original_code)
-    # Initialize transformer with the class name and parent class name
-    transformer = ParentClassAdder(class_name, parent_class_name)
-    # Apply the transformation
-    modified_module = module.visit(transformer)
-    # Check if the class was found
-    if not transformer.class_found:
-        raise ValueError(f"Class {class_name} not found in the provided code.")
-    # Return the modified code
-    return modified_module.code

zrb/util/codemod/prepend_property_to_class.py

@@ -1,55 +0,0 @@
-import libcst as cst
-
-
-class ClassPropertyAdder(cst.CSTTransformer):
-    def __init__(
-        self, class_name: str, property_name: str, annotation: str, default_value: str
-    ):
-        self.class_name = class_name
-        self.property_name = property_name
-        self.annotation = cst.Annotation(cst.parse_expression(annotation))
-        self.default_value = cst.parse_expression(default_value)
-        self.class_found = False
-
-    def leave_ClassDef(
-        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
-    ) -> cst.ClassDef:
-        # Check if this is the target class
-        if original_node.name.value == self.class_name:
-            self.class_found = True
-            # Create the annotated property with a default value
-            new_property = cst.SimpleStatementLine(
-                body=[
-                    cst.AnnAssign(
-                        target=cst.Name(self.property_name),
-                        annotation=self.annotation,
-                        value=self.default_value,
-                    )
-                ]
-            )
-            # Insert the new property at the start of the class body with a newline
-            new_body = cst.IndentedBlock(body=(new_property,) + updated_node.body.body)
-            return updated_node.with_changes(body=new_body)
-        return updated_node
-
-
-def prepend_property_to_class(
-    original_code: str,
-    class_name: str,
-    property_name: str,
-    annotation: str,
-    default_value: str,
-) -> str:
-    # Parse the original code into a module
-    module = cst.parse_module(original_code)
-    # Initialize transformer with the class name, property name, annotation, and default value
-    transformer = ClassPropertyAdder(
-        class_name, property_name, annotation, default_value
-    )
-    # Apply the transformation
-    modified_module = module.visit(transformer)
-    # Check if the class was found
-    if not transformer.class_found:
-        raise ValueError(f"Class {class_name} not found in the provided code.")
-    # Return the modified code
-    return modified_module.code