Respan Dataset Explorer

You are an expert system that converts a user's natural language question into a structured JSON query plan.
Your ONLY job is to return a single, valid JSON object that strictly follows the schema.

---
**SCHEMA DEFINITION:**
{
    "question_type": "The type of question (WHO, WHAT, WHEN_START, WHEN_END, VERIFY).",
    "entities": [{ "name": "Name of the entity", "type": "Type of the entity (optional)" }],
    "relationship": { "type": "The type of relationship (e.g., CEO_OF)", "direction": "Direction from the entity's perspective ('from' or 'to')" },
    "time_constraint": { "year": YYYY, "date": "YYYY-MM-DD" }
}
---
**INSTRUCTIONS & EXAMPLES:**

1.  **WHO/WHAT questions:**
    -   Question: "Who was the CEO of Stellar Dynamics in 2022?"
    -   JSON:
        {
            "question_type": "WHO",
            "entities": [{ "name": "Stellar Dynamics", "type": "Company" }],
            "relationship": { "type": "CEO_OF", "direction": "to" },
            "time_constraint": { "year": 2022 }
        }

2.  **WHEN questions (start and end):**
    -   Question: "When did Maria Flores become CEO?"
    -   JSON:
        {
            "question_type": "WHEN_START",
            "entities": [{ "name": "Maria Flores", "type": "Person" }],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }
    -   **FIXED**: Question: "When did Maria Flores stop being CEO of Stellar Dynamics?"
    -   JSON:
        {
            "question_type": "WHEN_END",
            "entities": [
                { "name": "Maria Flores", "type": "Person" },
                { "name": "Stellar Dynamics", "type": "Company" }
            ],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }


3.  **VERIFY questions (Is/Was/Are/Did):**
    -   Question: "Was Maria Flores the CEO of Stellar Dynamics in 2023?"
    -   JSON:
        {
            "question_type": "VERIFY",
            "entities": [{ "name": "Maria Flores", "type": "Person" }, { "name": "Stellar Dynamics", "type": "Company" }],
            "relationship": { "type": "CEO_OF", "direction": "from" },
            "time_constraint": { "year": 2023 }
        }
    -   Question: "Is Maria Flores the CEO now?"
    -   JSON:
        {
            "question_type": "VERIFY",
            "entities": [{ "name": "Maria Flores", "type": "Person" }],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }

---
Now, strictly follow all rules and the schema to create a query plan for the following question.

Question: "Is Maria Flores the CEO of Stellar Dynamics now?"

{
    "question_type": "VERIFY",
    "entities": [
        { "name": "Maria Flores", "type": "Person" },
        { "name": "Stellar Dynamics", "type": "Company" }
    ],
    "relationship": { "type": "CEO_OF", "direction": "from" }
}

You are an expert system that converts a user's natural language question into a structured JSON query plan.
Your ONLY job is to return a single, valid JSON object that strictly follows the schema.

---
**SCHEMA DEFINITION:**
{
    "question_type": "The type of question (WHO, WHAT, WHEN_START, WHEN_END, VERIFY).",
    "entities": [{ "name": "Name of the entity", "type": "Type of the entity (optional)" }],
    "relationship": { "type": "The type of relationship (e.g., CEO_OF)", "direction": "Direction from the entity's perspective ('from' or 'to')" },
    "time_constraint": { "year": YYYY, "date": "YYYY-MM-DD" }
}
---
**INSTRUCTIONS & EXAMPLES:**

1.  **WHO/WHAT questions:**
    -   Question: "Who was the CEO of Stellar Dynamics in 2022?"
    -   JSON:
        {
            "question_type": "WHO",
            "entities": [{ "name": "Stellar Dynamics", "type": "Company" }],
            "relationship": { "type": "CEO_OF", "direction": "to" },
            "time_constraint": { "year": 2022 }
        }

2.  **WHEN questions (start and end):**
    -   Question: "When did Maria Flores become CEO?"
    -   JSON:
        {
            "question_type": "WHEN_START",
            "entities": [{ "name": "Maria Flores", "type": "Person" }],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }
    -   **FIXED**: Question: "When did Maria Flores stop being CEO of Stellar Dynamics?"
    -   JSON:
        {
            "question_type": "WHEN_END",
            "entities": [
                { "name": "Maria Flores", "type": "Person" },
                { "name": "Stellar Dynamics", "type": "Company" }
            ],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }


