-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT
{-# LANGUAGE TypeFamilies #-}

-- | Pack supported file members while reducing their typed facts. Only diagnostics decode a file again.
module Ecluse.Core.Registry.PyPI.FileWriter (
    FileWriter,
    fileWriter,
    FileValue (..),
) where

import Control.Monad.ST (ST)
import Data.Aeson (Value (..), parseJSON)
import Data.Aeson.Types (parseMaybe)
import Data.Bits ((.&.), (.|.))
import Data.Map.Strict qualified as Map
import Data.Primitive.MutVar (MutVar, newMutVar, readMutVar, writeMutVar)
import Data.Primitive.PrimVar (PrimVar, newPrimVar, readPrimVar, writePrimVar)
import Data.Time (UTCTime)

import Ecluse.Core.Package (CoreMetadata (..))
import Ecluse.Core.Package.Entry (EntryKey (SingletonEntry))
import Ecluse.Core.Registry.Json.Intern (entryText, nameText)
import Ecluse.Core.Registry.Json.Shape (Build (..), MemberKey (..), memberText)
import Ecluse.Core.Registry.Json.Walk (Steps)
import Ecluse.Core.Registry.Json.Writer (Frame, Writer)
import Ecluse.Core.Registry.PyPI.Wire (IndexFile (..), YankState (FileOffered), parseCoreMetadata, yankState)
import Ecluse.Core.Registry.WireSupport (parsePublishTime)

-- | A writer with the object depth that tells file fields from digest members, and the open file's facts.
data FileWriter st = FileWriter (Writer st) (PrimVar st Int) (FactSlots st)

-- | Attach typed reduction to a read's existing scratch writer.
fileWriter :: Writer st -> ST st (FileWriter st)
fileWriter :: forall st. Writer st -> ST st (FileWriter st)
fileWriter Writer st
writer = Writer st -> PrimVar st Int -> FactSlots st -> FileWriter st
forall st.
Writer st -> PrimVar st Int -> FactSlots st -> FileWriter st
FileWriter Writer st
writer (PrimVar st Int -> FactSlots st -> FileWriter st)
-> ST st (PrimVar st Int) -> ST st (FactSlots st -> FileWriter st)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ST st (PrimVar (PrimState (ST st)) Int)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
a -> m (PrimVar (PrimState m) a)
newPrimVar Int
0 ST st (FactSlots st -> FileWriter st)
-> ST st (FactSlots st) -> ST st (FileWriter st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ST st (FactSlots st)
forall st. ST st (FactSlots st)
newFactSlots

-- | Completed facts keep no error tree after a failed typed decode.
data FileValue
    = -- | Text already decoded by the walk.
      TextValue Text
    | -- | An integer the walk already represents as 'Int'.
      IntegerValue Int
    | -- | Other scalars and the empty-array container fallback.
      ScalarValue Value
    | -- | Digest text by algorithm, or a failed digest value.
      HashValue (Maybe (Map Text Text))
    | -- | A decoded file, or a failure whose diagnostic needs the packed payload.
      FileValue (Maybe IndexFile)

-- Failed digests reserve their keys so a duplicate cannot repair the first value.
data FileFields
    = FileFields Frame {-# UNPACK #-} !Word16
    | HashFields Frame (Map Text Text) Bool

-- One slot per fact. A file object resets them as it opens, each member writes one, and the close reads them.
data FactSlots st = FactSlots
    { forall st. FactSlots st -> MutVar st (Maybe Text)
slotFilename :: MutVar st (Maybe Text)
    , forall st. FactSlots st -> MutVar st (Maybe Text)
slotUrl :: MutVar st (Maybe Text)
    , forall st. FactSlots st -> MutVar st (Maybe (Map Text Text))
slotHashes :: MutVar st (Maybe (Map Text Text))
    , forall st. FactSlots st -> MutVar st (Maybe Text)
slotRequiresPython :: MutVar st (Maybe Text)
    , forall st. FactSlots st -> MutVar st (Maybe Int)
slotSize :: MutVar st (Maybe Int)
    , forall st. FactSlots st -> MutVar st (Maybe UTCTime)
slotUploadTime :: MutVar st (Maybe UTCTime)
    , forall st. FactSlots st -> MutVar st YankState
slotYanked :: MutVar st YankState
    , forall st. FactSlots st -> MutVar st (Maybe Text)
slotProvenance :: MutVar st (Maybe Text)
    , forall st. FactSlots st -> MutVar st (Maybe CoreMetadata)
slotCoreMetadata :: MutVar st (Maybe CoreMetadata)
    , forall st. FactSlots st -> MutVar st Bool
slotValid :: MutVar st Bool
    }

-- Slots start invalid, so they yield no file before the first reset.
newFactSlots :: ST st (FactSlots st)
newFactSlots :: forall st. ST st (FactSlots st)
newFactSlots =
    MutVar st (Maybe Text)
-> MutVar st (Maybe Text)
-> MutVar st (Maybe (Map Text Text))
-> MutVar st (Maybe Text)
-> MutVar st (Maybe Int)
-> MutVar st (Maybe UTCTime)
-> MutVar st YankState
-> MutVar st (Maybe Text)
-> MutVar st (Maybe CoreMetadata)
-> MutVar st Bool
-> FactSlots st
forall st.
MutVar st (Maybe Text)
-> MutVar st (Maybe Text)
-> MutVar st (Maybe (Map Text Text))
-> MutVar st (Maybe Text)
-> MutVar st (Maybe Int)
-> MutVar st (Maybe UTCTime)
-> MutVar st YankState
-> MutVar st (Maybe Text)
-> MutVar st (Maybe CoreMetadata)
-> MutVar st Bool
-> FactSlots st
FactSlots
        (MutVar st (Maybe Text)
 -> MutVar st (Maybe Text)
 -> MutVar st (Maybe (Map Text Text))
 -> MutVar st (Maybe Text)
 -> MutVar st (Maybe Int)
 -> MutVar st (Maybe UTCTime)
 -> MutVar st YankState
 -> MutVar st (Maybe Text)
 -> MutVar st (Maybe CoreMetadata)
 -> MutVar st Bool
 -> FactSlots st)
-> ST st (MutVar st (Maybe Text))
-> ST
     st
     (MutVar st (Maybe Text)
      -> MutVar st (Maybe (Map Text Text))
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe Int)
      -> MutVar st (Maybe UTCTime)
      -> MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> ST st (MutVar (PrimState (ST st)) (Maybe Text))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe Text
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe Text)
   -> MutVar st (Maybe (Map Text Text))
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe Int)
   -> MutVar st (Maybe UTCTime)
   -> MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe Text))
