I have a codebase that was developed using Python 3.10 and was originally designed to run on a that version of Python. However, we have migrated to use Google Cloud Composer, which only supports Python 3.8.12.
The main issue I am running into is that our codebase uses a lot of the newer typing syntax and features that are only available on 3.10+ such as the new union syntax. Is there anyway to remove all type hints from our code?
Here is a sample function showcasing some of the issues:
def sampleFunction( self, argument1: bool, argument2: str, argument3: float, ) -> dict[str, list[float]]: var1: bool = True var2: str = "Hello"There are thousands of lines of code in this codebase, and it would be impossible to remove it all by hand. I've tried writing a quick script using Python's AST package to remove all type hints, but it doesn't really work. Specifically, it removes the type hints around function arguments and returns, but not for variable declarations.
class TypeHintRemover(ast.NodeTransformer): def recursive(func):"""decorator to make visitor work recursive""" def wrapper(self, node): self.generic_visit(node) return func(self, node) return wrapper def visit_FunctionDef(self, node): # remove the return type definition node.returns = None # remove all argument annotations if node.args.args: for arg in node.args.args: arg.annotation = None return node def visit_Assign(self, node): for target in node.targets: if hasattr(target, "type_comment") and target.type_comment: target.type_comment = None return node def visit_Attribute(self, node: Attribute) -> Any: if hasattr(node, "type_comment") and node.type_comment: node.type_comment = None return node @recursive def visit(self, node): return super().visit(node)