3.  **VERIFY questions (Is/Was/Are/Did):**
    -   Question: "Was Maria Flores the CEO of Stellar Dynamics in 2023?"
    -   JSON:
        {
            "question_type": "VERIFY",
            "entities": [{ "name": "Maria Flores", "type": "Person" }, { "name": "Stellar Dynamics", "type": "Company" }],
            "relationship": { "type": "CEO_OF", "direction": "from" },
            "time_constraint": { "year": 2023 }
        }
    -   Question: "Is Maria Flores the CEO now?"
    -   JSON:
        {
            "question_type": "VERIFY",
            "entities": [{ "name": "Maria Flores", "type": "Person" }],
            "relationship": { "type": "CEO_OF", "direction": "from" }
        }

---
Now, strictly follow all rules and the schema to create a query plan for the following question.

Question: "What is the capital of France?"

```json
{
    "question_type": "WHAT",
    "entities": [{ "name": "France", "type": "Country" }],
    "relationship": { "type": "CAPITAL_OF", "direction": "to" }
}
```

I have my own dictionary or notes file with translation of words or phrases. Its just a text file with format: word_or_phrase : translation. I want a script (I will use colab google) which shall help me to learn new (and remind old) phrases and words. But I still don't have a clear vision of my script. Can you help me?

Absolutely! It’s great that you already have a dictionary-like text file with your words and translations. We can create an interactive script in Python (which you can run in Google Colab) to help you learn new phrases and review old ones.

### Core Ideas for Your Script:

1. **Load your dictionary file**  
   Parse your text file and load the word/phrase and their translations into a Python dictionary.

2. **Basic interaction modes:**
   - **Learning new words:** Show the original word/phrase and ask for the translation (or vice versa). Check the answer.
   - **Review old words:** Repeat words you have learned before, ideally those you struggled with or that haven’t been reviewed recently.

3. **Tracking progress:**
   - Keep track of which words you have seen and how well you answered them.
   - Use spaced repetition logic to remind you of words at increasing intervals based on performance (optional for now, but powerful).

4. **User interface:**
   - Since you’re using Google Colab, the simplest way is to use input()/print() loops.
   - Later, you could adapt it to use widgets or even export a flashcard app format.

---

### Step-by-step plan and example code

Assuming your file (`dictionary.txt`) looks like this:

```
hello : hola
thank you : gracias
good morning : buenos días
see you later : hasta luego
```

---

### 1. Load the dictionary file

```python
def load_dictionary(filename):
    dictionary = {}
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if ':' in line:
                word, translation = line.strip().split(':', 1)
                dictionary[word.strip()] = translation.strip()
    return dictionary
```

---

### 2. Basic testing interface

```python
import random

def quiz(dictionary):
    words = list(dictionary.keys())
    print("Type 'exit' anytime to quit.")
    while True:
        word = random.choice(words)
        print(f"What is the translation of: '{word}'?")
        answer = input("Your answer: ").strip()
        if answer.lower() == 'exit':
            print("Ending session. Goodbye!")
            break
        
        correct = dictionary[word]
        if answer.lower() == correct.lower():
            print("Correct! Well done.\n")
        else:
            print(f"Wrong. The correct answer is: {correct}\n")
```

---

### 3. Putting it all together in Colab

Upload your `dictionary.txt` to the Colab environment, then:

```python
dictionary = load_dictionary('dictionary.txt')
quiz(dictionary)
```

---

### 4. Optional: Track performance and spaced repetition (basic version)

