Minimize redundancy in IOSimPOR logs

Is your feature request related to a problem? Please describe.
Recently I had to debug a IOSimPOR test failure (See #154) and although IOSimPOR is complicated, analysing the logs adds an extra layer of difficulty because the logs are quite large and have a lot of redundant information. I'll explain:
Here's the excerpt of a log for an IOSimPOR run with explorationDebugLevel = 2:
0s - Thread {1}.2 1 - Races {activeRaces = [StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}, stepInfoControl = ControlFollow [(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],5),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 4], effectWrites = fromList [TVarId 4], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],4),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],3),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [2], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [3]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],1),(ThreadId [],26)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [3], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],0),(ThreadId [],11)])}, stepInfoControl = ControlFollow [(RacyThreadId [3],0),(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)] [], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [4], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [4],1),(ThreadId [],26)])}, stepInfoControl = ControlAwait [ScheduleMod (RacyThreadId [4],2) ControlDefault [(RacyThreadId [3],0),(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)]], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 4], effectWrites = fromList [TVarId 4], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [3]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],0),(ThreadId [],11)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [4], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [4],0),(ThreadId [],15)])}, stepInfoControl = ControlAwait [ScheduleMod (RacyThreadId [4],2) ControlDefault [(RacyThreadId [3],0),(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)]], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [5], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 6], effectWrites = fromList [TVarId 6], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [5], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(RacyThreadId [5],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 4], effectWrites = fromList [TVarId 4], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [3]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],0),(ThreadId [],11)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [5], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [5],2),(ThreadId [],26)])}, stepInfoControl = ControlAwait [ScheduleMod (RacyThreadId [4],2) ControlDefault [(RacyThreadId [3],0),(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)]], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [2], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [3]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],0),(ThreadId [],11)])},Step {stepThreadId = RacyThreadId [4], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [4],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [4], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [4],0),(ThreadId [],15)])}], stepInfoRaces = []},StepInfo {stepInfoStep = Step {stepThreadId = RacyThreadId [5], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [5],1),(ThreadId [],26)])}, stepInfoControl = ControlAwait [ScheduleMod (RacyThreadId [4],2) ControlDefault [(RacyThreadId [3],0),(RacyThreadId [3],1),(RacyThreadId [3],2),(RacyThreadId [2],0),(RacyThreadId [3],3),(RacyThreadId [3],4),(RacyThreadId [3],5),(RacyThreadId [2],1),(RacyThreadId [2],2),(RacyThreadId [2],3),(RacyThreadId [2],4),(RacyThreadId [5],3),(RacyThreadId [5],4),(RacyThreadId [5],5),(RacyThreadId [1],0),(RacyThreadId [1],1),(RacyThreadId [1],2)]], stepInfoConcurrent = fromList [RacyThreadId [1],RacyThreadId [4],RacyThreadId [6],ThreadId []], stepInfoNonDep = [Step {stepThreadId = RacyThreadId [1], stepStep = 2, stepEffect = Effect {effectReads = fromList [TVarId 0], effectWrites = fromList [TVarId 0], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [1], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [1],0),(ThreadId [],3)])},Step {stepThreadId = RacyThreadId [2], stepStep = 4, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [5],RacyThreadId [6]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],4),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 3, stepEffect = Effect {effectReads = fromList [TVarId 3], effectWrites = fromList [TVarId 3], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],3),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],2),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 1, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],1),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 5, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],5),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 4, stepEffect = Effect {effectReads = fromList [TVarId 4], effectWrites = fromList [TVarId 4], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],4),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 3, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],3),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [2], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList [RacyThreadId [3]]}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 2, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [RacyThreadId [2]], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [2],0),(RacyThreadId [3],2),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],1),(ThreadId [],26)])},Step {stepThreadId = RacyThreadId [3], stepStep = 0, stepEffect = Effect {effectReads = fromList [], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [3],0),(ThreadId [],11)])},Step {stepThreadId = RacyThreadId [4], stepStep = 1, stepEffect = Effect {effectReads = fromList [TVarId 1], effectWrites = fromList [], effectForks = fromList [], effectThrows = [], effectWakeup = fromList []}, stepVClock = VectorClock (fromList [(RacyThreadId [4],1),(ThreadId [],26)])},...

This is only 1 line worth of trace out of 355 total lines, AND I had to truncate this line of code to not exceed GitHub's limit of 65k words. It has A LOT of useless information.
Describe the solution you'd like
Here's the data types involved in the trace I mentioned above:
type StepId = (IOSimThreadId, Int)

-- | A schedule modification inserted at given execution step.
--
data ScheduleMod = ScheduleMod{
    -- | Step at which the 'ScheduleMod' is activated.
    scheduleModTarget    :: StepId,
    -- | 'ScheduleControl' at the activation step.  It is needed by
    -- 'extendScheduleControl' when combining the discovered schedule with the
    -- initial one.
    scheduleModControl   :: ScheduleControl,
    -- | Series of steps which are executed at the target step.  This *includes*
    -- the target step, not necessarily as the last step.
    scheduleModInsertion :: [StepId]
  }
  deriving (Eq, Ord)

-- | Modified execution schedule.
--
data ScheduleControl = ControlDefault
                     -- ^ default scheduling mode
                     | ControlAwait [ScheduleMod]
                     -- ^ if the current control is 'ControlAwait', the normal
                     -- scheduling will proceed, until the thread found in the
                     -- first 'ScheduleMod' reaches the given step.  At this
                     -- point the thread is put to sleep, until after all the
                     -- steps are followed.
                     | ControlFollow [StepId] [ScheduleMod]
                     -- ^ follow the steps then continue with schedule
                     -- modifications.  This control is set by 'followControl'
                     -- when 'controlTargets' returns true.
  deriving (Eq, Ord, Show)