-> ST
     st
     (MutVar st (Maybe (Map Text Text))
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe Int)
      -> MutVar st (Maybe UTCTime)
      -> MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> ST st (MutVar (PrimState (ST st)) (Maybe Text))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe Text
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe (Map Text Text))
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe Int)
   -> MutVar st (Maybe UTCTime)
   -> MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe (Map Text Text)))
-> ST
     st
     (MutVar st (Maybe Text)
      -> MutVar st (Maybe Int)
      -> MutVar st (Maybe UTCTime)
      -> MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Map Text Text)
-> ST st (MutVar (PrimState (ST st)) (Maybe (Map Text Text)))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe (Map Text Text)
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe Text)
   -> MutVar st (Maybe Int)
   -> MutVar st (Maybe UTCTime)
   -> MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe Text))
-> ST
     st
     (MutVar st (Maybe Int)
      -> MutVar st (Maybe UTCTime)
      -> MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> ST st (MutVar (PrimState (ST st)) (Maybe Text))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe Text
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe Int)
   -> MutVar st (Maybe UTCTime)
   -> MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe Int))
-> ST
     st
     (MutVar st (Maybe UTCTime)
      -> MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Int -> ST st (MutVar (PrimState (ST st)) (Maybe Int))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe Int
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe UTCTime)
   -> MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe UTCTime))
-> ST
     st
     (MutVar st YankState
      -> MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe UTCTime -> ST st (MutVar (PrimState (ST st)) (Maybe UTCTime))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe UTCTime
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st YankState
   -> MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st YankState)
