1
import json
2

3
filename = "data.json"
4

5
# target file might not exist
6
with open(filename, "r", encoding="utf-8") as file:
7
    data = json.load(file)
8

9
# entries key might not exist
10
entries = data["entries"]
11

12
# some entries might not have the "disabled" key
13
filtered_entries = {k: v for k, v in entries.items() if not v["disabled"]}
14

15
new_data = {"entries": filtered_entries}
16

17
# writing to file might fail
18
with open("new_" + filename, "w", encoding="utf-8") as file:
19
    json.dump(new_data, file, ensure_ascii=False, indent=4)

1
import json
2
from returns.result import safe
3
# partial application, tap for side effects
4
from returns.functions import partial, tap
5

6
# @safe will wrap the return value in a ResultE type and automatically handle exceptions
7
@safe
8
def read_file(filename: str) -> dict:
9
    with open(filename, "r", encoding="utf-8") as file:
10
        return json.load(file)
11

12
@safe
13
def get_entries(data: dict) -> dict:
14
    filtered_entries = {
15
        k: v for k, v in data["entries"].items() if not v.get("disabled", False)
16
    }
17
    return {"entries": filtered_entries}
18

19
@safe
20
# return a dict so that we can tap it
21
def write_file(filename: str, data: dict) -> dict:
22
    with open(filename, "w", encoding="utf-8") as file:
23
        json.dump(data, file, ensure_ascii=False, indent=4)
24
    return data
25

26
filename = "data.json"
27

28
read_file(filename).bind(get_entries).bind(
29
    partial(write_file, "new_" + filename)
30
).map(tap(print))

1
#import "@preview/cetz:0.4.0"
2

3
#set page(height: auto, width: auto, margin: (x: 0pt, y: 10pt))
4

5
#set text(size: 10pt)
6

7
#cetz.canvas(length: 1.5cm, {
8
  let hid = hide
9
  import cetz.draw: *
10
  import cetz.angle: *
11
  let len = 4
12
  let nline = 30
13
  let stroke = 0.6pt
14
  let floorStroke = 1pt
15
  set-style(stroke: stroke)
16
  hide(line((0, 0), (30deg, len), name: "slope"))
17
  line((0, 0), (30deg, len), (rel: (0, -len / 2)), close: true)
18
  line((rel: (len / 8, 0)), (-len / 8, 0), name: "floor", stroke: floorStroke)
19
  let pos = range(1, nline + 1).map(x => x / nline * 100%)
20
  for i in pos {
21
    line(("floor.end", i, "floor.start"), (rel: (-0.2, -0.2)))
22
  }
23
  angle("slope.start", "slope.end", "floor.start", direction: "cw", name: "angle")
24
  content((name: "angle", anchor: 15deg), [$theta$], anchor: "west", padding: 0.04)
25
  {
26
    rotate(z: 30deg)
27
    rect((len * 1 / 2, 0), (rel: (len / 8, len / 8)), name: "obj")
28
    circle("obj", radius: 0.01, fill: black)
29
  }
30
  set-style(mark: (end: ">", scale: 0.4), fill: black)
31
  let len = 1
32
  line("obj.center", (rel: (-120deg, len)), name: "G")
33
  line("obj.center", (rel: (0, len * calc.cos(30deg))), name: "N")
34
  line("obj.center", (rel: (len * calc.sin(30deg), 0)), name: "f")
35
  content("G.end", [$m g$], anchor: "north")
36
  content("N.end", [$N$], anchor: "south-east")
37
  content("f.end", [$f$], anchor: "south-west")
38
  set-style(fill: red, stroke: red + stroke)
39
  line("obj.center", (rel: (0, -len * calc.cos(30deg))), name: "vG")
40
  line("obj.center", (rel: (-len * calc.sin(30deg), 0)), name: "hG")
41
  content("vG.end", [$m g cos theta$], anchor: "north-west")
42
  content("hG.end", [$m g sin theta$], anchor: "north-east", padding: 0.04)
43
  set-style(mark: none, stroke: (dash: "dashed", paint: red, thickness: stroke))
44
  line((), "G.end")
45
  line((), "vG.end")
46
})

1
#import "@preview/fletcher:0.5.8": *
2

3
#set page(height: auto, width: auto, margin: (x: 10pt, y: 10pt))
4

5
#diagram(
6
  cell-size: 20mm,
7
  let padding = -1mm,
8
  $cal(F)(U) edge("r", phi(U), ->) edge("d", rho_(U V), ->, label-anchor: "west", label-sep: #padding) & cal(G)(U) edge("d", rho'_(U V), ->) \
9
  cal(F)(V) edge("r", phi(V), ->) & cal(G)(V)$,
10
)