data Step = Step {
    stepThreadId :: !IOSimThreadId,
    stepStep     :: !Int,
    stepEffect   :: !Effect,
    stepVClock   :: !VectorClock
  }
  deriving Show

-- | As we execute a simulation, we collect information about each step.  This
-- information is updated as the simulation evolves by
-- `Control.Monad.IOSimPOR.Types.updateRaces`.
--
data StepInfo = StepInfo {
    -- | Step that we want to reschedule to run after a step in `stepInfoRaces`
    -- (there will be one schedule modification per step in
    -- `stepInfoRaces`).
    stepInfoStep       :: !Step,

    -- | Control information when we reached this step.
    stepInfoControl    :: !ScheduleControl,

    -- | Threads that are still concurrent with this step.
    stepInfoConcurrent :: !(Set IOSimThreadId),

    -- | Steps following this one that did not happen after it
    -- (in reverse order).
    stepInfoNonDep     :: ![Step],

    -- | Later steps that race with `stepInfoStep`.
    stepInfoRaces      :: ![Step]
  }
  deriving Show

--
-- Races
--

data Races = Races { -- These steps may still race with future steps
                     activeRaces   :: ![StepInfo],
                     -- These steps cannot be concurrent with future steps
                     completeRaces :: ![StepInfo]
                   }
  deriving Show

One can see how much information there's in each element of activeRaces or completeRaces fields. I propose either a refactorisation of these datatypes to avoid redundant information being stored, e.g.:
data StepInfo = StepInfo {
    -- | Step that we want to reschedule to run after a step in `stepInfoRaces`
    -- (there will be one schedule modification per step in
    -- `stepInfoRaces`).
    stepInfoStep       :: !Step,

    -- | Control information when we reached this step.
    stepInfoControl    :: !ScheduleControl,

    -- | Threads that are still concurrent with this step.
    stepInfoConcurrent :: !(Set IOSimThreadId),

    -- | Steps following this one that did not happen after it
    -- (in reverse order).
    stepInfoNonDep     :: ![IOSimThreadId],

    -- | Later steps that race with `stepInfoStep`.
    stepInfoRaces      :: ![IOSimThreadId]
  }
  deriving Show

and have a Map IOSimThreadId Step somewhere in the state. And the same for other similar places in the code.
OR
have a pretty printer with minimal verbosity that doesn't print all the information.
Are you willing to implement it?

[x] Are you? :smiley:

