EmberJson

from emberjson import from_json, Value, ParseOptions

# Use custom options
var json = from_json[Value, ParseOptions(ignore_unicode=True)](r'["\uD83D\uDD25"]')

from emberjson import from_json, Value

print(from_json[Value](r'["\uD83D\uDD25"]')) # prints '["🔥"]'

from emberjson import try_from_json, Value

var result = try_from_json[Value]('{"key": 123}')
if result:
    print(result.value())  # prints {"key":123}

from emberjson import from_json, to_json, Document

def main() raises:
    var d = from_json[Document]('{"name": "ember", "versions": [1, 2.5]}')

    print(d.root()["name"].string())        # ember
    print(d.root()["versions"][1].float())  # 2.5
    print(len(d.root()["versions"]))        # 2

    for entry in d.root().object():         # zero-copy keys and values
        print(entry.key)

    print(to_json(d))                       # serialize straight off the tape

    # Materialize an owned, mutable Value tree when you need to modify
    # the data or keep it beyond the Document's lifetime:
    var v = d.to_value()
    v["name"] = "modified"

from emberjson import parse_pointer

var name = parse_pointer(big_doc, "/statuses/99/user/screen_name")
print(name.string())

from emberjson import from_json, Value, is_valid_utf8, ParseOptions

var v = from_json[Value](untrusted_bytes)  # raises on invalid UTF-8

comptime trusted = ParseOptions(validate_utf8=False)
var w = from_json[Value, trusted](my_own_bytes)  # skips the check

# Also available standalone:
if is_valid_utf8(some_bytes):
    ...

from emberjson import from_json, to_json, to_json_pretty, Value

def main() raises:
    var json = from_json[Value]('{"key": 123}')

    print(to_json(json)) # prints {"key":123}
    print(to_json_pretty(json))
# prints:
#{
#    "key": 123
#}

from emberjson import minify

var compact = minify('{ "key" :  123 }')
print(compact)  # prints {"key":123}

from emberjson import *
from std.testing import assert_equal

var json = from_json[Value]('{"key": 123}')

# check inner type
print(json.is_object()) # prints True

# dict style access
print(json.object()["key"].int()) # prints 123

# array
var value = from_json[Value]('[123, 4.5, "string", true, null]')
ref array = value.array()

# array style access
print(array[3].bool()) # prints True

# equality checks
print(array[4] == Null()) # prints True

# None converts implicitly to Null
assert_equal(array[4], Value(None))

# Implicit ctors for Value
var v: Value = "some string"

# Convert Array and Dict back to stdlib types
# These are consuming actions so the original Array/Object will be moved
var arr = Array(123, False)
var l = arr.to_list()

var ob = Object()
var d = ob.to_dict()

from emberjson import from_json, try_from_json


@fieldwise_init
struct User(Defaultable, Movable):
    var id: Int
    var name: String
    var is_active: Bool
    var scores: List[Float64]

    def __init__(out self):
        self.id = 0
        self.name = ""
        self.is_active = False
        self.scores = List[Float64]()


def main() raises:
    var json_str = '{"id": 1, "name": "Mojo", "is_active": true, "scores": [9.9, 8.5]}'

    # Raises `DeserializationError` on invalid JSON
    var user = from_json[User](json_str)
    print(user.name)  # prints Mojo

    # Returns `Optional[User]` instead of raising
    var user_opt = try_from_json[User](json_str)
    if user_opt:
        print(user_opt.value().name)  # prints Mojo

from emberjson import from_json, try_from_json, ParseOptions

@fieldwise_init
struct Doc(Defaultable, Movable):
    var text: String

    def __init__(out self):
        self.text = ""


def main() raises:
    comptime fast = ParseOptions(ignore_unicode=True, validate_utf8=False)
    var d = from_json[Doc, fast]('{"text": "\\u0041"}')
    print(d.text)  # prints \u0041 -- the escape is left undecoded

    var maybe = try_from_json[Doc, fast]('{"text": "hi"}')
    print(maybe.value().text)  # prints hi

from emberjson import from_json


@fieldwise_init
struct Address(Defaultable, Movable):
    var city: String
    var zip: Optional[String]

    def __init__(out self):
        self.city = ""
        self.zip = None


@fieldwise_init
struct Person(Defaultable, Movable):
    var name: String
    var address: Address

    def __init__(out self):
        self.name = ""
        self.address = Address()


def main() raises:
    var json_str = '{"name": "Mojo", "address": {"city": "SF"}}'
    var person = from_json[Person](json_str)
    print(person.name)              # prints Mojo
    print(person.address.city)      # prints SF
    print(person.address.zip)       # prints None (missing field)

from emberjson import from_json
from emberserde import DenyUnknownFields


@fieldwise_init
struct Loose(Defaultable, Movable):
    var x: Int

    def __init__(out self):
        self.x = 0


@fieldwise_init
struct Strict(DenyUnknownFields, Defaultable, Movable):
    var x: Int

    def __init__(out self):
        self.x = 0