```python
import time

def quiz_with_tracking(dictionary):
    words = list(dictionary.keys())
    performance = {word: {'correct': 0, 'wrong': 0, 'last_seen': 0} for word in words}
    print("Type 'exit' anytime to quit.\n")
    
    while True:
        # Sort words by spaced repetition logic (simplest: prioritize words with more wrong and those not seen recently)
        words_sorted = sorted(words, key=lambda w: (performance[w]['wrong'] - performance[w]['correct'], time.time() - performance[w]['last_seen']), reverse=True)
        
        word = words_sorted[0]
        print(f"What is the translation of: '{word}'?")
        answer = input("Your answer: ").strip()
        if answer.lower() == 'exit':
            print("Ending session. Summary:")
            for w, stats in performance.items():
                print(f"{w}: Correct {stats['correct']} times, Wrong {stats['wrong']} times")
            break
        
        correct = dictionary[word]
        if answer.lower() == correct.lower():
            print("Correct! Well done.\n")
            performance[word]['correct'] += 1
        else:
            print(f"Wrong. The correct answer is: {correct}\n")
            performance[word]['wrong'] += 1
        
        performance[word]['last_seen'] = time.time()
```

---

### 5. Next steps and improvement ideas

- Add options to test from translation to original or vice versa.
- Export performance data to a file to keep it beyond the current session.
- Implement better spaced repetition algorithms (like SM2 from Anki).
- Build a simple GUI with `ipywidgets` for a friendlier interface.
- Add support for multiple translation languages or contexts.

---

### Summary

Your minimal working script in Colab:

```python
def load_dictionary(filename):
    dictionary = {}
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if ':' in line:
                word, translation = line.strip().split(':', 1)
                dictionary[word.strip()] = translation.strip()
    return dictionary

import random

def quiz(dictionary):
    words = list(dictionary.keys())
    print("Type 'exit' anytime to quit.")
    while True:
        word = random.choice(words)
        print(f"What is the translation of: '{word}'?")
        answer = input("Your answer: ").strip()
        if answer.lower() == 'exit':
            print("Ending session. Goodbye!")
            break
        
        correct = dictionary[word]
        if answer.lower() == correct.lower():
            print("Correct! Well done.\n")
        else:
            print(f"Wrong. The correct answer is: {correct}\n")


# Usage in your Colab cell:
dictionary = load_dictionary('dictionary.txt')
quiz(dictionary)
```

---

Feel free to ask if you want help implementing more advanced features or adapting the script!

We forgot something important! Since I use google-colab, I have to load files to it

Great point! Since Google Colab runs in a cloud environment, your local files aren’t accessible until you upload them or mount some storage.

Here are **2 simple ways** to get your dictionary file into Colab:

---

### 1. Upload the dictionary file manually in Colab

You can use Colab’s file upload widget to upload your file each session:

```python
from google.colab import files

uploaded = files.upload()  # this will prompt you to choose file(s)

# After this, the uploaded files will be in the Colab environment
# and you can access them by their filename, e.g.:

dictionary = load_dictionary('dictionary.txt')
quiz(dictionary)
```

> When you run `files.upload()`, a “Choose Files” button appears and you select your text dictionary from your computer.

---

### 2. Mount Google Drive and read file from there

If you want your dictionary to persist across sessions, you can store it in your Google Drive:

```python
from google.colab import drive
drive.mount('/content/drive')
```

After mounting, you can access your file using its path in Drive, for example:

```python
dictionary = load_dictionary('/content/drive/My Drive/your_folder/dictionary.txt')
quiz(dictionary)
```

---

### So your full flow in Colab might look like this for manual upload:

```python
from google.colab import files

# Upload your file
uploaded = files.upload()

# Now run your dictionary loading and quiz functions from previous step
def load_dictionary(filename):
    dictionary = {}
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if ':' in line:
                word, translation = line.strip().split(':', 1)
                dictionary[word.strip()] = translation.strip()
    return dictionary

import random

def quiz(dictionary):
    words = list(dictionary.keys())
    print("Type 'exit' anytime to quit.")
    while True:
        word = random.choice(words)
        print(f"What is the translation of: '{word}'?")
        answer = input("Your answer: ").strip()
        if answer.lower() == 'exit':
            print("Ending session. Goodbye!")
            break
        
        correct = dictionary[word]
        if answer.lower() == correct.lower():
            print("Correct! Well done.\n")
        else:
            print(f"Wrong. The correct answer is: {correct}\n")

# Replace 'dictionary.txt' below with the uploaded file's name
dictionary = load_dictionary('dictionary.txt')
quiz(dictionary)
```

---

If you prefer to **persist the file** on Drive and avoid uploading every time, use the Drive method.

Let me know if you want me to help you with Google Drive mounting or any other idea!