I am not sure if I follow the suggested refactrosiation.  Note that stepInfoNonDep and stepInfoRaces hold Steps different from the one in ``stepInfoStep.  Each thread has many Steps so Map IOSimThreadId Step` won't help.

For that we'd need Map StepId Step, but that will be a large map holding all Steps, which has other downsides.  I am not sure if optimising for pretty printing is the right way, so I'd prefer to have a nice pretty printer possibly with a verbosity parameter.

That would work as well!


As a dev, I want to replace direct SQL queries in tests with existing Python functions for better maintainability

Description:
In some test cases, SQL queries are written directly within the tests, even though there are existing Python functions and Pydantic models that could be used instead. This makes the tests harder to maintain and introduces redundancy. The goal is to replace all direct SQL queries in the test cases with calls to the appropriate existing Python functions and Pydantic models, ensuring the tests are easier to maintain, consistent, and align with the project structure.
Additionally, the folder structure for the tests has deviated from the original, making it harder to navigate. The folder structure should be reworked to match the original project structure for better maintainability.
Acceptance Criteria:

Identify test cases where direct SQL queries are used.
Replace direct SQL queries with existing Python functions that achieve the same result.
Use our Pydantic models instead of dictionary objects where applicable.
Ensure all tests still pass after making these changes.
Rework the test folder structure to match the original project structure.
Confirm that no redundant SQL queries remain in the test cases.

I suggest we also invest a bit of time to use the InspectionDB model in necessary tests

I also suggest in this issue we rework the tests to keep the object tests structure. Currently we have tests for each of our objects but we also have a update folder (and now a delete folder?) which tests each objects for their respective operation. We should keep all the tests for the same object into the object query tests file.

I also suggest in this issue we rework the tests to keep the object tests structure. Currently we have tests for each of our objects but we also have a update folder (and now a delete folder?) which tests each objects for their respective operation. We should keep all the tests for the same object into the object query tests file.

Updated.

Update: While working on #154 it became quite long to maintain the tests of update since there was changes to the tables, alot of tests has to be manually changed since they used queries.
Using queries also made the tests harder to read and understand what was happening and what was being tested.

Update: While working on #212 I had to update the Organizations test suites and made it into one suite with all functions instead of direct query to the DB which can be quite hard to maintain. It also reduced the number of global test needed and the code length of the tests


Natural Language v1beta2 GAPIC.

This adds the v1beta2 GAPIC on the side for Natural Language.

Needs some sort of documentation stating that v1beta2 follows v1.

Changes Unknown when pulling<PHONE_NUMBER>e3bf760181e7cd45102ef342344336 on lukesneeringer:nl-v1beta2 into ** on GoogleCloudPlatform:master**.

Needs some sort of documentation stating that v1beta2 follows v1.

We have not really documented that v1beta2 exists -- we are just sort of plopping it there.
I think the idea is that there will be separate beta documentation.


Fixes MAVSDK-Java#155 camera::possibleSettingOptions crashes as a result of erroneous string format

Corrects the conversion to numeric string representation

🤔 wouldn't that then not require the whole stringstream logic at all and you could just directly set the option_id?
option.option_id = value.get_string()

I'm not sure whether we're missing something here.

You're right, it's not needed anymore. I was originally basing the fix on existing logic.

I guess it doesn't break any tests, so I'm going to trust you that this is right.


docs: improve docker run command

Update Docker installation instructions so that:

Image pulled automatically
All ports exposed
Mount named volume instead of pwd
Container has name
Container automatically removed after stop

@morigs Thanks for your contribution! Looks good to me.
@sunng87 Please take a look.

Forgot to mention important fact: I've tried to run latest from docker.io with both old command and my command. In both cases all calls to API return empty response (no headers, no body), so it effectively doesn't work. I don't think it's because of the command, but perhaps I use API incorrectly or the image is broken

LGTM and thank you for reporting the connection issue. @morigs are you using linux as docker host? On linux, docker uses bridge network by default and greptimedb by default listens to <IP_ADDRESS>, so it's not possible to connect via "curl http://<IP_ADDRESS>:4000". To fix that issue, linux user will need to add additional arguments, for example, to expose http and mysql protocol to host:
docker run -p 4000-4004:4000-4004 -p 4242:4242 -v "greptime-vol:/tmp/greptimedb" --name greptime --rm greptime/greptimedb standalone start --http-addr <IP_ADDRESS>:4000 --mysql-addr <IP_ADDRESS>:4002

I think we can add this to our docs as well

@sunng87 Thanks. I'm on mac, but you're right, servers listen on <IP_ADDRESS> by default, changing host to <IP_ADDRESS> helps.
Perhaps <IP_ADDRESS> should be default on all platforms?

@morigs Thank for your suggestion. I have initialized a discussion to see if <IP_ADDRESS> works for other developers. I think the only concern is about the security by default.


Show tooltip when hovering over tool type icon

@ashwin-sureshkumar made the nice suggestion of showing some sort sort of indicator that explains what the tool type is aside from just the top of the site.
Thought: Show a small tool-tip when hovering over any of the icons within the card components.

As always - any thoughts, suggestions will be appreciated!

You should try to globally improve your SVGs' accessibility. Here are some reading:

Accessible inline SVG
Making SVG accessible by Leonie Watson

And there are probably tons of better link :)
You could probably go with aria-label and role="img" on each SVG, and display aria-label's content as a tooltip on hover in a pseudo-element.
Not quite sure of the accessibility of this, though. Maybe @Heydon would have a better idea?

I just came here to leave the same comment.
On my first visit to the page, my first instinct was to toggle the switches. The second is obvious what it does after the first click.
The menu toggle is not. I clicked it repeatedly, and didn't know what I was changing. I eventually scrolled down, and saw what it was doing.

Thanks a million folks, opened #19 to track adding a11y tags to the SVGs used in this app 🚀
@n8udd That's a very good point, and I think a lot of people are most likely thinking the same and are instinctively clicking the toggles as soon as they load the app. I initially didn't have the hero/sub-hero components describing the app so switching that toggle used to show the list changing above the fold, but that's not the case anymore.
Do you have anything in mind to possibly help for this? Only show that toggle when the user has scrolled down to a certain point? Is that a decent solution?


Use newer cabal-helper to avoid choking on CFLib

Probably we need to clean our cache of cabal-helpers regularly to catch such problems (it's in another place from other build products)
See #329

There is also this branch: https://github.com/alanz/haskell-ide-engine/commit/6941e6908c3a1141909526030e8876e3fc905a42
It uses the one under dev, with cabal 2.0 support.
But there is still one tiny thing before the merge.
cc @DanielG


GEODE-3145 Add new protocol to Geode JAR

Thank you for submitting a contribution to Apache Geode.
In order to streamline the review of the contribution we ask you
to ensure the following steps have been taken:
For all changes:

[x] Is there a JIRA ticket associated with this PR? Is it referenced in the commit message?
GEODE-3145

[x] Has your PR been rebased against the latest commit within the target branch (typically develop)?

[x] Is your initial contribution a single, squashed commit?

[x] Does gradlew build run cleanly?

[ ] Have you written or updated unit tests to verify your changes?

[x] If adding new dependencies to the code, are these dependencies licensed in a way that is compatible for inclusion under ASF 2.0?

Note:
Please ensure that once the PR is submitted, you check travis-ci for build issues and
submit an update to your PR as soon as possible. If you need help, please send an
email to<EMAIL_ADDRESS>

This has been merged in f63b9d .


[incubator-kie-issues#1528] Implement DMNEvent reporting inside DMNConditionalEvaluator.

FIxes incubator-kie-issues#1528
Requires
https://github.com/apache/incubator-kie-kogito-runtimes/pull/3727
This PR:

define and implement AfterEvaluateConditionalEvent and AfterConditionalEvaluationEvent
define methods to instantiate and propagate them inside DMNRuntimeEventManagerUtils
invoke above methods from DMNConditionalEvaluator
move EvaluatorResult to kie-dmn-api

How to replicate CI configuration locally?

Build Chain tool does "simple" maven build(s), the builds are just Maven commands, but because the repositories relates and depends on each other and any change in API or class method could affect several of those repositories there is a need to use build-chain tool to handle cross repository builds and be sure that we always use latest version of the code for each repository.
build-chain tool is a build tool which can be used on command line locally or in Github Actions workflow(s), in case you need to change multiple repositories and send multiple dependent pull requests related with a change you can easily reproduce the same build by executing it on Github hosted environment or locally in your development environment. See local execution details to get more information about it.

How to retest this PR or trigger a specific build:

for pull request and downstream checks

Push a new commit to the PR. An empty commit would be enough.

for a full downstream build

for github actions job: add the label run_fdb

for Jenkins PR check only

If you are an ASF committer for KIE podling, login to Jenkins (https://ci-builds.apache.org/job/KIE/job/drools/), go to the specific PR job, and click on Build Now button.

PR job #1 was: UNSTABLE
Possible explanation: This should be test failures

Reproducer
build-chain build full_downstream  -f 'https://raw.githubusercontent.com/${AUTHOR:apache}/incubator-kie-kogito-pipelines/${BRANCH:main}/.ci/buildchain-config-pr-cdb.yaml' -o 'bc' -p apache/incubator-kie-drools -u https://github.com/apache/incubator-kie-drools/pull/6124 --skipParallelCheckout
NOTE: To install the build-chain tool, please refer to https://github.com/kiegroup/github-action-build-chain#local-execution

Please look here: https://ci-builds.apache.org/job/KIE/job/drools/job/main/job/pullrequest_jobs/job/drools-pr/job/PR-6124/1/display/redirect
Test results:

PASSED: 22659
FAILED: 1

Those are the test failures:

org.kie.dmn.validation.ValidatorTest.validateAllValidSharedModels
Expecting empty but was: [Message [id=0, level=WARNING, path=valid_models/DMNv1_5/RiskScore_Simple.dmn, line=46, column=-1   text=DMN: Decision table with single output on node 'Risk Score' should not have output name (DMN id: _8694B6C1-E07D-49A0-B77B-B8BF99C85B1D, The referenced element should not have a name set) ]]

kogito-runtimes failure unrelated
 sonataflow-addons-quarkus-python-integration-tests


Large file chunk support

When a server sets the header to include 'Transfer-encoding: chunked' it also OMITS the 'Content-length: ' from the header. That means default _content_length remains 0. Then the save() function always creates the file and then exits...since 'remain = self._content_size - read' will always result in a value of 0.
The response parser was correctly detecting the 'Transfer-encoding: chunked' and setting the necessary flags so I added detection for that condition and just read the stream into the file until the chunk read returns nothing from the stream.
I have tested the change extensively within my own project that is using mrequests but am not sure how to add such testing to this repository. The external server has the responsibility of setting the transfer encoding value.  Please advise.

Sorry for taking waaayyyy to long to address this! :-(
If you are still interested, could you test your use cases with commit 6c7a943666adc51fdf70e60aaffdafc6ada2458f ?
(I didn't use your patch because from my analysis it would break chunked reading/saving of responses without chunked transfer encoding.)

Hey! Don't worry about it at all. I understand the rigours of life and finding time to do everything is tough.
I had actually tested both the chunked and un-chunked use cases but I will set up a test environment to see what your changes do to my code. :)
It might take me a few days/weeks to get to this as I am in the middle of a release cycle in my day job.
I'll read the diff now at least.
:)

I had actually tested both the chunked and un-chunked use cases

Well, not actually break the latter, but download it all at once, if my interpretation was correct.

So...I reviewed your version of the code. It seems you have done a more integrated change in the save method. I intentionally didn't change the 'content-length' part of the implementation because I didn't have all of the test paths for that part.
Ultimately the big change is the detection of the 'transfer-encoding: chunked' header which engages a different mode of byte transfer in the save function. Your code does the same thing that my pull request did...but does it better. :)
I'll test it as soon as I can but it looks good.


Low quality of mask, iOS

Hello. I just tryed to apply circle stroke mask.
Android 8 draws it perfectly like something vector.
But iOS draws it low quality:

(Screenshot from iOS)
import { Svg, Defs, Rect, Circle, LinearGradient, Stop, G, Mask, Use } from 'react-native-svg';

const STOP_COLOR = 'red';

class Keck extends PureComponent {
    render() {
        const { rotation } = this.props;
        const innerDefs = [
            // bottom left rectangle
            { x: 0, y: 60, start: 0.9, end: 1 },
            // top left rectangle
            { x: 0, y: 0, start: 0.9, end: 0.75 },
            // top right rectangle
            { x: 60, y: 0, start: 0.75, end: 0.3 },
            // bottom right rectangle
            { x: 60, y: 60, start: 0, end: 0.5 },
        ];
        return (
            <Svg height="120" width="120" fill="transparent">
                <Defs>
                    <Mask id="mask"
                        x="0"
                        y="0"
                        width={120}
                        height={120}
                        maskUnits="userSpaceOnUse"
                    >
                        <Circle
                            r={42}
                            cx={60}
                            cy={60}
                            stroke="white"
                            strokeWidth={6}
                            strokeDasharray="1 4.5"
                        />
                    </Mask>
                </Defs>
                <G mask="url(#mask)">
                    <G rotation={rotation} origin="60, 60">
                        <OpticalGradient definitions={innerDefs} />
                    </G>
                </G>
            </Svg>
        );
    }
}

Why does it happens? Looks like something about 1x, 2x, 3x dpi.. but I don't get it where props about resolution...
PS: I don't show you <OpticalGradient ... /> because it's simple gradients rectangles which works fine.  If I use <Circle ... /> without mask -- it renders well, but I need to rotate gradient only inside Circle strokes.

Interesting, not sure why that would happen, would need to debug the masking logic. Not sure when I'll have time to look at this atm.

Interesting, not sure why that would happen, would need to debug the masking logic. Not sure when I'll have time to look at this atm.

it's looks good on iOS then I add to parent scale=0.5:
<Svg height={CONTAINER_SIZE} width={CONTAINER_SIZE} fill="transparent" transform={[{scale: 0.5}]}>
...
</Svg>

But it is complicate....

Maybe I can do gradient line-dots-strokes  without masks?

Just change stroke to fill and get the same result....

You might want to set breakpoints in xcode and step through these two places:
https://github.com/react-native-community/react-native-svg/blob/467dd22d3e7132fa30a6f96f15ae341484fc4a97/ios/RNSVGNode.m#L296-L299
https://github.com/react-native-community/react-native-svg/blob/467dd22d3e7132fa30a6f96f15ae341484fc4a97/ios/RNSVGRenderable.m#L192-L222

Also, could you try the https://github.com/react-native-community/react-native-svg/tree/filters_rebase branch? It has an alternative implementation for this.

filters_rebase branch:
https://github.com/react-native-community/react-native-svg/blob/257c7082c28ae5c8f7072f2be528ec7cb2ab8c01/ios/RNSVGRenderable.m#L240-L263

@msand okay, my steps:

Width and height of  and  is 193.

Update rnsvg to 9.9.3 (was 9.5.x or something that)

Launch iPhone 5s emulator from XCode.

Breakpoint at line 296 of RNSVGNode.m but It doesn't worked, because if (self.clipPath) above is false.

Breakpoint at line 195 of RNSVGRenderable stopped with:

next steps I see values like 193...
It's my first time to do this in XCode and I can't understand what I should see.
What is going to happen? Number 193 should be 193*2? Or 193/2? I don't get it, sorry. Not so smart for this.
I prepared to you my component file, you can try with it:
https://gist.github.com/zmnv/85c8ac3ab6ea13555c40d06e70795505

@msand
I installed filters_rebase branch into new clean project.
But the result as the same.
package.json
  "dependencies": {
    "react": "16.8.6",
    "react-native": "0.60.5",
    "react-native-svg": "github:react-native-community/react-native-svg#filters_rebase"
  },

source - https://gist.github.com/zmnv/85c8ac3ab6ea13555c40d06e70795505

This version is more stranger.... It just Duke Nukem or first Doom...
You can try simple test project – https://gitlab.com/zmnv/rnsvg-ios-test
index.js -> SvgMask/SvgMask.js
https://gitlab.com/zmnv/rnsvg-ios-test/blob/svg/SvgMask/SvgMask.js

I can't use style={{transform: [{scale: TRANSFORM_RESOLUTION}]}} because it will drop fps with animation.

Looking closer I realize the bitmap used has a low resolution, add a viewBox attribute to ensure a large enough bitmap for the mask, and use percentages in the width and height attributes of the Svg root instead like this:
import React, {PureComponent} from 'react';
import {View, StyleSheet} from 'react-native';
import {
  Svg,
  Defs,
  Rect,
  Circle,
  LinearGradient,
  Stop,
  G,
  Mask,
  Use,
} from 'react-native-svg';

const STOP_COLOR = 'red'; // Gradient color
const CONTAINER_SIZE = 1000;
const ELEMENT_SIZE = CONTAINER_SIZE / 2;

const OpticalGradient = props => {
  return props.definitions.map(({x, y, start, end}) => [
    <Defs key="gradient">
      <LinearGradient id={`gradient-${x}-${y}`} gradientUnits="userSpaceOnUse">
        <Stop offset="0%" stopColor={STOP_COLOR} stopOpacity={start} />
        <Stop offset="100%" stopColor={STOP_COLOR} stopOpacity={end} />
      </LinearGradient>
    </Defs>,
    <Rect
      key="rectangle"
      x={x}
      y={y}
      width={ELEMENT_SIZE}
      height={ELEMENT_SIZE}
      fill={`url(#gradient-${x}-${y})`}
    />,
  ]);
};

