Python support for Fable 🎉

.gitignore

@@ -201,3 +201,7 @@ docs/tools/FSharp.Formatting.svclog
 .ionide.debug
 *.bak
 project.lock.json
+
+# Python
+.eggs/
+__pycache__/

build.fsx

@@ -170,6 +170,32 @@ let buildLibraryTs() =
     runInDir buildDirTs "npm run tsc -- --init --target es2020 --module es2020 --allowJs"
     runInDir buildDirTs ("npm run tsc -- --outDir ../../" + buildDirJs)
 
+let buildLibraryPy() =
+    let libraryDir = "src/fable-library-py"
+    let projectDir = libraryDir + "/fable"
+    let buildDirPy = "build/fable-library-py"
+
+    cleanDirs [buildDirPy]
+
+    runFableWithArgs projectDir [
+        "--outDir " + buildDirPy </> "fable"
+        "--fableLib " + buildDirPy </> "fable"
+        "--lang Python"
+        "--exclude Fable.Core"
+    ]
+    // Copy *.py from projectDir to buildDir
+    copyDirRecursive libraryDir buildDirPy
+    copyDirNonRecursive (buildDirPy </> "fable/fable-library") (buildDirPy </> "fable")
+    //copyFile (buildDirPy </> "fable/fable-library/*.py") (buildDirPy </> "fable")
+    copyFile (buildDirPy </> "fable/system.text.py") (buildDirPy </> "fable/system_text.py")
+    copyFile (buildDirPy </> "fable/fsharp.core.py") (buildDirPy </> "fable/fsharp_core.py")
+    copyFile (buildDirPy </> "fable/fsharp.collections.py") (buildDirPy </> "fable/fsharp_collections.py")
+    //copyFile (buildDirPy </> "fable/async.py") (buildDirPy </> "fable/async_.py")
+    removeFile (buildDirPy </> "fable/system.text.py")
+
+    runInDir buildDirPy ("python3 --version")
+    runInDir buildDirPy ("python3 ./setup.py develop")
+
 // Like testJs() but doesn't create bundles/packages for fable-standalone & friends
 // Mainly intended for CI
 let testJsFast() =
@@ -368,6 +394,24 @@ let test() =
     if envVarOrNone "APPVEYOR" |> Option.isSome then
         testJsFast()
 
+let testPython() =
+    buildLibraryIfNotExists() // NOTE: fable-library-py needs to be built seperatly.
+
+    let projectDir = "tests/Python"
+    let buildDir = "build/tests/Python"
+
+    cleanDirs [buildDir]
+    runInDir projectDir "dotnet test"
+    runFableWithArgs projectDir [
+        "--outDir " + buildDir
+        "--exclude Fable.Core"
+        "--lang Python"
+    ]
+
+    runInDir buildDir "touch __init__.py" // So relative imports works.
+    runInDir buildDir "pytest"
+
+
 let buildLocalPackageWith pkgDir pkgCommand fsproj action =
     let version = "3.0.0-local-build-" + DateTime.Now.ToString("yyyyMMdd-HHmm")
     action version
@@ -525,9 +569,16 @@ match argsLower with
 | "test-react"::_ -> testReact()
 | "test-compiler"::_ -> testCompiler()
 | "test-integration"::_ -> testIntegration()
+| "test-py"::_ -> testPython()
 | "quicktest"::_ ->
     buildLibraryIfNotExists()
     run "dotnet watch -p src/Fable.Cli run -- watch --cwd ../quicktest --exclude Fable.Core --noCache --runScript"
+| "quicktest-py"::_ ->
+    buildLibraryIfNotExists()
+    run "dotnet watch -p src/Fable.Cli run -- watch --cwd ../quicktest --lang Python --exclude Fable.Core --noCache"
+| "jupyter" :: _ ->
+    buildLibraryIfNotExists ()
+    run "dotnet watch -p src/Fable.Cli run -- watch --cwd ../Fable.Jupyter/src --lang Python --exclude Fable.Core --noCache 2>> /Users/dbrattli/Developer/GitHub/Fable.Jupyter/src/fable.out"
 
 | "run"::_ ->
     buildLibraryIfNotExists()