Can we add a new function?

Of course! What kind of function would you like to add? 

For example, we could add:

- A function to **add new words/phrases** interactively and save them back to your dictionary file.
- A function to **list all words/phrases** or search for a specific phrase.
- A function to **export your performance stats**.
- Anything else you have in mind!

Just let me know what functionality you’d like, and I’ll help you write it.

No. I want a function that will help me to remember phrases or words. Do you know what we can do?

Yes, I get what you mean! You want a function specifically designed to help you **remember** words or phrases — basically a **review or reminder mode** that focuses on making familiar phrases stick in your memory.

Here are some common approaches we can implement to **boost remembering**:

---

### Ideas for a "Remember Words" function

1. **Spaced repetition style quiz**  
   Words you got right less often or haven’t reviewed recently will be asked more frequently.

2. **Flashcard-style mode**  
   Show the word/phrase, wait for you to recall the translation silently (no input required), then show answer when you press Enter or after a pause.

3. **Fill-in-the-blank or multiple choice quizzes**  
   Make it more interactive and encourage active recall.

4. **Review only 'hard' words**  
   Filter and quiz only on words you’ve gotten wrong/sometimes wrong in previous sessions.

---

### What I suggest as a next step:

- Implement a **review mode** where you get a list of words (say those you marked as "difficult" or "not known well").
- The function shows the original phrase, waits for you to recall, then shows the translation.
- Optionally mark if you remembered correctly or not to help track progress.

---

### Example: Simple "review words" function

Let me write a minimal function that reviews words you struggled with (tracked in a performance dictionary as before):

```python
import time

def review_words(dictionary, performance):
    """Review only words you often get wrong."""
    # Filter words with more wrong than correct attempts
    hard_words = [w for w, stats in performance.items() if stats['wrong'] > stats['correct']]
    
    if not hard_words:
        print("No hard words to review right now! Great job!")
        return
    
    print(f"Let's review {len(hard_words)} challenging words/phrases.")
    print("Press Enter to see the translation, then decide if you remembered correctly.\n")
    
    for word in hard_words:
        print(f"Phrase: {word}")
        input("Recall it... then press Enter to see the translation.")
        print(f"Translation: {dictionary[word]}")
        correct = input("Did you remember it correctly? (y/n): ").strip().lower()
        if correct == 'y':
            performance[word]['correct'] += 1
            print("Great! Marked as correct.\n")
        else:
            performance[word]['wrong'] += 1
            print("No worries, keep practicing.\n")
        performance[word]['last_seen'] = time.time()
```

---

### How to integrate it

1. Create and maintain a `performance` dictionary as described before—tracking correct/wrong answers.
2. After or before quiz sessions, call `review_words(dictionary, performance)`.

---

### Summary

This helps you **actively recall** translations and mark how well you do, so you focus on what you *need* to remember better.

---

If you want, I can also help you add code to **save/load the performance data** (e.g., into a JSON file) so your progress lasts between Colab sessions.

Would you like me to do that next or help with another remembering technique?

how to use it?

Sure! Here's a step-by-step explanation on **how to use the `review_words` function**, including all the necessary setup so it fits nicely into your learning script.

---

## 1. Setup: Your dictionary and performance tracking

You already have your dictionary loaded from your file.

To **track which words you remembered well or struggled with**, you need a `performance` dictionary that stores stats for each word:

```python
import time

# Initialize performance dictionary for all words in your dictionary
performance = {word: {'correct': 0, 'wrong': 0, 'last_seen': 0} for word in dictionary.keys()}
```

In a more advanced version, you'd save/load this performance dictionary between sessions (I'll explain this later if you want).

---

## 2. Your existing quiz function should update the performance dict

Modify your quiz (or use a new quiz function) to update this performance data:

```python
def quiz_with_tracking(dictionary, performance):
    import random
    words = list(dictionary.keys())
    print("Type 'exit' anytime to quit.")

    while True:
        word = random.choice(words)
        print(f"What is the translation of: '{word}'?")
        answer = input("Your answer: ").strip()
        if answer.lower() == 'exit':
            print("Ending session. Goodbye!")
            break

        correct = dictionary[word]
        if answer.lower() == correct.lower():
            print("Correct! Well done.\n")
            performance[word]['correct'] += 1
        else:
            print(f"Wrong. The correct answer is: {correct}\n")
            performance[word]['wrong'] += 1

        performance[word]['last_seen'] = time.time()
```