class MaskedCircleWithDashes extends PureComponent {
  render() {
    const {rotation = 180} = this.props;
    const innerDefs = [
      // bottom left rectangle
      {x: 0, y: ELEMENT_SIZE, start: 0.9, end: 1},
      // top left rectangle
      {x: 0, y: 0, start: 0.9, end: 0.5},
      // top right rectangle
      {x: ELEMENT_SIZE, y: 0, start: 0.75, end: 0.5},
      // bottom right rectangle
      {x: ELEMENT_SIZE, y: ELEMENT_SIZE, start: 0, end: 0.5},
    ];
    return (
      <Svg
        width="100%"
        height="100%"
        fill="transparent"
        viewBox={`0 0 ${CONTAINER_SIZE} ${CONTAINER_SIZE}`}>
        <Defs>
          <Mask
            id="mask"
            x="0"
            y="0"
            width={CONTAINER_SIZE}
            height={CONTAINER_SIZE}
            maskUnits="userSpaceOnUse"
            maskContentUnits="userSpaceOnUse">
            <Circle
              r={ELEMENT_SIZE - 16}
              cx={ELEMENT_SIZE}
              cy={ELEMENT_SIZE}
              stroke="white" // Mask color
              strokeWidth="4%"
              strokeDasharray="1% 4%"
            />
          </Mask>
        </Defs>
        <G mask="url(#mask)">
          <G rotation={rotation} origin={`${ELEMENT_SIZE}, ${ELEMENT_SIZE}`}>
            <OpticalGradient definitions={innerDefs} />
          </G>
        </G>
      </Svg>
    );
  }
}

