exploration.tests.test_analysis

  1"""
  2- Authors: Nissi, Jada, Rachel, Kaitlyn, Kitty, Peter Mawhorter
  3- Consulted: Peter Mawhorter
  4- Date: 2022-12-5
  5- Purpose: Tests for exploration analysis.
  6"""
  7
  8from .. import analysis, journal, core, base
  9
 10#Part of Rachel's journal:
 11JOURNAL = """
 12S Start_room::Start
 13  zz Starting_region
 14  A gain attack
 15  o right
 16  o left
 17xt left coin_room sr
 18  o up above_coin_room fall
 19    q _wall_kick_jumps  # TODO: '?' syntax
 20t sr
 21xt right platforms rp
 22  o up
 23  o right
 24xt up dangerplat ud
 25"""
 26
 27BABY_JOURNAL = """
 28S Start
 29  A gain jump
 30  A gain attack
 31  n button check
 32  zz Wilds
 33  o up
 34    q _flight
 35  o left
 36xt left left_nook right
 37  a geo_rock
 38    At gain geo*15
 39    At deactivate
 40  o up
 41    q _tall_narrow
 42t right
 43  o right
 44    q attack
 45"""
 46
 47BABY_JOURNAL_2 = """
 48S Start
 49  A gain jump
 50  A gain attack
 51  n button check
 52  zz Wilds
 53  o up
 54    q _flight
 55  o left
 56xt left left_nook right
 57"""
 58
 59REVISITS_JOURNAL = """
 60S A
 61x right B left
 62x down C up
 63x left D right           # 4 decisions ABCD
 64r up A down              # revisit #1 for A
 65t right                  # revisit #1 for B
 66r down_left D up_right   # revisit #1 for D
 67t right                  # revisit #1 for C
 68t up                     # revisit #2 for A
 69t left                   # revisit #2 for B
 70t down                   # revisit #2 for C
 71
 72# now we have: 2 revisits each for A, B, and C, and 1 revisit for D
 73"""
 74
 75ACTIONS_JOURNAL = """
 76S A
 77  oa alpha
 78x right B left
 79  oa beta
 80t left
 81  ta alpha
 82  oa gamma
 83x down C up
 84  a delta
 85  a epsilon
 86x right D left
 87w
 88"""
 89
 90
 91def test_CreateExploration() -> None:
 92    """
 93    Simple test to make sure we can create an exploration object for
 94    other tests in this file.
 95    """
 96    ex = journal.convertJournal(JOURNAL)
 97    assert len(ex) == 6
 98    assert ex.getActiveDecisions(0) == set()
 99    assert ex.getActiveDecisions(1) == {0}