---

## 3. The `review_words` function (the remembering helper)

```python
def review_words(dictionary, performance):
    import time
    # Select words you struggle with (wrong attempts > correct attempts)
    hard_words = [w for w, stats in performance.items() if stats['wrong'] > stats['correct']]

    if not hard_words:
        print("No hard words to review right now! Great job!")
        return

    print(f"Let's review {len(hard_words)} challenging words/phrases.")
    print("Press Enter to see the translation, then decide if you remembered correctly.\n")

    for word in hard_words:
        print(f"Phrase: {word}")
        input("Recall it... then press Enter to see the translation.")
        print(f"Translation: {dictionary[word]}")
        correct = input("Did you remember it correctly? (y/n): ").strip().lower()
        if correct == 'y':
            performance[word]['correct'] += 1
            print("Great! Marked as correct.\n")
        else:
            performance[word]['wrong'] += 1
            print("No worries, keep practicing.\n")
        performance[word]['last_seen'] = time.time()
```

---

## 4. How to run all this in your Colab session

Here’s a minimal example of the whole flow:

```python
# 1. Load your dictionary (replace with your filename)
def load_dictionary(filename):
    dictionary = {}
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if ':' in line:
                word, translation = line.strip().split(':', 1)
                dictionary[word.strip()] = translation.strip()
    return dictionary

dictionary = load_dictionary('dictionary.txt')

# 2. Initialize performance
performance = {word: {'correct': 0, 'wrong': 0, 'last_seen': 0} for word in dictionary.keys()}

# 3. Define review_words and quiz_with_tracking (paste functions from above)

# 4. Run a quiz session first
quiz_with_tracking(dictionary, performance)

# 5. Then run your review session
review_words(dictionary, performance)
```

---

## 5. What to expect — sample session flow:

```
What is the translation of: 'hello'?
Your answer: hola
Correct! Well done.

What is the translation of: 'thank you'?
Your answer: gracias
Correct! Well done.

...

Ending session. Goodbye!

Let's review 2 challenging words/phrases.
Press Enter to see the translation, then decide if you remembered correctly.

Phrase: see you later
Recall it... then press Enter to see the translation.
Translation: hasta luego
Did you remember it correctly? (y/n): n
No worries, keep practicing.

Phrase: good morning
Recall it... then press Enter to see the translation.
Translation: buenos días
Did you remember it correctly? (y/n): y
Great! Marked as correct.
```

---

## 6. Bonus: Save and load performance data between Colab sessions

If you want your progress to persist beyond one Colab session, you can (optionally) save your performance dict to a JSON file and load it back:

```python
import json

# Save
with open('performance.json', 'w') as f:
    json.dump(performance, f)

# Load (if performance file exists)
import os

if os.path.exists('performance.json'):
    with open('performance.json', 'r') as f:
        performance = json.load(f)

    # Note: JSON loads keys as strings — if keys or values are complex objects,
    # you may need type conversions here.
```

You can upload/download this JSON file via Colab’s `files.upload()` and `files.download()` or store it in Google Drive for persistence.

---

### Summary

- Use the `performance` dictionary to track how well you know words.
- Use `quiz_with_tracking()` to train yourself while updating stats.
- Use `review_words()` to actively recall and reinforce harder words.
- Optionally save/load performance data to keep your progress.

---

If you want, I can prepare a **ready-to-run Colab notebook** snippet with all this code together. Would you like that?

You are an expert AI system. Your ONLY job is to return a single, valid JSON object that strictly follows the schema provided.

---
**ABSOLUTE RULES FOR JSON OUTPUT:**
1.  The final output MUST be a single JSON object and nothing else.
2.  The root object MUST have exactly two keys: "events" and "stateful_relationships".
3.  If no events are found, the value for "events" MUST be an empty list: `[]`.
4.  If no stateful relationships are found, the value for "stateful_relationships" MUST be an empty list: `[]`.
5.  Every object inside the lists MUST contain ALL required keys from the schema. DO NOT OMIT ANY KEYS unless they are explicitly marked as Optional in the schema.
6.  If a text provides new information about a stateful relationship (like an end_time for an existing one), extract it. The text does not need to contain both the start and end of the relationship.
---

