Core Types

from glyph import GValue

v = GValue.null()
print(v.is_null())  # True

v = GValue.bool_(True)
print(v.as_bool())  # True

v = GValue.int_(42)
print(v.as_int())  # 42

v = GValue.float_(3.14)
print(v.as_float())  # 3.14

v = GValue.str_("hello world")
print(v.as_str())  # "hello world"

v = GValue.bytes_(b"\x00\x01\x02")
print(v.as_bytes())  # b'\x00\x01\x02'

from datetime import datetime, timezone

dt = datetime(2025, 1, 13, 12, 0, 0, tzinfo=timezone.utc)
v = GValue.time(dt)
print(v.as_time())  # 2025-01-13 12:00:00+00:00

# With prefix
user_id = GValue.id("user", "123")
ref = user_id.as_id()
print(ref.prefix)  # "user"
print(ref.value)   # "123"

# Without prefix
simple_id = GValue.id("", "abc")

v = GValue.list_(
    GValue.int_(1),
    GValue.int_(2),
    GValue.int_(3)
)
print(len(v))  # 3

from glyph import MapEntry

v = GValue.map_(
    MapEntry("name", GValue.str_("Alice")),
    MapEntry("age", GValue.int_(30))
)
print(v.get("name").as_str())  # "Alice"

from glyph import MapEntry

v = GValue.struct("Person",
    MapEntry("name", GValue.str_("Alice")),
    MapEntry("age", GValue.int_(30))
)
struct = v.as_struct()
print(struct.type_name)  # "Person"

# Sum with value
some = GValue.sum("Some", GValue.int_(42))
sum_val = some.as_sum()
print(sum_val.tag)    # "Some"
print(sum_val.value.as_int())  # 42

# Sum without value
none = GValue.sum("None", None)

v = GValue.null()
if v.is_null():
    print("Value is null")

v = GValue.bool_(True)
result = v.as_bool()  # True

v = GValue.int_(42)
result = v.as_int()  # 42

v = GValue.float_(3.14)
result = v.as_float()  # 3.14

v = GValue.str_("hello")
result = v.as_str()  # "hello"

v = GValue.bytes_(b"data")
result = v.as_bytes()  # b"data"

from datetime import datetime, timezone

v = GValue.time(datetime.now(timezone.utc))
result = v.as_time()  # datetime object

v = GValue.id("user", "123")
ref = v.as_id()
print(ref.prefix)  # "user"
print(ref.value)   # "123"

v = GValue.list_(GValue.int_(1), GValue.int_(2))
lst = v.as_list()
for item in lst:
    print(item.as_int())

from glyph import MapEntry

v = GValue.map_(MapEntry("a", GValue.int_(1)))
entries = v.as_map()
for entry in entries:
    print(f"{entry.key} = {entry.value.as_int()}")

v = GValue.struct("Person", MapEntry("name", GValue.str_("Alice")))
struct = v.as_struct()
print(struct.type_name)  # "Person"
for field in struct.fields:
    print(f"{field.key}: {field.value}")

v = GValue.sum("Some", GValue.int_(42))
sum_val = v.as_sum()
print(sum_val.tag)     # "Some"
print(sum_val.value)   # GValue.int_(42)

v1 = GValue.int_(42)
v2 = GValue.float_(3.14)

print(v1.as_number())  # 42
print(v2.as_number())  # 3.14

v = GValue.map_(MapEntry("name", GValue.str_("Alice")))
name = v.get("name")
if name:
    print(name.as_str())  # "Alice"

v = GValue.list_(GValue.int_(1), GValue.int_(2), GValue.int_(3))
print(v.index(0).as_int())  # 1
print(v.index(2).as_int())  # 3

v = GValue.list_(GValue.int_(1), GValue.int_(2))
print(len(v))  # 2

v2 = GValue.map_(MapEntry("a", GValue.int_(1)))
print(len(v2))  # 1

v = GValue.map_()
v.set("name", GValue.str_("Alice"))
v.set("age", GValue.int_(30))

v = GValue.list_()
v.append(GValue.int_(1))
v.append(GValue.int_(2))
print(len(v))  # 2

original = GValue.list_(GValue.int_(1), GValue.int_(2))
copy = original.clone()
copy.append(GValue.int_(3))

print(len(original))  # 2
print(len(copy))      # 3

from glyph import GType

v = GValue.int_(42)
if v.type == GType.INT:
    print("It's an integer")

from glyph import MapEntry, GValue

entry = MapEntry("name", GValue.str_("Alice"))
print(entry.key)    # "name"
print(entry.value)  # GValue.str_("Alice")

from glyph import RefID

ref = RefID("user", "123")
print(ref.prefix)  # "user"
print(ref.value)   # "123"
print(str(ref))    # "^user:123"

from glyph import g, field

# Instead of GValue.str_("hello")
v = g.str("hello")

# Build complex structures
person = g.struct("Person",
    field("name", g.str("Alice")),
    field("age", g.int(30)),
    field("scores", g.list(g.int(95), g.int(87), g.int(92)))
)

from glyph import field, g

# Create fields
name_field = field("name", g.str("Alice"))
age_field = field("age", g.int(30))

# Use in structs
person = g.struct("Person", name_field, age_field)

from glyph import g, field
import glyph

# Create a match result
match = g.struct("Match",
    field("home", g.str("Arsenal")),
    field("away", g.str("Liverpool")),
    field("score", g.list(g.int(2), g.int(1))),
    field("date", g.str("2025-03-15")),
    field("venue", g.struct("Venue",
        field("name", g.str("Emirates Stadium")),
        field("capacity", g.int(60704))
    ))
)

# Emit to GLYPH format
text = glyph.emit(match)
print(text)

from glyph import GType

def process_value(v):
    """Process different value types."""
    if v.type == GType.NULL:
        return None
    elif v.type == GType.INT:
        return v.as_int() * 2
    elif v.type == GType.STR:
        return v.as_str().upper()
    elif v.type == GType.LIST:
        return [process_value(item) for item in v.as_list()]
    else:
        return v