codeshift 0.2.0__py3-none-any.whl

codeshift/migrator/transforms/requests_transformer.py

@@ -0,0 +1,218 @@
+"""Requests library transformation using LibCST."""
+
+import libcst as cst
+
+from codeshift.migrator.ast_transforms import BaseTransformer
+
+
+class RequestsTransformer(BaseTransformer):
+    """Transform Requests library code for version upgrades."""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def leave_ImportFrom(
+        self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom:
+        """Transform requests imports."""
+        if original_node.module is None:
+            return updated_node
+
+        module_name = self._get_module_name(original_node.module)
+
+        # Transform requests.packages.urllib3 imports
+        if module_name == "requests.packages.urllib3" or module_name.startswith(
+            "requests.packages.urllib3."
+        ):
+            new_module_name = module_name.replace("requests.packages.urllib3", "urllib3")
+            self.record_change(
+                description="Import urllib3 directly instead of through requests.packages",
+                line_number=1,
+                original=f"from {module_name}",
+                replacement=f"from {new_module_name}",
+                transform_name="urllib3_import_fix",
+            )
+            return updated_node.with_changes(module=self._build_module_node(new_module_name))
+
+        # Transform requests.compat imports
+        if module_name == "requests.compat":
+            if isinstance(updated_node.names, cst.ImportStar):
+                return updated_node
+
+            for name in updated_node.names:
+                if isinstance(name, cst.ImportAlias) and isinstance(name.name, cst.Name):
+                    import_name = name.name.value
+                    if import_name in (
+                        "urljoin",
+                        "urlparse",
+                        "urlsplit",
+                        "urlunparse",
+                        "urlencode",
+                        "quote",
+                        "unquote",
+                    ):
+                        self.record_change(
+                            description=f"Import {import_name} from urllib.parse instead of requests.compat",
+                            line_number=1,
+                            original=f"from requests.compat import {import_name}",
+                            replacement=f"from urllib.parse import {import_name}",
+                            transform_name=f"compat_{import_name}_fix",
+                        )
+                        return updated_node.with_changes(
+                            module=cst.Attribute(
+                                value=cst.Name("urllib"),
+                                attr=cst.Name("parse"),
+                            )
+                        )
+
+        return updated_node
+
+    def leave_Attribute(
+        self, original_node: cst.Attribute, updated_node: cst.Attribute
+    ) -> cst.Attribute | cst.Name:
+        """Transform requests.packages.urllib3 attribute access."""
+        # Check for requests.packages.urllib3 pattern
+        attr_str = self._get_full_attribute(updated_node)
+
+        if attr_str.startswith("requests.packages.urllib3"):
+            new_attr_str = attr_str.replace("requests.packages.urllib3", "urllib3")
+            self.record_change(
+                description="Access urllib3 directly instead of through requests.packages",
+                line_number=1,
+                original=attr_str,
+                replacement=new_attr_str,
+                transform_name="urllib3_attribute_fix",
+            )
+            return self._build_name_or_attribute_node(new_attr_str)
+
+        return updated_node
+
+    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
+        """Transform requests function calls."""
+        # Check for requests.get/post/put/delete without timeout
+        if isinstance(updated_node.func, cst.Attribute):
+            if (
+                isinstance(updated_node.func.value, cst.Name)
+                and updated_node.func.value.value == "requests"
+            ):
+                method_name = updated_node.func.attr.value
+                if method_name in ("get", "post", "put", "delete", "patch", "head", "options"):
+                    # Check if timeout is specified
+                    has_timeout = any(
+                        isinstance(arg.keyword, cst.Name) and arg.keyword.value == "timeout"
+                        for arg in updated_node.args
+                    )
+                    if not has_timeout:
+                        self.record_change(
+                            description=f"requests.{method_name}() called without explicit timeout",
+                            line_number=1,
+                            original=f"requests.{method_name}(...)",
+                            replacement=f"requests.{method_name}(..., timeout=30)",
+                            transform_name=f"{method_name}_add_explicit_timeout",
+                            confidence=0.7,
+                            notes="Consider adding explicit timeout parameter",
+                        )
+
+        # Check for session method calls without timeout
+        if isinstance(updated_node.func, cst.Attribute):
+            method_name = updated_node.func.attr.value
+            if method_name in (
+                "get",
+                "post",
+                "put",
+                "delete",
+                "patch",
+                "head",
+                "options",
+                "request",
+            ):
+                # Check if this might be a session call (heuristic)
+                has_timeout = any(
+                    isinstance(arg.keyword, cst.Name) and arg.keyword.value == "timeout"
+                    for arg in updated_node.args
+                )
+                if not has_timeout and isinstance(updated_node.func.value, cst.Name):
+                    value_name = updated_node.func.value.value.lower()
+                    if "session" in value_name or value_name in ("s", "sess", "client"):
+                        self.record_change(
+                            description=f"Session.{method_name}() called without explicit timeout",
+                            line_number=1,
+                            original=f"session.{method_name}(...)",
+                            replacement=f"session.{method_name}(..., timeout=30)",
+                            transform_name=f"session_{method_name}_add_timeout",
+                            confidence=0.6,
+                            notes="Consider adding explicit timeout parameter",
+                        )
+
+        return updated_node
+
+    def _get_module_name(self, module: cst.BaseExpression) -> str:
+        """Get the full module name from a Name or Attribute node."""
+        if isinstance(module, cst.Name):
+            return str(module.value)
+        elif isinstance(module, cst.Attribute):
+            return f"{self._get_module_name(module.value)}.{module.attr.value}"
+        return ""
+
+    def _build_module_node(self, module_name: str) -> cst.Name | cst.Attribute:
+        """Build a module node from a dotted name string."""
+        parts = module_name.split(".")
+        if len(parts) == 1:
+            return cst.Name(parts[0])
+
+        result: cst.Name | cst.Attribute = cst.Name(parts[0])
+        for part in parts[1:]:
+            result = cst.Attribute(value=result, attr=cst.Name(part))
+        return result
+
+    def _get_full_attribute(self, node: cst.Attribute) -> str:
+        """Get the full attribute path as a string."""
+        if isinstance(node.value, cst.Name):
+            return f"{node.value.value}.{node.attr.value}"
+        elif isinstance(node.value, cst.Attribute):
+            return f"{self._get_full_attribute(node.value)}.{node.attr.value}"
+        return str(node.attr.value)
+
+    def _build_attribute_node(self, attr_str: str) -> cst.Attribute:
+        """Build an attribute node from a dotted string."""
+        parts = attr_str.split(".")
+        result: cst.Name | cst.Attribute = cst.Name(parts[0])
+        for part in parts[1:]:
+            result = cst.Attribute(value=result, attr=cst.Name(part))
+        # Safe to cast since we always have at least 2 parts for an Attribute
+        assert isinstance(result, cst.Attribute)
+        return result
+
+    def _build_name_or_attribute_node(self, name_str: str) -> cst.Name | cst.Attribute:
+        """Build a Name or Attribute node from a dotted string."""
+        parts = name_str.split(".")
+        if len(parts) == 1:
+            return cst.Name(parts[0])
+        result: cst.Name | cst.Attribute = cst.Name(parts[0])
+        for part in parts[1:]:
+            result = cst.Attribute(value=result, attr=cst.Name(part))
+        return result
+
+
+def transform_requests(source_code: str) -> tuple[str, list]:
+    """Transform Requests library code.
+
+    Args:
+        source_code: The source code to transform
+
+    Returns:
+        Tuple of (transformed_code, list of changes)
+    """
+    try:
+        tree = cst.parse_module(source_code)
+    except cst.ParserSyntaxError:
+        return source_code, []
+
+    transformer = RequestsTransformer()
+    transformer.set_source(source_code)
+
+    try:
+        transformed_tree = tree.visit(transformer)
+        return transformed_tree.code, transformer.changes
+    except Exception:
+        return source_code, []

codeshift/migrator/transforms/sqlalchemy_transformer.py

@@ -0,0 +1,175 @@
+"""SQLAlchemy 1.x to 2.0 transformation using LibCST."""
+
+import libcst as cst
+
+from codeshift.migrator.ast_transforms import BaseTransformer
+
+
+class SQLAlchemyTransformer(BaseTransformer):
+    """Transform SQLAlchemy 1.x code to 2.0."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._needs_select_import = False
+        self._needs_text_import = False
+        self._has_declarative_base_import = False
+
+    def leave_ImportFrom(
+        self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom
+    ) -> cst.ImportFrom | cst.RemovalSentinel:
+        """Transform SQLAlchemy imports."""
+        if original_node.module is None:
+            return updated_node
+
+        module_name = self._get_module_name(original_node.module)
+
+        # Transform declarative_base import
+        if module_name == "sqlalchemy.ext.declarative":
+            if isinstance(updated_node.names, cst.ImportStar):
+                return updated_node
+
+            new_names = []
+            changed = False
+
+            for name in updated_node.names:
+                if isinstance(name, cst.ImportAlias):
+                    if isinstance(name.name, cst.Name) and name.name.value == "declarative_base":
+                        # Change to DeclarativeBase from sqlalchemy.orm
+                        self.record_change(
+                            description="Import DeclarativeBase from sqlalchemy.orm instead of declarative_base",
+                            line_number=1,
+                            original="from sqlalchemy.ext.declarative import declarative_base",
+                            replacement="from sqlalchemy.orm import DeclarativeBase",
+                            transform_name="import_declarative_base",
+                        )
+                        self._has_declarative_base_import = True
+                        # Return updated import from sqlalchemy.orm
+                        return updated_node.with_changes(
+                            module=cst.Attribute(
+                                value=cst.Name("sqlalchemy"),
+                                attr=cst.Name("orm"),
+                            ),
+                            names=[cst.ImportAlias(name=cst.Name("DeclarativeBase"))],
+                        )
+                    else:
+                        new_names.append(name)
+                else:
+                    new_names.append(name)
+
+            if changed and new_names:
+                return updated_node.with_changes(names=new_names)
+
+        # Handle backref import removal
+        if module_name == "sqlalchemy.orm":
+            if isinstance(updated_node.names, cst.ImportStar):
+                return updated_node
+
+            new_names = []
+            changed = False
+
+            for name in updated_node.names:
+                if isinstance(name, cst.ImportAlias):
+                    if isinstance(name.name, cst.Name) and name.name.value == "backref":
+                        self.record_change(
+                            description="Remove backref import (use back_populates instead)",
+                            line_number=1,
+                            original="backref",
+                            replacement="# backref removed, use back_populates",
+                            transform_name="remove_backref_import",
+                        )
+                        changed = True
+                        continue
+                    new_names.append(name)
+                else:
+                    new_names.append(name)
+
+            if changed:
+                if new_names:
+                    return updated_node.with_changes(names=new_names)
+                # If no names left, remove the import
+                return cst.RemovalSentinel.REMOVE
+
+        return updated_node
+
+    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
+        """Transform SQLAlchemy function calls."""
+        # Handle declarative_base() -> class Base(DeclarativeBase): pass
+        # This is complex - we just record the need for change
+        if isinstance(updated_node.func, cst.Name):
+            func_name = updated_node.func.value
+
+            if func_name == "declarative_base":
+                self.record_change(
+                    description="Replace declarative_base() with class Base(DeclarativeBase): pass",
+                    line_number=1,
+                    original="Base = declarative_base()",
+                    replacement="class Base(DeclarativeBase): pass",
+                    transform_name="declarative_base_to_class",
+                    confidence=0.8,
+                    notes="Manual review recommended - create class inheriting from DeclarativeBase",
+                )
+
+        # Handle create_engine future flag
+        if isinstance(updated_node.func, cst.Name) and updated_node.func.value == "create_engine":
+            new_args = []
+            changed = False
+            for arg in updated_node.args:
+                if isinstance(arg.keyword, cst.Name) and arg.keyword.value == "future":
+                    # Remove future=True as it's now default
+                    changed = True
+                    self.record_change(
+                        description="Remove future=True from create_engine (now default)",
+                        line_number=1,
+                        original="create_engine(..., future=True)",
+                        replacement="create_engine(...)",
+                        transform_name="remove_future_flag",
+                    )
+                    continue
+                new_args.append(arg)
+
+            if changed:
+                return updated_node.with_changes(args=new_args)
+
+        return updated_node
+
+    def leave_Attribute(
+        self, original_node: cst.Attribute, updated_node: cst.Attribute
+    ) -> cst.Attribute:
+        """Transform SQLAlchemy attribute accesses."""
+        # Handle method renames: .all() when preceded by query-like calls
+        # This is simplified - would need more context for accurate detection
+        # Note: attr_name = updated_node.attr.value would be used for future transforms
+
+        return updated_node
+
+    def _get_module_name(self, module: cst.BaseExpression) -> str:
+        """Get the full module name from a Name or Attribute node."""
+        if isinstance(module, cst.Name):
+            return str(module.value)
+        elif isinstance(module, cst.Attribute):
+            return f"{self._get_module_name(module.value)}.{module.attr.value}"
+        return ""
+
+
+def transform_sqlalchemy(source_code: str) -> tuple[str, list]:
+    """Transform SQLAlchemy code from 1.x to 2.0.
+
+    Args:
+        source_code: The source code to transform
+
+    Returns:
+        Tuple of (transformed_code, list of changes)
+    """
+    try:
+        tree = cst.parse_module(source_code)
+    except cst.ParserSyntaxError:
+        return source_code, []
+
+    transformer = SQLAlchemyTransformer()
+    transformer.set_source(source_code)
+
+    try:
+        transformed_tree = tree.visit(transformer)
+        return transformed_tree.code, transformer.changes
+    except Exception:
+        return source_code, []

codeshift/scanner/__init__.py

@@ -0,0 +1,6 @@
+"""Scanner module for finding library usage in code."""
+
+from codeshift.scanner.code_scanner import CodeScanner, ImportInfo, UsageInfo
+from codeshift.scanner.dependency_parser import Dependency, DependencyParser
+
+__all__ = ["CodeScanner", "ImportInfo", "UsageInfo", "DependencyParser", "Dependency"]