By default, all logs within a project are stored in the default context (represented by the empty string ""). 
unify.log(x=0, y=1, z=2)
When no context is specified in the interface or the table, then the default context is used. However, you can group your logs into non-overlapping contexts, which can then be displayed in separate tables. 
import unify
import random
from datetime import datetime

first_names = ["Zoe", "John", "Jane", "Jim", "Jill"]
last_names = ["Smith", "Johnson", "Williams", "Jones", "Brown"]
qnas = {
    "what is 1 + 1?": 2,
    "what is 2 * 3?": 6,
    "what is 3 - 2?": 1,
    "what is 4 / 2?": 2,
    "what is 5 % 2?": 1
}
regions = ["US", "EU", "UK", "AU", "CA"]

for _ in range(20):
    question = random.choice(
        list(qnas.keys())
    )
    unify.log(
        timestamp=datetime.now().isoformat(),
        first_name=random.choice(first_names),
        last_name=random.choice(last_names),
        question=question,
        region=random.choice(regions),
        dob=datetime(
            year=random.randint(1980, 2010),
            month=random.randint(1, 12),
            day=random.randint(1, 28)
        ).isoformat(),
        context="Traffic"
    )

predictions = [
    "six", "one", "two", "three", "four", "five"
]

for _ in range(15):
    question, answer = random.choice(
        list(qnas.items())
    )
    unify.log(
        question=question,
        agent_prediction=random.choice(
            predictions
        ),
        answer=answer,
        context="Evals"
    )

​
Context Handling

You can use with unify.Context("..."): to create a context, and all logging inside this block will adopt this context. 
import unify

with unify.Context("Traffic"):
    unify.log(
        name="Zoe",
        question="what is 1 + 1?",
        region="US"
    )
    unify.log(
        name="John",
        question="what is 2 + 2?",
        region="EU"
    )

​
Nested Contexts

These can also be arbitrarily nested, where each context string is joined via / to define the full context path. 
import unify

with unify.Context("Sciences"):
    with unify.Context("Maths"):
        unify.log(
            name="Zoe",
            question="what is 1 + 1?",
            region="US"
        )
        with unify.Context("Physics"):
            unify.log(
                name="John",
                question="what is the speed of light?",
                region="EU"
            )
with unify.Context("Arts"):
    with unify.Context("Literature"):
        unify.log(
            name="Jane",
            question="What does this sentence convey?",
            region="UK"
        )
The “Sciences” context cannot itself be selected in a table (there is no data), but it forms part of the directory structure for selecting the available contexts. However, “Sciences” can be selected as the context of the tab in the interface, which limits the search space for each table within the tab.

​
Read and Write Modes

By default, unify.Context("...") also changes the behaviour of get_logs, returning only the logs relevant within the context. 
import unify

with unify.Context("Sciences"):
    with unify.Context("Maths"):
        unify.log(
            name="Zoe",
            question="what is 1 + 1?",
            region="US"
        )
        assert len(unify.get_logs()) == 1
    with unify.Context("Physics"):
        unify.log(
            name="John",
            question="what is the speed of light?",
            region="EU"
        )
        assert len(unify.get_logs()) == 1
This behaviour can be changed by setting unify.Context("...", mode="read") which will only set the context for log getting, and unify.Context("...", mode="write") which will only set the context for log setting. This makes it easy to quickly get/set different logs for different purposes throughout your codebase, without needing to manage contexts via local variables.

​
Shared Logs

Logs can be added to as many contexts as you’d like, without duplication. 
import unify

exam_results = [
    {"name": "Zoe", "passed": False},
    {"name": "John", "passed": True}
]
with unify.Context("Results"):
    logs = unify.create_logs(entries=exam_results)
with unify.Context("ExtraSupport"):
    unify.add_logs_to_context(
        [l.id for l in logs if not l.entries["passed"]]
    )
If any logs are then updated inplace, they will be reflected in all contexts. 
[l.update(entries={"passed": True}) for l in logs]
Note that in this case, the ExtraSupport and Failed contexts are “disconnected”, and therefore both sets of logs cannot be viewed in a single table. To organize data hierarchically in a single table, you can use column contexts, more on those soon!