@@ -546,6 +597,7 @@ match argsLower with
 | ("watch-library")::_ -> watchLibrary()
 | ("fable-library"|"library")::_ -> buildLibrary()
 | ("fable-library-ts"|"library-ts")::_ -> buildLibraryTs()
+| ("fable-library-py"|"library-py")::_ -> buildLibraryPy()
 | ("fable-compiler-js"|"compiler-js")::_ -> buildCompilerJs(minify)
 | ("fable-standalone"|"standalone")::_ -> buildStandalone {|minify=minify; watch=false|}
 | "watch-standalone"::_ -> buildStandalone {|minify=false; watch=true|}

src/Fable.AST/Plugins.fs

@@ -12,6 +12,7 @@ type Verbosity =
 type Language =
     | JavaScript
     | TypeScript
+    | Python
     | Php
 
 type CompilerOptions =

src/Fable.Cli/Entry.fs

@@ -75,8 +75,8 @@ Arguments:
   --sourceMapsRoot  Set the value of the `sourceRoot` property in generated source maps
 
   --optimize        Compile with optimized F# AST (experimental)
-  --lang|--language Compile to JavaScript (default), "TypeScript" or "Php".
-                    Support for TypeScript and Php is experimental.
+  --lang|--language Compile to JavaScript (default), TypeScript, Php or Python.
+                    Support for TypeScript, Php and Python is experimental.
 
   Environment variables:
    DOTNET_USE_POLLING_FILE_WATCHER
@@ -92,6 +92,7 @@ let defaultFileExt language args =
         | None -> CompilerOptionsHelper.DefaultExtension
     match language with
     | TypeScript -> Path.replaceExtension ".ts" fileExt
+    | Python -> Path.replaceExtension ".py" fileExt
     | Php -> ".php"
     | _ -> fileExt
 
@@ -102,6 +103,7 @@ let argLanguage args =
     |> Option.defaultValue "JavaScript"
     |> (function
     | "ts" | "typescript" | "TypeScript" -> TypeScript
+    | "py" | "python" | "Python" -> Python
     | "php" | "Php" | "PHP" -> Php
     | _ -> JavaScript)
 

src/Fable.Cli/Main.fs

@@ -166,6 +166,29 @@ module private Util =
         member _.SourceMap =
             mapGenerator.Force().toJSON()
 