-> ST
     st
     (MutVar st (Maybe Text)
      -> MutVar st (Maybe CoreMetadata)
      -> MutVar st Bool
      -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> YankState -> ST st (MutVar (PrimState (ST st)) YankState)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar YankState
FileOffered
        ST
  st
  (MutVar st (Maybe Text)
   -> MutVar st (Maybe CoreMetadata)
   -> MutVar st Bool
   -> FactSlots st)
-> ST st (MutVar st (Maybe Text))
-> ST
     st
     (MutVar st (Maybe CoreMetadata) -> MutVar st Bool -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Text -> ST st (MutVar (PrimState (ST st)) (Maybe Text))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe Text
forall a. Maybe a
Nothing
        ST
  st
  (MutVar st (Maybe CoreMetadata) -> MutVar st Bool -> FactSlots st)
-> ST st (MutVar st (Maybe CoreMetadata))
-> ST st (MutVar st Bool -> FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe CoreMetadata
-> ST st (MutVar (PrimState (ST st)) (Maybe CoreMetadata))
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Maybe CoreMetadata
forall a. Maybe a
Nothing
        ST st (MutVar st Bool -> FactSlots st)
-> ST st (MutVar st Bool) -> ST st (FactSlots st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> ST st (MutVar (PrimState (ST st)) Bool)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Bool
False

resetFacts :: FactSlots st -> ST st ()
resetFacts :: forall st. FactSlots st -> ST st ()
resetFacts FactSlots st
slots = do
    MutVar (PrimState (ST st)) (Maybe Text) -> Maybe Text -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotFilename FactSlots st
slots) Maybe Text
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) (Maybe Text) -> Maybe Text -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotUrl FactSlots st
slots) Maybe Text
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) (Maybe (Map Text Text))
-> Maybe (Map Text Text) -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe (Map Text Text))
forall st. FactSlots st -> MutVar st (Maybe (Map Text Text))
slotHashes FactSlots st
slots) (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
forall a. Monoid a => a
mempty)
    MutVar (PrimState (ST st)) (Maybe Text) -> Maybe Text -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotRequiresPython FactSlots st
slots) Maybe Text
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) (Maybe Int) -> Maybe Int -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe Int)
forall st. FactSlots st -> MutVar st (Maybe Int)
slotSize FactSlots st
slots) Maybe Int
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) (Maybe UTCTime)
-> Maybe UTCTime -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe UTCTime)
forall st. FactSlots st -> MutVar st (Maybe UTCTime)
slotUploadTime FactSlots st
slots) Maybe UTCTime
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) YankState -> YankState -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st YankState
forall st. FactSlots st -> MutVar st YankState
slotYanked FactSlots st
slots) YankState
FileOffered
    MutVar (PrimState (ST st)) (Maybe Text) -> Maybe Text -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotProvenance FactSlots st
slots) Maybe Text
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) (Maybe CoreMetadata)
-> Maybe CoreMetadata -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st (Maybe CoreMetadata)
forall st. FactSlots st -> MutVar st (Maybe CoreMetadata)
slotCoreMetadata FactSlots st
slots) Maybe CoreMetadata
forall a. Maybe a
Nothing
    MutVar (PrimState (ST st)) Bool -> Bool -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (FactSlots st -> MutVar st Bool
forall st. FactSlots st -> MutVar st Bool
slotValid FactSlots st
slots) Bool
True

-- A slot holds an evaluated fact, never a thunk over the member's value.
setFact :: MutVar st a -> a -> ST st ()
setFact :: forall st a. MutVar st a -> a -> ST st ()
setFact MutVar st a
slot !a
fact = MutVar (PrimState (ST st)) a -> a -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar MutVar st a
MutVar (PrimState (ST st)) a
slot a
fact

instance Build (FileWriter st) (ST st (Steps (ST st) s)) where
    type Built (FileWriter st) = FileValue
    type Fields (FileWriter st) = FileFields
    type Items (FileWriter st) = Int
    sharedString :: FileWriter st
-> Entry
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
sharedString (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Entry
entry Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Entry
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Entry -> (Built b -> r) -> r
sharedString Writer st
writer Entry
entry (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Text -> FileValue
TextValue (Entry -> Text
entryText Entry
entry)))
    ownString :: FileWriter st
