anchor.diff:                      decls
   
           | Fable.ClassDeclaration decl ->
  -            // printfn "Class: %A" decl
  +            printfn "Class: %A" decl
               let ent = decl.Entity
   
               let classMembers =
  
positive.code:         let entRef = PY.Replacements.pyConstructor com ent
          com.TransformAsExpr(ctx, entRef)
  
  module Helpers =
      let index = (Seq.initInfinite id).GetEnumerator()
  
      let getUniqueIdentifier (name: string): Identifier =
          do index.MoveNext() |> ignore
          let idx = index.Current.ToString()
          let deliminator =
              if Char.IsLower name.[0] then "_" else ""
          Identifier($"{name}{deliminator}{idx}")
  
      /// Replaces all '$' and `.`with '_'
      let clean (name: string) =
          // printfn $"clean: {name}"
          match name with
          | "Infinity" -> "float('inf')"
          | _ ->
              (name, Naming.NoMemberPart) ||> Naming.sanitizeIdent (fun _ -> false)
  
      /// Normalize Fable import to be relative to outDir.
      /// TODO: decide if nugets referencing fable_library should be relative or absolute. Currently absolute.
      let normalizeModulePath (com: IPythonCompiler) modulePath =
          //printfn "---"
          //printfn "ModulePath: %s" modulePath
          let fileDir = Path.GetDirectoryName modulePath
          //printfn "dir: %A" dir
          let projDir = Path.GetDirectoryName(com.ProjectFile)
          let modulePathname =
              match fileDir with
              | "" | "." -> fileDir
              | _ ->
                  IO.Path.GetFullPath(Path.Combine(Path.GetDirectoryName(com.CurrentFile), fileDir))
                  |> Path.normalizePath
          let outDir = com.OutputDir |> Option.defaultValue projDir
  
          //printfn "modulePathname: %A" modulePathname
          //printfn $"OutputDir: {com.OutputDir}"
          //printfn $"LibraryDir: {com.LibraryDir}"
  
          let commonPrefix = Path.getCommonBaseDir [ modulePathname; com.ProjectFile ]
          //printfn "CommonPrefix: %A" commonPrefix
          let relativePath =
              // We know all modules will be placed somewhere in outDir or in a subdir below
              modulePathname
                  .Replace(outDir, String.Empty)   // Remove outDir from module path
                  .Replace(projDir, String.Empty)  // Remove projectDir from module path
  
          let relativePath =
              if commonPrefix.Length > 0 then
                  // Remove any common prefix between module path and project file
                  relativePath.Replace(commonPrefix, String.Empty)
              else
                  relativePath
  
          // Cleanup path
          let relativePath = relativePath.Replace("//", "/")
          let relativePath =
              if relativePath.StartsWith("/") then
                  $"./{relativePath.[1..]}"
              else
                  relativePath
  
          match fileDir, relativePath with
          | "", _ -> fileDir
          | _, "" -> "."
          | _ ->
              relativePath
  
      /// This function is a bit complex. Python imports are difficult.
      /// - Python libraries should use relative imports.
      /// - Python program must use absolute imports
      /// - Python cannot import outside the sub-dirs of the main Program (without setting PYTHONPATH)
      /// In addition when compiling a Fable project as a program, all dependencies will also be compiled as a program, even if they are
      /// a library (fable-modules). Thus we need to handle a lot of corner cases.
      ///
      ///  - OutDir
      ///    - fable_modules
      ///      - fable_library (may import itself)
      ///      - nuget_library (may import fable library)
      ///    - referenced_project
      ///      - util.py
      ///    - subdir
      ///      - misc.py
      ///    - program.py
      ///
      let rewriteFableImport (com: IPythonCompiler) (modulePath: string) =
          let commonPrefix = Path.getCommonBaseDir [ com.ProjectFile; com.CurrentFile ]
          let normalizedPath = normalizeModulePath com modulePath
          let projDir = Path.GetDirectoryName(com.ProjectFile)
          let fileDir = Path.GetDirectoryName(com.CurrentFile)
  
          /// True if we import something in a project reference
          let isProjectReference =
              let notInProjectDir = (not (projDir.EndsWith(commonPrefix)))
              // printfn "notInProjectDir: %A" notInProjectDir
              if normalizedPath.Length > 1 then
                  notInProjectDir
                  // import exists in file dir
                  && IO.Directory.Exists(Path.Combine(fileDir, normalizedPath))
                  // import exists in project dir
                  && (not (IO.Directory.Exists(Path.Combine(projDir, normalizedPath))))
              else
                  notInProjectDir
  
          //printfn "Prefix: %A" (commonPrefix, isProjectReference)
          let relative =
              match com.OutputType, isProjectReference with
              // If the compiled file is not in a sub-dir underneath the project file (e.g project reference) then use
              // relative imports if and only if the normalizedPath exists within that referenced project. This is e.g the
              // case when a test project references the library it's testing and the library wants to import own files
              | _, true  -> true
              | OutputType.Exe, _ -> false
              | _ -> true
  
          // printfn $"Relative: {relative}, {com.ProjectFile}, {com.CurrentFile}"
          // printfn $"OutputDir: {com.OutputDir}  "
          // printfn $"LibraryDir: {com.LibraryDir}"
          //printfn "normalizedPath: %A" (relative, normalizedPath)
  
          let moduleName =
              let lower =
                  let fileName = Path.GetFileNameWithoutExtension(modulePath)
                  match fileName with
                  | "" when modulePath.StartsWith(".") -> modulePath.[1..]
                  | _ -> fileName |> Naming.applyCaseRule CaseRules.SnakeCase
              (lower, Naming.NoMemberPart) ||> Naming.sanitizeIdent (fun _ -> false)
  
          let path =
              match relative, normalizedPath with
              | _, "" -> ""
              | true, "." -> "."
              | true, path when path.Contains("fable_modules") ->
                  path.Replace("./", "").Replace("./", ".").Replace("/", ".") + "."
              | true, path ->
                  //printfn "Path: %A" path
                  path.Replace("../", "..").Replace("./", ".").Replace("/", ".") + "."
              | false, "." -> ""
              | false, path ->
                  path.Replace("./", "").Replace("/", ".") + "."
  
          let moduleImport = $"{path}{moduleName}"
          //printfn "ModuleImport: %s" moduleImport
          moduleImport
  
      let unzipArgs (args: (Expression * Statement list) list): Expression list * Python.Statement list =
          let stmts = args |> List.map snd |> List.collect id
          let args = args |> List.map fst
          args, stmts
  
      /// A few statements in the generated Python AST do not produce any effect,
      /// and should not be printet.
      let isProductiveStatement (stmt: Python.Statement) =
          let rec hasNoSideEffects (e: Expression) =
              // printfn $"hasNoSideEffects: {e}"
  
              match e with
              | Constant _ -> true
              | Dict { Keys = keys } -> keys.IsEmpty // Empty object
              | Name _ -> true // E.g `void 0` is translated to Name(None)
              | _ -> false
  
          match stmt with
          // Remove `self = self`
          | Statement.Assign { Targets = [ Name {Id=Identifier(x)}]; Value = Name {Id=Identifier(y)}} when x = y -> None
          | Expr expr ->
              if hasNoSideEffects expr.Value then
                  None
              else
                  Some stmt
          | _ -> Some stmt
  
  
  // TODO: This is too implementation-dependent, ideally move it to Replacements
  module Reflection =
      open Lib
  
      let private libReflectionCall (com: IPythonCompiler) ctx r memberName args =
          libCall com ctx r "reflection" (memberName + "_type") args
  
      let private fableModuleHint (com: IPythonCompiler) ctx moduleName memberName args =
          let expr = com.TransformImport(ctx, memberName, getLibPath com moduleName)
          match args with
          | [] -> expr
          | [arg] -> Expression.subscript(expr, arg)
          | args -> Expression.subscript(expr, Expression.tuple(args))
  
      let private pythonModuleHint (com: IPythonCompiler) ctx moduleName memberName args =
          let expr = com.TransformImport(ctx, memberName, moduleName)
          match memberName, args with
          | _, [] -> expr
          | _, [arg] -> Expression.subscript(expr, arg)
          | "Callable", args ->
              let returnType = List.last args
              let args =
                  args
                  |> List.removeAt (args.Length - 1)
                  |> List.choose (function
                      | Expression.Name({ Id=Identifier "None" }) when args.Length = 2 -> None
                      | x -> Some x)
                  |> Expression.list
              Expression.subscript(expr, Expression.tuple([args; returnType]))
          | _, args ->
              Expression.subscript(expr, Expression.tuple(args))
  
      let private typingHint (com: IPythonCompiler) ctx memberName args =
          pythonModuleHint com ctx "typing"  memberName args
  
      let private transformRecordReflectionInfo com ctx r (ent: Fable.Entity) generics =
          // TODO: Refactor these three bindings to reuse in transformUnionReflectionInfo
  
negative.code:         declareType com ctx ent entName args body baseExpr classMembers
  
      let transformClassWithImplicitConstructor (com: IPythonCompiler) ctx (classDecl: Fable.ClassDecl) classMembers (cons: Fable.MemberDecl) =
          printfn "transformClassWithImplicitConstructor: %A" classDecl
          let classEnt = com.GetEntity(classDecl.Entity)
          let classIdent = Expression.name(com.GetIdentifier(ctx, classDecl.Name))
          let consArgs, consBody =
  