+    type PythonFileWriter(sourcePath: string, targetPath: string, cliArgs: CliArgs, dedupTargetDir) =
+        let fileExt = ".py"
+        let targetDir = Path.GetDirectoryName(targetPath)
+        // PEP8: Modules should have short, all-lowercase names
+        let fileName = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(targetPath))
+        let fileName = Naming.applyCaseRule Core.CaseRules.SnakeCase fileName
+        // Note that Python modules cannot contain dots or it will be impossible to import them
+        let targetPath = Path.Combine(targetDir, fileName + fileExt)
+
+        let stream = new IO.StreamWriter(targetPath)
+
+        interface PythonPrinter.Writer with
+            member _.Write(str) =
+                stream.WriteAsync(str) |> Async.AwaitTask
+            member _.MakeImportPath(path) =
+                let projDir = IO.Path.GetDirectoryName(cliArgs.ProjectFile)
+                let path = Imports.getImportPath dedupTargetDir sourcePath targetPath projDir cliArgs.OutDir path
+                if path.EndsWith(".fs") then
+                    let isInFableHiddenDir = Path.Combine(targetDir, path) |> Naming.isInFableHiddenDir
+                    changeFsExtension isInFableHiddenDir path "" // Remove file extension
+                else path
+            member _.Dispose() = stream.Dispose()
+
     let compileFile isRecompile (cliArgs: CliArgs) dedupTargetDir (com: CompilerImpl) = async {
         try
             let fable =
@@ -194,12 +217,18 @@ module private Util =
 
             | Php ->
                 let php = fable |> Fable2Php.transformFile com
-                
+
                 use w = new IO.StreamWriter(outPath)
                 let ctx = PhpPrinter.Output.Writer.create w
                 PhpPrinter.Output.writeFile ctx php
                 w.Flush()
 
+            | Python ->
+                let python = fable |> Fable2Python.Compiler.transformFile com
+                let map = { new PythonPrinter.SourceMapGenerator with
+                                member _.AddMapping(_,_,_,_,_) = () }
+                let writer = new PythonFileWriter(com.CurrentFile, outPath, cliArgs, dedupTargetDir)
+                do! PythonPrinter.run writer map python
 
             "Compiled " + File.getRelativePathFromCwd com.CurrentFile
             |> Log.verboseOrIf isRecompile

src/Fable.Core/Fable.Core.PY.fs

@@ -0,0 +1,17 @@
+namespace Fable.Import
+
+namespace Fable.Core
+
+open System
+open System.Text.RegularExpressions
+
+module PY =
+    type [<AllowNullLiteral>] ArrayConstructor =
+        [<Emit "$0([None]*$1...)">] abstract Create: size: int -> 'T[]
+        abstract isArray: arg: obj -> bool
+        abstract from: arg: obj -> 'T[]
+
+    [<RequireQualifiedAccess>]
+    module Constructors =
+
+        let [<Emit("list")>] Array: ArrayConstructor = pyNative

src/Fable.Core/Fable.Core.PyInterop.fs

@@ -0,0 +1,76 @@
+module Fable.Core.PyInterop
+
+open System
+open Fable.Core
+
+/// Has same effect as `unbox` (dynamic casting erased in compiled Python code).
+/// The casted type can be defined on the call site: `!!myObj?bar(5): float`
+let (!!) x: 'T = pyNative
+
+/// Implicit cast for erased unions (U2, U3...)
+let inline (!^) (x:^t1) : ^t2 = ((^t1 or ^t2) : (static member op_ErasedCast : ^t1 -> ^t2) x)
+
+/// Dynamically access a property of an arbitrary object.
+/// `myObj?propA` in Python becomes `myObj.propA`
+/// `myObj?(propA)` in Python becomes `myObj[propA]`
+let (?) (o: obj) (prop: obj): 'a = pyNative
+
+/// Dynamically assign a value to a property of an arbitrary object.
+/// `myObj?propA <- 5` in Python becomes `myObj.propA = 5`
+/// `myObj?(propA) <- 5` in Python becomes `myObj[propA] = 5`
+let (?<-) (o: obj) (prop: obj) (v: obj): unit = pyNative
+
+/// Destructure and apply a tuple to an arbitrary value.
+/// E.g. `myFn $ (arg1, arg2)` in Python becomes `myFn(arg1, arg2)`
+let ($) (callee: obj) (args: obj): 'a = pyNative
+
+/// Upcast the right operand to obj (and uncurry it if it's a function) and create a key-value tuple.
+/// Mostly convenient when used with `createObj`.
+/// E.g. `createObj [ "a" ==> 5 ]` in Python becomes `{ a: 5 }`
+let (==>) (key: string) (v: obj): string*obj = pyNative
+
+/// Destructure a tuple of arguments and applies to literal Python code as with EmitAttribute.
+/// E.g. `emitPyExpr (arg1, arg2) "$0 + $1"` in Python becomes `arg1 + arg2`
+let emitPyExpr<'T> (args: obj) (pyCode: string): 'T = pyNative
+
+/// Same as emitPyExpr but intended for Python code that must appear in a statement position
+/// E.g. `emitPyExpr aValue "while($0 < 5) doSomething()"`
+let emitPyStatement<'T> (args: obj) (pyCode: string): 'T = pyNative
+
+/// Create a literal Python object from a collection of key-value tuples.
+/// E.g. `createObj [ "a" ==> 5 ]` in Python becomes `{ a: 5 }`
+let createObj (fields: #seq<string*obj>): obj = pyNative
+
+/// Create a literal Python object from a collection of union constructors.
+/// E.g. `keyValueList CaseRules.LowerFirst [ MyUnion 4 ]` in Python becomes `{ myUnion: 4 }`
+let keyValueList (caseRule: CaseRules) (li: 'T seq): obj = pyNative
+
+/// Create a literal Py object from a mutator lambda. Normally used when
+/// the options interface has too many fields to be represented with a Pojo record.
+/// E.g. `pyOptions<MyOpt> (fun o -> o.foo <- 5)` in Python becomes `{ "foo": 5 }`
+let pyOptions<'T> (f: 'T->unit): 'T = pyNative
+
+/// Create an empty Python object: {}
+let createEmpty<'T> : 'T = pyNative
+
+[<Emit("type($0)")>]
+let pyTypeof (x: obj): string = pyNative
+
+[<Emit("isinstance($0, $1)")>]
+let pyInstanceof (x: obj) (cons: obj): bool = pyNative
+
+/// Works like `ImportAttribute` (same semantics as ES6 imports).
+/// You can use "*" or "default" selectors.
+let import<'T> (selector: string) (path: string):'T = pyNative
+
+/// F#: let myMember = importMember<string> "myModule"
+/// Py: from my_module import my_member
+/// Note the import must be immediately assigned to a value in a let binding
+let importMember<'T> (path: string):'T = pyNative
+
+/// F#: let myLib = importAll<obj> "myLib"
+/// Py: from my_lib import *
+let importAll<'T> (path: string):'T = pyNative
+
+/// Imports a file only for its side effects
+let importSideEffects (path: string): unit = pyNative

src/Fable.Core/Fable.Core.Util.fs

@@ -9,6 +9,7 @@ module Util =
         try failwith "JS only" // try/catch is just for padding so it doesn't get optimized
         with ex -> raise ex
 
+    let inline pyNative<'T> : 'T = jsNative
     let inline phpNative<'T> : 'T = jsNative
 
 module Experimental =

src/Fable.Core/Fable.Core.fsproj

@@ -12,8 +12,10 @@
     <Compile Include="Fable.Core.Types.fs" />
     <Compile Include="Fable.Core.Util.fs" />
     <Compile Include="Fable.Core.JS.fs" />
+    <Compile Include="Fable.Core.PY.fs" />
     <Compile Include="Fable.Core.JsInterop.fs" />
     <Compile Include="Fable.Core.PhpInterop.fs" />
+    <Compile Include="Fable.Core.PyInterop.fs" />
     <Compile Include="Fable.Core.Extensions.fs" />
   </ItemGroup>
   <ItemGroup>

src/Fable.Transforms/Fable.Transforms.fsproj

@@ -21,6 +21,9 @@
     <!-- <Compile Include="Fable2Extended.fs" /> -->
     <Compile Include="Fable2Babel.fs" />
     <Compile Include="BabelPrinter.fs" />
+    <Compile Include="Python/Python.fs" />
+    <Compile Include="Python/Fable2Python.fs" />
+    <Compile Include="Python/PythonPrinter.fs" />
     <Compile Include="Php/Php.fs" />
     <Compile Include="Php/Fable2Php.fs" />
     <Compile Include="Php/PhpPrinter.fs" />

src/Fable.Transforms/Global/Babel.fs

@@ -398,7 +398,6 @@ type ImportSpecifier =
     /// A namespace import specifier, e.g., * as foo in import * as foo from "mod".
     | ImportNamespaceSpecifier of local: Identifier
 
-
 /// An exported variable binding, e.g., {foo} in export {foo} or {bar as foo} in export {bar as foo}.
 /// The exported field refers to the name exported in the module.
 /// The local field refers to the binding into the local module scope.
@@ -409,7 +408,6 @@ type ExportSpecifier =
     | ExportSpecifier of local: Identifier * exported: Identifier
 
 // Type Annotations
-
 type TypeAnnotationInfo =
     | AnyTypeAnnotation
     | VoidTypeAnnotation

src/Fable.Transforms/Global/Compiler.fs

@@ -14,6 +14,7 @@ type CompilerOptionsHelper =
                        ?clampByteArrays) =
         let define = defaultArg define []
         let isDebug = List.contains "DEBUG" define
+
         { new CompilerOptions with
               member _.Define = define
               member _.DebugMode = isDebug