export default () => (
  <View style={styles.container}>
    <MaskedCircleWithDashes />
  </View>
);

const styles = StyleSheet.create({
  container: {
    backgroundColor: 'black',
    justifyContent: 'center',
    alignItems: 'center',
    flex: 1,
  },
});

Facing this issue as well
Without mask

With mask


Importing and calling JS closures

I've been wrestling with this for a bit now and I'm unable to reach any firm conclusion on this, so I'm going to open an dedicated issue for this and leave it unimplemented for now (but hopefully not forever!). This is related to https://github.com/alexcrichton/wasm-bindgen/issues/78, but specifically a subset of functionality where we're importing closures from JS and then invoking them.
I'm not sure how to do this in a performant fashion unfortunately. Ideally we'd have something like this:
#[wasm_bindgen]
fn foo(a: &Fn()) }
    // ...
}

This means that the Rust shim needs to manufacture a Rust closure which, when called, will invoke the JS closure. The only way for wasm to exit back into JS (as far as I know) is to invoke an import. The set of imports, however, must be known statically and done with extern { ... } blocks in Rust.
Unfortunately extern { ... } blocks can't reference any generic parameters (rightfully so), so we can't actually implement this today. Most of the implementation of shims is pushed onto the trait system in Rust and uses generics, but this strategy means that we can't generate a new symbol import for wasm-bindgen to fill in later.
One possible solution to this is to have a generic __wbindgen_stack_call(..) function that is exported by our JS shims. This'd take a runtime description of the number of arguments and such. The downside of this approach is that it's very incompatible with ever extending this to custom types and otherwise is pretty slow from a JS engine perspective. In other words it'd almost always be faster to write a custom monomorphic shim and call it.
I fear that the current strategy of implementing #[wasm_bindgen] won't be sufficient for implementing invoking JS closures in Rust. I'm not really sure what would need to be done to get this working as well :(