### SCHEMA DEFINITION
... (The schema definition section remains the same as last time) ...
---
EXAMPLE 1 (Complex Case with Start and End)
... (example remains the same) ...
---
**EXAMPLE 2 (Update Case with only End Time)**
Text: "Press Release - June 15, 2024 - Stellar Dynamics confirmed today that CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
Document Timestamp: "2024-06-15"

JSON Output:
{
  "events": [
    {
      "event_type": "RESIGNATION",
      "event_description": "CEO Maria Flores will be stepping down from her role at Stellar Dynamics.",
      "timestamp": "2024-06-30",
      "source_text": "Her last day will be June 30, 2024.",
      "participants": [
        { "entity_name": "Maria Flores", "entity_type": "Person", "role": "resignee" },
        { "entity_name": "Stellar Dynamics", "entity_type": "Company", "role": "former_employer" }
      ]
    }
  ],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": null,
      "end_time": "2024-06-30",
      "source_text": "CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
    }
  ]
}
---
EXAMPLE 3 (Simple Case with No Stateful Relationship)
... (example remains the same) ...
---

Now, strictly follow all rules and the schema to extract information from the following text.

Text: "
    New York, NY - March 1, 2021 - Following a board meeting, tech conglomerate 'Stellar Dynamics'
    announced that Maria Flores has been appointed as the new Chief Executive Officer, effective immediately.
    "
Document Timestamp: "2021-03-01T09:00:00Z"

{
  "events": [
    {
      "event_type": "APPOINTMENT",
      "event_description": "Maria Flores has been appointed as the new Chief Executive Officer of Stellar Dynamics, effective immediately.",
      "timestamp": "2021-03-01T09:00:00Z",
      "source_text": "Following a board meeting, tech conglomerate 'Stellar Dynamics' announced that Maria Flores has been appointed as the new Chief Executive Officer, effective immediately.",
      "participants": [
        {
          "entity_name": "Maria Flores",
          "entity_type": "Person",
          "role": "appointee"
        },
        {
          "entity_name": "Stellar Dynamics",
          "entity_type": "Company",
          "role": "employer"
        }
      ]
    }
  ],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": "2021-03-01T09:00:00Z",
      "end_time": null,
      "source_text": "Following a board meeting, tech conglomerate 'Stellar Dynamics' announced that Maria Flores has been appointed as the new Chief Executive Officer, effective immediately."
    }
  ]
}

You are an expert AI system. Your ONLY job is to return a single, valid JSON object that strictly follows the schema provided.

---
**ABSOLUTE RULES FOR JSON OUTPUT:**
1.  The final output MUST be a single JSON object and nothing else.
2.  The root object MUST have exactly two keys: "events" and "stateful_relationships".
3.  If no events are found, the value for "events" MUST be an empty list: `[]`.
4.  If no stateful relationships are found, the value for "stateful_relationships" MUST be an empty list: `[]`.
5.  Every object inside the lists MUST contain ALL required keys from the schema. DO NOT OMIT ANY KEYS unless they are explicitly marked as Optional in the schema.
6.  If a text provides new information about a stateful relationship (like an end_time for an existing one), extract it. The text does not need to contain both the start and end of the relationship.
---

### SCHEMA DEFINITION
... (The schema definition section remains the same as last time) ...
---
EXAMPLE 1 (Complex Case with Start and End)
... (example remains the same) ...
---
**EXAMPLE 2 (Update Case with only End Time)**
Text: "Press Release - June 15, 2024 - Stellar Dynamics confirmed today that CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
Document Timestamp: "2024-06-15"

JSON Output:
{
  "events": [
    {
      "event_type": "RESIGNATION",
      "event_description": "CEO Maria Flores will be stepping down from her role at Stellar Dynamics.",
      "timestamp": "2024-06-30",
      "source_text": "Her last day will be June 30, 2024.",
      "participants": [
        { "entity_name": "Maria Flores", "entity_type": "Person", "role": "resignee" },
        { "entity_name": "Stellar Dynamics", "entity_type": "Company", "role": "former_employer" }
      ]
    }
  ],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": null,
      "end_time": "2024-06-30",
      "source_text": "CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
    }
  ]
}
---
EXAMPLE 3 (Simple Case with No Stateful Relationship)
... (example remains the same) ...
---

