    -- | Code generation for sequential Python.
    module Futhark.CodeGen.Backends.SequentialPython
      ( compileProg,
      )
    where

    import Control.Monad
    import Data.Text qualified as T
    import Futhark.CodeGen.Backends.GenericPython qualified as GenericPython
    import Futhark.CodeGen.Backends.GenericPython.AST
    import Futhark.CodeGen.ImpCode.Sequential qualified as Imp
    import Futhark.CodeGen.ImpGen.Sequential qualified as ImpGen
    import Futhark.IR.SeqMem
    import Futhark.MonadFreshNames

    -- | Compile the program to Python.
    compileProg ::
      (MonadFreshNames m) =>
      GenericPython.CompilerMode ->
      String ->
      Prog SeqMem ->
      m (ImpGen.Warnings, T.Text)
    compileProg :: forall (m :: * -> *).
    MonadFreshNames m =>
    CompilerMode -> String -> Prog SeqMem -> m (Warnings, Text)
    compileProg CompilerMode
    mode String
    class_name =
      Prog SeqMem -> m (Warnings, Program)
    forall (m :: * -> *).
    MonadFreshNames m =>
    Prog SeqMem -> m (Warnings, Program)
    ImpGen.compileProg
        (Prog SeqMem -> m (Warnings, Program))
    -> ((Warnings, Program) -> m (Warnings, Text))
    -> Prog SeqMem
    -> m (Warnings, Text)
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (Program -> m Text) -> (Warnings, Program) -> m (Warnings, Text)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> (Warnings, a) -> f (Warnings, b)
    traverse
          ( CompilerMode
    -> String
    -> Constructor
    -> [PyStmt]
    -> [PyStmt]
    -> Operations Sequential ()
    -> ()
    -> [PyStmt]
    -> [Option]
    -> Program
    -> m Text
    forall (m :: * -> *) op s.
    MonadFreshNames m =>
    CompilerMode
    -> String
    -> Constructor
    -> [PyStmt]
    -> [PyStmt]
    -> Operations op s
    -> s
    -> [PyStmt]
    -> [Option]
    -> Definitions op
    -> m Text
    GenericPython.compileProg
              CompilerMode
    mode
              String
    class_name
              Constructor
    GenericPython.emptyConstructor
              [PyStmt]
    imports
              [PyStmt]
    forall {a}. [a]
    defines
              Operations Sequential ()
    operations
              ()
              []
              []
          )
      where
        imports :: [PyStmt]
    imports =
          [ String -> Maybe String -> PyStmt
    Import String
    "sys" Maybe String
    forall a. Maybe a
    Nothing,
            String -> Maybe String -> PyStmt
    Import String
    "numpy" (Maybe String -> PyStmt) -> Maybe String -> PyStmt
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe String
    forall a. a -> Maybe a
    Just String
    "np",
            String -> Maybe String -> PyStmt
    Import String
    "ctypes" (Maybe String -> PyStmt) -> Maybe String -> PyStmt
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe String
    forall a. a -> Maybe a
    Just String
    "ct",
            String -> Maybe String -> PyStmt
    Import String
    "time" Maybe String
    forall a. Maybe a
    Nothing
          ]
        defines :: [a]
    defines = []
        operations :: GenericPython.Operations Imp.Sequential ()
        operations :: Operations Sequential ()
    operations =
          Operations Sequential ()
    forall op s. Operations op s
    GenericPython.defaultOperations
            { GenericPython.opsCompiler = const $ pure ()
            }