I think this is "closed enough" with js_sys::Function for now, and we can investigate more specialized solutions as the need arises.


ClusterLoader - Storing resources versions

CreateObject and PatchObject return server objects
test executor stores resource types versions in State.

/assign @wojtek-t

As discussed offline - this won't be needed. So closing.


⚠ MineVN Maven & Resource Pack has degraded performance

In d73fe67, MineVN Maven & Resource Pack (http://app.minevn.net/pack) experienced degraded performance:

HTTP code: 404
Response time: 10516 ms

Resolved: MineVN Maven & Resource Pack performance has improved in a354b9b.


Gemfile with ruby version marker, instead of specific gemfiles/ files

This PR changes the Gemfile for the project, to include the Bundler feature ruby RUBY_VERSION, so that Bundler can locate the right gems for the current Ruby version.
Current status: ~experimental~ This passes all Travis tests, and does the right thing.

hutch.gemspec: Avoid concatenating a String by using line-continuation operator instead.

Thank you!


BLD: deploy to VM

Right now http://euphoria-recruiting.club redirects to the IP address (and port number) of our VM. We just need to manually deploy our code to the VM and make sure everything is set up correctly.

(Btw the domain name will expire in a year and I don't intend on renewing it)

Closed with a lot of help from @luster. Forgoing the domain name for now because honestly I'm cutting our losses at $2.


[CMake] Use CMAKE_CURRENT_SOURCE_DIR as base for includes in SwiftCompilerSources

When using a unified LLVM + Swift build (using LLVM_EXTERNAL_PROJECTS=swift),
CMAKE_SOURCE_DIR is llvm-project/llvm, and appending include/swift to that directory doesn’t result in the directory that contains Swift’s header files.
Instead, look up the header files relative to CMAKE_CURRENT_SOURCE_DIR.

@swift-ci Please smoke test


Matching a String array with an Element

Please use the following questions as a guideline to help me answer
your issue/question without further inquiry. Thank you.
Which version of Elastic are you using?
[ ] elastic.v2 (for Elasticsearch 1.x)
[ ] elastic.v3 (for Elasticsearch 2.x)
[ ] elastic.v5 (for Elasticsearch 5.x)
GET /mo_tracker/_search
{
"took": 2,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 1,
"max_score": 1,
"hits": [
{
"_index": "mo_tracker",
"_type": "msisdn",
"_id": "661234567890",
"_score": 1,
"_source": {
"msisdn": "661234567890",
"blocked": "false",
"offerIDs": [
"251",
"301"
],
"updatedAt": "2017-03-24T10:12:29.496510445Z"
}
}
]
}
}
Below query is not  for matching string array for an item is not working ?
offerFilter := elastic.NewTermQuery("offerIDs", offerID)
offerBoolFilter := elastic.NewBoolQuery().Should(offerFilter)
results, err := ESClient.Search().Index().Index(constants.MOTracker).Type(constants.MSISDN).Query(offerBoolFilter).Pretty(false).Do(context.Background())

Please describe the expected behavior
Please describe the actual behavior
Any steps to reproduce the behavior?
all the documents are getting matched irrespective of filter query ?

Maybe you need a TermsQuery, not a TermQuery? Notice the plural s.

Am 24.03.2017 um 11:59 schrieb dinilv<EMAIL_ADDRESS>Please use the following questions as a guideline to help me answer
your issue/question without further inquiry. Thank you.
Which version of Elastic are you using?
[ ] elastic.v2 (for Elasticsearch 1.x)
[ ] elastic.v3 (for Elasticsearch 2.x)
[ ] elastic.v5 (for Elasticsearch 5.x)
GET /mo_tracker/_search
{
"took": 2,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 1,
"max_score": 1,
"hits": [
{
"_index": "mo_tracker",
"_type": "msisdn",
"_id": "661234567890",
"_score": 1,
"_source": {
"msisdn": "661234567890",
"blocked": "false",
"offerIDs": [
"251",
"301"
],
"updatedAt": "2017-03-24T10:12:29.496510445Z"
}
}
]
}
}
Below query is not for matching string array for an item is not working ?
offerFilter := elastic.NewTermQuery("offerIDs", offerID)
offerBoolFilter := elastic.NewBoolQuery().Should(offerFilter)
results, err := ESClient.Search().Index().Index(constants.MOTracker).Type(constants.MSISDN).Query(offerBoolFilter).Pretty(false).Do(context.Background())
Please describe the expected behavior
Please describe the actual behavior
Any steps to reproduce the behavior?
all the documents are getting matched irrespective of filter query ?
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub, or mute the thread.

Thanks Olivere, i got the issue..


feature: add gesture handler and platform dependent touchable component