100
101    assert bool(ex.getSituation(1).graph) is True
102
103
104def test_countActionsAtDecision() -> None:
105    """
106    Test to make sure the number of actions in the whole graph
107    at each step is accurate.
108    """
109    ex = journal.convertJournal(BABY_JOURNAL)
110    assert [
111        analysis.totalActions(ex, i)
112        for i in range(len(ex))
113    ] == [0, 0, 1, 1, 1]
114
115    now = ex.getSituation()
116    graph = now.graph
117    startID = graph.resolveDecision("Start")
118    nookID = graph.resolveDecision("left_nook")
119    assert analysis.actionCount(ex, len(ex) - 1, startID) == 0
120    assert analysis.actionCount(ex, len(ex) - 1, nookID) == 1
121
122    ex2 = journal.convertJournal(ACTIONS_JOURNAL)
123    assert [
124        analysis.totalActions(ex2, i)
125        for i in range(len(ex2))
126    ] == [0, 1, 2, 2, 3, 4, 5, 5, 5, 5]
127    assert [
128        analysis.meanActions(ex2, i)
129        for i in range(len(ex2))
130    ] == [0.0, 1/2, 2/2, 2/2, 3/3, 4/3, 5/3, 5/4, 5/4, 5/4]
131
132    for step in range(len(ex2)):
133        assert (
134            analysis.totalActions(ex2, step) /
135            analysis.totalDecisionsSoFar(ex2, step)
136         == analysis.meanActions(ex2, step)
137        )
138
139
140def test_count_actions() -> None:
141    """
142    Tests the 'actionCount' metric and its total/mean combiner values.
143    """
144    ex = journal.convertJournal(BABY_JOURNAL)
145    ex2 = journal.convertJournal(ACTIONS_JOURNAL)
146
147    assert analysis.actionCount(ex, 1, 0) == 0
148    assert analysis.actionCount(ex, 2, 1) == 0
149
150
151def test_describeProgress() -> None:
152    """
153    Tests the `describeProgress` function.
154    """
155    e1 = journal.convertJournal(BABY_JOURNAL)
156    e2 = journal.convertJournal(BABY_JOURNAL_2)
157    e3 = journal.convertJournal(REVISITS_JOURNAL)
158
159    description = analysis.describeProgress(e1)
160    assert description == """\
161Start of the exploration
162Start exploring domain main at 0 (Start)
163  Gained capability 'attack'
164  Gained capability 'jump'
165At decision 0 (Start)
166  In region Wilds
167  There are transitions:
168    left to unconfirmed
169    up to unconfirmed; requires _flight
170  1 note(s) at this step
171Explore left from decision 0 (Start) to 2 (now Wilds::left_nook)
172At decision 2 (left_nook)
173  There are transitions:
174    right to 0 (Start)
175  There are actions:
176    geo_rock
177Do action geo_rock
178  Gained 15 geo(s)
179Take right from decision 2 (left_nook) to 0 (Start)
180At decision 0 (Start)
181  There are transitions:
182    left to 2 (left_nook)
183    right to unconfirmed; requires attack
184    up to unconfirmed; requires _flight
185Waiting for another action...
186End of the exploration.
187"""
188
189    description2 = analysis.describeProgress(e2)
190    assert description2 == """\
191Start of the exploration
192Start exploring domain main at 0 (Start)
193  Gained capability 'attack'
194  Gained capability 'jump'
195At decision 0 (Start)
196  In region Wilds
197  There are transitions:
198    left to unconfirmed
199    up to unconfirmed; requires _flight
200  1 note(s) at this step
201Explore left from decision 0 (Start) to 2 (now Wilds::left_nook)
202At decision 2 (left_nook)
203  There are transitions:
204    right to 0 (Start)
205Waiting for another action...
206End of the exploration.
207"""
208
209    description3 = analysis.describeProgress(e3)
210    assert description3 == """\
211Start of the exploration
212Start exploring domain main at 0 (A)
213At decision 0 (A)
214  There are transitions:
215    right to unconfirmed
216Explore right from decision 0 (A) to 1 (now B)
217At decision 1 (B)
218  There are transitions:
219    down to unconfirmed
220    left to 0 (A)
221Explore down from decision 1 (B) to 2 (now C)
222At decision 2 (C)
223  There are transitions:
224    left to unconfirmed
225    up to 1 (B)
226Explore left from decision 2 (C) to 3 (now D)
227At decision 3 (D)
228  There are transitions:
229    right to 2 (C)
230    up to 0 (A)
231Take up from decision 3 (D) to 0 (A)
232At decision 0 (A)
233  There are transitions:
234    down to 3 (D)
235    right to 1 (B)
236Take right from decision 0 (A) to 1 (B)
237At decision 1 (B)
238  There are transitions:
239    down to 2 (C)
240    down_left to 3 (D)
241    left to 0 (A)
242Take down_left from decision 1 (B) to 3 (D)
243At decision 3 (D)
244  There are transitions:
245    right to 2 (C)
246    up to 0 (A)
247    up_right to 1 (B)
248Take right from decision 3 (D) to 2 (C)
249At decision 2 (C)
250  There are transitions:
251    left to 3 (D)
252    up to 1 (B)
253Take up from decision 2 (C) to 1 (B)
254At decision 1 (B)
255  There are transitions:
256    down to 2 (C)
257    down_left to 3 (D)
258    left to 0 (A)
259Take left from decision 1 (B) to 0 (A)
260At decision 0 (A)
261  There are transitions:
262    down to 3 (D)
263    right to 1 (B)
264Take down from decision 0 (A) to 3 (D)
265At decision 3 (D)
266  There are transitions:
267    right to 2 (C)
268    up to 0 (A)
269    up_right to 1 (B)
270Waiting for another action...
271End of the exploration.
272"""
273
274
275def test_unexploredBranches() -> None:
276    """
277    Tests the `unexploredBranches` and related count functions.
278    """
279    ex = journal.convertJournal(JOURNAL)
280    assert analysis.unexploredBranches(ex.getSituation(0).graph) == []
281    g1 = ex.getSituation(1).graph
282    assert g1.destinationsFrom(0) == {
283        'right': 1,
284        'left': 2
285    }
286    assert g1.nameFor(1) == '_u.0'
287    assert g1.nameFor(2) == '_u.1'
288    assert analysis.unexploredBranches(ex.getSituation(1).graph) == [
289        (0, 'right'),
290        (0, 'left'),
291    ]
292    assert analysis.unexploredBranches(ex.getSituation(2).graph) == [
293        (0, 'right'),
294        (2, 'up'),
295    ]
296    assert analysis.unexploredBranches(ex.getSituation(3).graph) == [
297        (0, 'right'),
298        (2, 'up'),
299    ]
300    g4 = ex.getSituation(4).graph
301    assert g4.namesListing(set(g4.nodes)) == """\
302  0 (Start_room::Start)
303  1 (Start_room::platforms)
304  2 (Start_room::coin_room)
305  3 (Start_room::above_coin_room)
306  4 (_u.3)
307  5 (_u.4)
308"""
309    assert analysis.unexploredBranches(ex.getSituation(4).graph) == [
310        (1, 'up'),
311        (1, 'right'),
312        (2, 'up'),
313    ]
314    assert analysis.unexploredBranches(ex.getSituation(5).graph) == [
315        (1, 'right'),
316        (2, 'up'),
317    ]
318    allPerStep = [
319        analysis.unexploredBranchCount(ex, step)
320        for step in range(len(ex))
321    ]
322    traversablePerStep = [
323        analysis.traversableUnexploredCount(ex, step)
324        for step in range(len(ex))
325    ]
326    assert allPerStep == [0, 2, 2, 2, 3, 2]
327    assert traversablePerStep == [0, 2, 1, 1, 2, 1]
328    # TODO
329
330
331def test_countBranches() -> None:
332    """
333    Tests the `countBranches` function.
334    """
335    ex = journal.convertJournal(BABY_JOURNAL)
336    ex2 = journal.convertJournal(BABY_JOURNAL_2)
337
338    # Note: as of v0.6, we can index an exploration to get a Situation,
339    # and most analysis functions want Situations as input
340
341    first = ex[0]
342    second = ex[1]
343    third = ex[2]
344    fourth = ex[3]
345    fifth = ex[4]
346
347    ex2first = ex2[0]
348    ex2second = ex2[1]
349    ex2third = ex2[2]
350
351    assert first.graph.namesListing(set(first.graph.nodes)) == """\
352  0 (Start)
353"""
354    assert analysis.meanBranches(ex, 0) == 0
355    assert analysis.meanBranches(ex, 1) == 2
356    assert analysis.meanBranches(ex, 2) == 1.5
357    assert analysis.meanBranches(ex, 3) == 2
358    assert analysis.meanBranches(ex, 4) == 2.5
359
360    startID = fifth.graph.resolveDecision("Start")
361    nookID = fifth.graph.resolveDecision("left_nook")
362    assert analysis.branches(ex, 1, startID) == 2
363    assert analysis.branches(ex, 2, startID) == 2
364    assert analysis.branches(ex, 2, nookID) == 1
365    assert analysis.branches(ex, 4, startID) == 3
366    assert analysis.branches(ex, 4, nookID) == 2
367
368    assert analysis.meanBranches(ex2, 0) == 0
369    assert analysis.meanBranches(ex2, 1) == 2
370    assert analysis.meanBranches(ex2, 2) == 1.5
371
372
373def test_revisits() -> None:
374    """
375    Tests the `arrivals`, `revisits`, and related total/mean/median
376    functions.
377    """
378
379    babyExp = journal.convertJournal(BABY_JOURNAL)
380    graph = babyExp.getSituation().graph
381    startID = graph.resolveDecision("Start")
382    nookID = graph.resolveDecision("left_nook")
383    assert analysis.stepsVisited(babyExp) == {
384        startID: [1, 4],
385        nookID: [2, 3]
386    }
387    assert analysis.arrivals(babyExp, startID) == 2
388    assert analysis.revisits(babyExp, startID) == 1
389    assert analysis.arrivals(babyExp, nookID) == 1
390    assert analysis.revisits(babyExp, nookID) == 0
391    assert analysis.arrivals(babyExp, 28309823) == 0
392    assert analysis.revisits(babyExp, 28309823) == 0
393
394    fullExp = journal.convertJournal(JOURNAL)
395    graph = fullExp.getSituation().graph
396    startID = graph.resolveDecision("Start")
397    coinRoomID = graph.resolveDecision("coin_room")
398    platformsID = graph.resolveDecision("platforms")
399    dangerplatID = graph.resolveDecision("dangerplat")
400    assert analysis.revisits(fullExp, startID) == 1
401    assert analysis.revisits(fullExp, coinRoomID) == 0
402    assert analysis.revisits(fullExp, platformsID) == 0
403    assert analysis.revisits(fullExp, dangerplatID) == 0
404
405    revExp = journal.convertJournal(REVISITS_JOURNAL)
406    graph = revExp.getSituation().graph
407    aID = graph.resolveDecision('A')
408    bID = graph.resolveDecision('B')
409    cID = graph.resolveDecision('C')
410    dID = graph.resolveDecision('D')
411    assert analysis.revisits(revExp, aID) == 2
412    assert analysis.revisits(revExp, bID) == 2
413    assert analysis.revisits(revExp, cID) == 1
414    assert analysis.revisits(revExp, dID) == 2
415
416    assert analysis.totalRevisits(babyExp) == 1
417    assert analysis.meanRevisits(babyExp) == 1/5
418    assert analysis.medianRevisits(babyExp) == 0
419    assert analysis.totalRevisits(fullExp) == 1
420    assert analysis.meanRevisits(fullExp) == 1/6
421    assert analysis.medianRevisits(fullExp) == 0
422    assert analysis.totalRevisits(revExp) == 7
423    assert analysis.meanRevisits(revExp) == 7/4
424    assert analysis.medianRevisits(revExp) == 2.0
425
426    blankExp = core.DiscreteExploration()
427    assert analysis.totalRevisits(blankExp) == 0
428    assert analysis.meanRevisits(blankExp) is None
429    assert analysis.medianRevisits(blankExp) is None
430
431    soloExp = core.DiscreteExploration()
432    soloExp.start("start")
433    assert analysis.totalRevisits(soloExp) == 0
434    assert analysis.meanRevisits(soloExp) == 0
435    assert analysis.medianRevisits(soloExp) == 0
436
437    doubleExp = core.DiscreteExploration()
438    doubleExp.start("start")
439    doubleExp.observe("start", "up")
440    doubleExp.explore("up", "above", "down")
441    assert analysis.totalRevisits(doubleExp) == 0
442    assert analysis.meanRevisits(doubleExp) == 0
443    assert analysis.medianRevisits(doubleExp) == 0
444
445
446def test_makeFractionCombiner() -> None:
447    """
448    Tests `makeFractionCombiner`.
449    """
450    c = analysis.makeFractionCombiner(lambda k, x: x > 2, lambda k, x: x < 0)
451    d = {
452        'a': 1,
453        'b': -2,
454        'c': 5,
455        'd': 3,
456        'e': 2.1
457    }
458    assert c(d) == 0.75  # type:ignore
459    c = analysis.makeFractionCombiner(lambda k, x: x < 0, lambda k, x: x > 0)
460    assert c(d) == 1.0  # type:ignore
461    c = analysis.makeFractionCombiner(lambda k, x: x < 0)
462    assert c(d) == 0.2  # type:ignore
463    c = analysis.makeFractionCombiner(lambda k, x: x > 2)
464    assert c(d) == 0.6  # type:ignore
465    c = analysis.makeFractionCombiner(lambda k, x: x % 3 == 7)
466    assert c(d) == 0.0  # type:ignore
467
468def test_cycleBasis() -> None:
469    """
470    Tests `cycleBasis`.
471    """
472    # Test using a custom several-cycle decision graph:
473    g = core.DecisionGraph()
474    g.addDecision('A')  # 0
475    g.addDecision('B')  # 1
476    g.addDecision('C')  # 2
477    g.addDecision('D')  # 3
478    g.addDecision('E')  # 4
479    g.addDecision('F')  # 5
480    g.addDecision('G')  # 6
481    g.addDecision('H')  # 7
482    g.addDecision('I')  # 8
483    assert analysis.cycleBasis(g) == []
484    g.addTransition('A', 'left', 'B', 'right')
485    g.addTransition('B', 'down', 'C', 'upRight')
486    assert analysis.cycleBasis(g) == []
487    g.addTransition('A', 'down', 'C', 'upLeft')  # triangle
488    assert analysis.cycleBasis(g) == [[0, 1, 2]]
489    g.addTransition('C', 'down', 'D', 'up')
490    g.addTransition('D', 'down', 'E', 'up')  # D is in-between
491    assert analysis.cycleBasis(g) == [[0, 1, 2]]
492    g.addTransition('E', 'downLeft', 'F', 'up')
493    g.addTransition('F', 'right', 'G', 'left')
494    g.addTransition('G', 'right', 'H', 'left')
495    assert analysis.cycleBasis(g) == [[0, 1, 2]]
496    g.addTransition('H', 'up', 'E', 'downRight')  # 4-node cycle
497    assert {frozenset(c) for c in analysis.cycleBasis(g)} == {
498        frozenset({0, 1, 2}),
499        frozenset({4, 5, 6, 7})
500    }
501    g.addTransition('G', 'down', 'I', 'up')  # branches off
502    assert {frozenset(c) for c in analysis.cycleBasis(g)} == {
503        frozenset({0, 1, 2}),
504        frozenset({4, 5, 6, 7})
505    }
506    g.setTransitionRequirement('C', 'down', base.ReqCapability('fly'))
507    g.setTransitionRequirement('E', 'up', base.ReqCapability('fly'))
508    assert {frozenset(c) for c in analysis.cycleBasis(g)} == {
509        frozenset({0, 1, 2}),
510        frozenset({4, 5, 6, 7})
511    }
512
513    # Test using snippet from problematic journal
514    cotmStart = """\
515# Setup
516P softerChecks on
517
518= enemy which common level rare rareLevel [
519  gd enemy:{which}
520  oa farm{which}{common}
521    e { <{level}>luck{ gain {common}*1 }{ } }
522  oa farm{which}{rare}
523    e { <{rareLevel}>luck{ gain {rare}*1 }{ } }
524]
525
526= farm from what [
527  ta farm{from}{what}%s
528]
529
530= cardEnemy which card level otherDrop otherLevel [
531  gd enemy:{which}
532  oa farmCard{which}{card}
533    e { <{level}>luck{ gain {card}; deactivate }{ } }
534  oa farm{which}{otherDrop}
535    e { <{otherLevel}>luck{ gain {otherDrop}*1 }{ } }
536]
537
538= gotCard from which [
539  ta farmCard{from}{which}%s
540]
541
542= subweapon which [
543  oa take{which}
544    e { lose Dagger; lose HolyWater; lose Boomerang; lose Axe; gain {which} }
545]
546
547= getItem what [
548  a get{what}
549    At { gain {what}*1; deactivate }
550]
551
552# Start
553S ConfrontationSite::main
554  zz Catacombs
555  o left
556  o down
557  m door:sealed
558  o right
559    qb door:unsealed
560  @
561    xt down RubbleTowerShaft::shaft up
562      gd suspended
563  @ @
564  a meetDracula
565    gt triggered
566    At follow down
567
568n at: RubbleTowerShaft::shaft
569  o fall bottom flyUp
570    qr ?flight
571  !a fallDown
572    q !?flight
573    gt triggered
574    At follow fall
575  n at: RubbleTowerShaft::bottom
576
577x down RubbleTowerBase::top up
578  > cardEnemy SkeletonBomber Salamander 1 Potion 6
579    n [ Real chances are 20% / 1%; this gives 25% / 0.78% ]
580  > gotCard SkeletonBomber Salamander
581    n [ Literally first enemy I touched; super lucky! ]
582x down mid up
583  > cardEnemy SkeletonBomber Salamander 1 Potion 6
584  o leftCrack
585    q ?airSlide
586x down bottom up
587  > cardEnemy SkeletonBomber Salamander 1 Potion 6
588
589x right CatacombsEntrance::top left
590  > cardEnemy SkeletonBomber Salamander 1 Potion 6
591  o upLeft
592    q ?higherJump
593  o upRight
594    q ?higherJump
595  > enemy Bat WristBand 4 Heart 7
596    n [ Real 2.5% / 0.5%; these are 3.125% / 0.39% ]
597    """
598    exp = journal.convertJournal(cotmStart)
599    assert analysis.cycleBasis(exp.getSituation().graph) == []