def main() raises:
    # Unknown wire fields are SKIPPED by default (they are still fully
    # validated on the way past, not blindly hopped over).
    print(from_json[Loose]('{"x": 1, "extra": [1, 2]}').x)  # prints 1

    # Opt back in to rejecting them per type.
    try:
        _ = from_json[Strict]('{"x": 1, "extra": 2}')
    except e:
        print(e.kind)  # prints UnknownField

from emberjson import to_json


@fieldwise_init
struct Point:
    var x: Int
    var y: Int


def main() raises:
    print(to_json(Point(1, 2)))               # prints {"x":1,"y":2}
    print(to_json[pretty=True](Point(1, 2)))  # pretty printed

from emberjson import from_json, DeserializationError, DerErrorKind


@fieldwise_init
struct Inner(Defaultable, Movable):
    var x: Int
    var y: Int

    def __init__(out self):
        self.x = 0
        self.y = 0


@fieldwise_init
struct Outer(Defaultable, Movable):
    var label: String
    var inner: Inner

    def __init__(out self):
        self.label = ""
        self.inner = Inner()


def main() raises:
    try:
        _ = from_json[Outer]('{"label": "a", "inner": {"x": 1}}')
    except e:
        print(e.message)  # missing field: y
        print(e.kind)     # MissingField
        print(e.path)     # .inner

from emberjson import from_json, to_json
from emberserde import (
    DerErrorKind,
    Deserializable,
    DeserializationError,
    Deserializer,
    Serializable,
    SerializationError,
    Serializer,
)


@fieldwise_init
struct Celsius(Deserializable, Serializable):
    var degrees: Float64

    def serialize(self, mut s: Some[Serializer]) raises SerializationError:
        # Ride the wire as "21.5C" instead of a bare number.
        s.serialize_string(String(self.degrees) + "C")

    @staticmethod
    def deserialize(
        mut d: Some[Deserializer],
    ) raises DeserializationError -> Self:
        var raw = d.expect_string()
        try:
            return Self(atof(raw.removesuffix("C")))
        except:
            # `atof` raises an untyped `Error`; the trait's contract is a
            # typed `DeserializationError`, so convert at the boundary.
            raise DeserializationError(
                String("not a temperature: ") + raw,
                DerErrorKind.InvalidValue,
            )


def main() raises:
    print(to_json(Celsius(21.5)))                 # prints "21.5C"
    print(from_json[Celsius]('"21.5C"').degrees)  # prints 21.5

from emberjson import from_json, to_json, Field, Defaulted


# `Defaultable` because the payloads have non-trivial destructors: the
# framework only claims an unwritten struct in place when every field is
# trivially destructible, otherwise it wants a real default to fill in.
@fieldwise_init
struct Config(Defaultable, Movable):
    var host: Field[String, rename="hostname"]
    var port: Defaulted[Int, 8080]
    var cache: Field[String, skip=True]

    def __init__(out self):
        self.host = {}
        self.port = {}
        self.cache = {}


def main() raises:
    var c = from_json[Config]('{"hostname": "localhost"}')
    print(c.host[])          # prints localhost
    print(c.port[])          # prints 8080 -- the key was absent
    print(to_json(c))        # prints {"hostname":"localhost","port":8080}

from emberjson import from_json, LazyValue, LazyString

struct Event[origin: ImmOrigin](Movable):
    var id: Int64                      # parsed eagerly
    var payload: LazyValue[Self.origin]  # span captured, parsed on demand
    var note: LazyString[Self.origin]

var e = from_json[Event[origin_of(data)]](data)
print(e.id)                  # already materialized
print(e.payload.get())       # parses just this subtree, now

from emberjson import *

var port = Range[Int, 1, 65535](8080)
print(port[])  # prints 8080

var port2 = from_json[Range[Int, 1, 65535]]("443")
print(port2[])  # prints 443

from emberjson import *

# Validate on deserialization
var name = from_json[NonEmpty[String]]('"Alice"')

# Validate on construction
var score = Range[Float64, 0.0, 100.0](95.5)

# Enum-style validation (the element type is inferred from the values)
comptime Color = Enum["red", "green", "blue"]
var c = from_json[Color]('"red"')
print(c[])  # prints red

from emberjson import *

# AllOf: ALL validators must pass
var v = from_json[
    AllOf[String, Size[String, 3, 7], StartsWith["a"]]
]('"astring"')

# OneOf: EXACTLY one validator must pass
var o = from_json[
    OneOf[String, Eq["red"], Eq["green"], Eq["blue"]]
]('"red"')

# AnyOf: AT LEAST one validator must pass
var a = from_json[
    AnyOf[Int, Eq[1], Eq[2], Range[Int, 10, 20]]
]("15")

# NoneOf: NO validators must pass
var n = from_json[
    NoneOf[Int, Range[Int, 0, 5], Eq[100]]
]("7")

# Not: invert any validator
var x = from_json[Not[Int, Range[Int, 0, 10]]]("15")

from emberjson import *