A platform dependent version of the TouchableHighlight.
Touchables don't usually work well with components like Gorhom's Bottom Sheet, or just don't work properly at all depending on the OS, so I ran some tests and figured the Native version works with iOS and Gesture Handler version works with Android. Might not be the case for everyone, but I hope this works as a solution.

I am extremely hesitant to add Gesture Handler as a dependency.  Have you tried Pressable?

can we merge this?
Need it


Add visualization + app building packages

holoviews (panel), dash (plotly) and streamlit are similar to
voila, in helping build 'dashboard' style interfaces that can
be used without needing to write code.
flask & fastapi can be used to develop and build servers that
provide a similar experience as a dashboard, but with more work

Based on conversations with @chicocvenancio, @fuzheado and Tina in the Jupyter / GLAM reconciliation group

@chicocvenancio does merging automatically build and push this? Or is that manual still?


'CFSDK/CFSDK-Swift.h' file not found (PgCordovaWrapper.m)

I am using cordova plugin ionic , trying to build ios
#import <CFSDK/CFSDK-Swift.h>
'CFSDK/CFSDK-Swift.h' file not found
Lexical or Preprocessor Issue Group

added config.xml


setxkbmap not working after 1.3.1

I recently upgraded to 2.2.0 beta and noticed setxkbmap -option "shift:both_capslock" (ran after keyd) no longer allows me to tap both shift keys to turn on capslock. So I decided to compile a few different versions to see where it broke, and I found that setxkbmap stopped functioning with 2.2.0 beta commit ad6d734d51a3e1ce1b693518af76b0bd35e7cd32. Currently I'm using v1.3.1 (9a424b4ad512804bce198af1281b01fb3a701030) where it works properly.
If this can be fixed, I'd appreciate it, otherwise I guess I will have to find another way using only keyd (if it's possible).
For 1.3.1, default.cfg is just:
capslock = overload(C, esc)
For new versions, I use default.conf which is:
[ids]
*

[main]
capslock = overload(C, esc)

I don't know if it matters, but I'm on Manjaro, XFCE, Linux kernel 5.15. Tested on a Logitech K845 and a Microsoft Wired Keyboard 600. Also I compiled keyd manually myself (not using AUR).

Thanks for putting in the effort to find the problematic commit.
This is not surprising given that 2.0 internally simplifies modifier handling.
In general my advice would be to avoid mixing keyd and setxkbmap (with the possible exception of setting your letter layout) since the two have different internal notions of keycodes. Anything that can be done with setxkbmap should be achievable with keyd.
In this particular case I believe you want:
[shift]
rightshift = capslock
leftshift = capslock

shift should just be treated like another layer (with some exceptions) so this should naturally read as:
modify the rightshift and leftshift keycodes within the shift layer. The first rightshift or leftshift will thus activate the shift layer to which these bindings will then apply. The end result is that simultaneously holding both shift keys will activate  capslock.

In this particular case I believe you want

Yep, this seems to work the same as the "shift:both_capslock" option. Thanks for the config snippet and explanation, I really appreciate it!


Enable SQL Savepoints

Background: https://airtable.com/tblD3oZPLJgGhCmch/viw1DKmbKhg2MIECH/recxI0iMnCxdfpS2h
Description: This feature is KV supporting SQL's adding Savepoint syntax.
A Savepoint is a marker within a transaction that allows rolling back to a specific point in a transaction.
Team: John Kendall, Andrew Kimball, Andrew Woods, Raphael 'kena' Poss, Andrei Matei, Bilal Akhtar

Testing.


Mismatch of data in Elastic and DB on deletes

Describe the bug
When a field in an aspect is updated to empty, DB gets updated, but ES keeps the previous value.
For e.g. there is a field called description in an aspect for some entity. And currently it contains some value, which is present in DB as well as ES. When the description is updated to empty string. DB is updated to empty string and UI shows accordingly, but ES still holds the previous description value. Although the hasDescription field in ES gets updated to false.
To Reproduce
Steps to reproduce the behavior:

Create any entity which has a valid description.
Update / Ingest the description to be empty string.
We can check the value in DB being empty string.
But the value of description in ES is still the previous description.

Expected behavior
Value of the description should be empty as well, matching what is in DB.
Desktop (please complete the following information):

OS: MacOS 14.6.1
Browser Chrome
Datahub-Version - 0.13.3

Additional context
As per initial analysis, its found that the document is upserted. So, the previous and current document are merged, hence the description from the previous document gets retained in the process.

@david-leifker Do you mind taking a look?

This will treat empty strings as null for ES indexing -> https://github.com/datahub-project/datahub/pull/11514

@david-leifker - Thanks !


fix: correctly apply extra params if builder is enabled

I noticed it is not possible to run mixed vc<>bn clients if builder / mev is enabled as it applies extra flags from other clients in vc_extra_params as the params are applied based on cl_type but it should be done based on vc_type.
I tested this using the following config with both mev_type: mock and mev_type: flashbots.

Good catch!


Refactor: Use late static binding for improved inheritance in Server recorder class

Overview
This pull request addresses an important improvement in the codebase by refactoring the usage of self::class to static::class in situations where we want to leverage late static binding. This change ensures greater flexibility, allowing for better inheritance and extension of the Server class.
Problem Statement
The current implementation uses self::class for obtaining the class name in the record method in Recorders\Servers. While this is appropriate in certain scenarios, it limits the ability of child classes to override the record method and inherit the desired behavior with additional functionalities. In this particular case, self::class is used to obtain the class name, and it serves as the key in the recorders array in the configuration file (config/pulse.php). For example,
// Obtain server_name and directories values from the configuration file
$server = $this->config->get('pulse.recorders.'.self::class.'.server_name');
$directories = $this->config->get('pulse.recorders.'.self::class.'.directories');

