{- This file was auto-generated from tensorflow/core/protobuf/debug.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, MultiParamTypeClasses, FlexibleContexts,
  FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude
  #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
module Proto.Tensorflow.Core.Protobuf.Debug where
import qualified Data.ProtoLens.Reexport.Prelude as Prelude
import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int
import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word
import qualified Data.ProtoLens.Reexport.Data.ProtoLens
       as Data.ProtoLens
import qualified
       Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum
       as Data.ProtoLens.Message.Enum
import qualified Data.ProtoLens.Reexport.Lens.Family2
       as Lens.Family2
import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked
       as Lens.Family2.Unchecked
import qualified Data.ProtoLens.Reexport.Data.Default.Class
       as Data.Default.Class
import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text
import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map
import qualified Data.ProtoLens.Reexport.Data.ByteString
       as Data.ByteString
import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels

data DebugOptions = DebugOptions{_DebugOptions'debugTensorWatchOpts
                                 :: ![DebugTensorWatch],
                                 _DebugOptions'globalStep :: !Data.Int.Int64}
                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ [DebugTensorWatch], b ~ [DebugTensorWatch],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "debugTensorWatchOpts" f DebugOptions
           DebugOptions
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugOptions'debugTensorWatchOpts
                 (\ x__ y__ -> x__{_DebugOptions'debugTensorWatchOpts = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "globalStep" f DebugOptions DebugOptions a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugOptions'globalStep
                 (\ x__ y__ -> x__{_DebugOptions'globalStep = y__}))
              Prelude.id

instance Data.Default.Class.Default DebugOptions where
        def
          = DebugOptions{_DebugOptions'debugTensorWatchOpts = [],
                         _DebugOptions'globalStep = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message DebugOptions where
        descriptor
          = let debugTensorWatchOpts__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "debug_tensor_watch_opts"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor DebugTensorWatch)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         debugTensorWatchOpts)
                      :: Data.ProtoLens.FieldDescriptor DebugOptions
                globalStep__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "global_step"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional globalStep)
                      :: Data.ProtoLens.FieldDescriptor DebugOptions
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.DebugOptions")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 4, debugTensorWatchOpts__field_descriptor),
                    (Data.ProtoLens.Tag 10, globalStep__field_descriptor)])
                (Data.Map.fromList
                   [("debug_tensor_watch_opts",
                     debugTensorWatchOpts__field_descriptor),
                    ("global_step", globalStep__field_descriptor)])

data DebugTensorWatch = DebugTensorWatch{_DebugTensorWatch'nodeName
                                         :: !Data.Text.Text,
                                         _DebugTensorWatch'outputSlot :: !Data.Int.Int32,
                                         _DebugTensorWatch'debugOps :: ![Data.Text.Text],
                                         _DebugTensorWatch'debugUrls :: ![Data.Text.Text],
                                         _DebugTensorWatch'tolerateDebugOpCreationFailures ::
                                         !Prelude.Bool}
                      deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "nodeName" f DebugTensorWatch DebugTensorWatch
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugTensorWatch'nodeName
                 (\ x__ y__ -> x__{_DebugTensorWatch'nodeName = y__}))
              Prelude.id

instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "outputSlot" f DebugTensorWatch
           DebugTensorWatch
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugTensorWatch'outputSlot
                 (\ x__ y__ -> x__{_DebugTensorWatch'outputSlot = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "debugOps" f DebugTensorWatch DebugTensorWatch
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugTensorWatch'debugOps
                 (\ x__ y__ -> x__{_DebugTensorWatch'debugOps = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "debugUrls" f DebugTensorWatch DebugTensorWatch
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebugTensorWatch'debugUrls
                 (\ x__ y__ -> x__{_DebugTensorWatch'debugUrls = y__}))
              Prelude.id

instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) =>
         Lens.Labels.HasLens "tolerateDebugOpCreationFailures" f
           DebugTensorWatch
           DebugTensorWatch
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _DebugTensorWatch'tolerateDebugOpCreationFailures
                 (\ x__ y__ ->
                    x__{_DebugTensorWatch'tolerateDebugOpCreationFailures = y__}))
              Prelude.id

instance Data.Default.Class.Default DebugTensorWatch where
        def
          = DebugTensorWatch{_DebugTensorWatch'nodeName =
                               Data.ProtoLens.fieldDefault,
                             _DebugTensorWatch'outputSlot = Data.ProtoLens.fieldDefault,
                             _DebugTensorWatch'debugOps = [], _DebugTensorWatch'debugUrls = [],
                             _DebugTensorWatch'tolerateDebugOpCreationFailures =
                               Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message DebugTensorWatch where
        descriptor
          = let nodeName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "node_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional nodeName)
                      :: Data.ProtoLens.FieldDescriptor DebugTensorWatch
                outputSlot__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "output_slot"
                      (Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional outputSlot)
                      :: Data.ProtoLens.FieldDescriptor DebugTensorWatch
                debugOps__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "debug_ops"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked debugOps)
                      :: Data.ProtoLens.FieldDescriptor DebugTensorWatch
                debugUrls__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "debug_urls"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked debugUrls)
                      :: Data.ProtoLens.FieldDescriptor DebugTensorWatch
                tolerateDebugOpCreationFailures__field_descriptor
                  = Data.ProtoLens.FieldDescriptor
                      "tolerate_debug_op_creation_failures"
                      (Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         tolerateDebugOpCreationFailures)
                      :: Data.ProtoLens.FieldDescriptor DebugTensorWatch
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.DebugTensorWatch")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, nodeName__field_descriptor),
                    (Data.ProtoLens.Tag 2, outputSlot__field_descriptor),
                    (Data.ProtoLens.Tag 3, debugOps__field_descriptor),
                    (Data.ProtoLens.Tag 4, debugUrls__field_descriptor),
                    (Data.ProtoLens.Tag 5,
                     tolerateDebugOpCreationFailures__field_descriptor)])
                (Data.Map.fromList
                   [("node_name", nodeName__field_descriptor),
                    ("output_slot", outputSlot__field_descriptor),
                    ("debug_ops", debugOps__field_descriptor),
                    ("debug_urls", debugUrls__field_descriptor),
                    ("tolerate_debug_op_creation_failures",
                     tolerateDebugOpCreationFailures__field_descriptor)])

data DebuggedSourceFile = DebuggedSourceFile{_DebuggedSourceFile'host
                                             :: !Data.Text.Text,
                                             _DebuggedSourceFile'filePath :: !Data.Text.Text,
                                             _DebuggedSourceFile'lastModified :: !Data.Int.Int64,
                                             _DebuggedSourceFile'bytes :: !Data.Int.Int64,
                                             _DebuggedSourceFile'lines :: ![Data.Text.Text]}
                        deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "host" f DebuggedSourceFile DebuggedSourceFile
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFile'host
                 (\ x__ y__ -> x__{_DebuggedSourceFile'host = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "filePath" f DebuggedSourceFile
           DebuggedSourceFile
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFile'filePath
                 (\ x__ y__ -> x__{_DebuggedSourceFile'filePath = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "lastModified" f DebuggedSourceFile
           DebuggedSourceFile
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFile'lastModified
                 (\ x__ y__ -> x__{_DebuggedSourceFile'lastModified = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "bytes" f DebuggedSourceFile DebuggedSourceFile
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFile'bytes
                 (\ x__ y__ -> x__{_DebuggedSourceFile'bytes = y__}))
              Prelude.id

instance (a ~ [Data.Text.Text], b ~ [Data.Text.Text],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "lines" f DebuggedSourceFile DebuggedSourceFile
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFile'lines
                 (\ x__ y__ -> x__{_DebuggedSourceFile'lines = y__}))
              Prelude.id

instance Data.Default.Class.Default DebuggedSourceFile where
        def
          = DebuggedSourceFile{_DebuggedSourceFile'host =
                                 Data.ProtoLens.fieldDefault,
                               _DebuggedSourceFile'filePath = Data.ProtoLens.fieldDefault,
                               _DebuggedSourceFile'lastModified = Data.ProtoLens.fieldDefault,
                               _DebuggedSourceFile'bytes = Data.ProtoLens.fieldDefault,
                               _DebuggedSourceFile'lines = []}

instance Data.ProtoLens.Message DebuggedSourceFile where
        descriptor
          = let host__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "host"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional host)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFile
                filePath__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "file_path"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional filePath)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFile
                lastModified__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "last_modified"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional lastModified)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFile
                bytes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "bytes"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional bytes)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFile
                lines__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "lines"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked lines)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFile
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.DebuggedSourceFile")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, host__field_descriptor),
                    (Data.ProtoLens.Tag 2, filePath__field_descriptor),
                    (Data.ProtoLens.Tag 3, lastModified__field_descriptor),
                    (Data.ProtoLens.Tag 4, bytes__field_descriptor),
                    (Data.ProtoLens.Tag 5, lines__field_descriptor)])
                (Data.Map.fromList
                   [("host", host__field_descriptor),
                    ("file_path", filePath__field_descriptor),
                    ("last_modified", lastModified__field_descriptor),
                    ("bytes", bytes__field_descriptor),
                    ("lines", lines__field_descriptor)])

data DebuggedSourceFiles = DebuggedSourceFiles{_DebuggedSourceFiles'sourceFiles
                                               :: ![DebuggedSourceFile]}
                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ [DebuggedSourceFile], b ~ [DebuggedSourceFile],
          Prelude.Functor f) =>
         Lens.Labels.HasLens "sourceFiles" f DebuggedSourceFiles
           DebuggedSourceFiles
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _DebuggedSourceFiles'sourceFiles
                 (\ x__ y__ -> x__{_DebuggedSourceFiles'sourceFiles = y__}))
              Prelude.id

instance Data.Default.Class.Default DebuggedSourceFiles where
        def = DebuggedSourceFiles{_DebuggedSourceFiles'sourceFiles = []}

instance Data.ProtoLens.Message DebuggedSourceFiles where
        descriptor
          = let sourceFiles__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "source_files"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor DebuggedSourceFile)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked sourceFiles)
                      :: Data.ProtoLens.FieldDescriptor DebuggedSourceFiles
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.DebuggedSourceFiles")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, sourceFiles__field_descriptor)])
                (Data.Map.fromList
                   [("source_files", sourceFiles__field_descriptor)])

bytes ::
      forall f s t a b . (Lens.Labels.HasLens "bytes" f s t a b) =>
        Lens.Family2.LensLike f s t a b
bytes
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "bytes")

debugOps ::
         forall f s t a b . (Lens.Labels.HasLens "debugOps" f s t a b) =>
           Lens.Family2.LensLike f s t a b
debugOps
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "debugOps")

debugTensorWatchOpts ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "debugTensorWatchOpts" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
debugTensorWatchOpts
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "debugTensorWatchOpts")

debugUrls ::
          forall f s t a b . (Lens.Labels.HasLens "debugUrls" f s t a b) =>
            Lens.Family2.LensLike f s t a b
debugUrls
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "debugUrls")

filePath ::
         forall f s t a b . (Lens.Labels.HasLens "filePath" f s t a b) =>
           Lens.Family2.LensLike f s t a b
filePath
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "filePath")

globalStep ::
           forall f s t a b . (Lens.Labels.HasLens "globalStep" f s t a b) =>
             Lens.Family2.LensLike f s t a b
globalStep
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "globalStep")

host ::
     forall f s t a b . (Lens.Labels.HasLens "host" f s t a b) =>
       Lens.Family2.LensLike f s t a b
host
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "host")

lastModified ::
             forall f s t a b .
               (Lens.Labels.HasLens "lastModified" f s t a b) =>
               Lens.Family2.LensLike f s t a b
lastModified
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "lastModified")

lines ::
      forall f s t a b . (Lens.Labels.HasLens "lines" f s t a b) =>
        Lens.Family2.LensLike f s t a b
lines
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "lines")

nodeName ::
         forall f s t a b . (Lens.Labels.HasLens "nodeName" f s t a b) =>
           Lens.Family2.LensLike f s t a b
nodeName
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nodeName")

outputSlot ::
           forall f s t a b . (Lens.Labels.HasLens "outputSlot" f s t a b) =>
             Lens.Family2.LensLike f s t a b
outputSlot
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "outputSlot")

sourceFiles ::
            forall f s t a b . (Lens.Labels.HasLens "sourceFiles" f s t a b) =>
              Lens.Family2.LensLike f s t a b
sourceFiles
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sourceFiles")

tolerateDebugOpCreationFailures ::
                                forall f s t a b .
                                  (Lens.Labels.HasLens "tolerateDebugOpCreationFailures" f s t a
                                     b) =>
                                  Lens.Family2.LensLike f s t a b
tolerateDebugOpCreationFailures
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "tolerateDebugOpCreationFailures")