-> Name
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
ownString (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Name
name Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Name
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Name -> (Built b -> r) -> r
ownString Writer st
writer Name
name (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Text -> FileValue
TextValue (Name -> Text
nameText Name
name)))
    integer :: FileWriter st
-> Int
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
integer (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Int
number Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Int
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Int -> (Built b -> r) -> r
integer Writer st
writer Int
number (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Int -> FileValue
IntegerValue Int
number))
    whole :: FileWriter st
-> Value
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
whole (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Value
value Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Value
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Value -> (Built b -> r) -> r
whole Writer st
writer Value
value (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Value -> FileValue
ScalarValue Value
value))
    emptyContainer :: FileWriter st
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
emptyContainer (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> (Built b -> r) -> r
emptyContainer Writer st
writer (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Value -> FileValue
ScalarValue (Array -> Value
Array Array
forall a. Monoid a => a
mempty)))
    openObject :: FileWriter st
-> (Fields (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
openObject (FileWriter Writer st
writer PrimVar st Int
depth FactSlots st
slots) Fields (FileWriter st) -> ST st (Steps (ST st) s)
next = do
        level <- PrimVar (PrimState (ST st)) Int -> ST st Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar st Int
PrimVar (PrimState (ST st)) Int
depth
        writePrimVar depth (level + 1)
        if level == 0
            then resetFacts slots >> openObject writer (\Fields (Writer st)
frame -> Fields (FileWriter st) -> ST st (Steps (ST st) s)
next (Frame -> Word16 -> FileFields
FileFields Fields (Writer st)
Frame
frame Word16
0))
            else openObject writer (\Fields (Writer st)
frame -> Fields (FileWriter st) -> ST st (Steps (ST st) s)
next (Frame -> Map Text Text -> Bool -> FileFields
HashFields Fields (Writer st)
Frame
frame Map Text Text
forall a. Monoid a => a
mempty Bool
True))
    beginMember :: FileWriter st
-> MemberKey
-> Fields (FileWriter st)
-> (Bool -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
beginMember (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) MemberKey
key Fields (FileWriter st)
fields Bool -> ST st (Steps (ST st) s)
next = Writer st
-> MemberKey
-> Fields (Writer st)
-> (Bool -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Fields b -> (Bool -> r) -> r
beginMember Writer st
writer MemberKey
key (FileFields -> Frame
frameOf Fields (FileWriter st)
FileFields
fields) ((Bool -> ST st (Steps (ST st) s)) -> ST st (Steps (ST st) s))
-> (Bool -> ST st (Steps (ST st) s)) -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \Bool
repeated ->
        Bool -> ST st (Steps (ST st) s)
next (Bool
repeated Bool -> Bool -> Bool
|| MemberKey -> FileFields -> Bool
seenMember MemberKey
key Fields (FileWriter st)
FileFields
fields)
    addMember :: FileWriter st
-> MemberKey
-> Built (FileWriter st)
-> Fields (FileWriter st)
-> (Fields (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
addMember (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
slots) MemberKey
key Built (FileWriter st)
value Fields (FileWriter st)
fields Fields (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> MemberKey
-> Built (Writer st)
-> Fields (Writer st)
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Built b -> Fields b -> (Fields b -> r) -> r
addMember Writer st
writer MemberKey
key () (FileFields -> Frame
frameOf Fields (FileWriter st)
FileFields
fields) ((Fields (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \Fields (Writer st)
frame -> case Fields (FileWriter st)
fields of
        FileFields Frame
_ Word16
seen -> do
            FactSlots st -> Text -> FileValue -> ST st ()
forall st. FactSlots st -> Text -> FileValue -> ST st ()
reduceMember FactSlots st
slots (MemberKey -> Text
memberText MemberKey
key) Built (FileWriter st)
FileValue
value
            Fields (FileWriter st) -> ST st (Steps (ST st) s)
FileFields -> ST st (Steps (ST st) s)
next (FileFields -> ST st (Steps (ST st) s))
-> FileFields -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$! Frame -> Word16 -> FileFields
FileFields Fields (Writer st)
Frame
frame (Word16 -> FileFields) -> Word16 -> FileFields
forall a b. (a -> b) -> a -> b
$ case MemberKey
key of
                OwnKey Key
_ -> Word16
seen Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.|. Text -> Word16
fileFieldBit (MemberKey -> Text
memberText MemberKey
key)
                SharedKey Entry
_ -> Word16
seen
        HashFields Frame
_ Map Text Text
hashes Bool
valid ->
            let text :: Maybe Text
text = FileValue -> Maybe Text
scalarText Built (FileWriter st)
FileValue
value
             in Fields (FileWriter st) -> ST st (Steps (ST st) s)
FileFields -> ST st (Steps (ST st) s)
next (FileFields -> ST st (Steps (ST st) s))
-> FileFields -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$! Frame -> Map Text Text -> Bool -> FileFields
HashFields Fields (Writer st)
Frame
frame (Text -> Text -> Map Text Text -> Map Text Text
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (MemberKey -> Text
memberText MemberKey
key) (Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" Maybe Text
text) Map Text Text
hashes) (Bool
valid Bool -> Bool -> Bool
&& Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
text)
    dropValue :: FileWriter st
-> Built (FileWriter st)
-> ST st (Steps (ST st) s)
-> ST st (Steps (ST st) s)
dropValue (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Built (FileWriter st)
_ = Writer st
-> Built (Writer st)
-> ST st (Steps (ST st) s)
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Built b -> r -> r
dropValue Writer st
writer ()
    closeObject :: FileWriter st
-> Fields (FileWriter st)
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
closeObject (FileWriter Writer st
writer PrimVar st Int
depth FactSlots st
slots) Fields (FileWriter st)
fields Built (FileWriter st) -> ST st (Steps (ST st) s)
next = do
        level <- PrimVar (PrimState (ST st)) Int -> ST st Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar st Int
PrimVar (PrimState (ST st)) Int
depth
        writePrimVar depth (level - 1)
        closeObject writer (frameOf fields) $ \() -> case Fields (FileWriter st)
fields of
            FileFields{} -> FactSlots st -> ST st (Maybe IndexFile)
forall st. FactSlots st -> ST st (Maybe IndexFile)
finishFacts FactSlots st
slots ST st (Maybe IndexFile)
-> (Maybe IndexFile -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe IndexFile
file -> Built (FileWriter st) -> ST st (Steps (ST st) s)
FileValue -> ST st (Steps (ST st) s)
next (FileValue -> ST st (Steps (ST st) s))
-> FileValue -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$! Maybe IndexFile -> FileValue
FileValue Maybe IndexFile
file
            HashFields Frame
_ Map Text Text
hashes Bool
valid -> Built (FileWriter st) -> ST st (Steps (ST st) s)
FileValue -> ST st (Steps (ST st) s)
next (FileValue -> ST st (Steps (ST st) s))
-> FileValue -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$! Maybe (Map Text Text) -> FileValue
HashValue (if Bool
valid then Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
hashes else Maybe (Map Text Text)
forall a. Maybe a
Nothing)
    openArray :: FileWriter st
-> (Items (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
openArray (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) = Writer st
-> (Items (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> (Items b -> r) -> r
openArray Writer st
writer
    addItem :: FileWriter st
-> Built (FileWriter st)
-> Items (FileWriter st)
-> (Items (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
addItem (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Built (FileWriter st)
_ = Writer st
-> Built (Writer st)
-> Items (Writer st)
-> (Items (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> Built b -> Items b -> (Items b -> r) -> r
addItem Writer st
writer ()
    closeArray :: FileWriter st
-> Int
-> Items (FileWriter st)
-> (Built (FileWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
closeArray (FileWriter Writer st
writer PrimVar st Int
_ FactSlots st
_) Int
count Items (FileWriter st)
start Built (FileWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Int
-> Items (Writer st)
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Int -> Items b -> (Built b -> r) -> r
closeArray Writer st
writer Int
count Items (Writer st)
Items (FileWriter st)
start (\() -> Built (FileWriter st) -> ST st (Steps (ST st) s)
next (Value -> FileValue
ScalarValue (Array -> Value
Array Array
forall a. Monoid a => a
mempty)))
    {-# INLINE sharedString #-}
    {-# INLINE ownString #-}
    {-# INLINE integer #-}
    {-# INLINE whole #-}
    {-# INLINE emptyContainer #-}
    {-# INLINE openObject #-}
    {-# INLINE beginMember #-}
    {-# INLINE addMember #-}
    {-# INLINE dropValue #-}
    {-# INLINE closeObject #-}
    {-# INLINE openArray #-}
    {-# INLINE addItem #-}
    {-# INLINE closeArray #-}

frameOf :: FileFields -> Frame
frameOf :: FileFields -> Frame
frameOf = \case
    FileFields Frame
frame Word16
_ -> Frame
frame
    HashFields Frame
frame Map Text Text
_ Bool
_ -> Frame
frame

seenMember :: MemberKey -> FileFields -> Bool
seenMember :: MemberKey -> FileFields -> Bool
seenMember MemberKey
key FileFields
fields = case (MemberKey
key, FileFields
fields) of
    (OwnKey Key
_, FileFields Frame
_ Word16
seen) -> Word16
seen Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.&. Text -> Word16
fileFieldBit (MemberKey -> Text
memberText MemberKey
key) Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
0
    (MemberKey
_, HashFields Frame
_ Map Text Text
hashes Bool
_) -> Text -> Map Text Text -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member (MemberKey -> Text
memberText MemberKey
key) Map Text Text
hashes
    (MemberKey, FileFields)
_ -> Bool
False

fileFieldBit :: Text -> Word16
fileFieldBit :: Text -> Word16
fileFieldBit = \case
    Text
"filename" -> Word16
0x01
    Text
"url" -> Word16
0x02
    Text
"hashes" -> Word16
0x04
    Text
"requires-python" -> Word16
0x08
    Text
"size" -> Word16
0x10
    Text
"upload-time" -> Word16
0x20
    Text
"yanked" -> Word16
0x40
    Text
"provenance" -> Word16
0x80
    Text
"core-metadata" -> Word16
0x100
    Text
_ -> Word16
0

scalarText :: FileValue -> Maybe Text
scalarText :: FileValue -> Maybe Text
scalarText = \case
    TextValue Text
text -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
text
    ScalarValue (String Text
text) -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
text
    FileValue
_ -> Maybe Text
forall a. Maybe a
Nothing

reduceMember :: FactSlots st -> Text -> FileValue -> ST st ()
reduceMember :: forall st. FactSlots st -> Text -> FileValue -> ST st ()
reduceMember FactSlots st
slots Text
key FileValue
value = case (Text
key, FileValue
value) of
    (Text
"filename", FileValue
_) -> MutVar st (Maybe Text) -> Maybe Text -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotFilename FactSlots st
slots) (FileValue -> Maybe Text
scalarText FileValue
value)
    (Text
"url", FileValue
_) -> MutVar st (Maybe Text) -> Maybe Text -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotUrl FactSlots st
slots) (FileValue -> Maybe Text
scalarText FileValue
value)
    (Text
"hashes", HashValue Maybe (Map Text Text)
hashes) -> MutVar st (Maybe (Map Text Text))
-> Maybe (Map Text Text) -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe (Map Text Text))
forall st. FactSlots st -> MutVar st (Maybe (Map Text Text))
slotHashes FactSlots st
slots) Maybe (Map Text Text)
hashes
    (Text
"hashes", ScalarValue Value
Null) -> MutVar st (Maybe (Map Text Text))
-> Maybe (Map Text Text) -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe (Map Text Text))
forall st. FactSlots st -> MutVar st (Maybe (Map Text Text))
slotHashes FactSlots st
slots) (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
forall a. Monoid a => a
mempty)
    (Text
"hashes", FileValue
_) -> MutVar st (Maybe (Map Text Text))
-> Maybe (Map Text Text) -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe (Map Text Text))
forall st. FactSlots st -> MutVar st (Maybe (Map Text Text))
slotHashes FactSlots st
slots) Maybe (Map Text Text)
forall a. Maybe a
Nothing
    (Text
"core-metadata", HashValue (Just Map Text Text
hashes)) -> MutVar st (Maybe CoreMetadata) -> Maybe CoreMetadata -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe CoreMetadata)
forall st. FactSlots st -> MutVar st (Maybe CoreMetadata)
slotCoreMetadata FactSlots st
slots) (CoreMetadata -> Maybe CoreMetadata
forall a. a -> Maybe a
Just (Map Text Text -> CoreMetadata
MetadataDigests Map Text Text
hashes))
    (Text
"core-metadata", ScalarValue Value
scalar) -> ST st ()
-> (CoreMetadata -> ST st ()) -> Maybe CoreMetadata -> ST st ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ST st ()
invalid (MutVar st (Maybe CoreMetadata) -> Maybe CoreMetadata -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe CoreMetadata)
forall st. FactSlots st -> MutVar st (Maybe CoreMetadata)
slotCoreMetadata FactSlots st
slots) (Maybe CoreMetadata -> ST st ())
-> (CoreMetadata -> Maybe CoreMetadata) -> CoreMetadata -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoreMetadata -> Maybe CoreMetadata
forall a. a -> Maybe a
Just) ((Value -> Parser CoreMetadata) -> Value -> Maybe CoreMetadata
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser CoreMetadata
parseCoreMetadata Value
scalar)
    (Text
"core-metadata", FileValue
_) -> ST st ()
invalid
    (Text
"requires-python", FileValue
_) -> MutVar st (Maybe Text) -> ST st ()
optionalFact (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotRequiresPython FactSlots st
slots)
    (Text
"provenance", FileValue
_) -> MutVar st (Maybe Text) -> ST st ()
optionalFact (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotProvenance FactSlots st
slots)
    (Text
"size", IntegerValue Int
number) -> MutVar st (Maybe Int) -> Maybe Int -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe Int)
forall st. FactSlots st -> MutVar st (Maybe Int)
slotSize FactSlots st
slots) (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
number)
    (Text
"size", FileValue
_) -> (Value -> ST st ()) -> ST st ()
withScalar (MutVar st (Maybe Int) -> Maybe Int -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe Int)
forall st. FactSlots st -> MutVar st (Maybe Int)
slotSize FactSlots st
slots) (Maybe Int -> ST st ())
-> (Value -> Maybe Int) -> Value -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Int -> Maybe Int
forall a. NFData a => a -> a
force (Maybe Int -> Maybe Int)
-> (Value -> Maybe Int) -> Value -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser Int) -> Value -> Maybe Int
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON)
    (Text
"upload-time", FileValue
_) -> (Value -> ST st ()) -> ST st ()
withScalar (MutVar st (Maybe UTCTime) -> Maybe UTCTime -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st (Maybe UTCTime)
forall st. FactSlots st -> MutVar st (Maybe UTCTime)
slotUploadTime FactSlots st
slots) (Maybe UTCTime -> ST st ())
-> (Value -> Maybe UTCTime) -> Value -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe UTCTime -> Maybe UTCTime
forall a. NFData a => a -> a
force (Maybe UTCTime -> Maybe UTCTime)
-> (Value -> Maybe UTCTime) -> Value -> Maybe UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser UTCTime) -> Value -> Maybe UTCTime
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser UTCTime
parsePublishTime)
    (Text
"yanked", FileValue
_) -> (Value -> ST st ()) -> ST st ()
withScalar (MutVar st YankState -> YankState -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st YankState
forall st. FactSlots st -> MutVar st YankState
slotYanked FactSlots st
slots) (YankState -> ST st ())
-> (Value -> YankState) -> Value -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Value -> YankState
yankState (Maybe Value -> YankState)
-> (Value -> Maybe Value) -> Value -> YankState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe Value
forall a. a -> Maybe a
Just)
    (Text, FileValue)
_ -> ST st ()
forall (f :: * -> *). Applicative f => f ()
pass
  where
    invalid :: ST st ()
invalid = MutVar st Bool -> Bool -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact (FactSlots st -> MutVar st Bool
forall st. FactSlots st -> MutVar st Bool
slotValid FactSlots st
slots) Bool
False
    withScalar :: (Value -> ST st ()) -> ST st ()
withScalar Value -> ST st ()
update = case FileValue
value of
        TextValue Text
text -> Value -> ST st ()
update (Text -> Value
String Text
text)
        IntegerValue Int
number -> Value -> ST st ()
update (Scientific -> Value
Number (Int -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
number))
        ScalarValue Value
scalar -> Value -> ST st ()
update Value
scalar
        FileValue
_ -> ST st ()
forall (f :: * -> *). Applicative f => f ()
pass
    optionalFact :: MutVar st (Maybe Text) -> ST st ()
optionalFact MutVar st (Maybe Text)
slot = case FileValue
value of
        ScalarValue Value
Null -> MutVar st (Maybe Text) -> Maybe Text -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact MutVar st (Maybe Text)
slot Maybe Text
forall a. Maybe a
Nothing
        HashValue{} -> ST st ()
forall (f :: * -> *). Applicative f => f ()
pass
        FileValue{} -> ST st ()
forall (f :: * -> *). Applicative f => f ()
pass
        FileValue
_ -> ST st () -> (Text -> ST st ()) -> Maybe Text -> ST st ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ST st ()
invalid (MutVar st (Maybe Text) -> Maybe Text -> ST st ()
forall st a. MutVar st a -> a -> ST st ()
setFact MutVar st (Maybe Text)
slot (Maybe Text -> ST st ())
-> (Text -> Maybe Text) -> Text -> ST st ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe Text
forall a. a -> Maybe a
Just) (FileValue -> Maybe Text
scalarText FileValue
value)

finishFacts :: FactSlots st -> ST st (Maybe IndexFile)
finishFacts :: forall st. FactSlots st -> ST st (Maybe IndexFile)
finishFacts FactSlots st
slots = do
    valid <- MutVar (PrimState (ST st)) Bool -> ST st Bool
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar (FactSlots st -> MutVar st Bool
forall st. FactSlots st -> MutVar st Bool
slotValid FactSlots st
slots)
    required <- (,,) <$> readMutVar (slotFilename slots) <*> readMutVar (slotUrl slots) <*> readMutVar (slotHashes slots)
    case required of
        (Just Text
name, Just Text
url, Just Map Text Text
hashes) | Bool
valid -> do
            requiresPython <- MutVar (PrimState (ST st)) (Maybe Text) -> ST st (Maybe Text)
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar (FactSlots st -> MutVar st (Maybe Text)
forall st. FactSlots st -> MutVar st (Maybe Text)
slotRequiresPython FactSlots st
slots)
            size <- readMutVar (slotSize slots)
            uploadTime <- readMutVar (slotUploadTime slots)
            yanked <- readMutVar (slotYanked slots)
            coreMetadata <- readMutVar (slotCoreMetadata slots)
            provenance <- readMutVar (slotProvenance slots)
            let !file =
                    IndexFile
                        { ifEntryKey :: EntryKey
ifEntryKey = EntryKey
SingletonEntry
                        , ifFilename :: Text
ifFilename = Text
name
                        , ifUrl :: Text
ifUrl = Text
url
                        , ifHashes :: Map Text Text
ifHashes = Map Text Text
hashes
                        , ifRequiresPython :: Maybe Text
ifRequiresPython = Maybe Text
requiresPython
                        , ifSize :: Maybe Int
ifSize = Maybe Int
size
                        , ifUploadTime :: Maybe UTCTime
ifUploadTime = Maybe UTCTime
uploadTime
                        , ifYanked :: YankState
ifYanked = YankState
yanked
                        , ifCoreMetadata :: Maybe CoreMetadata
ifCoreMetadata = Maybe CoreMetadata
coreMetadata
                        , ifProvenance :: Maybe Text
ifProvenance = Maybe Text
provenance
                        }
            pure (Just file)
        (Maybe Text, Maybe Text, Maybe (Map Text Text))
_ -> Maybe IndexFile -> ST st (Maybe IndexFile)
forall a. a -> ST st a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe IndexFile
forall a. Maybe a
Nothing