Here, the self::class references the class name where the record method is defined and uses it as the key in the recorders array. Once we override the Server class, we lose access to the key in the recorders array because the Recorders\Server namespace will be replaced with our custom class namespace in the recorders array. This returns null for server_name and directories, affecting metrics display in our dashboard.
I propose replacing instances of self::class with static::class in cases where we anticipate class inheritance. This change allows us to get the class name from which the record method was called, providing access to server_name and directories values from child classes with minimum effort.
Please review the proposed changes and provide feedback. This modification is aimed at improving the extensibility of our code. Thank you!

@taylorotwell are we going to get this update in the coming updates?

Pulse cards are not meant for extending. You should define your own card and use our helpers if you want.


Fix finding jsoncpp

Fixes multi-include bug that occurs for jsoncpp.
More information https://github.com/open-source-parsers/jsoncpp/issues/1356

@Serafadam thanks! How did you hit into that issue? Including core into some project that already uses jsoncpp?
I'm thinking if we should do a bugfix release or not...

This occurs when builting RTABMap standalone with DepthAI support


FTP Support

At the moment TS blocks requests for FTP URLs with an 'Unsupported Protocol' error message. This precludes TS from simply forwarding requests for FTP URLs to an upstream (parent) proxy.
We propose a fix to allow TS to forward FTP URLs to an upstream (parent) proxy; where this proxy supports HTTP/FTP conversion (e.g. Squid) this would enable FTP resources to be retrieved via TS. This change would also allow protocol plugins to be developed that support FTP URLs.
FTP Support would be optionally enabled with a new configuration setting in records.config preserving existing functionality if not present or set to the default value of false.
e.g.
proxy.config.ftp_enabled=1
Copy of Pull Request 1608 as no reply received so have raised as an issue.
https://github.com/apache/trafficserver/pull/1608

Closes as a duplicate. See PR #1608


fixed wrong alignment visium_io

minor visium fix (please after the review merge directly).

Tested with napari_spatialdata, without the change the data is not aligned. Also by placing the transformations this way all the layers are aligned together, so switching between hi and low res switches "in-place" between the low and high res image.

yeah the error is actually even different, it should be identity for the images (as they are already downscaled) while true scaling for shapes, will fix it in separate branch but this is how it looks like

in napari it's working because you are effectively upscaling the hires/lowres images to the true size image, hence you need identity for shapes....

I still believe that the napari version is the one we want. Here we have two options:

assuming the images (pixes) are the correct units everything will align to
aligning things in space when they represent the same thing.

I strongly believe that we want to go for 2. This would make plotting different (as one can't just plot the image with transformed shapes on top), but we will have the plotting library for this.

Side note: it would still be good to have everything "aligned" for practical purpose (also reported by Elyas), I thought about this and I am going to discuss this in a response to the discussion here in the next hour: https://github.com/scverse/spatialdata/issues/169

I still believe that the napari version is the one we want. Here we have two options:

assuming the images (pixes) are the correct units everything will align to
aligning things in space when they represent the same thing.
I strongly believe that we want to go for 2. This would make plotting different (as one can't just plot the image with transformed shapes on top), but we will have the plotting library for this.

yeah but this would still be wrong. In fact, the way it was before is that scaling is effectively upscaling the images/coordinates, whereas it should downscale.
the way it should be is the following

image_hires: 1 transform = Identity
image_lowres: 1 transform = Identity

and the hires/lower transform for shapes should be actual scaling (like downscaling). This would be faithful to how the data has been generated by space ranger. The reason it worked for napari it was basically 2 bugs cancelling each other.
It also doesn't make sense that two transformations (hires and lowres) for shapes are both identity, it's counterintuitive.
I'll fix this in this PR and then the spatialdata-sandbox should work out of the box

Codecov Report

Merging #21 (11fc08c) into main (330724a) will not change coverage.
The diff coverage is 33.33%.

Additional details and impacted files
@@           Coverage Diff           @@
##             main      #21   +/-   ##
=======================================
  Coverage   42.54%   42.54%
=======================================
  Files          13       13
  Lines         604      604
=======================================
  Hits          257      257
  Misses        347      347

Impacted Files
Coverage Δ

src/spatialdata_io/readers/visium.py
35.00% <0.00%> (ø)

src/spatialdata_io/_constants/_constants.py
100.00% <100.00%> (ø)

not yet, current version si basically what was at the beginning, I will fix and merge tomorrow!


Add support for running Puma with SSL

Puma will be executed using SSL. If the port provided is 80 (we will
be serving autoyast with no safe transport in 1.0), then we only
create the autoyast route, since we should not let the customers handle
Velum through an insecure connection.
Connect to the salt-api using TLS.
Remove certificate details from the UI and related code.
Fixes: bsc#1043570
Depends on:

https://github.com/kubic-project/salt/pull/136
https://github.com/kubic-project/caasp-container-manifests/pull/67

 Bug 1043570 - Velum – Content served over an insecure connection (HTTP)

 Bug 1043589 - Saltstack – API runs with SSL disabled

Force merged 3 TLS PRs that go together
https://github.com/kubic-project/velum/pull/210
https://github.com/kubic-project/salt/pull/136
https://github.com/kubic-project/caasp-container-manifests/pull/67


Corrected and added German translation

 Thank you for your submission, we really appreciate it. Like many open source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution.You have signed the CLA already but the status is still pending? Let us recheck it.

Hello,
Thank you very much for your contribution and sorry for the late update.
Your changes seem to be OK looking at the content of the commits. We will need to verify if they show correctly and nothing broke before merging them.
I will try to do it by the end of the week (week-end included) and i'll let you know.
Best Regards,
Romaric

Everything seems to be working correctly. I merge your contribution into the project.
Thanks again for the translation.