# Default: use a fallback value when the field is missing from the object.
# `Default[T, d]` is emberserde's `Field[T, default=d]`, so the fallback
# fires on an ABSENT KEY only -- an explicit `null` is a present value and
# is parsed as `T` (see the struct example below). Wrap the payload in
# `Optional` when `null` should be tolerated too:
#   Defaulted[Optional[Int], Optional[Int](42)]
var d = from_json[Default[Int, 42]]("7")
print(d[])  # prints 7

# Secret: deserializes normally, serializes as "********"
var pw = from_json[Secret[String]]('"my_password"')
print(pw[])         # prints my_password
print(to_json(pw))  # prints "********"

# Clamp: constrains value to a range instead of rejecting
var c = from_json[Clamp[Int, 0, 100]]("150")
print(c[])  # prints 100 (clamped to max)

# CoerceInt/CoerceFloat/CoerceString: type coercion from JSON
var i = from_json[CoerceInt]('"123"')
print(i[])  # prints 123 (coerced from string)

# Transform: apply a function during deserialization
def date_to_epoch(s: String) -> Int:
    if s == "2024-01-01":
        return 1704067200
    return 0

var epoch = from_json[Transform[String, Int, date_to_epoch]]('"2024-01-01"')
print(epoch[])  # prints 1704067200

from emberjson import *

struct Config(Movable):
    var port: Range[Int, 1, 65535]
    var retries: Range[Int, 0, 10]
    var timeout: Default[Int, 30]

def main() raises:
    var cfg = from_json[Config]('{"port": 8080, "retries": 3}')
    print(cfg.port[])      # prints 8080
    print(cfg.retries[])   # prints 3
    print(cfg.timeout[])   # prints 30 (default, since missing from JSON)
    print(to_json(cfg))    # prints {"port":8080,"retries":3,"timeout":30}

from emberjson import *
from emberjson.schema import CrossFieldValidator

@fieldwise_init
struct DateRange(Defaultable, Movable):
    var start: Int
    var end: Int

    def __init__(out self):
        self.start = 0
        self.end = 0

def validate_order(start: Int, end: Int) raises:
    if start >= end:
        raise Error("start must be before end")

def main() raises:
    var dr = from_json[
        CrossFieldValidator[DateRange, "start", "end", validate_order]
    ]('{"start": 1, "end": 10}')
    print(dr[].start)  # prints 1
    print(dr[].end)    # prints 10

from emberjson import from_json, Value

var j = from_json[Value]('{"foo": ["bar", "baz"]}')

# Access nested values
print(j.get("/foo/1").string())  # prints baz

# Syntactic sugar via backticks
print(j.`/foo/1`.string())

# Modify values
j.get("/foo/1") = "modified"
# or
j.`/foo/1` = "modified"

# RFC 6901 Escaping (~1 for /, ~0 for ~) covers special characters
var j2 = from_json[Value]('{"a/b": 1, "m~n": 2}')
print(j2.get("/a~1b").int()) # prints 1
print(j2.get("/m~0n").int()) # prints 2

# Dot access for standard identifiers
print(j.foo)  # Equivalent to j.get("/foo")

# Backtick syntax for full pointer paths
print(j.`/foo/1`.string())  # Equivalent to j.get("/foo/1")

# In-place modification via backticks
j.`/foo/1` = "updated"
print(j.`/foo/1`.string())  # prints "updated"

# Chained access for nest objects
j = {"foo": {"bar": [1, 2, 3]}}
print(j.foo.bar[1])  # prints 2

from emberjson import from_json, Value, Object
from emberjson.patch import patch, merge_patch

def main() raises:
    # RFC 6902: apply a sequence of operations
    var doc = from_json[Value]('{"foo": "bar", "items": [1, 2]}')
    patch(doc, """[
        {"op": "replace", "path": "/foo", "value": "baz"},
        {"op": "add", "path": "/items/-", "value": 3},
        {"op": "remove", "path": "/items/0"}
    ]""")
    # doc is now {"foo": "baz", "items": [2, 3]}

    # Supported operations: add, remove, replace, move, copy, test
    # "test" asserts a value matches — raises if it doesn't
    patch(doc, '[{"op": "test", "path": "/foo", "value": "baz"}]')

    # RFC 7386: recursive merge patch
    var target = from_json[Value]('{"a": "b", "c": {"d": "e", "f": "g"}}')
    merge_patch(target, '{"a": "z", "c": {"f": null}}')
    # target is now {"a": "z", "c": {"d": "e"}}
    # null values remove keys

from emberjson import read_lines, write_lines, Value, Array
from std.pathlib import Path

def main() raises:
    # Read: iterate over lines lazily
    for value in read_lines("data.jsonl"):
        print(value)

    # Read: collect all lines into a list
    var all_values = read_lines("data.jsonl").collect()

    # Write: save a list of values as JSONL
    var lines: List[Value] = [Value(1), Value(2), Value(3)]
    write_lines(Path("output.jsonl"), lines)