Now, strictly follow all rules and the schema to extract information from the following text.

Text: "
    Press Release - June 15, 2024 - Stellar Dynamics confirmed today that CEO Maria Flores
    will be stepping down from her role at the end of the month to pursue new ventures.
    Her last day will be June 30, 2024.
    "
Document Timestamp: "2024-06-15T11:00:00Z"

{
  "events": [
    {
      "event_type": "RESIGNATION",
      "event_description": "CEO Maria Flores will be stepping down from her role at Stellar Dynamics at the end of the month to pursue new ventures.",
      "timestamp": "2024-06-30",
      "source_text": "CEO Maria Flores will be stepping down from her role at the end of the month to pursue new ventures. Her last day will be June 30, 2024.",
      "participants": [
        {
          "entity_name": "Maria Flores",
          "entity_type": "Person",
          "role": "resignee"
        },
        {
          "entity_name": "Stellar Dynamics",
          "entity_type": "Company",
          "role": "former_employer"
        }
      ]
    }
  ],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": null,
      "end_time": "2024-06-30",
      "source_text": "CEO Maria Flores will be stepping down from her role at the end of the month to pursue new ventures. Her last day will be June 30, 2024."
    }
  ]
}

You are an expert AI system. Your ONLY job is to return a single, valid JSON object that strictly follows the schema provided.

---
**ABSOLUTE RULES FOR JSON OUTPUT:**
1.  The final output MUST be a single JSON object and nothing else.
2.  The root object MUST have exactly two keys: "events" and "stateful_relationships".
3.  If no events are found, the value for "events" MUST be an empty list: `[]`.
4.  If no stateful relationships are found, the value for "stateful_relationships" MUST be an empty list: `[]`.
5.  Every object inside the lists MUST contain ALL required keys from the schema. DO NOT OMIT ANY KEYS unless they are explicitly marked as Optional in the schema.
6.  If a text provides new information about a stateful relationship (like an end_time for an existing one), extract it. The text does not need to contain both the start and end of the relationship.
---

### SCHEMA DEFINITION
... (The schema definition section remains the same as last time) ...
---
EXAMPLE 1 (Complex Case with Start and End)
... (example remains the same) ...
---
**EXAMPLE 2 (Update Case with only End Time)**
Text: "Press Release - June 15, 2024 - Stellar Dynamics confirmed today that CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
Document Timestamp: "2024-06-15"

JSON Output:
{
  "events": [
    {
      "event_type": "RESIGNATION",
      "event_description": "CEO Maria Flores will be stepping down from her role at Stellar Dynamics.",
      "timestamp": "2024-06-30",
      "source_text": "Her last day will be June 30, 2024.",
      "participants": [
        { "entity_name": "Maria Flores", "entity_type": "Person", "role": "resignee" },
        { "entity_name": "Stellar Dynamics", "entity_type": "Company", "role": "former_employer" }
      ]
    }
  ],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": null,
      "end_time": "2024-06-30",
      "source_text": "CEO Maria Flores will be stepping down from her role. Her last day will be June 30, 2024."
    }
  ]
}
---
EXAMPLE 3 (Simple Case with No Stateful Relationship)
... (example remains the same) ...
---

Now, strictly follow all rules and the schema to extract information from the following text.

Text: "
    A 2022 filing revealed that Maria Flores's appointment as CEO of Stellar Dynamics in March 2021
    was a pivotal moment for the company.
    "
Document Timestamp: "2024-06-16T11:00:00Z"

```json
{
  "events": [],
  "stateful_relationships": [
    {
      "source_entity_name": "Maria Flores",
      "source_entity_type": "Person",
      "relationship_type": "CEO_OF",
      "target_entity_name": "Stellar Dynamics",
      "target_entity_type": "Company",
      "start_time": "2021-03",
      "end_time": null,
      "source_text": "Maria Flores's appointment as CEO of Stellar Dynamics in March 2021"
    }
  ]
}
```