From 75ba27ddb811b15134566dd09e2fb88cc1fc337a Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 08:31:43 -0700
Subject: [PATCH 01/59] git output via openai migrate

---
 scripts/rag/llama_index_w_evals_and_qa.py     |  4 +--
 src/phoenix/experimental/evals/retrievals.py  |  6 ++--
 tests/trace/openai/test_instrumentor.py       | 30 +++++++++++--------
 ...ild_arize_docs_index_langchain_pinecone.py |  3 --
 4 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/scripts/rag/llama_index_w_evals_and_qa.py b/scripts/rag/llama_index_w_evals_and_qa.py
index ba9d56ca7a..7d791c2782 100644
--- a/scripts/rag/llama_index_w_evals_and_qa.py
+++ b/scripts/rag/llama_index_w_evals_and_qa.py
@@ -11,7 +11,6 @@
 
 import cohere
 import numpy as np
-import openai
 import pandas as pd
 import phoenix.experimental.evals.templates.default_templates as templates
 import requests
@@ -380,8 +379,7 @@ def process_row(row, formatted_evals_column, k):
 
 
 def check_keys() -> None:
-    openai.api_key = os.getenv("OPENAI_API_KEY")
-    if openai.api_key is None:
+    if os.getenv("OPENAI_API_KEY") is None:
         raise RuntimeError(
             "OpenAI API key missing. Please set it up in your environment as OPENAI_API_KEY"
         )
diff --git a/src/phoenix/experimental/evals/retrievals.py b/src/phoenix/experimental/evals/retrievals.py
index 671c139538..127cca0973 100644
--- a/src/phoenix/experimental/evals/retrievals.py
+++ b/src/phoenix/experimental/evals/retrievals.py
@@ -75,13 +75,15 @@ def classify_relevance(query: str, document: str, model_name: str) -> Optional[b
             unparseable output.
     """
 
-    from openai import ChatCompletion
+    from openai import OpenAI
+
+    client = OpenAI()
 
     prompt = _QUERY_CONTEXT_PROMPT_TEMPLATE.format(
         query=query,
         reference=document,
     )
-    response = ChatCompletion.create(  # type: ignore
+    response = client.chat.completions.create(
         messages=[
             {"role": "system", "content": _EVALUATION_SYSTEM_MESSAGE},
             {"role": "user", "content": prompt},
diff --git a/tests/trace/openai/test_instrumentor.py b/tests/trace/openai/test_instrumentor.py
index e8e8020bf7..f0dc271fc2 100644
--- a/tests/trace/openai/test_instrumentor.py
+++ b/tests/trace/openai/test_instrumentor.py
@@ -4,6 +4,7 @@
 import openai
 import pytest
 import responses
+from openai import OpenAI
 from openai.error import AuthenticationError
 from phoenix.trace.openai.instrumentor import OpenAIInstrumentor
 from phoenix.trace.schemas import SpanException, SpanKind, SpanStatusCode
@@ -41,14 +42,18 @@ def reload_openai_api_requestor() -> None:
 @pytest.fixture
 def openai_api_key(monkeypatch) -> None:
     api_key = "sk-0123456789"
-    openai.api_key = api_key
     monkeypatch.setenv("OPENAI_API_KEY", api_key)
     return api_key
 
 
+@pytest.fixture
+def client(openai_api_key) -> OpenAI:
+    return OpenAI(api_key=openai_api_key)
+
+
 @responses.activate
 def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
-    reload_openai_api_requestor, openai_api_key
+    reload_openai_api_requestor, client
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -77,7 +82,9 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
         },
         status=200,
     )
-    response = openai.ChatCompletion.create(model=model, messages=messages, temperature=temperature)
+    response = client.chat.completions.create(
+        model=model, messages=messages, temperature=temperature
+    )
     response_text = response.choices[0]["message"]["content"]
 
     assert response_text == expected_response_text
@@ -166,7 +173,7 @@ def test_openai_instrumentor_includes_function_call_attributes(
         },
         status=200,
     )
-    response = openai.ChatCompletion.create(model=model, messages=messages, functions=functions)
+    response = client.chat.completions.create(model=model, messages=messages, functions=functions)
 
     function_call_data = response.choices[0]["message"]["function_call"]
     assert set(function_call_data.keys()) == {"name", "arguments"}
@@ -206,7 +213,7 @@ def test_openai_instrumentor_includes_function_call_attributes(
 
 @responses.activate
 def test_openai_instrumentor_includes_function_call_message_attributes(
-    reload_openai_api_requestor, openai_api_key
+    reload_openai_api_requestor, client
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -269,7 +276,7 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
         status=200,
     )
 
-    response = openai.ChatCompletion.create(model=model, messages=messages, functions=functions)
+    response = client.chat.completions.create(model=model, messages=messages, functions=functions)
     response_text = response.choices[0]["message"]["content"]
     spans = list(tracer.get_spans())
     span = spans[0]
@@ -326,7 +333,7 @@ def test_openai_instrumentor_records_authentication_error(
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
 
     with pytest.raises(AuthenticationError):
-        openai.ChatCompletion.create(model=model, messages=messages)
+        client.chat.completions.create(model=model, messages=messages)
 
     spans = list(tracer.get_spans())
     assert len(spans) == 1
@@ -343,7 +350,7 @@ def test_openai_instrumentor_records_authentication_error(
 
 @responses.activate
 def test_openai_instrumentor_does_not_interfere_with_completions_api(
-    reload_openai_api_requestor, openai_api_key
+    reload_openai_api_requestor, client
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -368,10 +375,7 @@ def test_openai_instrumentor_does_not_interfere_with_completions_api(
         },
         status=200,
     )
-    response = openai.Completion.create(
-        model=model,
-        prompt=prompt,
-    )
+    response = client.completions.create(model=model, prompt=prompt)
     response_text = response.choices[0]["text"]
     spans = list(tracer.get_spans())
 
@@ -409,7 +413,7 @@ def test_openai_instrumentor_instrument_method_is_idempotent(
         },
         status=200,
     )
-    response = openai.ChatCompletion.create(model=model, messages=messages)
+    response = client.chat.completions.create(model=model, messages=messages)
     response_text = response.choices[0]["message"]["content"]
     spans = list(tracer.get_spans())
     span = spans[0]
diff --git a/tutorials/build_arize_docs_index_langchain_pinecone.py b/tutorials/build_arize_docs_index_langchain_pinecone.py
index 15c56a2eb2..f521843f4d 100644
--- a/tutorials/build_arize_docs_index_langchain_pinecone.py
+++ b/tutorials/build_arize_docs_index_langchain_pinecone.py
@@ -15,7 +15,6 @@
 from typing import Dict, List, Optional
 
 import numpy as np
-import openai
 import pandas as pd
 import pinecone  # type: ignore
 import tiktoken
@@ -147,10 +146,8 @@ def _convert_text_to_embedding_map_to_dataframe(
     pinecone_api_key = args.pinecone_api_key
     pinecone_index_name = args.pinecone_index_name
     pinecone_environment = args.pinecone_environment
-    openai_api_key = args.openai_api_key
     output_parquet_path = args.output_parquet_path
 
-    openai.api_key = openai_api_key
     pinecone.init(api_key=pinecone_api_key, environment=pinecone_environment)
 
     docs_url = "https://docs.arize.com/arize/"

From 740553a262cedd26462a421b08a7bef9346e626d Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 09:39:56 -0700
Subject: [PATCH 02/59] WIP

---
 pyproject.toml                                  |  4 ++--
 src/phoenix/experimental/evals/models/openai.py | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 5a652a213b..0eb22d9861 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -92,8 +92,8 @@ dependencies = [
   "pytest-lazy-fixture",
   "arize",
   "langchain>=0.0.324",
-  "llama-index>=0.8.29",
-  "openai",
+  "llama-index>=0.8.63.post2",
+  "openai>1",
   "tenacity",
   "nltk==3.8.1",
   "sentence-transformers==2.2.2",
diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 8bc37cc845..d4c21bb98d 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -9,7 +9,7 @@
     from tiktoken import Encoding
 
 OPENAI_API_KEY_ENVVAR_NAME = "OPENAI_API_KEY"
-MINIMUM_OPENAI_VERSION = "0.26.4"
+MINIMUM_OPENAI_VERSION = "1.1.1"
 MODEL_TOKEN_LIMIT_MAPPING = {
     "gpt-3.5-turbo-instruct": 4096,
     "gpt-3.5-turbo-0301": 4096,
@@ -71,12 +71,12 @@ def __post_init__(self) -> None:
     def _init_environment(self) -> None:
         try:
             import openai
-            import openai.util
-            from openai import error as openai_error
+            import openai._utils as openai_util
+            from openai._exceptions import OpenAIError
 
             self._openai = openai
-            self._openai_error = openai_error
-            self._openai_util = openai.util
+            self._openai_error = OpenAIError
+            self._openai_util = openai_util
         except ImportError:
             self._raise_import_error(
                 package_display_name="OpenAI",
@@ -110,7 +110,7 @@ def _init_open_ai(self) -> None:
         self.openai_api_version = self.openai_api_version or self._openai.api_version
         self.openai_organization = self.openai_organization or self._openai.organization
         # use enum to validate api type
-        self._openai_util.ApiType.from_str(self.openai_api_type)  # type: ignore
+        self._openai_util.api_typeApiType.from_str(self.openai_api_type)
         self._is_azure = self.openai_api_type.lower().startswith("azure")
 
         if self._is_azure:

From a288ae2429f1a4e7c90820e1cab1492076b10663 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 08:31:43 -0700
Subject: [PATCH 03/59] git output via openai migrate

WIP
---
 .../experimental/evals/models/test_openai.py  | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 tests/experimental/evals/models/test_openai.py

diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
new file mode 100644
index 0000000000..65b1c7175a
--- /dev/null
+++ b/tests/experimental/evals/models/test_openai.py
@@ -0,0 +1,38 @@
+from phoenix.experimental.evals.models.openai import OpenAIModel
+
+
+def test_openai_model():
+    """
+    Sanity check of the initialization of OpenAI wrapper
+    """
+    model = OpenAIModel("gpt-4-")
+    assert model.model_name == "gpt2"
+    assert model.model_type == "openai"
+    assert model.model is not None
+    assert model.tokenizer is not None
+    assert model.device == "cpu"
+    assert model.max_length == 20
+    assert model.min_length == 1
+    assert model.do_sample == True
+    assert model.top_k == 50
+    assert model.top_p == 0.95
+    assert model.temperature == 1.0
+    assert model.repetition_penalty == 1.0
+    assert model.length_penalty == 1.0
+    assert model.num_beams == 1
+    assert model.num_return_sequences == 1
+    assert model.early_stopping == True
+    assert model.no_repeat_ngram_size == 0
+    assert model.num_beam_groups == 1
+    assert model.diversity_penalty == 0.0
+    assert model.prefix_allowed_tokens_fn == None
+    assert model.output_scores == False
+    assert model.output_attentions == False
+    assert model.output_hidden_states == False
+    assert model.output_past == True
+    assert model.use_cache == True
+    assert model.return_dict_in_generate == False
+    assert model.return_dict == True
+    assert model.return_dict_in_generate == False
+    assert model.return_dict_in_generate == False
+    assert model.return_dict_in_generate == False

From 9a119e492ed14c5a51383426e347ffe2daa05bdb Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 15:35:46 -0700
Subject: [PATCH 04/59] get pytests running

---
 .../experimental/evals/models/openai.py       | 26 ++++++--------
 .../experimental/evals/models/test_openai.py  | 35 +++----------------
 tests/trace/llama_index/test_callback.py      |  5 ++-
 tests/trace/openai/test_instrumentor.py       |  3 +-
 4 files changed, 18 insertions(+), 51 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 304945a020..353af0e89d 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -29,7 +29,6 @@ class OpenAIModel(BaseEvalModel):
     openai_api_type: Optional[str] = field(default=None)
     openai_api_version: Optional[str] = field(default=None)
     openai_api_key: Optional[str] = field(repr=False, default=None)
-    openai_api_base: Optional[str] = field(repr=False, default=None)
     openai_organization: Optional[str] = field(repr=False, default=None)
     engine: str = ""
     """Azure engine (the Deployment Name of your model)"""
@@ -72,10 +71,8 @@ def _init_environment(self) -> None:
         try:
             import openai
             import openai._utils as openai_util
-            from openai._exceptions import OpenAIError
 
             self._openai = openai
-            self._openai_error = OpenAIError
             self._openai_util = openai_util
         except ImportError:
             self._raise_import_error(
@@ -105,13 +102,13 @@ def _init_open_ai(self) -> None:
                     "or set it in your environment: 'export OPENAI_API_KEY=sk-****'"
                 )
             self.openai_api_key = api_key
-        self.openai_api_base = self.openai_api_base or self._openai.api_base
+        client = self._openai.Client(api_key=self.openai_api_key)
+        self._client = client
         self.openai_api_type = self.openai_api_type or self._openai.api_type
         self.openai_api_version = self.openai_api_version or self._openai.api_version
         self.openai_organization = self.openai_organization or self._openai.organization
-        # use enum to validate api type
-        self._openai_util.api_typeApiType.from_str(self.openai_api_type)
-        self._is_azure = self.openai_api_type.lower().startswith("azure")
+
+        self._is_azure = (self._openai.api_type or "").lower().startswith("azure")
 
         if self._is_azure:
             if not self.engine:
@@ -173,11 +170,11 @@ def _generate(self, prompt: str, **kwargs: Any) -> str:
     def _generate_with_retry(self, **kwargs: Any) -> Any:
         """Use tenacity to retry the completion call."""
         openai_retry_errors = [
-            self._openai_error.Timeout,
-            self._openai_error.APIError,
-            self._openai_error.APIConnectionError,
-            self._openai_error.RateLimitError,
-            self._openai_error.ServiceUnavailableError,
+            self._openai.APITimeoutError,
+            self._openai.APIError,
+            self._openai.APIConnectionError,
+            self._openai.RateLimitError,
+            self._openai.InternalServerError,
         ]
 
         @self.retry(
@@ -193,8 +190,8 @@ def _completion_with_retry(**kwargs: Any) -> Any:
                         (message.get("content") or "")
                         for message in (kwargs.pop("messages", None) or ())
                     )
-                return self._openai.Completion.create(**kwargs)
-            return self._openai.ChatCompletion.create(**kwargs)
+                return self._client.completions.create(**kwargs)
+            return self._client.chat.completions.create(**kwargs)
 
         return _completion_with_retry(**kwargs)
 
@@ -236,7 +233,6 @@ def _credentials(self) -> Dict[str, Any]:
         """Get the default parameters for calling OpenAI API."""
         return {
             "api_key": self.openai_api_key,
-            "api_base": self.openai_api_base,
             "api_type": self.openai_api_type,
             "api_version": self.openai_api_version,
             "organization": self.openai_organization,
diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
index 65b1c7175a..f19e28ffe4 100644
--- a/tests/experimental/evals/models/test_openai.py
+++ b/tests/experimental/evals/models/test_openai.py
@@ -4,35 +4,8 @@
 def test_openai_model():
     """
     Sanity check of the initialization of OpenAI wrapper
+    NB: this is intentionally white-box testing since
+    we cannot rely on the OpenAI API to be stable and don't
     """
-    model = OpenAIModel("gpt-4-")
-    assert model.model_name == "gpt2"
-    assert model.model_type == "openai"
-    assert model.model is not None
-    assert model.tokenizer is not None
-    assert model.device == "cpu"
-    assert model.max_length == 20
-    assert model.min_length == 1
-    assert model.do_sample == True
-    assert model.top_k == 50
-    assert model.top_p == 0.95
-    assert model.temperature == 1.0
-    assert model.repetition_penalty == 1.0
-    assert model.length_penalty == 1.0
-    assert model.num_beams == 1
-    assert model.num_return_sequences == 1
-    assert model.early_stopping == True
-    assert model.no_repeat_ngram_size == 0
-    assert model.num_beam_groups == 1
-    assert model.diversity_penalty == 0.0
-    assert model.prefix_allowed_tokens_fn == None
-    assert model.output_scores == False
-    assert model.output_attentions == False
-    assert model.output_hidden_states == False
-    assert model.output_past == True
-    assert model.use_cache == True
-    assert model.return_dict_in_generate == False
-    assert model.return_dict == True
-    assert model.return_dict_in_generate == False
-    assert model.return_dict_in_generate == False
-    assert model.return_dict_in_generate == False
+    model = OpenAIModel("gpt-4-1106-preview")
+    assert model.model_name == "gpt-4-1106-preview"
diff --git a/tests/trace/llama_index/test_callback.py b/tests/trace/llama_index/test_callback.py
index 922c57557d..a77812b67b 100644
--- a/tests/trace/llama_index/test_callback.py
+++ b/tests/trace/llama_index/test_callback.py
@@ -18,8 +18,7 @@
 from llama_index.llms.base import llm_completion_callback
 from llama_index.query_engine import RetrieverQueryEngine
 from llama_index.schema import Document, TextNode
-from openai import ChatCompletion
-from openai.error import RateLimitError
+from openai import Client, RateLimitError
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
 from phoenix.trace.exporter import NoOpExporter
 from phoenix.trace.llama_index import OpenInferenceTraceCallbackHandler
@@ -138,7 +137,7 @@ def test_callback_llm_rate_limit_error_has_exception_event(
     )
     query_engine = index.as_query_engine(service_context=service_context)
 
-    with patch.object(ChatCompletion, "create") as mocked_chat_completion_create:
+    with patch.object(Client.chat.completions, "create") as mocked_chat_completion_create:
         mocked_chat_completion_create.side_effect = RateLimitError("message")
         with pytest.raises(RateLimitError):
             query_engine.query(query)
diff --git a/tests/trace/openai/test_instrumentor.py b/tests/trace/openai/test_instrumentor.py
index f0dc271fc2..0c250571e3 100644
--- a/tests/trace/openai/test_instrumentor.py
+++ b/tests/trace/openai/test_instrumentor.py
@@ -4,8 +4,7 @@
 import openai
 import pytest
 import responses
-from openai import OpenAI
-from openai.error import AuthenticationError
+from openai import AuthenticationError, OpenAI
 from phoenix.trace.openai.instrumentor import OpenAIInstrumentor
 from phoenix.trace.schemas import SpanException, SpanKind, SpanStatusCode
 from phoenix.trace.semantic_conventions import (

From dfce296902421f0783d26a3a05f3667549a9f9c4 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 15:41:07 -0700
Subject: [PATCH 05/59] get pytests running

---
 tests/experimental/evals/functions/test_classify.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/experimental/evals/functions/test_classify.py b/tests/experimental/evals/functions/test_classify.py
index 02cb716ca9..3f9db4f782 100644
--- a/tests/experimental/evals/functions/test_classify.py
+++ b/tests/experimental/evals/functions/test_classify.py
@@ -230,8 +230,8 @@ def test_llm_classify_shows_retry_info_with_verbose_flag(monkeypatch: pytest.Mon
         waiting_fn = "phoenix.experimental.evals.models.base.wait_random_exponential"
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
-        stack.enter_context(patch.object(model._openai.ChatCompletion, "create", mock_openai))
-        stack.enter_context(pytest.raises(model._openai_error.ServiceUnavailableError))
+        stack.enter_context(patch.object(model._client.chat.completions, "create", mock_openai))
+        stack.enter_context(pytest.raises(model._openai.ServiceUnavailableError))
         llm_classify(
             dataframe=dataframe,
             template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -266,8 +266,8 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
     model = OpenAIModel(max_retries=2)
 
     openai_retry_errors = [
-        model._openai_error.Timeout("test timeout"),
-        model._openai_error.APIError("test api error"),
+        model._openai.APITimeoutError("test timeout"),
+        model._openai.APIError("test api error"),
     ]
     mock_openai = MagicMock()
     mock_openai.side_effect = openai_retry_errors

From b14ee5347d861e83f530ea0869948c75976ccd92 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 16:43:47 -0700
Subject: [PATCH 06/59] completions changes

---
 cspell.json                                   |   1 +
 pyproject.toml                                |   4 +-
 .../experimental/evals/models/openai.py       |  12 +-
 .../evals/functions/test_classify.py          |   8 +-
 .../evaluate_relevance_classifications.ipynb  | 354 +++---------------
 5 files changed, 75 insertions(+), 304 deletions(-)

diff --git a/cspell.json b/cspell.json
index 292e29eb74..cb2d614d2d 100644
--- a/cspell.json
+++ b/cspell.json
@@ -16,6 +16,7 @@
         "llamaindex",
         "NDJSON",
         "numpy",
+        "pydantic",
         "quickstart",
         "RERANKER",
         "rgba",
diff --git a/pyproject.toml b/pyproject.toml
index 5ecb21a618..9851b6e075 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -55,7 +55,7 @@ dev = [
   "strawberry-graphql[debug-server]==0.208.2",
   "pre-commit",
   "arize[AutoEmbeddings, LLM_Evaluation]",
-  "llama-index>=0.8.29",
+  "llama-index>=0.8.64",
   "langchain>=0.0.324",
 ]
 experimental = [
@@ -108,7 +108,7 @@ dependencies = [
 [tool.hatch.envs.type]
 dependencies = [
   "mypy==1.5.1",
-  "llama-index>=0.8.29",
+  "llama-index>=0.8.64",
   "pandas-stubs<=2.0.2.230605",  # version 2.0.3.230814 is causing a dependency conflict.
   "types-psutil",
   "types-tqdm",
diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 353af0e89d..91059a3542 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -17,7 +17,6 @@
     "gpt-3.5-turbo-16k-0613": 16385,
     "gpt-4-0314": 8192,
     "gpt-4-0613": 8192,  # Current gpt-4 default
-    "gpt-4-32k-0314": 32768,
     "gpt-4-32k-0613": 32768,
 }
 LEGACY_COMPLETION_API_MODELS = ("gpt-3.5-turbo-instruct",)
@@ -53,7 +52,7 @@ class OpenAIModel(BaseEvalModel):
     batch_size: int = 20
     # TODO: IMPLEMENT BATCHING
     """Batch size to use when passing multiple documents to generate."""
-    request_timeout: Optional[Union[float, Tuple[float, float]]] = None
+    timeout: Optional[Union[float, Tuple[float, float]]] = None
     """Timeout for requests to OpenAI completion API. Default is 600 seconds."""
     max_retries: int = 20
     """Maximum number of retries to make when generating."""
@@ -190,8 +189,10 @@ def _completion_with_retry(**kwargs: Any) -> Any:
                         (message.get("content") or "")
                         for message in (kwargs.pop("messages", None) or ())
                     )
-                return self._client.completions.create(**kwargs)
-            return self._client.chat.completions.create(**kwargs)
+                # OpenAI 1.0.0 API responses are pydantic objects, not dicts
+                # We must dump the model to get the dict
+                return self._client.completions.create(**kwargs).model_dump()
+            return self._client.chat.completions.create(**kwargs).model_dump()
 
         return _completion_with_retry(**kwargs)
 
@@ -225,7 +226,6 @@ def public_invocation_params(self) -> Dict[str, Any]:
     def invocation_params(self) -> Dict[str, Any]:
         return {
             **self.public_invocation_params,
-            **self._credentials,
         }
 
     @property
@@ -248,7 +248,7 @@ def _default_params(self) -> Dict[str, Any]:
             "presence_penalty": self.presence_penalty,
             "top_p": self.top_p,
             "n": self.n,
-            "request_timeout": self.request_timeout,
+            "timeout": self.timeout,
         }
 
     @property
diff --git a/tests/experimental/evals/functions/test_classify.py b/tests/experimental/evals/functions/test_classify.py
index 3f9db4f782..4bc78b29bc 100644
--- a/tests/experimental/evals/functions/test_classify.py
+++ b/tests/experimental/evals/functions/test_classify.py
@@ -276,8 +276,10 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
         waiting_fn = "phoenix.experimental.evals.models.base.wait_random_exponential"
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
-        stack.enter_context(patch.object(model._openai.ChatCompletion, "create", mock_openai))
-        stack.enter_context(pytest.raises(model._openai_error.APIError))
+        stack.enter_context(
+            patch.object(model._openai.client.chat.completions, "create", mock_openai)
+        )
+        stack.enter_context(pytest.raises(model._openai.OpenAIError))
         llm_classify(
             dataframe=dataframe,
             template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -298,7 +300,7 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
         waiting_fn = "phoenix.experimental.evals.models.base.wait_random_exponential"
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
-        stack.enter_context(patch.object(model._openai.ChatCompletion, "create", mock_openai))
+        stack.enter_context(patch.object(model._client.chat.completions, "create", mock_openai))
         stack.enter_context(pytest.raises(model._openai_error.APIError))
         llm_classify(
             dataframe=dataframe,
diff --git a/tutorials/evals/evaluate_relevance_classifications.ipynb b/tutorials/evals/evaluate_relevance_classifications.ipynb
index 0406da42cb..8f4950d005 100644
--- a/tutorials/evals/evaluate_relevance_classifications.ipynb
+++ b/tutorials/evals/evaluate_relevance_classifications.ipynb
@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -45,16 +45,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,7 +62,6 @@
     "from getpass import getpass\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
-    "import openai\n",
     "import pandas as pd\n",
     "from phoenix.experimental.evals import (\n",
     "    RAG_RELEVANCY_PROMPT_RAILS_MAP,\n",
@@ -91,15 +90,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "\n",
-       "  <div id=\"df-55ef854d-96a3-49f1-92a8-fa476184fca5\" class=\"colab-df-container\">\n",
-       "    <div>\n",
+       "<div>\n",
        "<style scoped>\n",
        "    .dataframe tbody tr th:only-of-type {\n",
        "        vertical-align: middle;\n",
@@ -173,215 +170,7 @@
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "</div>\n",
-       "    <div class=\"colab-df-buttons\">\n",
-       "\n",
-       "  <div class=\"colab-df-container\">\n",
-       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-55ef854d-96a3-49f1-92a8-fa476184fca5')\"\n",
-       "            title=\"Convert this dataframe to an interactive table.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
-       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
-       "  </svg>\n",
-       "    </button>\n",
-       "\n",
-       "  <style>\n",
-       "    .colab-df-container {\n",
-       "      display:flex;\n",
-       "      gap: 12px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert {\n",
-       "      background-color: #E8F0FE;\n",
-       "      border: none;\n",
-       "      border-radius: 50%;\n",
-       "      cursor: pointer;\n",
-       "      display: none;\n",
-       "      fill: #1967D2;\n",
-       "      height: 32px;\n",
-       "      padding: 0 0 0 0;\n",
-       "      width: 32px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert:hover {\n",
-       "      background-color: #E2EBFA;\n",
-       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "      fill: #174EA6;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-buttons div {\n",
-       "      margin-bottom: 4px;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert {\n",
-       "      background-color: #3B4455;\n",
-       "      fill: #D2E3FC;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert:hover {\n",
-       "      background-color: #434B5C;\n",
-       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
-       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
-       "      fill: #FFFFFF;\n",
-       "    }\n",
-       "  </style>\n",
-       "\n",
-       "    <script>\n",
-       "      const buttonEl =\n",
-       "        document.querySelector('#df-55ef854d-96a3-49f1-92a8-fa476184fca5 button.colab-df-convert');\n",
-       "      buttonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "\n",
-       "      async function convertToInteractive(key) {\n",
-       "        const element = document.querySelector('#df-55ef854d-96a3-49f1-92a8-fa476184fca5');\n",
-       "        const dataTable =\n",
-       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
-       "                                                    [key], {});\n",
-       "        if (!dataTable) return;\n",
-       "\n",
-       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
-       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
-       "          + ' to learn more about interactive tables.';\n",
-       "        element.innerHTML = '';\n",
-       "        dataTable['output_type'] = 'display_data';\n",
-       "        await google.colab.output.renderOutput(dataTable, element);\n",
-       "        const docLink = document.createElement('div');\n",
-       "        docLink.innerHTML = docLinkHtml;\n",
-       "        element.appendChild(docLink);\n",
-       "      }\n",
-       "    </script>\n",
-       "  </div>\n",
-       "\n",
-       "\n",
-       "<div id=\"df-ef724071-9b67-4712-a7e7-ce98d558de79\">\n",
-       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-ef724071-9b67-4712-a7e7-ce98d558de79')\"\n",
-       "            title=\"Suggest charts.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
-       "     width=\"24px\">\n",
-       "    <g>\n",
-       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
-       "    </g>\n",
-       "</svg>\n",
-       "  </button>\n",
-       "\n",
-       "<style>\n",
-       "  .colab-df-quickchart {\n",
-       "      --bg-color: #E8F0FE;\n",
-       "      --fill-color: #1967D2;\n",
-       "      --hover-bg-color: #E2EBFA;\n",
-       "      --hover-fill-color: #174EA6;\n",
-       "      --disabled-fill-color: #AAA;\n",
-       "      --disabled-bg-color: #DDD;\n",
-       "  }\n",
-       "\n",
-       "  [theme=dark] .colab-df-quickchart {\n",
-       "      --bg-color: #3B4455;\n",
-       "      --fill-color: #D2E3FC;\n",
-       "      --hover-bg-color: #434B5C;\n",
-       "      --hover-fill-color: #FFFFFF;\n",
-       "      --disabled-bg-color: #3B4455;\n",
-       "      --disabled-fill-color: #666;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart {\n",
-       "    background-color: var(--bg-color);\n",
-       "    border: none;\n",
-       "    border-radius: 50%;\n",
-       "    cursor: pointer;\n",
-       "    display: none;\n",
-       "    fill: var(--fill-color);\n",
-       "    height: 32px;\n",
-       "    padding: 0;\n",
-       "    width: 32px;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart:hover {\n",
-       "    background-color: var(--hover-bg-color);\n",
-       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "    fill: var(--button-hover-fill-color);\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart-complete:disabled,\n",
-       "  .colab-df-quickchart-complete:disabled:hover {\n",
-       "    background-color: var(--disabled-bg-color);\n",
-       "    fill: var(--disabled-fill-color);\n",
-       "    box-shadow: none;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-spinner {\n",
-       "    border: 2px solid var(--fill-color);\n",
-       "    border-color: transparent;\n",
-       "    border-bottom-color: var(--fill-color);\n",
-       "    animation:\n",
-       "      spin 1s steps(1) infinite;\n",
-       "  }\n",
-       "\n",
-       "  @keyframes spin {\n",
-       "    0% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "      border-left-color: var(--fill-color);\n",
-       "    }\n",
-       "    20% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    30% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    40% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    60% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    80% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "    90% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "  }\n",
-       "</style>\n",
-       "\n",
-       "  <script>\n",
-       "    async function quickchart(key) {\n",
-       "      const quickchartButtonEl =\n",
-       "        document.querySelector('#' + key + ' button');\n",
-       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
-       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
-       "      try {\n",
-       "        const charts = await google.colab.kernel.invokeFunction(\n",
-       "            'suggestCharts', [key], {});\n",
-       "      } catch (error) {\n",
-       "        console.error('Error during call to suggestCharts:', error);\n",
-       "      }\n",
-       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
-       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
-       "    }\n",
-       "    (() => {\n",
-       "      let quickchartButtonEl =\n",
-       "        document.querySelector('#df-ef724071-9b67-4712-a7e7-ce98d558de79 button');\n",
-       "      quickchartButtonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "    })();\n",
-       "  </script>\n",
-       "</div>\n",
-       "    </div>\n",
-       "  </div>\n"
+       "</div>"
       ],
       "text/plain": [
        "  query_id  \\\n",
@@ -427,7 +216,7 @@
        "4     False  "
       ]
      },
-     "execution_count": null,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -450,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -504,21 +293,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔑 Enter your OpenAI API key: ··········\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "openai.api_key = openai_api_key\n",
     "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
@@ -534,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -558,17 +338,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = OpenAIModel(\n",
     "    model_name=\"gpt-4\",\n",
@@ -578,26 +350,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-11 21:36:12.529169 |█████████████████████████████| 100.0% (1/1) [00:01<00:00,  1.52s/it]\n"
-     ]
-    },
     {
      "data": {
-      "application/vnd.google.colaboratory.intrinsic+json": {
-       "type": "string"
-      },
       "text/plain": [
        "\"Hello! I'm working perfectly. How can I assist you today?\""
       ]
      },
-     "execution_count": null,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -617,15 +379,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-11 21:43:25.509018 |█████████████████████████| 100.0% (100/100) [07:07<00:00,  4.27s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a12a5284ad8c455aa6efcf0152100d43",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -652,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -661,12 +430,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    relevant       0.67      0.90      0.77        40\n",
-      "  irrelevant       0.91      0.70      0.79        60\n",
+      "    relevant       0.72      0.89      0.80        44\n",
+      "  irrelevant       0.89      0.73      0.80        56\n",
       "\n",
-      "    accuracy                           0.78       100\n",
-      "   macro avg       0.79      0.80      0.78       100\n",
-      "weighted avg       0.81      0.78      0.78       100\n",
+      "    accuracy                           0.80       100\n",
+      "   macro avg       0.81      0.81      0.80       100\n",
+      "weighted avg       0.82      0.80      0.80       100\n",
       "\n"
      ]
     },
@@ -676,13 +445,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": null,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHHCAYAAAChjmJTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfYklEQVR4nO3deVhUZfsH8O8MMuwDKgiICCGikgqKiksmFoq5oqmoJEilbbxpSJqpLG64i/pamrllmuRaaeKCWym54L7vYiabJggoy8z5/eGP8zqyOAODMMP303Wuy3nOc85zn2Fibp7lHIkgCAKIiIiIdIi0qgMgIiIi0hQTGCIiItI5TGCIiIhI5zCBISIiIp3DBIaIiIh0DhMYIiIi0jlMYIiIiEjnMIEhIiIincMEhoiIiHQOExiiUly7dg3du3eHpaUlJBIJtm3bptXz3759GxKJBKtXr9bqeXWZj48PfHx8tHrOu3fvwtjYGIcPH9bqeasziUSCqKgo8fXq1ashkUhw+/btVxqHs7MzRowYIb6Oj4+Hubk50tPTX2kcpJ+YwFC1duPGDXz00UdwcXGBsbEx5HI5OnXqhIULF+LJkyeV2nZwcDDOnTuH6dOnY+3atWjTpk2ltvcqjRgxAhKJBHK5vMT38dq1a5BIJJBIJJg7d67G5//nn38QFRWF06dPayHaipkyZQq8vb3RqVMnsazo+lu2bImSnqYikUgQGhr6KsOsEXr06AFXV1fExMRUdSikB5jAULW1Y8cOtGjRAj///DP69OmDxYsXIyYmBg0bNsSXX36J0aNHV1rbT548QWJiIj744AOEhobivffeQ4MGDbTahpOTE548eYLhw4dr9bzqqlWrFnJzc/Hbb78V27du3ToYGxuX+9z//PMPoqOjNU5gdu/ejd27d5e73Relp6djzZo1+Pjjj0vcf+7cOWzZskVr7VVXw4cPx5MnT+Dk5FTVoeCjjz7CsmXL8Pjx46oOhXQcExiqlm7duoUhQ4bAyckJFy9exMKFCzFy5Eh89tln+Omnn3Dx4kW8/vrrldZ+URe3lZVVpbUhkUhgbGwMAwODSmujLEZGRnj77bfx008/Fdu3fv169OrV65XFkpubCwCQyWSQyWRaO++PP/6IWrVqoU+fPsX2mZiYwM3NDVOmTCmxF0ZbCgsLkZ+fX2nnV4eBgQGMjY0hkUiqNA4AePfdd5GXl4eNGzdWdSik45jAULU0e/ZsZGdnY8WKFbC3ty+239XVVaUHprCwEFOnTkWjRo1gZGQEZ2dnfP3118jLy1M5ztnZGb1798aff/6Jdu3awdjYGC4uLvjhhx/EOlFRUeJfql9++SUkEgmcnZ0BPBt6KPr386Kioop9OezZswdvvPEGrKysYG5ujiZNmuDrr78W95c2B2bfvn3o3LkzzMzMYGVlhX79+uHSpUsltnf9+nWMGDECVlZWsLS0REhIiJgMqGPYsGHYuXMnHj16JJYdP34c165dw7Bhw4rVf/jwIcLDw9GiRQuYm5tDLpfjnXfewZkzZ8Q6Bw4cQNu2bQEAISEh4lBU0XX6+PigefPmSEpKwptvvglTU1PxfXlxDkxwcDCMjY2LXb+fnx9q166Nf/75p8zr27ZtG7y9vWFubl5sn1QqxaRJk3D27Fls3bq1zPMAQFpaGj744APY2trC2NgYHh4eWLNmjUqdop/p3LlzERsbK34eL168KP7Mrl69ivfeew+WlpawsbHB5MmTIQgC7t69i379+kEul8POzg7z5s1TOXd+fj4iIiLg5eUFS0tLmJmZoXPnzti/f/9LY39xDkxRLCVtz89ZUSqViI2Nxeuvvw5jY2PY2trio48+wr///qtyfkEQMG3aNDRo0ACmpqbo2rUrLly4UGIs9erVQ8uWLfHLL7+8NG6isjCBoWrpt99+g4uLCzp27KhW/Q8//BARERFo3bo1FixYgC5duiAmJgZDhgwpVvf69esYOHAgunXrhnnz5qF27doYMWKE+At3wIABWLBgAQBg6NChWLt2LWJjYzWK/8KFC+jduzfy8vIwZcoUzJs3D3379n3pRNK9e/fCz88PaWlpiIqKQlhYGI4cOYJOnTqVOAFz8ODBePz4MWJiYjB48GCsXr0a0dHRasc5YMAASCQSlWGU9evXo2nTpmjdunWx+jdv3sS2bdvQu3dvzJ8/H19++SXOnTuHLl26iMlEs2bNMGXKFADAqFGjsHbtWqxduxZvvvmmeJ4HDx7gnXfegaenJ2JjY9G1a9cS41u4cCFsbGwQHBwMhUIBAFi2bBl2796NxYsXo379+qVeW0FBAY4fP17idRQZNmwYGjdu/NJemCdPnsDHxwdr165FYGAg5syZA0tLS4wYMQILFy4sVn/VqlVYvHgxRo0ahXnz5qFOnTrivoCAACiVSsycORPe3t6YNm0aYmNj0a1bNzg4OGDWrFlwdXVFeHg4Dh06JB6XlZWF77//Hj4+Ppg1axaioqKQnp4OPz8/jYfqBgwYIP5cirYxY8YAeJZgFPnoo4/w5ZdfivPOQkJCsG7dOvj5+aGgoECsFxERgcmTJ8PDwwNz5syBi4sLunfvjpycnBLb9/LywpEjRzSKmagYgaiayczMFAAI/fr1U6v+6dOnBQDChx9+qFIeHh4uABD27dsnljk5OQkAhEOHDollaWlpgpGRkTB27Fix7NatWwIAYc6cOSrnDA4OFpycnIrFEBkZKTz/v9OCBQsEAEJ6enqpcRe1sWrVKrHM09NTqFevnvDgwQOx7MyZM4JUKhWCgoKKtff++++rnLN///5C3bp1S23z+eswMzMTBEEQBg4cKLz99tuCIAiCQqEQ7OzshOjo6BLfg6dPnwoKhaLYdRgZGQlTpkwRy44fP17s2op06dJFACAsXbq0xH1dunRRKdu1a5cAQJg2bZpw8+ZNwdzcXPD393/pNV6/fl0AICxevLjM61+zZo0AQNiyZYu4H4Dw2Wefia9jY2MFAMKPP/4oluXn5wsdOnQQzM3NhaysLPG9ACDI5XIhLS1Npc2in9moUaPEssLCQqFBgwaCRCIRZs6cKZb/+++/gomJiRAcHKxSNy8vT+Wc//77r2Bra1vscwBAiIyMFF+vWrVKACDcunWrxPcqPT1daNiwodCiRQshOztbEARB+OOPPwQAwrp161TqxsfHq5SnpaUJMplM6NWrl6BUKsV6X3/9tQBA5RqKzJgxQwAgpKamlhgPkTrYA0PVTlZWFgDAwsJCrfq///47ACAsLEylfOzYsQCeTQZ+nru7Ozp37iy+trGxQZMmTXDz5s1yx/yiorkzv/zyC5RKpVrH3L9/H6dPn8aIESNU/mJv2bIlunXrJl7n816cnNq5c2c8ePBAfA/VMWzYMBw4cAApKSnYt28fUlJSShw+Ap7Nm5FKn/3aUCgUePDggTg8dvLkSbXbNDIyQkhIiFp1u3fvjo8++ghTpkzBgAEDYGxsjGXLlr30uAcPHgAAateuXWa9wMDAl/bC/P7777Czs8PQoUPFMkNDQ3z++efIzs7GwYMHVeq/++67sLGxKfFcH374ofhvAwMDtGnTBoIg4IMPPhDLraysin0mDQwMxPlBSqUSDx8+RGFhIdq0aaPRe/8ihUKBoUOH4vHjx9i6dSvMzMwAABs3boSlpSW6deuGjIwMcfPy8oK5ubk4dLV3717k5+fjP//5j8owalGPTkmKfiYZGRnljpuICQxVO3K5HADUXqVw584dSKVSuLq6qpTb2dnBysoKd+7cUSlv2LBhsXPUrl272Lh+RQQEBKBTp0748MMPYWtriyFDhuDnn38uM5kpirNJkybF9jVr1gwZGRnFuuRfvJaiLwZNrqVnz56wsLBAXFwc1q1bh7Zt2xZ7L4solUosWLAAjRs3hpGREaytrWFjY4OzZ88iMzNT7TYdHBw0mqw7d+5c1KlTB6dPn8aiRYtUhjleprSkpIiBgQEmTZqE06dPl3qvnzt37qBx48Zi8lakWbNm4v7nvfbaa6W29+LPzNLSEsbGxrC2ti5W/uLPcc2aNWjZsiWMjY1Rt25d2NjYYMeOHRq99y+aNGkS9u3bh/Xr16NRo0Zi+bVr15CZmYl69erBxsZGZcvOzkZaWhqA/11748aNVc5rY2NTavJY9DOpDpOKSXfVquoAiF4kl8tRv359nD9/XqPj1P1lWNqqn5d90ZXVRtH8jCImJiY4dOgQ9u/fjx07diA+Ph5xcXF46623sHv3bq2tPKrItRQxMjLCgAEDsGbNGty8eVPlBmgvmjFjBiZPnoz3338fU6dORZ06dSCVSjFmzBi1e5qAZ++PJk6dOiV+YZ47d06lJ6Q0devWBaBeMhcYGIipU6diypQp8Pf31yi2kpR1fSX9zNT5Of74448YMWIE/P398eWXX6JevXowMDBATEwMbty4Ua44t23bhlmzZmHq1Kno0aOHyj6lUol69eph3bp1JR5bWg+TOop+Ji8mbUSaYAJD1VLv3r3x3XffITExER06dCizrpOTE5RKJa5duyb+RQwAqampePTokVbvfVG7dm2VFTtFXvwLHHi2yuXtt9/G22+/jfnz52PGjBmYOHEi9u/fD19f3xKvAwCuXLlSbN/ly5dhbW0tdu9r27Bhw7By5UpIpdISJz4X2bRpE7p27YoVK1aolD969Ejly0ibf1nn5OQgJCQE7u7u6NixI2bPno3+/fuLK51K07BhQ5iYmODWrVsvbaOoF2bEiBElro5xcnLC2bNnoVQqVXphLl++LO6vbJs2bYKLiwu2bNmi8v5GRkaW63xXr15FcHAw/P39VVbHFWnUqBH27t2LTp06lZmQFV37tWvX4OLiIpanp6eXmjzeunVL7L0jKi8OIVG1NG7cOJiZmeHDDz9Eampqsf03btwQV3/07NkTAIqtFJo/fz4AaPV+Jo0aNUJmZibOnj0rlt2/f7/YMtyHDx8WO9bT0xMAii3tLmJvbw9PT0+sWbNGJUk6f/48du/eLV5nZejatSumTp2K//73v7Czsyu1noGBQbHenY0bN+LevXsqZUWJVknJnqbGjx+P5ORkrFmzBvPnz4ezszOCg4NLfR+LGBoaok2bNjhx4oRa7bz33ntwdXUtcRVXz549kZKSgri4OLGssLAQixcvhrm5Obp06aLZRZVDUS/N8+//0aNHkZiYqPG5srOz0b9/fzg4OGDNmjUlJpyDBw+GQqHA1KlTi+0rLCwUf7a+vr4wNDTE4sWLVWIra+VeUlLSS/8wIXoZ9sBQtdSoUSOsX78eAQEBaNasGYKCgtC8eXPk5+fjyJEj2Lhxo3i/Cg8PDwQHB+O7777Do0eP0KVLFxw7dgxr1qyBv79/qUt0y2PIkCEYP348+vfvj88//xy5ubn49ttv4ebmpjKRcsqUKTh06BB69eoFJycnpKWl4ZtvvkGDBg3wxhtvlHr+OXPm4J133kGHDh3wwQcf4MmTJ1i8eDEsLS3LHNqpqKJ7orxM7969MWXKFISEhKBjx444d+4c1q1bp/KXN/Ds52dlZYWlS5fCwsICZmZm8Pb2LnNuSEn27duHb775BpGRkeJy6FWrVsHHxweTJ0/G7Nmzyzy+X79+mDhxIrKyssS5VaUxMDDAxIkTS5xcPGrUKCxbtgwjRoxAUlISnJ2dsWnTJhw+fBixsbFqTziviN69e2PLli3o378/evXqhVu3bmHp0qVwd3dHdna2RueKjo7GxYsXMWnSpGI9To0aNUKHDh3QpUsXfPTRR4iJicHp06fRvXt3GBoa4tq1a9i4cSMWLlyIgQMHwsbGBuHh4YiJiUHv3r3Rs2dPnDp1Cjt37ixxiCgtLQ1nz57FZ599VqH3g4jLqKlau3r1qjBy5EjB2dlZkMlkgoWFhdCpUydh8eLFwtOnT8V6BQUFQnR0tPDaa68JhoaGgqOjozBhwgSVOoLwbBl1r169irXz4vLd0pZRC4Ig7N69W2jevLkgk8mEJk2aCD/++GOxZdQJCQlCv379hPr16wsymUyoX7++MHToUOHq1avF2nhxqfHevXuFTp06CSYmJoJcLhf69OkjXLx4UaVOUXsvLtN+2XLZIs8vIy5Nacuox44dK9jb2wsmJiZCp06dhMTExBKXP//yyy+Cu7u7UKtWLZXr7NKli/D666+X2Obz58nKyhKcnJyE1q1bCwUFBSr1vvjiC0EqlQqJiYllXkNqaqpQq1YtYe3atWpdf0FBgdCoUaNiy6iLzhUSEiJYW1sLMplMaNGiRbGfXVmfm9J+ZqXF8uL7pFQqhRkzZghOTk6CkZGR0KpVK2H79u0lLu3HS5ZRBwcHCwBK3F5c9vzdd98JXl5egomJiWBhYSG0aNFCGDdunPDPP/+IdRQKhRAdHS1+Lnx8fITz588LTk5Oxc737bffCqampuLSc6LykghCJd5Dm4ioin3wwQe4evUq/vjjj6oOhQC0atUKPj4+4s0iicqLCQwR6bXk5GS4ubkhISFB5YnU9OrFx8dj4MCBuHnzpkZL4YlKwgSGiIiIdA5XIREREZHOYQJDREREFbZkyRI4OzvD2NgY3t7eOHbsWKl1CwoKMGXKFDRq1Eh8unt8fLxG7TGBISIiogqJi4tDWFgYIiMjcfLkSXh4eMDPz0+8g/aLJk2ahGXLlmHx4sW4ePEiPv74Y/Tv3x+nTp1Su03OgSEiIqIK8fb2Rtu2bfHf//4XwLNHUTg6OuI///kPvvrqq2L169evj4kTJ6rcD+jdd9+FiYkJfvzxR7Xa5I3sdIBSqcQ///wDCwsLPvyMiEgHCYKAx48fo379+sUeCqpNT58+RX5+foXPIwhCse8bIyMjGBkZFaubn5+PpKQkTJgwQSyTSqXw9fUt9U7ReXl5MDY2VikzMTHBn3/+qXaMTGB0wD///ANHR8eqDoOIiCro7t27aNCgQaWc++nTpzCxqAsU5lb4XObm5sXu8BwZGVniHcEzMjKgUChga2urUm5rays+L+xFfn5+mD9/Pt588000atQICQkJ2LJlS7EH45aFCYwOKLpNucw9GBIDWRVHQ1Q5kg/MreoQiCrN46wsuL7mWKmPncjPzwcKc2HkHgxU5LtCkY/si2tw9+5dlUdwlNT7Ul4LFy7EyJEj0bRpU0gkEjRq1AghISFYuXKl2udgAqMDirrxJAYyJjCkt172rCIiffBKpgHUMq7Qd4UgeTbEJZfL1fr/0traGgYGBsUevJuamlrqw2FtbGywbds2PH36FA8ePED9+vXx1VdfFXuuWlm4ComIiEifSABIJBXYNGtOJpPBy8sLCQkJYplSqURCQsJLnzpubGwMBwcHFBYWYvPmzejXr5/a7bIHhoiISJ9IpM+2ihyvobCwMAQHB6NNmzZo164dYmNjkZOTIz7dPSgoCA4ODoiJiQEAHD16FPfu3YOnpyfu3buHqKgoKJVKjBs3Tu02mcAQERFRhQQEBCA9PR0RERFISUmBp6cn4uPjxYm9ycnJKquvnj59ikmTJuHmzZswNzdHz549sXbtWlhZWandJu8DowOysrJgaWkJoxYjOQeG9Na/x/9b1SEQVZqsrCzY1rVEZmZmpc33Er8rWn0KiUH5J9wKijzknfqmUmPVBvbAEBER6ZMqGEKqCroRJREREdFz2ANDRESkT4pWE1XkeB3ABIaIiEivVHAISUcGZ3QjSiIiIqLnsAeGiIhIn3AIiYiIiHQOVyERERERVU/sgSEiItInHEIiIiIinVNDhpCYwBAREemTGtIDoxtpFhEREdFz2ANDRESkTziERERERDpHIqlgAsMhJCIiIqJKwR4YIiIifSKVPNsqcrwOYAJDRESkT2rIHBjdiJKIiIjoOeyBISIi0ic15D4wTGCIiIj0CYeQiIiIiKon9sAQERHpEw4hERERkc6pIUNITGCIiIj0SQ3pgdGNNIuIiIjoOeyBISIi0iccQiIiIiKdwyEkIiIiouqJPTBERER6pYJDSDrSt8EEhoiISJ9wCImIiIioemIPDBERkT6RSCq4Ckk3emCYwBAREemTGrKMWjeiJCIiInoOe2CIiIj0CSfxEhERkc4pGkKqyFYOS5YsgbOzM4yNjeHt7Y1jx46VWT82NhZNmjSBiYkJHB0d8cUXX+Dp06dqt8cEhoiISJ8U9cBUZNNQXFwcwsLCEBkZiZMnT8LDwwN+fn5IS0srsf769evx1VdfITIyEpcuXcKKFSsQFxeHr7/+Wu02mcAQERFRhcyfPx8jR45ESEgI3N3dsXTpUpiammLlypUl1j9y5Ag6deqEYcOGwdnZGd27d8fQoUNf2mvzPCYwRERE+kRLQ0hZWVkqW15eXonN5efnIykpCb6+vmKZVCqFr68vEhMTSzymY8eOSEpKEhOWmzdv4vfff0fPnj3VvkxO4iUiItInWprE6+joqFIcGRmJqKioYtUzMjKgUChga2urUm5ra4vLly+X2MSwYcOQkZGBN954A4IgoLCwEB9//LFGQ0hMYIiIiKiYu3fvQi6Xi6+NjIy0du4DBw5gxowZ+Oabb+Dt7Y3r169j9OjRmDp1KiZPnqzWOZjAEBER6RGJRAKJFnpg5HK5SgJTGmtraxgYGCA1NVWlPDU1FXZ2diUeM3nyZAwfPhwffvghAKBFixbIycnBqFGjMHHiREilL5/hwjkwREREeqQoganIpgmZTAYvLy8kJCSIZUqlEgkJCejQoUOJx+Tm5hZLUgwMDAAAgiCo1S57YIiIiKhCwsLCEBwcjDZt2qBdu3aIjY1FTk4OQkJCAABBQUFwcHBATEwMAKBPnz6YP38+WrVqJQ4hTZ48GX369BETmZdhAkNERKRPJP+/VeR4DQUEBCA9PR0RERFISUmBp6cn4uPjxYm9ycnJKj0ukyZNgkQiwaRJk3Dv3j3Y2NigT58+mD59uvphCur21VCVycrKgqWlJYxajITEQFbV4RBVin+P/7eqQyCqNFlZWbCta4nMzEy15pWUtw1LS0uY+n8DiaFJuc8jFDxB7rZPKzVWbeAcGCIiItI5HEIiIiLSI9pahVTdMYEhIiLSI0xgiIiISOfUlASGc2CIiIhI57AHhoiISJ9UwTLqqsAEhoiISI9wCImIiIiommIPDBERkR6RSFDBHhjtxVKZmMAQERHpEQkqOISkIxkMh5CIiIhI57AHhoiISI/UlEm8TGCIiIj0SQ1ZRs0hJCIiItI57IEhIiLSJxUcQhI4hERERESvWkXnwFRsBdOrwwSGiIhIj9SUBIZzYIiIiEjnsAeGiIhIn9SQVUhMYIiIiPQIh5CIiIiIqin2wBAREemRmtIDwwSGiIhIj9SUBIZDSERERKRz2ANDRESkR2pKDwwTGCIiIn1SQ5ZRcwiJiIiIdA57YIiIiPQIh5CIiIhI5zCBISIiIp1TUxIYzoEhIiIincMeGCIiIn1SQ1YhMYEhIiLSIxxCIiIiIqqm9DKB8fHxwZgxY6o6DKrGPhz0Js78Eo37fy7AnlXhaO3uVGrdWgZSfPlhD5zcGon7fy7AH+u+wtsdmr3CaIk0t/zng2jZNwJ2ncbAd8QcJF24XWrdSzfuI2jccrTsG4HabUPx7fr9ry5Q0rqiHpiKbLpALxOY6oqJVfXQv1trTBvTH7O+3wmf4bNw/to9bF78Gaxrm5dYf9InfTCi/xsYP2cj2gdMw6otf2Lt7JFo4dbgFUdOpJ4tu5MwKXYrxn/4Dg6sHY/mjR3w7n+WIP3h4xLrP3maDycHa0SG9oVtXfkrjpa0TYIKJjDlnASzZMkSODs7w9jYGN7e3jh27FipdX18fEpsu1evXmq3p3MJTH5+flWHQDru02Fv4YdtR7D+t79w5VYKwmI2IPdpPt7r26HE+oN7tsOC1bux58hF3Ln3ACs3/4k9Ry4i9L23XnHkROr5Zv0+BPl3RGDfDmjqYo/5E4bA1FiGH39NLLF+69edMHV0f7zbvQ1kMk6NJM3FxcUhLCwMkZGROHnyJDw8PODn54e0tLQS62/ZsgX3798Xt/Pnz8PAwACDBg1Su81qn8D4+PggNDQUY8aMgbW1Nfz8/HD+/Hm88847MDc3h62tLYYPH46MjIxSz5GXl4fw8HA4ODjAzMwM3t7eOHDgAAAgKysLJiYm2Llzp8oxW7duhYWFBXJzcwEA48ePh5ubG0xNTeHi4oLJkyejoKBArB8VFQVPT0+sXbsWzs7OsLS0xJAhQ/D48bO/eEaMGIGDBw9i4cKFYqZ5+/Zt7b5Z9FKGtQzg2dQRB45dEcsEQcDBY1fQtsVrJR5jZFgLT/MKVMqe5uWjvUejSo2VqDzyCwpx+vJd+LRrIpZJpVJ0adcEx8/dqsLI6FWpiiGk+fPnY+TIkQgJCYG7uzuWLl0KU1NTrFy5ssT6derUgZ2dnbjt2bMHpqam+pXAAMCaNWsgk8lw+PBhzJw5E2+99RZatWqFEydOID4+HqmpqRg8eHCpx4eGhiIxMREbNmzA2bNnMWjQIPTo0QPXrl2DXC5H7969sX79epVj1q1bB39/f5iamgIALCwssHr1aly8eBELFy7E8uXLsWDBApVjbty4gW3btmH79u3Yvn07Dh48iJkzZwIAFi5ciA4dOmDkyJFixuno6Kjld4pepq6VOWrVMijWlZ7+MAv1Suk63/fXJXwa+BZcHG0gkUjg064penf1hK01u9qp+nnwKBsKhRI2dSxUym3qyJH2IKuKoqJXSqKFTQP5+flISkqCr6+vWCaVSuHr64vExJJ7/V60YsUKDBkyBGZmZmq3qxN9hY0bN8bs2bMBANOmTUOrVq0wY8YMcf/KlSvh6OiIq1evws3NTeXY5ORkrFq1CsnJyahfvz4AIDw8HPHx8Vi1ahVmzJiBwMBADB8+HLm5uTA1NUVWVhZ27NiBrVu3iueZNGmS+G9nZ2eEh4djw4YNGDdunFiuVCqxevVqWFg8+8UxfPhwJCQkYPr06bC0tIRMJoOpqSns7OzKvN68vDzk5eWJr7Oy+EunKn01bxMWThyKYxsnQxAE3LqXgfW//YXAPu2rOjQiokrz4nePkZERjIyMitXLyMiAQqGAra2tSrmtrS0uX7780naOHTuG8+fPY8WKFRrFpxMJjJeXl/jvM2fOYP/+/TA3Lz7h8saNG8USmHPnzkGhUBQrz8vLQ926dQEAPXv2hKGhIX799VcMGTIEmzdvhlwuV8km4+LisGjRIty4cQPZ2dkoLCyEXK76F7izs7OYvACAvb19qeN/ZYmJiUF0dLTGx9HLPXiUjcJChUZ/nT54lI33vlwOI1kt1LE0w/30TESF9sPtfx68ipCJNFLXyhwGBlKNehlJv2jrPjAvjhJERkYiKiqqIqGVaMWKFWjRogXatWun0XE6kcA836WUnZ2NPn36YNasWcXq2dvbFyvLzs6GgYEBkpKSYGBgoLKvKAmSyWQYOHAg1q9fjyFDhmD9+vUICAhArVrP3p7ExEQEBgYiOjoafn5+sLS0xIYNGzBv3jyV8xkaGqq8lkgkUCqVGl/vhAkTEBYWJr7OysricJOWFBQqcPryXXRp2wS/HzwL4NnP6c22bvh+46Eyj83LL8T99EzUMpCiz1ue2Lb35KsImUgjMsNa8GzqiIPHr6CXjweAZ73Dh45fxYeD3qzi6OhV0FYCc/fuXZU/1EvqfQEAa2trGBgYIDU1VaU8NTX1pSMOOTk52LBhA6ZMmaJxnDqRwDyvdevW2Lx5M5ydncUEoyytWrWCQqFAWloaOnfuXGq9wMBAdOvWDRcuXMC+ffswbdo0cd+RI0fg5OSEiRMnimV37tzROHaZTAaFQvHSeqV105F2fLN+H76JHI5Tl5Jx8sJtfDK0K8xMjLDut78AAN9GDcf99ExMWfIrAMDrdSfY17PCuat/o76NFcaP6gmpVIKFP+ytyssgKtWnw97Cp9Fr0apZQ7R+3Rnf/rQfOU/yxGHPjyN/gL2NJSJD+wF4NvH3ys0UAEBBQSH+SX+Ec1f+hpmpEVwcbarsOqh8JJJnW0WOBwC5XF5spKEkMpkMXl5eSEhIgL+/P4BnSXNCQgJCQ0PLPHbjxo3Iy8vDe++9p3GcOpfAfPbZZ1i+fDmGDh2KcePGoU6dOrh+/To2bNiA77//vlgvi5ubGwIDAxEUFIR58+ahVatWSE9PR0JCAlq2bCmuOX/zzTdhZ2eHwMBAvPbaa/D29hbP0bhxYyQnJ2PDhg1o27Ztsfkx6nJ2dsbRo0dx+/ZtmJubo06dOpBKdWIetV7ZuuckrK3M8fVHvVCvrgXOXb2HgZ//7x4ZDezqQCkIYn0jI0NM/Lg3nB2skfMkD3sOX8DHET8gK/tJVV0CUZkGdPdCxqNszFi2A2kPHqOFmwM2LfpMHEL6O+UhpM99w6WkZ+LN92aKr//7YwL++2MCOrV2xfZlY151+KSDwsLCEBwcjDZt2qBdu3aIjY1FTk4OQkJCAABBQUFwcHBATEyMynErVqyAv7+/OKVDEzqXwNSvXx+HDx/G+PHj0b17d+Tl5cHJyQk9evQoNRlYtWoVpk2bhrFjx+LevXuwtrZG+/bt0bt3b7GORCLB0KFDMXv2bERERKgc37dvX3zxxRcIDQ1FXl4eevXqhcmTJ2s8FhgeHo7g4GC4u7vjyZMnuHXrFpydnTV9C0gLlm88hOWlDBn1+XihyusjJ6+jQ8D0VxEWkdaMGtwFowZ3KXHfi0lJw/p18e/x/76CqOhVeNYDU5EhJM2PCQgIQHp6OiIiIpCSkgJPT0/Ex8eLE3uTk5OLfUdfuXIFf/75J3bv3l2+OAXhuT81qVrKysqCpaUljFqMhMRAVtXhEFUKfoGSPsvKyoJtXUtkZmaqNSxT3jYsLS3h8vkmGBipvxz5RYq8HNxcNLBSY9UGjl8QERGRztG5ISQiIiIqnbZWIVV3TGCIiIj0iLZWIVV3HEIiIiIincMeGCIiIj0ilUoglZa/G0WowLGvEhMYIiIiPcIhJCIiIqJqij0wREREeoSrkIiIiEjn1JQhJCYwREREeqSm9MBwDgwRERHpHPbAEBER6ZGa0gPDBIaIiEiP1JQ5MBxCIiIiIp3DHhgiIiI9IkEFh5CgG10wTGCIiIj0CIeQiIiIiKop9sAQERHpEa5CIiIiIp3DISQiIiKiaoo9MERERHqEQ0hERESkc2rKEBITGCIiIj1SU3pgOAeGiIiIdA57YIiIiPRJBYeQdORGvExgiIiI9AmHkIiIiIiqKfbAEBER6RGuQiIiIiKdwyEkIiIiomqKPTBERER6hENIREREpHM4hERERERUTbEHhoiISI/UlB4YJjBERER6pKbMgeEQEhERkR4p6oGpyFYeS5YsgbOzM4yNjeHt7Y1jx46VWf/Ro0f47LPPYG9vDyMjI7i5ueH3339Xuz32wBAREVGFxMXFISwsDEuXLoW3tzdiY2Ph5+eHK1euoF69esXq5+fno1u3bqhXrx42bdoEBwcH3LlzB1ZWVmq3qXEC8+TJEwiCAFNTUwDAnTt3sHXrVri7u6N79+6ano6IiIi0qCqGkObPn4+RI0ciJCQEALB06VLs2LEDK1euxFdffVWs/sqVK/Hw4UMcOXIEhoaGAABnZ2eN2tR4CKlfv3744YcfADzr/vH29sa8efPQr18/fPvtt5qejoiIiLToVQ8h5efnIykpCb6+vmKZVCqFr68vEhMTSzzm119/RYcOHfDZZ5/B1tYWzZs3x4wZM6BQKNRuV+ME5uTJk+jcuTMAYNOmTbC1tcWdO3fwww8/YNGiRZqejoiIiKqhrKwslS0vL6/EehkZGVAoFLC1tVUpt7W1RUpKSonH3Lx5E5s2bYJCocDvv/+OyZMnY968eZg2bZra8WmcwOTm5sLCwgIAsHv3bgwYMABSqRTt27fHnTt3ND0dERERaZEE/xtGKtf2/+dxdHSEpaWluMXExGgtRqVSiXr16uG7776Dl5cXAgICMHHiRCxdulTtc2g8B8bV1RXbtm1D//79sWvXLnzxxRcAgLS0NMjlck1PR0RERFoklUggrcAkmKJj7969q/K9bmRkVGJ9a2trGBgYIDU1VaU8NTUVdnZ2JR5jb28PQ0NDGBgYiGXNmjVDSkoK8vPzIZPJXh7nS2u8ICIiAuHh4XB2dka7du3QoUMHAM96Y1q1aqXp6YiIiKgaksvlKltpCYxMJoOXlxcSEhLEMqVSiYSEBDFHeFGnTp1w/fp1KJVKsezq1auwt7dXK3kBypHADBw4EMnJyThx4gR27dollr/99ttYsGCBpqcjIiIiLarQ8FE5VzCFhYVh+fLlWLNmDS5duoRPPvkEOTk54qqkoKAgTJgwQaz/ySef4OHDhxg9ejSuXr2KHTt2YMaMGfjss8/UbrNc94Gxs7NDdnY29uzZgzfffBMmJiZo27atztx+mIiISF9VxaMEAgICkJ6ejoiICKSkpMDT0xPx8fHixN7k5GRIpf/rM3F0dBSnobRs2RIODg4YPXo0xo8fr3abGicwDx48wODBg7F//35IJBJcu3YNLi4u+OCDD1C7dm3MmzdP01MSERGRlkglz7aKHF8eoaGhCA0NLXHfgQMHipV16NABf/31V/kaQzmGkL744gsYGhoiOTlZvJkd8Cz7io+PL3cgREREROrSuAdm9+7d2LVrFxo0aKBS3rhxYy6jJiIiqmqSCj5RWkdmg2icwOTk5Kj0vBR5+PBhqTOUiYiI6NXg06hL0blzZ/FRAsCzLE+pVGL27Nno2rWrVoMjIiIiKonGPTCzZ8/G22+/jRMnTiA/Px/jxo3DhQsX8PDhQxw+fLgyYiQiIiI1Sf7/v4ocrws07oFp3rw5rl69ijfeeAP9+vVDTk4OBgwYgFOnTqFRo0aVESMRERGpqWgVUkU2XVCu+8BYWlpi4sSJ2o6FiIiISC0a98DEx8fjzz//FF8vWbIEnp6eGDZsGP7991+tBkdERESaKbqRXUU2XaBxAvPll18iKysLAHDu3DmEhYWhZ8+euHXrFsLCwrQeIBEREamvKh4lUBU0HkK6desW3N3dAQCbN29Gnz59MGPGDJw8eRI9e/bUeoBEREREL9K4B0YmkyE3NxcAsHfvXnTv3h0AUKdOHbFnhoiIiKqGVCKp8KYLNO6BeeONNxAWFoZOnTrh2LFjiIuLA/DsMdgv3p2XiIiIXi3eyK4U//3vf1GrVi1s2rQJ3377LRwcHAAAO3fuRI8ePbQeIBEREamvpkzi1bgHpmHDhti+fXux8gULFmglICIiIqKX0bgH5uTJkzh37pz4+pdffoG/vz++/vpr5OfnazU4IiIi0kxNWYWkcQLz0Ucf4erVqwCAmzdvYsiQITA1NcXGjRsxbtw4rQdIRERE6qspk3g1TmCuXr0KT09PAMDGjRvx5ptvYv369Vi9ejU2b96s7fiIiIiIitF4DowgCFAqlQCeLaPu3bs3AMDR0REZGRnajY6IiIg0Ivn/rSLH6wKNE5g2bdpg2rRp8PX1xcGDB/Htt98CeHaDO1tbW60HSEREROqr6EoiXVmFpPEQUmxsLE6ePInQ0FBMnDgRrq6uAIBNmzahY8eOWg+QiIiI6EUa98C0bNlSZRVSkTlz5sDAwEArQREREVH5SCXPtoocrws0TmBKY2xsrK1TERERUTnVlCEkjRMYhUKBBQsW4Oeff0ZycnKxe788fPhQa8ERERERlUTjOTDR0dGYP38+AgICkJmZibCwMAwYMABSqRRRUVGVECIRERFpQt9vYgeUI4FZt24dli9fjrFjx6JWrVoYOnQovv/+e0REROCvv/6qjBiJiIhITTXlWUgaJzApKSlo0aIFAMDc3ByZmZkAgN69e2PHjh3ajY6IiIg0UjSJtyKbLtA4gWnQoAHu378PAGjUqBF2794NADh+/DiMjIy0Gx0RERFRCTROYPr374+EhAQAwH/+8x9MnjwZjRs3RlBQEN5//32tB0hERETqqylDSBqvQpo5c6b474CAADRs2BCJiYlo3Lgx+vTpo9XgiIiISDN8lICaOnTogA4dOmgjFiIiIiK1qJXA/Prrr2qfsG/fvuUOhoiIiCpGKpFAWoFhoIoc+yqplcD4+/urdTKJRAKFQlGReIiIiKgCKno/Fx3JX9RLYJRKZWXHQURERKQ2rT0LiYiIiKpeTXkWktrLqPft2wd3d3dkZWUV25eZmYnXX38dhw4d0mpwREREpJmKPEZAlx4noHYCExsbi5EjR0IulxfbZ2lpiY8++ggLFizQanBEREREJVE7gTlz5gx69OhR6v7u3bsjKSlJK0ERERFR+RStQqrIVh5LliyBs7MzjI2N4e3tjWPHjpVad/Xq1cVunmdsbKzZdapbMTU1FYaGhqXur1WrFtLT0zVqnIiIiLSrKoaQ4uLiEBYWhsjISJw8eRIeHh7w8/NDWlpaqcfI5XLcv39f3O7cuaNRm2onMA4ODjh//nyp+8+ePQt7e3uNGiciIiLtqopHCcyfPx8jR45ESEgI3N3dsXTpUpiammLlypVlxmlnZydutra2GrWpdgLTs2dPTJ48GU+fPi2278mTJ4iMjETv3r01apyIiIiqp6ysLJUtLy+vxHr5+flISkqCr6+vWCaVSuHr64vExMRSz5+dnQ0nJyc4OjqiX79+uHDhgkbxqb2MetKkSdiyZQvc3NwQGhqKJk2aAAAuX76MJUuWQKFQYOLEiRo1TprZvmYSzCyKT6Im0gfu436v6hCIKo0yL/eVtSVFOZ7U/MLxAODo6KhSHhkZiaioqGL1MzIyoFAoivWg2Nra4vLlyyW20aRJE6xcuRItW7ZEZmYm5s6di44dO+LChQto0KCBWnGqncDY2triyJEj+OSTTzBhwgQIggDgWReQn58flixZonH3DxEREWmXtu4Dc/fuXZWVx0ZGRhWOrciLz1Hs2LEjmjVrhmXLlmHq1KlqnUOjG9k5OTnh999/x7///ovr169DEAQ0btwYtWvX1ixyIiIiqtbkcnmJt055kbW1NQwMDJCamqpSnpqaCjs7O7XaMjQ0RKtWrXD9+nW14ytXL1Pt2rXRtm1btGvXjskLERFRNSKRANIKbJp23shkMnh5eSEhIUEsUyqVSEhIUOllKYtCocC5c+c0WgzERwkQERHpkaJEpCLHayosLAzBwcFo06YN2rVrh9jYWOTk5CAkJAQAEBQUBAcHB8TExAAApkyZgvbt28PV1RWPHj3CnDlzcOfOHXz44Ydqt8kEhoiIiCokICAA6enpiIiIQEpKCjw9PREfHy/OjU1OToZU+r9Bn3///RcjR45ESkoKateuDS8vLxw5cgTu7u5qt8kEhoiISI9U1cMcQ0NDERoaWuK+AwcOqLxesGBBhR8/xASGiIhIj1TFEFJVUCuB+fXXX9U+Yd++fcsdDBEREZE61Epg/P391TqZRCKBQqGoSDxERERUAeV9ntHzx+sCtRIYpVJZ2XEQERGRFlTkidJFx+sCzoEhIiLSI9p6lEB1V64EJicnBwcPHkRycjLy8/NV9n3++edaCYyIiIioNBonMKdOnULPnj2Rm5uLnJwc1KlTBxkZGTA1NUW9evWYwBAREVWhmjIHRuOeoi+++AJ9+vTBv//+CxMTE/z111+4c+cOvLy8MHfu3MqIkYiIiNQkhUScB1OuDbqRwWicwJw+fRpjx46FVCqFgYEB8vLy4OjoiNmzZ+Prr7+ujBiJiIiIVGicwBgaGoq3A65Xrx6Sk5MBAJaWlrh79652oyMiIiKNFA0hVWTTBRrPgWnVqhWOHz+Oxo0bo0uXLoiIiEBGRgbWrl2L5s2bV0aMREREpKaacidejXtgZsyYIT7uevr06ahduzY++eQTpKen47vvvtN6gEREREQv0rgHpk2bNuK/69Wrh/j4eK0GREREROUnkVTsZnR6O4RERERE1VdNWUatcQLz2muvlfmo7Zs3b1YoICIiIqKX0TiBGTNmjMrrgoICnDp1CvHx8fjyyy+1FRcRERGVQ02ZxKtxAjN69OgSy5csWYITJ05UOCAiIiIqP8n//1eR43WB1p7Z9M4772Dz5s3aOh0RERGVQ1EPTEU2XaC1BGbTpk2oU6eOtk5HREREVKpy3cju+Um8giAgJSUF6enp+Oabb7QaHBEREWmGc2BK0a9fP5UERiqVwsbGBj4+PmjatKlWgyMiIiLNSCSSMlcLq3O8LtA4gYmKiqqEMIiIiIjUp/EcGAMDA6SlpRUrf/DgAQwMDLQSFBEREZVPTZnEq3EPjCAIJZbn5eVBJpNVOCAiIiIqP96J9wWLFi0C8Gxs7Pvvv4e5ubm4T6FQ4NChQ5wDQ0RERK+E2gnMggULADzrgVm6dKnKcJFMJoOzszOWLl2q/QiJiIhIbVKJpEIPc6zIsa+S2gnMrVu3AABdu3bFli1bULt27UoLioiIiMqHy6hLsX///sqIg4iIiEhtGq9CevfddzFr1qxi5bNnz8agQYO0EhQRERGVk+R/E3nLs+nIo5A0T2AOHTqEnj17Fit/5513cOjQIa0ERUREROUjhaTCmy7QeAgpOzu7xOXShoaGyMrK0kpQREREVD41ZRm1xj0wLVq0QFxcXLHyDRs2wN3dXStBEREREZVF4x6YyZMnY8CAAbhx4wbeeustAEBCQgJ++uknbNy4UesBEhERkfq4CqkUffr0wbZt2zBjxgxs2rQJJiYmaNmyJfbu3YsuXbpURoxERESkJt4Hpgy9evVCr169ipWfP38ezZs3r3BQRERERGXReA7Mix4/fozvvvsO7dq1g4eHhzZiIiIionKqyBLqikwAXrJkCZydnWFsbAxvb28cO3ZMreM2bNgAiUQCf39/jdordwJz6NAhBAUFwd7eHnPnzsVbb72Fv/76q7ynIyIiIi2QQiIOI5VrK8cy6ri4OISFhSEyMhInT56Eh4cH/Pz8kJaWVuZxt2/fRnh4ODp37lyO69RASkoKZs6cicaNG2PQoEGwtLREXl4etm3bhpkzZ6Jt27YaB0BERES6bf78+Rg5ciRCQkLg7u6OpUuXwtTUFCtXriz1GIVCgcDAQERHR8PFxUXjNtVOYPr06YMmTZrg7NmziI2NxT///IPFixdr3CARERFVHm0NIWVlZalseXl5JbaXn5+PpKQk+Pr6imVSqRS+vr5ITEwsNc4pU6agXr16+OCDD8p1nWpP4t25cyc+//xzfPLJJ2jcuHG5GiMiIqLKJUXFJrgWHevo6KhSHhkZiaioqGL1MzIyoFAoYGtrq1Jua2uLy5cvl9jGn3/+iRUrVuD06dPljlPtBKaoMS8vLzRr1gzDhw/HkCFDyt0wERERVV93796FXC4XXxsZGWnlvI8fP8bw4cOxfPlyWFtbl/s8aicw7du3R/v27REbG4u4uDisXLkSYWFhUCqV2LNnDxwdHWFhYVHuQIiIiKjiJBIJJBW4l0vRsXK5XCWBKY21tTUMDAyQmpqqUp6amgo7O7ti9W/cuIHbt2+jT58+YplSqQQA1KpVC1euXEGjRo1e2q7GvUxmZmZ4//338eeff+LcuXMYO3YsZs6ciXr16qFv376ano6IiIi0SKKFTRMymQxeXl5ISEgQy5RKJRISEtChQ4di9Zs2bYpz587h9OnT4ta3b1907doVp0+fLjZ0VZoK3QemSZMmmD17Nv7++2/89NNPFTkVERERaUGFllCX8y6+YWFhWL58OdasWYNLly7hk08+QU5ODkJCQgAAQUFBmDBhAgDA2NgYzZs3V9msrKxgYWGB5s2bl/jA6JKU6068LzIwMIC/v7/GN6EhIiIi3RcQEID09HREREQgJSUFnp6eiI+PFyf2JicnQyqt8L1zVWglgSEiIqLqoyqeZhQaGorQ0NAS9x04cKDMY1evXq1xe0xgiIiI9EhFHgdQdLwu0G5/DhEREdErwB4YIiIiPaKtZdTVHRMYIiIiPaKtO/FWd7oSJxEREZGIPTBERER6hENIREREpHPKczfdF4/XBRxCIiIiIp3DHhgiIiI9wiEkIiIi0jk1ZRUSExgiIiI9UlN6YHQl0SIiIiISsQeGiIhIj9SUVUhMYIiIiPQIH+ZIREREVE2xB4aIiEiPSCGBtAIDQRU59lViAkNERKRHOIREREREVE2xB4aIiEiPSP7/v4ocrwuYwBAREekRDiERERERVVPsgSEiItIjkgquQuIQEhEREb1yNWUIiQkMERGRHqkpCQznwBAREZHOYQ8MERGRHuEyaiIiItI5UsmzrSLH6wIOIREREZHOYQ8MERGRHuEQEhEREekcrkIiIiIiqqbYA0NERKRHJKjYMJCOdMAwgSEiItInXIVEREREVE1VaQ+Mj48PPD09ERsbq9Xzrl69GmPGjMGjR4+0el7SH9vi/0Lcr3/i4aNsNHKyw3/e741mjRuUWPfQ0QtYv+Ug7qU8hEKhgINdXQzq0wndu7R6xVETqW9oBye83+U1WFsY4cr9x5j+ywWcu5tZYt3VH3mjXaO6xcoPXkrDJ6tOVHaopGU1ZRVSlfbAbNmyBVOnTq3KEF6p1atXw8rKqqrDqPH2Hz6Hb9fsRNCgrlg261M0crLD+Omr8W9mdon15eYmCBzgg/9OH4Xlc0PRo2trzP5mK46fvvaKIydSTw8Pe4zv0xTf7L2OgQsP4/L9LHz3QTvUMZOVWH/0Dyfx5pS94tZ33iEUKpTYdfb+K46ctKFoFVJFtvJYsmQJnJ2dYWxsDG9vbxw7dqzUulu2bEGbNm1gZWUFMzMzeHp6Yu3atRq1V6UJTJ06dWBhYVHivvz8/GJlCoUCSqWyssMiPbdx+2H0fLsN3unqBWfHevhiVF8YyQyxc19SifU9X3dBZ293ODWoBwe7uni3V0e4ONni3OU7rzhyIvWM6PwaNh69i60n/saNtGxEbzmPpwUKDGhbci9j5pMCZGTni1uHxtZ4WqDArrMprzhy0gaJFjZNxcXFISwsDJGRkTh58iQ8PDzg5+eHtLS0EuvXqVMHEydORGJiIs6ePYuQkBCEhIRg165dardZpQmMj48PxowZAwBwdnbG1KlTERQUBLlcjlGjRok9Fr/++ivc3d1hZGSE5ORk5OXlITw8HA4ODjAzM4O3tzcOHDhQZlu//PILWrduDWNjY7i4uCA6OhqFhYUAgGHDhiEgIEClfkFBAaytrfHDDz8AAOLj4/HGG2/AysoKdevWRe/evXHjxg2x/u3btyGRSLBlyxZ07doVpqam8PDwQGJiIgDgwIEDCAkJQWZmJiQSCSQSCaKiorTzRpLaCgoKcfXmP/Bq2Ugsk0ql8GrZCBev3n3p8YIg4OS5G/j7nwy0bOZciZESlY+hgQTuDnL8df2BWCYIQOK1DHg61VbrHO+2dcTvZ+7jSYGissIkPTN//nyMHDkSISEhcHd3x9KlS2FqaoqVK1eWWN/Hxwf9+/dHs2bN0KhRI4wePRotW7bEn3/+qXab1WoS79y5c+Hh4YFTp05h8uTJAIDc3FzMmjUL33//PS5cuIB69eohNDQUiYmJ2LBhA86ePYtBgwahR48euHat5C79P/74A0FBQRg9ejQuXryIZcuWYfXq1Zg+fToAIDAwEL/99huys/83hLBr1y7k5uaif//+AICcnByEhYXhxIkTSEhIgFQqRf/+/Yv1CE2cOBHh4eE4ffo03NzcMHToUBQWFqJjx46IjY2FXC7H/fv3cf/+fYSHh5cYb15eHrKyslQ20o7Mx7lQKpWobWmuUl7b0hwPH5U8hAQA2TlP0fO9Keg+NBITYtbiP+/3RhsP18oOl0hjVmYy1DKQIuNxnkr5g+w8WFsYvfT4Fo6WcLO3wOZjL0/oqXqSQgKppALb//fBvPg9lJeXV2J7+fn5SEpKgq+v7/9ikErh6+sr/hFfFkEQkJCQgCtXruDNN99U+zqr1TLqt956C2PHjhVf//HHHygoKMA333wDDw8PAEBycjJWrVqF5ORk1K9fHwAQHh6O+Ph4rFq1CjNmzCh23ujoaHz11VcIDg4GALi4uGDq1KkYN24cIiMj4efnBzMzM2zduhXDhw8HAKxfvx59+/YVh7jeffddlXOuXLkSNjY2uHjxIpo3by6Wh4eHo1evXmK7r7/+Oq5fv46mTZvC0tISEokEdnZ2Zb4PMTExiI6O1ui9o8plaiLD8jmf4cnTfJw8fwPfrNkJe9va8HzdpapDI9Kqd9s64sr9rFIn/FL1V95hoOePBwBHR0eV8sjIyBJHDjIyMqBQKGBra6tSbmtri8uXL5faTmZmJhwcHJCXlwcDAwN888036Natm9pxVqsEpk2bNsXKZDIZWrZsKb4+d+4cFAoF3NzcVOrl5eWhbt3is+gB4MyZMzh8+LDY4wI8m0/z9OlT5ObmwtTUFIMHD8a6deswfPhw5OTk4JdffsGGDRvE+teuXUNERASOHj2KjIwMseclOTlZJYF5PlZ7e3sAQFpaGpo2bar2+zBhwgSEhYWJr7Oysop9kKh8LC1MIZVKi03Y/TczG3WszEs56tlfEw72zz5frq/ZI/nvdKzfeogJDFU7j3LyUahQFuttqWtuVKxX5kUmhgZ4x8Mei3dzgjoBd+/ehVwuF18bGb28B08TFhYWOH36NLKzs5GQkICwsDC4uLjAx8dHreOrVQJjZmZWrMzExASS56ZEZ2dnw8DAAElJSTAwMFCpa25e8hdQdnY2oqOjMWDAgGL7jI2NATwbRurSpQvS0tKwZ88emJiYoEePHmK9Pn36wMnJCcuXL0f9+vWhVCrRvHnzYpONDQ0NxX8Xxa3pxGMjIyOtf1DoGUPDWnBzqY+T527ijXbuAJ79fE6euwn/Ht5qn0cpCCgoKKysMInKrUAh4OK9LLR3rYuEC6kAnq0qae9aF+uPlD3x3K+lHWS1pPjt1L1XESpVFi11wcjlcpUEpjTW1tYwMDBAamqqSnlqamqZIw5SqRSurs+G4j09PXHp0iXExMToZgKjjlatWkGhUCAtLQ2dO3dW65jWrVvjypUr4htVko4dO8LR0RFxcXHYuXMnBg0aJCYjDx48wJUrV7B8+XKxTU0mGhWRyWRQKDgprqoN6t0JM5dsRpNG9dHUtQE27ziCp3n56NHVCwAQs3gTrOvIMTKwOwBg/daDcHNxQH27OigoKMTRU1ex59BpjBnZtyovg6hUq/+4hZjBLXH+70ycu/sIQW+8BhNZLWw98TcAICagJdIy87Ag/orKce+2c0TChVRk5hZURdikJa/6PjAymQxeXl5ISEiAv78/gGd/GCYkJCA0NFTt8yiVylLn2ZRE5xIYNzc3BAYGIigoCPPmzUOrVq2Qnp6OhIQEtGzZUpx/8ryIiAj07t0bDRs2xMCBAyGVSnHmzBmcP38e06ZNE+sNGzYMS5cuxdWrV7F//36xvHbt2qhbty6+++472NvbIzk5GV999ZXGsTs7O4tdZR4eHjA1NYWpqWn53ggqt66dWuBRVg5WxSXg30fZaORsj1kTg8UhpLSMR5A+1+v35Gk+Fn7/G9IfZMJIZghHB2t8/Z9B6NqpRVVdAlGZ4s/cRx0zGf7T3Q3WFjJc/ucxPlpxDA+yn/UY21uZQCmoHuNsYwav1+rgg+Wl37uDqDRhYWEIDg5GmzZt0K5dO8TGxiInJwchISEAgKCgIDg4OCAmJgbAs7mebdq0QaNGjZCXl4fff/8da9euxbfffqt2mzqXwADAqlWrMG3aNIwdOxb37t2DtbU12rdvj969e5dY38/PD9u3b8eUKVMwa9YsGBoaomnTpvjwww9V6gUGBmL69OlwcnJCp06dxHKpVIoNGzbg888/R/PmzdGkSRMsWrRI7W6uIh07dsTHH3+MgIAAPHjwoNQJUVT5+r/THv3faV/ivgXRqp+LD4Z2wwdD1Z9YRlQdrD9yp9QhoxHLjhYru52eA/dxv1d2WPQqVOBmdEXHayogIADp6emIiIhASkoKPD09ER8fL07sTU5OhlT6v4XPOTk5+PTTT/H333/DxMQETZs2xY8//ljsliZlhikIgvDyalSVsrKyYGlpiT0n78DM4uXjkUS6KPCbI1UdAlGlUebl4s43g5CZmanWvJLyKPqu2Hc6GeYV+K7IfpyFtzwbVmqs2lCt7gNDREREpA6dHEIiIiKiUmjrRjDVHBMYIiIiPVJTnkbNBIaIiEiPVOSJ0kXH6wLOgSEiIiKdwx4YIiIiPVJDpsAwgSEiItIrNSSD4RASERER6Rz2wBAREekRrkIiIiIincNVSERERETVFHtgiIiI9EgNmcPLBIaIiEiv1JAMhkNIREREpHPYA0NERKRHuAqJiIiIdE5NWYXEBIaIiEiP1JApMJwDQ0RERLqHPTBERET6pIZ0wTCBISIi0iM1ZRIvh5CIiIhI57AHhoiISI9wFRIRERHpnBoyBYZDSERERKR72ANDRESkT2pIFwwTGCIiIj3CVUhERERE1RR7YIiIiPQIVyERERGRzqkhU2CYwBAREemVGpLBcA4MERER6Rz2wBAREemRmrIKiQkMERGRPqngJF4dyV84hERERES6hz0wREREeqSGzOFlDwwREZFekWhhK4clS5bA2dkZxsbG8Pb2xrFjx0qtu3z5cnTu3Bm1a9dG7dq14evrW2b9kjCBISIiogqJi4tDWFgYIiMjcfLkSXh4eMDPzw9paWkl1j9w4ACGDh2K/fv3IzExEY6OjujevTvu3bundptMYIiIiPSIRAv/aWr+/PkYOXIkQkJC4O7ujqVLl8LU1BQrV64ssf66devw6aefwtPTE02bNsX3338PpVKJhIQEtdtkAkNERKRHih4lUJFNE/n5+UhKSoKvr69YJpVK4evri8TERLXOkZubi4KCAtSpU0ftdjmJl4iIiIrJyspSeW1kZAQjI6Ni9TIyMqBQKGBra6tSbmtri8uXL6vV1vjx41G/fn2VJOhl2ANDRESkR7Q1h9fR0RGWlpbiFhMTUynxzpw5Exs2bMDWrVthbGys9nHsgSEiItInWlpHfffuXcjlcrG4pN4XALC2toaBgQFSU1NVylNTU2FnZ1dmU3PnzsXMmTOxd+9etGzZUqMw2QNDRESkR7Q1iVcul6tspSUwMpkMXl5eKhNwiybkdujQodQ4Z8+ejalTpyI+Ph5t2rTR+DrZA0NEREQVEhYWhuDgYLRp0wbt2rVDbGwscnJyEBISAgAICgqCg4ODOAw1a9YsREREYP369XB2dkZKSgoAwNzcHObm5mq1yQSGiIhIj0hQsWchlefQgIAApKenIyIiAikpKfD09ER8fLw4sTc5ORlS6f8Gfb799lvk5+dj4MCBKueJjIxEVFSUWm0ygSEiItIjVfUogdDQUISGhpa478CBAyqvb9++Xc5W/odzYIiIiEjnsAeGiIhIj5TnZnQvHq8LmMAQERHplZrxPGoOIREREZHOYQ8MERGRHuEQEhEREemcmjGAxCEkIiIi0kHsgSEiItIjHEIiIiIinfP884zKe7wuYAJDRESkT2rIJBjOgSEiIiKdwx4YIiIiPVJDOmCYwBAREemTmjKJl0NIREREpHPYA0NERKRHuAqJiIiIdE8NmQTDISQiIiLSOeyBISIi0iM1pAOGCQwREZE+4SokIiIiomqKPTBERER6pWKrkHRlEIkJDBERkR7hEBIRERFRNcUEhoiIiHQOh5CIiIj0SE0ZQmICQ0REpEdqyqMEOIREREREOoc9MERERHqEQ0hERESkc2rKowQ4hEREREQ6hz0wRERE+qSGdMEwgSEiItIjXIVEREREVE2xB4aIiEiPcBUSERER6ZwaMgWGQ0hERER6RaKFrRyWLFkCZ2dnGBsbw9vbG8eOHSu17oULF/Duu+/C2dkZEokEsbGxGrfHBIaIiIgqJC4uDmFhYYiMjMTJkyfh4eEBPz8/pKWllVg/NzcXLi4umDlzJuzs7MrVJhMYIiIiPSLRwn+amj9/PkaOHImQkBC4u7tj6dKlMDU1xcqVK0us37ZtW8yZMwdDhgyBkZFRua6TCQwREZEeKZrEW5FNE/n5+UhKSoKvr69YJpVK4evri8TERC1f3f9wEq8OEAQBAJCT/biKIyGqPMq83KoOgajSKPOffb6Lfp9XpqysLK0c/+J5jIyMSuwtycjIgEKhgK2trUq5ra0tLl++XKFYysIERgc8fvwscfF/s3kVR0JERBXx+PFjWFpaVsq5ZTIZ7Ozs0Pg1xwqfy9zcHI6OqueJjIxEVFRUhc+tLUxgdED9+vVx9+5dWFhYQKIrC/R1XFZWFhwdHXH37l3I5fKqDodIq/j5fvUEQcDjx49Rv379SmvD2NgYt27dQn5+foXPJQhCse+b0uaqWFtbw8DAAKmpqSrlqamp5Z6gqw4mMDpAKpWiQYMGVR1GjSSXy/kLnvQWP9+vVmX1vDzP2NgYxsbGld7O82QyGby8vJCQkAB/f38AgFKpREJCAkJDQyutXSYwREREVCFhYWEIDg5GmzZt0K5dO8TGxiInJwchISEAgKCgIDg4OCAmJgbAs4m/Fy9eFP997949nD59Gubm5nB1dVWrTSYwREREVCEBAQFIT09HREQEUlJS4Onpifj4eHFib3JyMqTS/y18/ueff9CqVSvx9dy5czF37lx06dIFBw4cUKtNifAqpkQT6Zi8vDzExMRgwoQJ5b5HAVF1xc836QMmMERERKRzeCM7IiIi0jlMYIiIiEjnMIEhIiIincMEhvSaj48PxowZU9VhEBVTWZ/N1atXw8rKSuvnJapumMAQVQEmVrRlyxZMnTq1qsN4ZZhYkbYxgSGdpY3bZRNVlTp16sDCwqLEfSV9thUKBZRKZWWHRaQzmMCQzvDx8UFoaCjGjBkDa2tr+Pn54fz583jnnXdgbm4OW1tbDB8+HBkZGaWeIy8vD+Hh4XBwcICZmRm8vb3FmyZlZWXBxMQEO3fuVDlm69atsLCwQG7us6fJjh8/Hm5ubjA1NYWLiwsmT56MgoICsX5UVBQ8PT2xdu1aODs7w9LSEkOGDBEfyjlixAgcPHgQCxcuhEQigUQiwe3bt7X7ZlG193wvnLOzM6ZOnYqgoCDI5XKMGjVK7LH49ddf4e7uDiMjIyQnJ5f5GS7NL7/8gtatW8PY2BguLi6Ijo5GYWEhAGDYsGEICAhQqV9QUABra2v88MMPAID4+Hi88cYbsLKyQt26ddG7d2/cuHFDrH/79m1IJBJs2bIFXbt2hampKTw8PJCYmAgAOHDgAEJCQpCZmSl+5qvTQwFJNzGBIZ2yZs0ayGQyHD58GDNnzsRbb72FVq1a4cSJE4iPj0dqaioGDx5c6vGhoaFITEzEhg0bcPbsWQwaNAg9evTAtWvXIJfL0bt3b6xfv17lmHXr1sHf3x+mpqYAAAsLC6xevRoXL17EwoULsXz5cixYsEDlmBs3bmDbtm3Yvn07tm/fjoMHD2LmzJkAgIULF6JDhw4YOXIk7t+/j/v37xd76ivVPHPnzoWHhwdOnTqFyZMnAwByc3Mxa9YsfP/997hw4QLq1atX5me4JH/88QeCgoIwevRoXLx4EcuWLcPq1asxffp0AEBgYCB+++03ZGdni8fs2rULubm56N+/PwAgJycHYWFhOHHiBBISEiCVStG/f/9iPUITJ05EeHg4Tp8+DTc3NwwdOhSFhYXo2LEjYmNjIZfLxc98eHh4ZbyNVJMIRDqiS5cuQqtWrcTXU6dOFbp3765S5+7duwIA4cqVK+Ixo0ePFgRBEO7cuSMYGBgI9+7dUznm7bffFiZMmCAIgiBs3bpVMDc3F3JycgRBEITMzEzB2NhY2LlzZ6lxzZkzR/Dy8hJfR0ZGCqampkJWVpZY9uWXXwre3t4q11IUF9VMz38GnJycBH9/f5X9q1atEgAIp0+fFsvU+QyvWrVKsLS0VNk3Y8YMlfpr164V7O3tBUEQhIKCAsHa2lr44YcfxP1Dhw4VAgICSo09PT1dACCcO3dOEARBuHXrlgBA+P7778U6Fy5cEAAIly5dKjEuooris5BIp3h5eYn/PnPmDPbv3w9zc/Ni9W7cuAE3NzeVsnPnzkGhUBQrz8vLQ926dQEAPXv2hKGhIX799VcMGTIEmzdvhlwuh6+vr1g/Li4OixYtwo0bN5CdnY3CwsJiT/R1dnZWmd9gb2+PtLS08l846b02bdoUK5PJZGjZsqX4Wp3P8IvOnDmDw4cPiz0uwLP5NE+fPkVubi5MTU0xePBgrFu3DsOHD0dOTg5++eUXbNiwQax/7do1RERE4OjRo8jIyBB7XpKTk9G8eXOx3vOx2tvbAwDS0tLQtGlTTd4KIrUwgSGdYmZmJv47Ozsbffr0waxZs4rVK/rl+bzs7GwYGBggKSkJBgYGKvuKkiCZTIaBAwdi/fr1GDJkCNavX4+AgADUqvXsf5XExEQEBgYiOjoafn5+sLS0xIYNGzBv3jyV8xkaGqq8lkgknIBJZXr+s13ExMQEEolEfK3OZ/hF2dnZiI6OxoABA4rtMzY2BvBsGKlLly5IS0vDnj17YGJigh49eoj1+vTpAycnJyxfvhz169eHUqlE8+bNi002fv5zXxQ3P/dUWZjAkM5q3bo1Nm/eDGdnZzHBKEurVq2gUCiQlpaGzp07l1ovMDAQ3bp1w4ULF7Bv3z5MmzZN3HfkyBE4OTlh4sSJYtmdO3c0jl0mk0GhUGh8HNVs6n6Gn9e6dWtcuXIFrq6updbp2LEjHB0dERcXh507d2LQoEFiMvLgwQNcuXIFy5cvF9v8888/NY6dn3nSNk7iJZ312Wef4eHDhxg6dCiOHz+OGzduYNeuXQgJCSnxF6WbmxsCAwMRFBSELVu24NatWzh27BhiYmKwY8cOsd6bb74JOzs7BAYG4rXXXoO3t7e4r3HjxkhOTsaGDRtw48YNLFq0CFu3btU4dmdnZxw9ehS3b99W6ZInKou6n+HnRURE4IcffkB0dDQuXLiAS5cuYcOGDZg0aZJKvWHDhmHp0qXYs2cPAgMDxfLatWujbt26+O6773D9+nXs27cPYWFhGsfu7OyM7OxsJCQkICMjQ1zVR1ReTGBIZ9WvXx+HDx+GQqFA9+7d0aJFC4wZMwZWVlaQSkv+aK9atQpBQUEYO3YsmjRpAn9/fxw/fhwNGzYU60gkEgwdOhRnzpxR+UUOAH379sUXX3yB0NBQeHp64siRI+KKEU2Eh4fDwMAA7u7usLGxQXJyssbnoJpJnc/w8/z8/LB9+3bs3r0bbdu2Rfv27bFgwQI4OTmp1AsMDMTFixfh4OCATp06ieVSqRQbNmxAUlISmjdvji+++AJz5szROO6OHTvi448/RkBAAGxsbDB79myNz0H0PIkgCEJVB0FERESkCfbAEBERkc5hAkNEREQ6hwkMERER6RwmMERERKRzmMAQERGRzmECQ0RERDqHCQwRERHpHCYwRIQRI0bA399ffO3j44MxY8a88jgOHDgAiUSCR48eVYvzEFH1xQSGqJoaMWIEJBIJJBIJZDIZXF1dMWXKFBQWFlZ621u2bMHUqVPVqlsVycKpU6cwaNAg2NrawtjYGI0bN8bIkSNx9erVVxYDEVUtJjBE1ViPHj1w//59XLt2DWPHjkVUVFSpt3F/8cnAFVGnTh1YWFho7XzatH37drRv3x55eXlYt24dLl26hB9//BGWlpbleqwDEekmJjBE1ZiRkRHs7Ozg5OSETz75BL6+vvj1118B/G/YZ/r06ahfvz6aNGkCALh79y4GDx4MKysr1KlTB/369cPt27fFcyoUCoSFhcHKygp169bFuHHj8OITRV4cQsrLy8P48ePh6OgIIyMjuLq6YsWKFbh9+za6du0K4NlD/yQSCUaMGAEAUCqViImJwWuvvQYTExN4eHhg06ZNKu38/vvvcHNzg4mJCbp27aoSZ0lyc3MREhKCnj174tdff4Wvr6/4wM25c+di2bJlJR734MEDDB06FA4ODjA1NUWLFi3w008/qdTZtGkTWrRoARMTE9StWxe+vr7IyckB8KyXqV27djAzM4OVlRU6deqk8hTyX375Ba1bt4axsTFcXFwQHR0t9pQJgoCoqCg0bNgQRkZGqF+/Pj7//PMyr5OIXq5WVQdAROozMTHBgwcPxNcJCQmQy+XYs2cPAKCgoAB+fn7o0KED/vjjD9SqVQvTpk1Djx49cPbsWchkMsybNw+rV6/GypUr0axZM8ybNw9bt27FW2+9VWq7QUFBSExMxKJFi+Dh4YFbt24hIyMDjo6O2Lx5M959911cuXIFcrkcJiYmAICYmBj8+OOPWLp0KRo3boxDhw7hvffeg42NDbp06YK7d+9iwIAB+OyzzzBq1CicOHECY8eOLfP6d+3ahYyMDIwbN67E/VZWViWWP336FF5eXhg/fjzkcjl27NiB4cOHo1GjRmjXrh3u37+PoUOHYvbs2ejfvz8eP36MP/74A4IgoLCwEP7+/hg5ciR++ukn5Ofn49ixY5BIJACAP/74A0FBQVi0aBE6d+6MGzduYNSoUQCAyMhIbN68GQsWLMCGDRvw+uuvIyUlBWfOnCnzOolIDQIRVUvBwcFCv379BEEQBKVSKezZs0cwMjISwsPDxf22trZCXl6eeMzatWuFJk2aCEqlUizLy8sTTExMhF27dgmCIAj29vbC7Nmzxf0FBQVCgwYNxLYEQRC6dOkijB49WhAEQbhy5YoAQNizZ0+Jce7fv18AIPz7779i2dOnTwVTU1PhyJEjKnU/+OADYejQoYIgCMKECRMEd3d3lf3jx48vdq7nzZo1SwAgPHz4sMT9ZcX0ol69egljx44VBEEQkpKSBADC7du3i9V78OCBAEA4cOBAied5++23hRkzZqiUrV27VrC3txcEQRDmzZsnuLm5Cfn5+WXGTESaYQ8MUTW2fft2mJubo6CgAEqlEsOGDUNUVJS4v0WLFpDJZOLrM2fO4Pr168Xmrzx9+hQ3btxAZmYm7t+/D29vb3FfrVq10KZNm2LDSEVOnz4NAwMDdOnSRe24r1+/jtzcXHTr1k2lPD8/H61atQIAXLp0SSUOAOjQoUOZ5y0txpdRKBSYMWMGfv75Z9y7dw/5+fnIy8uDqakpAMDDwwNvv/02WrRoAT8/P3Tv3h0DBw5E7dq1UadOHYwYMQJ+fn7o1q0bfH19MXjwYNjb2wN49p4fPnwY06dPV2nv6dOnyM3NxaBBgxAbGwsXFxf06NEDPXv2RJ8+fVCrFn/9ElUE/w8iqsa6du2Kb7/9FjKZDPXr1y/2pWdmZqbyOjs7G15eXli3bl2xc9nY2JQrhqIhIU1kZ2cDAHbs2AEHBweVfUZGRuWKAwDc3NwAAJcvX35psvO8OXPmYOHChYiNjUWLFi1gZmaGMWPGiBOfDQwMsGfPHhw5cgS7d+/G4sWLMXHiRBw9ehSvvfYaVq1ahc8//xzx8fGIi4vDpEmTsGfPHrRv3x7Z2dmIjo7GgAEDirVrbGwMR0dHXLlyBXv37sWePXvw6aefYs6cOTh48CAMDQ3L/V4Q1XScxEtUjZmZmcHV1RUNGzZU6y/21q1b49q1a6hXrx5cXV1VNktLS1haWsLe3h5Hjx4VjyksLERSUlKp52zRogWUSiUOHjxY4v6iHiCFQiGWubu7w8jICMnJycXicHR0BAA0a9YMx44dUznXX3/9Veb1de/eHdbW1pg9e3aJ+0tbyn348GH069cP7733Hjw8PODi4lJsybVEIkGnTp0QHR2NU6dOQSaTYevWreL+Vq1aYcKECThy5AiaN2+O9evXA3j2nl+5cqXYdbq6ukIqffYr1sTEBH369MGiRYtw4MABJCYm4ty5c2VeKxGVjQkMkR4JDAyEtbU1+vXrhz/++AO3bt3CgQMH8Pnnn+Pvv/8GAIwePRozZ87Etm3bcPnyZXz66adl3sPF2dkZwcHBeP/997Ft2zbxnD///DMAwMnJCRKJBNu3b0d6ejqys7NhYWGB8PBwfPHFF1izZg1u3LiBkydPYvHixVizZg0A4OOPP8a1a9fw5Zdf4sqVK1i/fj1Wr15d5vWZmZnh+++/x44dO9C3b1/s3bsXt2/fxokTJzBu3Dh8/PHHJR7XuHFjsYfl0qVL+Oijj5CamiruP3r0KGbMmIETJ04gOTkZW7ZsQXp6Opo1a4Zbt25hwoQJSExMxJ07d7B7925cu3YNzZo1AwBERETghx9+QHR0NC5cuIBLly5hw4YNmDRpEgBg9erVWLFiBc6fP4+bN2/ixx9/hImJCZycnNT6mRJRKap6Eg4Rlez5Sbya7L9//74QFBQkWFtbC0ZGRoKLi4swcuRIITMzUxCEZ5N2R48eLcjlcsHKykoICwsTgoKCSp3EKwiC8OTJE+GLL74Q7O3tBZlMJri6ugorV64U90+ZMkWws7MTJBKJEBwcLAjCs4nHsbGxQpMmTQRDQ0PBxsZG8PPzEw4ePCge99tvvwmurq6CkZGR0LlzZ2HlypUvnXwrCIJw/PhxYcCAAYKNjY1gZGQkuLq6CqNGjRKuXbsmCELxSbwPHjwQ+vXrJ5ibmwv16tUTJk2apHLNFy9eFPz8/MTzubm5CYsXLxYEQRBSUlIEf39/8dqdnJyEiIgIQaFQiPHEx8cLHTt2FExMTAS5XC60a9dO+O677wRBEIStW7cK3t7eglwuF8zMzIT27dsLe/fuLfP6iOjlJIJQzllxRERERFWEQ0hERESkc5jAEBERkc5hAkNEREQ6hwkMERER6RwmMERERKRzmMAQERGRzmECQ0RERDqHCQwRERHpHCYwREREpHOYwBAREZHOYQJDREREOocJDBEREemc/wMVrOjVnoGmEgAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -718,32 +487,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20)"
+    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, timeout=20)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-11 21:46:46.559520 |█████████████████████████| 100.0% (100/100) [01:12<00:00,  1.37it/s]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3aa50b8a5cbe4c4cb109a44b24bd2fb2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -755,7 +523,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -764,12 +532,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    relevant       0.42      1.00      0.59        40\n",
-      "  irrelevant       1.00      0.08      0.15        60\n",
+      "    relevant       0.47      0.98      0.63        44\n",
+      "  irrelevant       0.88      0.12      0.22        56\n",
       "\n",
-      "    accuracy                           0.45       100\n",
-      "   macro avg       0.71      0.54      0.37       100\n",
-      "weighted avg       0.77      0.45      0.33       100\n",
+      "    accuracy                           0.50       100\n",
+      "   macro avg       0.67      0.55      0.43       100\n",
+      "weighted avg       0.70      0.50      0.40       100\n",
       "\n"
      ]
     },
@@ -779,13 +547,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": null,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAHHCAYAAAChjmJTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABgKElEQVR4nO3deVyNaf8H8M85aV+ltJCSCo0kITGmjEYGjRhbGqUxmHl4LAljULKPNYwZg7EzjN1YskQYGkv2ZQglM6PVkopS3b8/+nUeRyfOqZM6p8/7eZ3X41z3dV339z6dyde13LdIEAQBRERERCpEXNUBEBERESmKCQwRERGpHCYwREREpHKYwBAREZHKYQJDREREKocJDBEREakcJjBERESkcpjAEBERkcphAkNEREQqhwkMURkSEhLQuXNnGBsbQyQSYffu3UrtPykpCSKRCGvXrlVqv6rM29sb3t7eSu3z4cOH0NHRwenTp5Xab3UmEokwdepUyfu1a9dCJBIhKSnpvcZhZ2eHQYMGSd5HR0fDwMAA6enp7zUOUk9MYKhau3fvHoYNGwZ7e3vo6OjAyMgI7du3x+LFi/HixYtKPXdwcDCuXbuGmTNnYsOGDWjVqlWlnu99GjRoEEQiEYyMjGR+jgkJCRCJRBCJRJg/f77C/f/777+YOnUqLl++rIRoK2batGnw8PBA+/btJWUl19+8eXPIepqKSCTCiBEj3meYNUKXLl3g4OCA2bNnV3UopAaYwFC1tX//fri4uOC3336Dn58fli5ditmzZ6NBgwYYN24cRo0aVWnnfvHiBeLi4jB48GCMGDECX3zxBerXr6/Uc9ja2uLFixcYOHCgUvuVV61atZCbm4vff/+91LFNmzZBR0en3H3/+++/iIyMVDiBOXz4MA4fPlzu874pPT0d69atw9dffy3z+LVr17Bz506lna+6GjhwIF68eAFbW9uqDgXDhg3Dzz//jOfPn1d1KKTimMBQtZSYmIj+/fvD1tYWN2/exOLFizFkyBAMHz4cv/76K27evIkPPvig0s5fMsRtYmJSaecQiUTQ0dGBhoZGpZ3jbbS1tdGpUyf8+uuvpY5t3rwZ3bp1e2+x5ObmAgC0tLSgpaWltH43btyIWrVqwc/Pr9QxXV1dODk5Ydq0aTJHYZSloKAA+fn5lda/PDQ0NKCjowORSFSlcQDA559/jry8PGzbtq2qQyEVxwSGqqW5c+ciOzsbv/zyC6ysrEodd3BwkBqBKSgowPTp09GoUSNoa2vDzs4O3333HfLy8qTa2dnZoXv37vjjjz/Qpk0b6OjowN7eHuvXr5fUmTp1quRfquPGjYNIJIKdnR2A4qmHkj+/burUqaX+cjhy5Ag+/PBDmJiYwMDAAI0bN8Z3330nOV7WGphjx46hQ4cO0NfXh4mJCXr06IFbt27JPN/du3cxaNAgmJiYwNjYGCEhIZJkQB4DBgzAwYMH8fTpU0nZ+fPnkZCQgAEDBpSq//jxY4SFhcHFxQUGBgYwMjLCp59+iitXrkjqxMbGonXr1gCAkJAQyVRUyXV6e3ujWbNmiI+Px0cffQQ9PT3J5/LmGpjg4GDo6OiUun5fX1/Url0b//7771uvb/fu3fDw8ICBgUGpY2KxGJMnT8bVq1exa9eut/YDAGlpaRg8eDAsLCygo6MDV1dXrFu3TqpOyc90/vz5iIqKknwfb968KfmZ3blzB1988QWMjY1hbm6OKVOmQBAEPHz4ED169ICRkREsLS2xYMECqb7z8/MRHh4Od3d3GBsbQ19fHx06dMDx48ffGfuba2BKYpH1en3NSlFREaKiovDBBx9AR0cHFhYWGDZsGJ48eSLVvyAImDFjBurXrw89PT107NgRN27ckBlL3bp10bx5c+zZs+edcRO9DRMYqpZ+//132Nvbo127dnLV/+qrrxAeHo6WLVti0aJF8PLywuzZs9G/f/9Sde/evYvevXvjk08+wYIFC1C7dm0MGjRI8gu3V69eWLRoEQAgICAAGzZsQFRUlELx37hxA927d0deXh6mTZuGBQsW4LPPPnvnQtKjR4/C19cXaWlpmDp1KkJDQ3HmzBm0b99e5gLMvn374vnz55g9ezb69u2LtWvXIjIyUu44e/XqBZFIJDWNsnnzZjRp0gQtW7YsVf/+/fvYvXs3unfvjoULF2LcuHG4du0avLy8JMlE06ZNMW3aNADA0KFDsWHDBmzYsAEfffSRpJ/MzEx8+umnaNGiBaKiotCxY0eZ8S1evBjm5uYIDg5GYWEhAODnn3/G4cOHsXTpUlhbW5d5ba9evcL58+dlXkeJAQMGwNHR8Z2jMC9evIC3tzc2bNiAwMBAzJs3D8bGxhg0aBAWL15cqv6aNWuwdOlSDB06FAsWLICpqankWL9+/VBUVIQ5c+bAw8MDM2bMQFRUFD755BPUq1cP33//PRwcHBAWFoaTJ09K2mVlZWHVqlXw9vbG999/j6lTpyI9PR2+vr4KT9X16tVL8nMpeY0ePRpAcYJRYtiwYRg3bpxk3VlISAg2bdoEX19fvHr1SlIvPDwcU6ZMgaurK+bNmwd7e3t07twZOTk5Ms/v7u6OM2fOKBQzUSkCUTXz7NkzAYDQo0cPuepfvnxZACB89dVXUuVhYWECAOHYsWOSMltbWwGAcPLkSUlZWlqaoK2tLYwdO1ZSlpiYKAAQ5s2bJ9VncHCwYGtrWyqGiIgI4fX/nBYtWiQAENLT08uMu+Qca9askZS1aNFCqFu3rpCZmSkpu3LliiAWi4WgoKBS5/vyyy+l+uzZs6dQp06dMs/5+nXo6+sLgiAIvXv3Fjp16iQIgiAUFhYKlpaWQmRkpMzP4OXLl0JhYWGp69DW1hamTZsmKTt//nypayvh5eUlABCWL18u85iXl5dU2aFDhwQAwowZM4T79+8LBgYGgr+//zuv8e7duwIAYenSpW+9/nXr1gkAhJ07d0qOAxCGDx8ueR8VFSUAEDZu3Cgpy8/PFzw9PQUDAwMhKytL8lkAEIyMjIS0tDSpc5b8zIYOHSopKygoEOrXry+IRCJhzpw5kvInT54Iurq6QnBwsFTdvLw8qT6fPHkiWFhYlPoeABAiIiIk79esWSMAEBITE2V+Vunp6UKDBg0EFxcXITs7WxAEQTh16pQAQNi0aZNU3ejoaKnytLQ0QUtLS+jWrZtQVFQkqffdd98JAKSuocSsWbMEAEJqaqrMeIjkwREYqnaysrIAAIaGhnLVP3DgAAAgNDRUqnzs2LEAihcDv87Z2RkdOnSQvDc3N0fjxo1x//79csf8ppK1M3v27EFRUZFcbR49eoTLly9j0KBBUv9ib968OT755BPJdb7uzcWpHTp0QGZmpuQzlMeAAQMQGxuLlJQUHDt2DCkpKTKnj4DidTNicfGvjcLCQmRmZkqmxy5evCj3ObW1tRESEiJX3c6dO2PYsGGYNm0aevXqBR0dHfz888/vbJeZmQkAqF279lvrBQYGvnMU5sCBA7C0tERAQICkTFNTEyNHjkR2djZOnDghVf/zzz+Hubm5zL6++uoryZ81NDTQqlUrCIKAwYMHS8pNTExKfSc1NDQk64OKiorw+PFjFBQUoFWrVgp99m8qLCxEQEAAnj9/jl27dkFfXx8AsG3bNhgbG+OTTz5BRkaG5OXu7g4DAwPJ1NXRo0eRn5+P//73v1LTqCUjOrKU/EwyMjLKHTcRExiqdoyMjABA7l0KDx48gFgshoODg1S5paUlTExM8ODBA6nyBg0alOqjdu3apeb1K6Jfv35o3749vvrqK1hYWKB///747bff3prMlMTZuHHjUseaNm2KjIyMUkPyb15LyV8MilxL165dYWhoiK1bt2LTpk1o3bp1qc+yRFFRERYtWgRHR0doa2vDzMwM5ubmuHr1Kp49eyb3OevVq6fQYt358+fD1NQUly9fxpIlS6SmOd6lrKSkhIaGBiZPnozLly+Xea+fBw8ewNHRUZK8lWjatKnk+OsaNmxY5vne/JkZGxtDR0cHZmZmpcrf/DmuW7cOzZs3h46ODurUqQNzc3Ps379foc/+TZMnT8axY8ewefNmNGrUSFKekJCAZ8+eoW7dujA3N5d6ZWdnIy0tDcD/rt3R0VGqX3Nz8zKTx5KfSXVYVEyqq1ZVB0D0JiMjI1hbW+P69esKtZP3l2FZu37e9Rfd285Rsj6jhK6uLk6ePInjx49j//79iI6OxtatW/Hxxx/j8OHDStt5VJFrKaGtrY1evXph3bp1uH//vtQN0N40a9YsTJkyBV9++SWmT58OU1NTiMVijB49Wu6RJqD481HEpUuXJH9hXrt2TWokpCx16tQBIF8yFxgYiOnTp2PatGnw9/dXKDZZ3nZ9sn5m8vwcN27ciEGDBsHf3x/jxo1D3bp1oaGhgdmzZ+PevXvlinP37t34/vvvMX36dHTp0kXqWFFREerWrYtNmzbJbFvWCJM8Sn4mbyZtRIpgAkPVUvfu3bFixQrExcXB09PzrXVtbW1RVFSEhIQEyb+IASA1NRVPnz5V6r0vateuLbVjp8Sb/wIHine5dOrUCZ06dcLChQsxa9YsTJo0CcePH4ePj4/M6wCA27dvlzr2119/wczMTDK8r2wDBgzA6tWrIRaLZS58LrF9+3Z07NgRv/zyi1T506dPpf4yUua/rHNychASEgJnZ2e0a9cOc+fORc+ePSU7ncrSoEED6OrqIjEx8Z3nKBmFGTRokMzdMba2trh69SqKioqkRmH++usvyfHKtn37dtjb22Pnzp1Sn29ERES5+rtz5w6Cg4Ph7+8vtTuuRKNGjXD06FG0b9/+rQlZybUnJCTA3t5eUp6enl5m8piYmCgZvSMqL04hUbU0fvx46Ovr46uvvkJqamqp4/fu3ZPs/ujatSsAlNoptHDhQgBQ6v1MGjVqhGfPnuHq1auSskePHpXahvv48eNSbVu0aAEApbZ2l7CyskKLFi2wbt06qSTp+vXrOHz4sOQ6K0PHjh0xffp0/PDDD7C0tCyznoaGRqnRnW3btuGff/6RKitJtGQle4qaMGECkpOTsW7dOixcuBB2dnYIDg4u83MsoampiVatWuHChQtyneeLL76Ag4ODzF1cXbt2RUpKCrZu3SopKygowNKlS2FgYAAvLy/FLqocSkZpXv/8z549i7i4OIX7ys7ORs+ePVGvXj2sW7dOZsLZt29fFBYWYvr06aWOFRQUSH62Pj4+0NTUxNKlS6Vie9vOvfj4+Hf+w4ToXTgCQ9VSo0aNsHnzZvTr1w9NmzZFUFAQmjVrhvz8fJw5cwbbtm2T3K/C1dUVwcHBWLFiBZ4+fQovLy+cO3cO69atg7+/f5lbdMujf//+mDBhAnr27ImRI0ciNzcXP/30E5ycnKQWUk6bNg0nT55Et27dYGtri7S0NPz444+oX78+PvzwwzL7nzdvHj799FN4enpi8ODBePHiBZYuXQpjY+O3Tu1UVMk9Ud6le/fumDZtGkJCQtCuXTtcu3YNmzZtkvqXN1D88zMxMcHy5cthaGgIfX19eHh4vHVtiCzHjh3Djz/+iIiICMl26DVr1sDb2xtTpkzB3Llz39q+R48emDRpErKysiRrq8qioaGBSZMmyVxcPHToUPz8888YNGgQ4uPjYWdnh+3bt+P06dOIioqSe8F5RXTv3h07d+5Ez5490a1bNyQmJmL58uVwdnZGdna2Qn1FRkbi5s2bmDx5cqkRp0aNGsHT0xNeXl4YNmwYZs+ejcuXL6Nz587Q1NREQkICtm3bhsWLF6N3794wNzdHWFgYZs+eje7du6Nr1664dOkSDh48KHOKKC0tDVevXsXw4cMr9HkQcRs1VWt37twRhgwZItjZ2QlaWlqCoaGh0L59e2Hp0qXCy5cvJfVevXolREZGCg0bNhQ0NTUFGxsbYeLEiVJ1BKF4G3W3bt1KnefN7btlbaMWBEE4fPiw0KxZM0FLS0to3LixsHHjxlLbqGNiYoQePXoI1tbWgpaWlmBtbS0EBAQId+7cKXWON7caHz16VGjfvr2gq6srGBkZCX5+fsLNmzel6pSc781t2u/aLlvi9W3EZSlrG/XYsWMFKysrQVdXV2jfvr0QFxcnc/vznj17BGdnZ6FWrVpS1+nl5SV88MEHMs/5ej9ZWVmCra2t0LJlS+HVq1dS9caMGSOIxWIhLi7urdeQmpoq1KpVS9iwYYNc1//q1SuhUaNGpbZRl/QVEhIimJmZCVpaWoKLi0upn93bvjdl/czKiuXNz6moqEiYNWuWYGtrK2hrawtubm7Cvn37ZG7txzu2UQcHBwsAZL7e3Pa8YsUKwd3dXdDV1RUMDQ0FFxcXYfz48cK///4rqVNYWChERkZKvhfe3t7C9evXBVtb21L9/fTTT4Kenp5k6zlReYkEoRLvoU1EVMUGDx6MO3fu4NSpU1UdCgFwc3ODt7e35GaRROXFBIaI1FpycjKcnJwQExMj9URqev+io6PRu3dv3L9/X6Gt8ESyMIEhIiIilcNdSERERKRymMAQERFRuZ08eRJ+fn6wtraGSCQq847Wr4uNjUXLli2hra0NBwcHydPqFcEEhoiIiMotJycHrq6uWLZsmVz1ExMT0a1bN3Ts2BGXL1/G6NGj8dVXX+HQoUMKnZdrYIiIiEgpRCIRdu3a9dZHckyYMAH79++XelxM//798fTpU0RHR8t9Lt7ITgUUFRXh33//haGhIR9+RkSkggRBwPPnz2FtbV3qoaDK9PLlS+Tn51e4H0EQSv19o62tDW1t7Qr3HRcXV+pxKr6+vm99grksTGBUwL///gsbG5uqDoOIiCro4cOHqF+/fqX0/fLlS+ga1gEKcivcl4GBQak7PEdERCjljuApKSmwsLCQKrOwsEBWVhZevHgh98NemcCogJLblGs5B0OkoVXF0RBVjuTY+VUdAlGleZ6VBYeGNpX62In8/HygIBfazsFARf6uKMxH9s11ePjwodQjOJQx+qJMTGBUQMkwnkhDiwkMqa13PauISB28l2UAtXQq9HeFICqe4jIyMqqU/y4tLS1LPaQ3NTUVRkZGco++AExgiIiI1IsIQEUSpUrOsTw9PXHgwAGpsiNHjij8hHJuoyYiIlInInHFXwrIzs7G5cuXcfnyZQDF26QvX76M5ORkAMDEiRMRFBQkqf/111/j/v37GD9+PP766y/8+OOP+O233zBmzBiFzssEhoiIiMrtwoULcHNzg5ubGwAgNDQUbm5uCA8PBwA8evRIkswAQMOGDbF//34cOXIErq6uWLBgAVatWgVfX1+FzsspJCIiInUiElVwCkmxtt7e3njbLeVk3WXX29sbly5dUjQyKUxgiIiI1Ek5poFKtVcBqhElERER0Ws4AkNERKRO3vMUUlVhAkNERKRWKjiFpCKTM6oRJREREdFrOAJDRESkTjiFRERERCqHu5CIiIiIqieOwBAREakTTiERERGRyqkhU0hMYIiIiNRJDRmBUY00i4iIiOg1HIEhIiJSJ5xCIiIiIpUjElUwgeEUEhEREVGl4AgMERGROhGLil8Vaa8CmMAQERGpkxqyBkY1oiQiIiJ6DUdgiIiI1EkNuQ8MExgiIiJ1wikkIiIiouqJIzBERETqhFNIREREpHJqyBQSExgiIiJ1UkNGYFQjzSIiIiJ6DUdgiIiI1AmnkIiIiEjlcAqJiIiIqHriCAwREZFaqeAUkoqMbTCBISIiUiecQiIiIiKqnjgCQ0REpE5EogruQlKNERgmMEREROqkhmyjVo0oiYiIiF7DERgiIiJ1UkMW8TKBISIiUic1ZAqJCQwREZE6qSEjMKqRZhERERG9hiMwRERE6oRTSERERKRyOIVEREREVD1xBIaIiEiNiEQiiGrACAwTGCIiIjVSUxIYTiERERGRyuEIDBERkToR/f+rIu1VABMYIiIiNcIpJCIiIqJqiiMwREREaqSmjMAwgSEiIlIjTGCIiIhI5dSUBIZrYIiIiEjlcASGiIhInXAbNREREakaTiERERERVVMcgSEiIlIjIhEqOAKjvFgqExMYIiIiNSJCBaeQVCSD4RQSERERqRyOwBAREamRmrKIlwkMERGROqkh26g5hUREREQqhyMwRERE6qSCU0gCp5CIiIjofavoGpiK7WB6f5jAEBERqZGaksBwDQwRERFV2LJly2BnZwcdHR14eHjg3Llzb60fFRWFxo0bQ1dXFzY2NhgzZgxevnwp9/mYwBAREakTkRJeCtq6dStCQ0MRERGBixcvwtXVFb6+vkhLS5NZf/Pmzfj2228RERGBW7du4ZdffsHWrVvx3XffyX1OJjBERERqpGQKqSIvRS1cuBBDhgxBSEgInJ2dsXz5cujp6WH16tUy6585cwbt27fHgAEDYGdnh86dOyMgIOCdozavYwJDREREpWRlZUm98vLyZNbLz89HfHw8fHx8JGVisRg+Pj6Ii4uT2aZdu3aIj4+XJCz379/HgQMH0LVrV7nj4yJeIiIiNaKsRbw2NjZS5REREZg6dWqp+hkZGSgsLISFhYVUuYWFBf766y+Z5xgwYAAyMjLw4YcfQhAEFBQU4Ouvv1ZoCokJDBERkRpRVgLz8OFDGBkZScq1tbUrHFuJ2NhYzJo1Cz/++CM8PDxw9+5djBo1CtOnT8eUKVPk6oMJDBEREZViZGQklcCUxczMDBoaGkhNTZUqT01NhaWlpcw2U6ZMwcCBA/HVV18BAFxcXJCTk4OhQ4di0qRJEIvfvcKFa2CIiIjUyPtexKulpQV3d3fExMRIyoqKihATEwNPT0+ZbXJzc0slKRoaGgAAQRDkOi9HYIiIiNRJFTzMMTQ0FMHBwWjVqhXatGmDqKgo5OTkICQkBAAQFBSEevXqYfbs2QAAPz8/LFy4EG5ubpIppClTpsDPz0+SyLwLExgiIiKqkH79+iE9PR3h4eFISUlBixYtEB0dLVnYm5ycLDXiMnnyZIhEIkyePBn//PMPzM3N4efnh5kzZ8p9TpEg71gNVZmsrCwYGxtD22UIRBpaVR0OUaV4cv6Hqg6BqNJkZWXBoo4xnj17Jte6kvKew9jYGJZfboRYS6/c/RTl5yJl9ReVGqsycASGiIhIjdSUZyExgSEiIlIjNSWB4S4kIiIiUjkcgSEiIlInVbALqSowgSEiIlIjnEIiIiIiqqbUMoHx9vbG6NGjqzoMqqbauTXCrwuH4eaBmXhy/gd09Wr+zjbtWzoidsMEpJxehPidEQjo7vEeIiUqv5W/nUDzz8Jh2X40fAbNQ/yNpLfW3330Itr0ng7L9qPRrv9MHD594/0ESkr3vu/EW1XUMoGprphYVQ96utq4fucfjJu7Va76DazrYGvU1zgVfwcfBc7B8l+PY8mkAfi4bdNKjpSofHYejsfkqF2Y8NWniN0wAc0c6+Hz/y5D+uPnMuufvXIfX01eiy96eOLExm/RzcsVX4StwM27/77nyEkZRKhgAqMii2BULoHJz8+v6hBIxR09cxMzl+/D/tirctX/steHSP43E1OiduFOUipWbjuJvccu45sBHSs5UqLy+XHzMQT5t0PgZ55oYm+FhRP7Q09HCxv3xsms//OWWHTybIqRA33QuKElJn3THa5NbLBy24n3HDmR/Kp9AuPt7Y0RI0Zg9OjRMDMzg6+vL65fv45PP/0UBgYGsLCwwMCBA5GRkVFmH3l5eQgLC0O9evWgr68PDw8PxMbGAii+c6Guri4OHjwo1WbXrl0wNDREbm4uAGDChAlwcnKCnp4e7O3tMWXKFLx69UpSf+rUqWjRogU2bNgAOzs7GBsbo3///nj+vPhfPIMGDcKJEyewePFiSZablJSk3A+LKkVrl4aIPXdbqizmz1to49KwiiIiKlv+qwJc/ushvNs0lpSJxWJ4tWmM89cSZbY5dy0R3q2bSJV93LYpzl9LqsxQqZJwCqkaWbduHbS0tHD69GnMmTMHH3/8Mdzc3HDhwgVER0cjNTUVffv2LbP9iBEjEBcXhy1btuDq1avo06cPunTpgoSEBBgZGaF79+7YvHmzVJtNmzbB398fenrFt2M2NDTE2rVrcfPmTSxevBgrV67EokWLpNrcu3cPu3fvxr59+7Bv3z6cOHECc+bMAQAsXrwYnp6eGDJkCB49eoRHjx7BxsZGyZ8UVYa6dYxKDb2nZ2bByEAXOtqaVRQVkWyZT7NRWFgEc1NDqXJzUyOkZWbJbJOWmQXzOm/WNyyzPlVzIiW8VIBKbKN2dHTE3LlzAQAzZsyAm5sbZs2aJTm+evVq2NjY4M6dO3BycpJqm5ycjDVr1iA5ORnW1tYAgLCwMERHR2PNmjWYNWsWAgMDMXDgQOTm5kJPTw9ZWVnYv38/du3aJeln8uTJkj/b2dkhLCwMW7Zswfjx4yXlRUVFWLt2LQwNi38RDBw4EDExMZg5cyaMjY2hpaUFPT09WFpavvV68/LykJeXJ3mflcVfIkRERK9TiQTG3d1d8ucrV67g+PHjMDAwKFXv3r17pRKYa9euobCwsFR5Xl4e6tSpAwDo2rUrNDU1sXfvXvTv3x87duyAkZERfHx8JPW3bt2KJUuW4N69e8jOzkZBQUGph1zZ2dlJkhcAsLKyQlpamsLXO3v2bERGRircjipHWmZW6X/N1jFCVvYLvMx7VUYroqpRx8QAGhri0qOGj7NQt47sB/PVrWOE9Mw36z8vsz5Vb7wPTDWir68v+XN2djb8/Pxw+fJlqVdCQgI++uijUm2zs7OhoaGB+Ph4qfq3bt3C4sWLAQBaWlro3bu3ZBpp8+bN6NevH2rVKs7v4uLiEBgYiK5du2Lfvn24dOkSJk2aVGpBsaam9HSCSCRCUVGRwtc7ceJEPHv2TPJ6+PChwn2Q8py/lgiv1o2lyjq2aYJzZawnIKpKWpq10KKJDU6c/9+6raKiIpw8fwety1i31caloVR9ADh+9i+0drGrzFCpktSUNTAqMQLzupYtW2LHjh2ws7OTJBhv4+bmhsLCQqSlpaFDhw5l1gsMDMQnn3yCGzdu4NixY5gxY4bk2JkzZ2Bra4tJkyZJyh48eKBw7FpaWigsLHxnPW1tbWhrayvcP8lHX1cLDW3MJe9treugmVM9PH2Wi79TnyB8+GewMjfGN1M3AABW7/wDX/X9CJH/7YGNe//ER62d4O/jhn5jllfVJRC91X8GfIz/RG6AW9MGaPmBHX769ThyXuQh0K8tAODriPWwMjdGxIgeAIBh/b3RfVgUftgYg84ffoCdh+Nx+VYyor4LqMrLoHISiYpfFWmvClQugRk+fDhWrlyJgIAAjB8/Hqamprh79y62bNmCVatWQUNDQ6q+k5MTAgMDERQUhAULFsDNzQ3p6emIiYlB8+bN0a1bNwDARx99BEtLSwQGBqJhw4bw8PjfjcocHR2RnJyMLVu2oHXr1qXWx8jLzs4OZ8+eRVJSEgwMDGBqagqxWCUGwdRKi6a22PfzKMn7WaGfAwA27/sTwyM3wsLMCPUtTSXHk//NRL/RyzErtBeG9ffGv2lPMXLmZhz789Z7j51IHr06uyPjaTZm/bwfaZnP4eJUD9uXDJdMCf2d8hji1/6W8nC1x8oZgzDzp32Y/uPvsLcxx8b5Q+HsYF1Vl0D0TiqXwFhbW+P06dOYMGECOnfujLy8PNja2qJLly5lJgNr1qzBjBkzMHbsWPzzzz8wMzND27Zt0b17d0kdkUiEgIAAzJ07F+Hh4VLtP/vsM4wZMwYjRoxAXl4eunXrhilTpmDq1KkKxR4WFobg4GA4OzvjxYsXSExMhJ2dnaIfAVXQ6YsJqN16RJnHh0dulNnG64vvKzMsIqUa2tcLQ/t6yTy27+fRpcr8fVrC36dlJUdF70PxCExF1sAoMZhKJBIEQajqIOjtsrKyYGxsDG2XIRBpaFV1OESV4sn5H6o6BKJKk5WVBYs6xnj27FmpDSDKPIexsTHsR26Hhrb+uxuUoTAvB/eX9K7UWJWB8xdERESkclRuComIiIjKVlO2UTOBISIiUiM1ZRcSp5CIiIhI5XAEhoiISI2IxSKIxeUfRhEq0PZ9YgJDRESkRjiFRERERFRNcQSGiIhIjXAXEhEREamcmjKFxASGiIhIjdSUERiugSEiIiKVwxEYIiIiNVJTRmCYwBAREamRmrIGhlNIREREpHI4AkNERKRGRKjgFBJUYwiGCQwREZEa4RQSERERUTXFERgiIiI1wl1IREREpHI4hURERERUTXEEhoiISI1wComIiIhUTk2ZQmICQ0REpEZqyggM18AQERGRyuEIDBERkTqp4BSSityIlwkMERGROuEUEhEREVE1xREYIiIiNcJdSERERKRyOIVEREREVE1xBIaIiEiNcAqJiIiIVA6nkIiIiIiqKY7AEBERqZGaMgLDBIaIiEiNcA0MERERqZyaMgLDNTBERESkchROYF68eIHc3FzJ+wcPHiAqKgqHDx9WamBERESkuJIppIq8VIHCCUyPHj2wfv16AMDTp0/h4eGBBQsWoEePHvjpp5+UHiARERHJr2QKqSIvVaBwAnPx4kV06NABALB9+3ZYWFjgwYMHWL9+PZYsWaL0AImIiIjepPAi3tzcXBgaGgIADh8+jF69ekEsFqNt27Z48OCB0gMkIiIi+YlQwV1ISoukcik8AuPg4IDdu3fj4cOHOHToEDp37gwASEtLg5GRkdIDJCIiIvmJRaIKv1SBwglMeHg4wsLCYGdnhzZt2sDT0xNA8WiMm5ub0gMkIiIiepPCU0i9e/fGhx9+iEePHsHV1VVS3qlTJ/Ts2VOpwREREZFiasqN7Mp1HxhLS0sYGhriyJEjePHiBQCgdevWaNKkiVKDIyIiIsVwF1IZMjMz0alTJzg5OaFr16549OgRAGDw4MEYO3as0gMkIiIi+YlFFX+Vx7Jly2BnZwcdHR14eHjg3Llzb63/9OlTDB8+HFZWVtDW1oaTkxMOHDgg/3UqGuCYMWOgqamJ5ORk6OnpScr79euH6OhoRbsjIiIiFbd161aEhoYiIiICFy9ehKurK3x9fZGWliazfn5+Pj755BMkJSVh+/btuH37NlauXIl69erJfU6F18AcPnwYhw4dQv369aXKHR0duY2aiIioqokq+DyjcjRduHAhhgwZgpCQEADA8uXLsX//fqxevRrffvttqfqrV6/G48ePcebMGWhqagIA7OzsFDqnwiMwOTk5UiMvJR4/fgxtbW1FuyMiIiIlUtajBLKysqReeXl5Ms+Xn5+P+Ph4+Pj4SMrEYjF8fHwQFxcns83evXvh6emJ4cOHw8LCAs2aNcOsWbNQWFgo93UqnMB06NBB8igBoDjLKyoqwty5c9GxY0dFuyMiIqJqyMbGBsbGxpLX7NmzZdbLyMhAYWEhLCwspMotLCyQkpIis839+/exfft2FBYW4sCBA5gyZQoWLFiAGTNmyB2fwlNIc+fORadOnXDhwgXk5+dj/PjxuHHjBh4/fozTp08r2h0REREpkej//1eR9gDw8OFDqRvUKnOWpaioCHXr1sWKFSugoaEBd3d3/PPPP5g3bx4iIiLk6kPhBKZZs2a4c+cOfvjhBxgaGiI7Oxu9evWSrCQmIiKiqlORnUQl7QHAyMhIrjvsm5mZQUNDA6mpqVLlqampsLS0lNnGysoKmpqa0NDQkJQ1bdoUKSkpyM/Ph5aW1jvPq3ACAwDGxsaYNGlSeZoSERGRGtHS0oK7uztiYmLg7+8PoHiEJSYmBiNGjJDZpn379ti8eTOKioogFhevZrlz5w6srKzkSl6AcqyBiY6Oxh9//CF5v2zZMrRo0QIDBgzAkydPFO2OiIiIlKgqbmQXGhqKlStXYt26dbh16xa++eYb5OTkSHYlBQUFYeLEiZL633zzDR4/foxRo0bhzp072L9/P2bNmoXhw4fLfU6FE5hx48YhKysLAHDt2jWEhoaia9euSExMRGhoqKLdERERkRIpaxeSIvr164f58+cjPDwcLVq0wOXLlxEdHS1Z2JucnCy58S1QvED40KFDOH/+PJo3b46RI0di1KhRMrdcl0XhKaTExEQ4OzsDAHbs2AE/Pz/MmjULFy9eRNeuXRXtjoiIiNTAiBEjypwyio2NLVXm6emJP//8s9znU3gERktLC7m5uQCAo0ePonPnzgAAU1NTycgMERERVQ2xSFThlypQeATmww8/RGhoKNq3b49z585h69atAIoX37x5d14iIiJ6v/g06jL88MMPqFWrFrZv346ffvpJ8tyCgwcPokuXLkoPkIiIiORXU55GrfAITIMGDbBv375S5YsWLVJKQERERETvovAIzMWLF3Ht2jXJ+z179sDf3x/fffcd8vPzlRocERERKaYqdiFVBYUTmGHDhuHOnTsAip9l0L9/f+jp6WHbtm0YP3680gMkIiIi+dWURbwKJzB37txBixYtAADbtm3DRx99hM2bN2Pt2rXYsWOHsuMjIiIiKkXhNTCCIKCoqAhA8Tbq7t27Ayi+KU1GRoZyoyMiIiKFiP7/VZH2qkDhBKZVq1aYMWMGfHx8cOLECfz0008Aim9w9+ajtImIiOj9quhOIlXZhaTwFFJUVBQuXryIESNGYNKkSXBwcAAAbN++He3atVN6gERERERvUngEpnnz5lK7kErMmzdP6rHYRERE9P6JRcWvirRXBQonMGXR0dFRVldERERUTjVlCknhBKawsBCLFi3Cb7/9huTk5FL3fnn8+LHSgiMiIiKSReE1MJGRkVi4cCH69euHZ8+eITQ0FL169YJYLMbUqVMrIUQiIiJShLrfxA4oRwKzadMmrFy5EmPHjkWtWrUQEBCAVatWITw8vEKPxSYiIqKKqynPQlI4gUlJSYGLiwsAwMDAAM+ePQMAdO/eHfv371dudERERKSQkkW8FXmpAoUTmPr16+PRo0cAgEaNGuHw4cMAgPPnz0NbW1u50RERERHJoHAC07NnT8TExAAA/vvf/2LKlClwdHREUFAQvvzyS6UHSERERPKrKVNICu9CmjNnjuTP/fr1Q4MGDRAXFwdHR0f4+fkpNTgiIiJSDB8lICdPT094enoqIxYiIiIiuciVwOzdu1fuDj/77LNyB0NEREQVIxaJIK7ANFBF2r5PciUw/v7+cnUmEolQWFhYkXiIiIioAip6PxcVyV/kS2CKiooqOw4iIiIiuSntWUhERERU9WrKs5Dk3kZ97NgxODs7Iysrq9SxZ8+e4YMPPsDJkyeVGhwREREppiKPEVClxwnIncBERUVhyJAhMDIyKnXM2NgYw4YNw6JFi5QaHBEREZEscicwV65cQZcuXco83rlzZ8THxyslKCIiIiqfkl1IFXmpArnXwKSmpkJTU7PsjmrVQnp6ulKCIiIiovKpKbuQ5B6BqVevHq5fv17m8atXr8LKykopQREREVH51JRHCcidwHTt2hVTpkzBy5cvSx178eIFIiIi0L17d6UGR0RERCSL3FNIkydPxs6dO+Hk5IQRI0agcePGAIC//voLy5YtQ2FhISZNmlRpgRIAswZALZ2qjoKoUjzJya/qEIgqzfP3+P0WoxxPan6jvSqQO4GxsLDAmTNn8M0332DixIkQBAFA8VCVr68vli1bBgsLi0oLlIiIiN6tptwHRqEb2dna2uLAgQN48uQJ7t69C0EQ4OjoiNq1a1dWfERERESllOtOvLVr10br1q2VHQsRERFVkEgEiGvALiQ+SoCIiEiNiCuYwFSk7fukKmt1iIiIiCQ4AkNERKRGuIiXiIiIVE5NmUKSK4HZu3ev3B1+9tln5Q6GiIiISB5yJTD+/v5ydSYSiVBYWFiReIiIiKgCasqzkORKYIqKiio7DiIiIlKCij5RWu2eRk1ERETVHx8l8BY5OTk4ceIEkpOTkZ8v/XyHkSNHKiUwIiIiorIonMBcunQJXbt2RW5uLnJycmBqaoqMjAzo6emhbt26TGCIiIiqUE1ZA6PwSNGYMWPg5+eHJ0+eQFdXF3/++ScePHgAd3d3zJ8/vzJiJCIiIjmJIZKsgynXC6qRwSicwFy+fBljx46FWCyGhoYG8vLyYGNjg7lz5+K7776rjBiJiIiIpCicwGhqakIsLm5Wt25dJCcnAwCMjY3x8OFD5UZHRERECimZQqrISxUovAbGzc0N58+fh6OjI7y8vBAeHo6MjAxs2LABzZo1q4wYiYiISE415U68Co/AzJo1C1ZWVgCAmTNnonbt2vjmm2+Qnp6OFStWKD1AIiIiojcpPALTqlUryZ/r1q2L6OhopQZERERE5ScSVexmdGo7hURERETVV03ZRq1wAtOwYcO3Pmr7/v37FQqIiIiI6F0UTmBGjx4t9f7Vq1e4dOkSoqOjMW7cOGXFRUREROVQUxbxKpzAjBo1Smb5smXLcOHChQoHREREROUn+v//VaS9KlDaM5s+/fRT7NixQ1ndERERUTmUjMBU5KUKlJbAbN++HaampsrqjoiIiKhM5bqR3euLeAVBQEpKCtLT0/Hjjz8qNTgiIiJSDNfAlKFHjx5SCYxYLIa5uTm8vb3RpEkTpQZHREREihGJRG/dLSxPe1WgcAIzderUSgiDiIiISH4Kr4HR0NBAWlpaqfLMzExoaGgoJSgiIiIqn5qyiFfhERhBEGSW5+XlQUtLq8IBERERUfnxTrxvWLJkCYDiubFVq1bBwMBAcqywsBAnT57kGhgiIiJ6L+ROYBYtWgSgeARm+fLlUtNFWlpasLOzw/Lly5UfIREREclNLBJV6GGOFWn7Psm9BiYxMRGJiYnw8vLClStXJO8TExNx+/ZtHDp0CB4eHpUZKxEREb1DVa2BWbZsGezs7KCjowMPDw+cO3dOrnZbtmyBSCSCv7+/QudTeBHv8ePHUbt2bUWbERERkZraunUrQkNDERERgYsXL8LV1RW+vr4yN/28LikpCWFhYejQoYPC51Q4gfn888/x/ffflyqfO3cu+vTpo3AAREREpESi/y3kLc+rPI9CWrhwIYYMGYKQkBA4Oztj+fLl0NPTw+rVq8tsU1hYiMDAQERGRsLe3l7hcyqcwJw8eRJdu3YtVf7pp5/i5MmTCgdAREREyiOGqMIvAMjKypJ65eXlyTxffn4+4uPj4ePj878YxGL4+PggLi6uzDinTZuGunXrYvDgweW8TgVlZ2fL3C6tqamJrKyscgVBREREylGR0ZfXt2Db2NjA2NhY8po9e7bM82VkZKCwsBAWFhZS5RYWFkhJSZHZ5o8//sAvv/yClStXlvs6Fb4PjIuLC7Zu3Yrw8HCp8i1btsDZ2bncgRAREVH18fDhQxgZGUnea2trK6Xf58+fY+DAgVi5ciXMzMzK3Y/CCcyUKVPQq1cv3Lt3Dx9//DEAICYmBr/++iu2bdtW7kCIiIio4pT1MEcjIyOpBKYsZmZm0NDQQGpqqlR5amoqLC0tS9W/d+8ekpKS4OfnJykrKioCANSqVQu3b99Go0aN3nlehRMYPz8/7N69G7NmzcL27duhq6uL5s2b4+jRo/Dy8lK0OyIiIlKi930fGC0tLbi7uyMmJkayFbqoqAgxMTEYMWJEqfpNmjTBtWvXpMomT56M58+fY/HixbCxsZHrvAonMADQrVs3dOvWrVT59evX0axZs/J0SURERCoqNDQUwcHBaNWqFdq0aYOoqCjk5OQgJCQEABAUFIR69eph9uzZ0NHRKZUrmJiYAIBCOUS5EpjXPX/+HL/++itWrVqF+Ph4FBYWVrRLIiIiKqeqeBZSv379kJ6ejvDwcKSkpKBFixaIjo6WLOxNTk6GWKzwvqG3KncCc/LkSaxatQo7d+6EtbU1evXqhWXLlikzNiIiIlKQGBWcQirPjWAAjBgxQuaUEQDExsa+te3atWsVPp9CCUxKSgrWrl2LX375BVlZWejbty/y8vKwe/du7kAiIiKi90bu8Rw/Pz80btwYV69eRVRUFP79918sXbq0MmMjIiIiBSnrPjDVndwjMAcPHsTIkSPxzTffwNHRsTJjIiIionISoxx3qX2jvSqQO84//vgDz58/h7u7Ozw8PPDDDz8gIyOjMmMjIiIikknuBKZt27ZYuXIlHj16hGHDhmHLli2wtrZGUVERjhw5gufPn1dmnERERCQHkUhU4ZcqUHikSF9fH19++SX++OMPXLt2DWPHjsWcOXNQt25dfPbZZ5URIxEREclJpISXKqjQVFfjxo0xd+5c/P333/j111+VFRMRERGVU8mdeCvyUgVKWaujoaEBf39/7N27VxndEREREb1Vhe/ES0RERNWLaoyhVAwTGCIiIjVSFY8SqAqqst2biIiISIIjMERERGqkoluhVWUbNRMYIiIiNcI78RIRERFVUxyBISIiUiOcQiIiIiKVU9G76apG+sIpJCIiIlJBHIEhIiJSI5xCIiIiIpVTU3YhMYEhIiJSIzVlBEZVEi0iIiIiCY7AEBERqZGasguJCQwREZEa4cMciYiIiKopjsAQERGpETFEEFdgIqgibd8nJjBERERqhFNIRERERNUUR2CIiIjUiOj//1eR9qqACQwREZEa4RQSERERUTXFERgiIiI1IqrgLiROIREREdF7V1OmkJjAEBERqZGaksBwDQwRERGpHI7AEBERqRFuoyYiIiKVIxYVvyrSXhVwComIiIhUDkdgiIiI1AinkIiIiEjlcBcSERERUTXFERgiIiI1IkLFpoFUZACGCQwREZE64S4kIiIiomqqSkdgvL290aJFC0RFRSm137Vr12L06NF4+vSpUvul6uGr7i3w389bo25tfVxPTMeEn2Jw8U6KzLq1NMQY09cDAT4fwKqOAe7+/RhT15xETHySpE67ZvXx389bw9XBAlZ1DBA4fTcOxN0t1ZeTjSmmhnyE9i420NAQ43ZyJoJn7sHf6c8ldVo3scLk4A5wb2yFwqIiXL+fhs8n78DL/AK0d7HBvu/7yYzz41EbcSlB9jVQzbN+1x9YueU40h8/R1MHa0wd2ROuTW3LrH8g9jIW/hKNv1Mew66+GSYM646ObZ0lx3Ny8zB3xT4c+eM6nmTlwMaqDoJ7dUBgj3aSOpMW/IbT8QlIzXgGfV1ttGxmhwlDu6ORrQUA4MmzHIyZsRF/3X+Ep1k5qGNiCJ/2HyBsSDcY6usAAM5fvY+5K/bhXnIaXrzMRz0LUwR85onBfbwq6ZMiWbgL6T3YuXMnNDU1qzKE94qJVcX1/KgxZgzxRugPRxH/1yN87d8SO6b3Ruuhq5HxLLdU/clBH6JPx6YYveQw7vz9GJ1a2mHD5B7wHfsrrt1PAwDo6WjiemIaNh6+ho1T/GWe187SGAfnBWDj4WuYvfEMnufmoamtGV7mF0rqtG5ihe3Te2PRb2cx4acYFBQWoZl9XRQVCQCAc7f+QePAH6X6/W7gh/BybcDkhST2HbuEWT/uwfTQPmjRtAHWbD+J4HErcHTDtzCrbViqfvz1RIyathHjhnbFx54fYO/Ri/h68hrsXRGKxvZWAICZP+5B3MUELJwUiPqWpjh14TbCF+2AhZkRfNo3AwA0c7JBDx93WNetjafPc7F47SEEjfsZJ3+dDA0NMcRiEXw+bIbQwV1Rx0QfSf9kICJqJ54+34bFUwYCAPR0tTCw54doYm8NPR0tXLh2H5MWboeejhYC/Dzf34dYw3EX0ntgamoKQ8PS/0ECQH5+fqmywsJCFBUVVXZYVI39p2crrI++hs1HruP2w0yE/nAEuXmv8EXnZjLr9/3YGYt+O4sjFxLxIOUZVh+4giMXEjGiVytJnaMXEjFz/WnslzHqUmJKcAccuXAfEatP4tr9NCSlPMPBs/ekkqaZQzvi570XEbXtHP5KzsTdf55g96nbyC8oTnJeFRQh7Umu5PU46yW6tnXApqPXlfTpkDr4ZdsJ9OvWFn0+bQNHO0vMCO0NXR1NbDtwTmb9tTtO4aM2TTC0/8dwsLVA6OBP8YFjPazf9YekzsXrSejVpTXaujmgvpUpAvw80dTBGlduJUvqBPh5oo1rI9S3MkUzp/oIHfwpHqU9xd8pjwEAxoZ6+KJHezRvYoN6lqZo7+6EL/zb4cLVREkfHzjWx2edWsKpoSXqW5nCv3MrdGjdGOev3q+kT4tkESnhpQqqNIHx9vbG6NGjAQB2dnaYPn06goKCYGRkhKFDh2Lt2rUwMTHB3r174ezsDG1tbSQnJyMvLw9hYWGoV68e9PX14eHhgdjY2Leea8+ePWjZsiV0dHRgb2+PyMhIFBQUAAAGDBiAfv2kh/ZfvXoFMzMzrF+/HgAQHR2NDz/8ECYmJqhTpw66d++Oe/fuSeonJSVBJBJh586d6NixI/T09ODq6oq4uDgAQGxsLEJCQvDs2TOIRCKIRCJMnTpVOR9kDaFZS4wWDhaIvfxAUiYIwInLyWjdxFpmG21NDbzML5Aqe5lXgLYf1JP7vCIR8Elre9z95wm2T/8cdzb/B0cWBaKrp4OkjpmxHlo3sUb601wcmh+A25u+wb7v+6Gtc9nn+bRtI5ga6mDzYSYwVCz/VQGu3/4b7d2dJGVisRjt3Z1w6WaSzDYXbyShvbujVFmHNk2k6rdsZoejp28gJf0pBEFA3KUEJD5MR4fWjWX2mfsiD9sPnoONlSms6prIrJOa8QyHTl5DG1f7Mq/nRsLfuHg9CR6ujcqsQ1Re1WoR7/z58+Hq6opLly5hypQpAIDc3Fx8//33WLVqFW7cuIG6detixIgRiIuLw5YtW3D16lX06dMHXbp0QUJCgsx+T506haCgIIwaNQo3b97Ezz//jLVr12LmzJkAgMDAQPz+++/Izs6WtDl06BByc3PRs2dPAEBOTg5CQ0Nx4cIFxMTEQCwWo2fPnqVGhCZNmoSwsDBcvnwZTk5OCAgIQEFBAdq1a4eoqCgYGRnh0aNHePToEcLCwmTGm5eXh6ysLKkXAXWMdFFLQ4z0JzlS5elPc1DXVF9mm2MXk/Cfnq1gb20CkQjwdrNF93aOsCijvizmJnow1NPC6D4eiIlPQq/J27D/TAI2TOqBds3qAyieYgKAbwPbYd2ha+g9ZQeu3E3F7tl9YG9tIrPfgZ1dcOxiEv7NzJZ5nGqeJ89yUFhUBDNT6ZFps9qGSH/8XGabjMfP31k/YmQvONpZoF2faWjsMw4h41cgcnQvtHkjsdiw+zSadfkWzT6diBNn/8L6+V9DS1N6pcHIaRvg7DsBnr0jYaCvgznjSq/ratc7Ek0+GYcewxZhYM/26Ne9rUKfA1WMGCKIRRV4qcgYTLXaRv3xxx9j7NixkvenTp3Cq1ev8OOPP8LV1RUAkJycjDVr1iA5ORnW1sX/6g4LC0N0dDTWrFmDWbNmleo3MjIS3377LYKDgwEA9vb2mD59OsaPH4+IiAj4+vpCX18fu3btwsCBxXO5mzdvxmeffSaZ4vr888+l+ly9ejXMzc1x8+ZNNGv2v+mLsLAwdOvWTXLeDz74AHfv3kWTJk1gbGwMkUgES0vLt34Os2fPRmRkpEKfHcn27fJjWDyqM879/CUEAImPnmLz0esI/ET2lJMs4v+fED745138tDseAHD9fjraNLXGl11dceb63xD//77DtQevYPOR4hGVa/fT4NXCFl90dsG0taek+rSuY4CPW9ohZM7vSrhKordbv/MULt18gJWzBsPaojbOX7mHiKidqFvHGB+2+t9oTw+flviwlRPSM7Owcmss/hu5HtuW/hfa2v9bqzhleA+MCu6MxL/TMW/lfsz4cQ+mj+ktdb6tS0cg50UeLt98gLkr9sO2nhk+69TyvV1vTVfRaSDVSF+qWQLTqlWrUmVaWlpo3ry55P21a9dQWFgIJycnqXp5eXmoU6eOzH6vXLmC06dPS0ZcgOL1NC9fvkRubi709PTQt29fbNq0CQMHDkROTg727NmDLVu2SOonJCQgPDwcZ8+eRUZGhmTkJTk5WSqBeT1WK6viBXRpaWlo0qSJ3J/DxIkTERoaKnmflZUFGxsbudurq8ysFygoLIJ5benRE3MTfaQ9zimzzRfT90BbUwOmRrp4lJmNqSEfISnlmULnfVVQiL+SM6XK7zx8LJmKSvn/899+o87th5mob156ndeAzs3w+PlLHPzzXqljVHPVNtaHhliMjDdGWzKePIe5qez1gmamhm+t/zIvH/NXHcBP00PwsWfxzqSmjaxx8+6/WLX1uFQCY2SgCyMDXTSsb44WzrZw85uMQ39ck0o+zOsYwbyOERrZWsDYUA/9Rv6A/wZ1Rt06RpI6NlbFv4ub2Fsj43E2Fq89xASGlK5aJTD6+qWH9XV1dSF6bUl0dnY2NDQ0EB8fDw0NDam6BgYGMvvNzs5GZGQkevXqVeqYjk7x9r/AwEB4eXkhLS0NR44cga6uLrp06SKp5+fnB1tbW6xcuRLW1tYoKipCs2bNSi02fn1XVUncii481tbWhra2tkJtaoJXBUW4fDcVXq4NJNucRSLgoxYNsOr3S29tm/eqEI8ys1FLQwy/9o7Yfeq2Que9dCcFjvVrS5U3qlcbD9OKp/eSU5/h34zncKhvKlXHoV5tHL2QiDcF+jTDlpgbKCjkonT6Hy3NWmjWuD7OXExA5w4uAIp/f5yJT8DAnh/KbNPyAzucuZiAL1/bqnz6wh24OdsBKP7+vioolIwSltDQEKFIEMqMRRAAQRCQ/8YaMuk6xe3fVqdIKHrrcaoENWQIplolMPJwc3NDYWEh0tLS0KFDB7natGzZErdv34aDg0OZddq1awcbGxts3boVBw8eRJ8+fSTJSGZmJm7fvo2VK1dKzvnHH3+U2VdZtLS0UFhY+O6KVKYfd13Aj6Gf4lJCKi7eeYRverhDX1sTm/5/2uansZ/iUWa2ZMrGvbElrOoY4tr9NFjXMcCEwHYQi0RYvP28pE99HU00fG2diq2FMZrZm+Pp85eSe7ws2XEeq7/1w5lrf+PU1YfwcW+ILh6N4Ddhq6Td0h3nMfGL9rh+Px3X7qchwOcDONY3RfDMvVLX8JFrA9hZmWDDoWuV9TGRChvcxwths3+FS2MbuDZtgDXbTyD3ZT56f9oGADB21mZYmBlh/NDuAIBBn3dAwKhlWLU1Fh3bNsXvxy7h2u2HmDm2DwDAUF8HHq6NMOen36GjpYl6lrVx9vI97Dx0AZOG9wAAJP+biX3HL6FDq8YwNTFASvpTLN98DDramvBu2xQAcPzPm8h4ko3mjW2gr6uNO0kpmLP8d7g3a4j6VsWJ+/pdf6CeRW3YN6gLADh35R5WbY1FcC/5fleTcvA+MNWUk5MTAgMDERQUhAULFsDNzQ3p6emIiYlB8+bNJetPXhceHo7u3bujQYMG6N27N8RiMa5cuYLr169jxowZknoDBgzA8uXLcefOHRw/flxSXrt2bdSpUwcrVqyAlZUVkpOT8e233yocu52dHbKzsxETEwNXV1fo6elBT0+vfB9EDbXr5G2YGenhu4HtUbe2Hq7dT0fv8O1If1q8nbm+uZHkvisAoK1ZC5OCPoSdpTFyXuTjyIVEfD3/ALJy8iR1WjhaSt1gbtbQjgCAzUeuY/iiaADA/ri7CP3hCMb09cCcrz/G3b+fIGjmHvx58x9Ju+V7LkJHqxZmDfWGiaEubtxPQ69J20tNVw30dcHZm/8g4e/Hyv+ASOV1/9gNj59mY9GaaGQ8zkJTh3pYO3eoZEro39QnknVZAODerCGipnyBBb8cxPxV+2FXzxzLZ4RI7gEDAEvCB2Luyv0YM3Mjnmblop6FKcZ+1RWBnxXfyE5bqxbOX72PNdtPIuv5C5jVNkRrV3ts/2Gk5N4zOtqa2LrvT8z4YTfyXxXAqm5t+HZwwTcDOknOIwgC5q3Yj4cpj6GhIYatdR2MH9YdA3gPGKoEIkF4yxhiJXv9Trx2dnYYPXq0ZFs1UPaN3169eoUZM2Zg/fr1+Oeff2BmZoa2bdsiMjISLi4uMtsdOnQI06ZNw6VLl6CpqYkmTZrgq6++wpAhQyR1bt26BWdnZ9ja2iIxMVFq6uro0aMYOXIk7t+/j8aNG2PJkiXw9vbGrl274O/vj6SkJDRs2BCXLl1CixYtAABPnz5F7dq1cfz4cXh7ewMAvvnmG2zbtg2ZmZmIiIiQayt1VlYWjI2Nod1xOkS1dBT9mIlUwv1tI6s6BKJK8zwrC40bmOPZs2cwMjJ6d4NyKPm7IuZyMgwMy3+O7OdZ6NSiQaXGqgxVmsCQfJjAUE3ABIbU2ftMYI4pIYH5WAUSmGp1HxgiIiIieajcGhgiIiJ6C+5CIiIiIlXDXUhERESkcvg0aiIiIqJqiiMwREREaqSGLIFhAkNERKRWakgGwykkIiIiUjlMYIiIiNSISAn/K49ly5bBzs4OOjo68PDwwLlz58qsW/Jswdq1a6N27drw8fF5a31ZmMAQERGpkZJdSBV5KWrr1q0IDQ1FREQELl68CFdXV/j6+iItLU1m/djYWAQEBOD48eOIi4uDjY0NOnfujH/++UdmfVmYwBAREVGFLFy4EEOGDEFISAicnZ2xfPly6OnpYfXq1TLrb9q0Cf/5z3/QokULNGnSBKtWrUJRURFiYmLkPicTGCIiIjUiUsILKH620uuvvLw8mefLz89HfHw8fHx8JGVisRg+Pj6Ii4uTK+bc3Fy8evUKpqamcl8nExgiIiJ1oqQMxsbGBsbGxpLX7NmzZZ4uIyMDhYWFsLCwkCq3sLBASkqKXCFPmDAB1tbWUknQu3AbNREREZXy8OFDqadRa2trV8p55syZgy1btiA2NhY6Ojpyt2MCQ0REpEaU9SwkIyMjqQSmLGZmZtDQ0EBqaqpUeWpqKiwtLd/adv78+ZgzZw6OHj2K5s2bKxQnp5CIiIjUyPvehaSlpQV3d3epBbglC3I9PT3LbDd37lxMnz4d0dHRaNWqlcLXyREYIiIiNVIVN+INDQ1FcHAwWrVqhTZt2iAqKgo5OTkICQkBAAQFBaFevXqSdTTff/89wsPDsXnzZtjZ2UnWyhgYGMDAwECuczKBISIiogrp168f0tPTER4ejpSUFLRo0QLR0dGShb3JyckQi/836fPTTz8hPz8fvXv3luonIiICU6dOleucTGCIiIjUSRU9C2nEiBEYMWKEzGOxsbFS75OSksp3ktcwgSEiIlIjylrEW91xES8RERGpHI7AEBERqZHyPs/o9faqgAkMERGRGqmiJTDvHaeQiIiISOVwBIaIiEid1JAhGCYwREREaoS7kIiIiIiqKY7AEBERqRHuQiIiIiKVU0OWwDCBISIiUis1JIPhGhgiIiJSORyBISIiUiM1ZRcSExgiIiJ1UsFFvCqSv3AKiYiIiFQPR2CIiIjUSA1Zw8sEhoiISK3UkAyGU0hERESkcjgCQ0REpEa4C4mIiIhUTk15lACnkIiIiEjlcASGiIhIjdSQNbxMYIiIiNRKDclgmMAQERGpkZqyiJdrYIiIiEjlcASGiIhIjYhQwV1ISoukcjGBISIiUiM1ZAkMp5CIiIhI9XAEhoiISI3UlBvZMYEhIiJSKzVjEolTSERERKRyOAJDRESkRjiFRERERCqnZkwgcQqJiIiIVBBHYIiIiNQIp5CIiIhI5dSUZyExgSEiIlInNWQRDNfAEBERkcrhCAwREZEaqSEDMExgiIiI1ElNWcTLKSQiIiJSORyBISIiUiPchURERESqp4YsguEUEhEREakcjsAQERGpkRoyAMMEhoiISJ1wFxIRERFRNcURGCIiIrVSsV1IqjKJxASGiIhIjXAKiYiIiKiaYgJDREREKodTSERERGqkpkwhMYEhIiJSIzXlUQKcQiIiIiKVwxEYIiIiNcIpJCIiIlI5NeVRApxCIiIiIpXDERgiIiJ1UkOGYJjAEBERqRHuQiIiIiKqpjgCQ0REpEa4C4mIiIhUTg1ZAsMpJCIiIrUiUsKrHJYtWwY7Ozvo6OjAw8MD586de2v9bdu2oUmTJtDR0YGLiwsOHDig0PmYwBAREVGFbN26FaGhoYiIiMDFixfh6uoKX19fpKWlyax/5swZBAQEYPDgwbh06RL8/f3h7++P69evy31OJjBERERqRKSE/ylq4cKFGDJkCEJCQuDs7Izly5dDT08Pq1evlll/8eLF6NKlC8aNG4emTZti+vTpaNmyJX744Qe5z8kEhoiISI2ULOKtyEsR+fn5iI+Ph4+Pj6RMLBbDx8cHcXFxMtvExcVJ1QcAX1/fMuvLwkW8KkAQhOL/L3hZxZEQVZ7nWVlVHQJRpcl+/hzA/36fV6asCv63VNL+zX60tbWhra1dqn5GRgYKCwthYWEhVW5hYYG//vpL5jlSUlJk1k9JSZE7TiYwKuD5/3/x80/NrOJIiCpP4wZTqjoEokr3/PlzGBsbV0rfWlpasLS0hGNDmwr3ZWBgABsb6X4iIiIwderUCvetLExgVIC1tTUePnwIQ0NDiFRlg76Ky8rKgo2NDR4+fAgjI6OqDodIqfj9fv8EQcDz589hbW1daefQ0dFBYmIi8vPzK9yXIAil/r6RNfoCAGZmZtDQ0EBqaqpUeWpqKiwtLWW2sbS0VKi+LExgVIBYLEb9+vWrOowaycjIiL/gSW3x+/1+VdbIy+t0dHSgo6NT6ed5nZaWFtzd3RETEwN/f38AQFFREWJiYjBixAiZbTw9PRETE4PRo0dLyo4cOQJPT0+5z8sEhoiIiCokNDQUwcHBaNWqFdq0aYOoqCjk5OQgJCQEABAUFIR69eph9uzZAIBRo0bBy8sLCxYsQLdu3bBlyxZcuHABK1askPucTGCIiIioQvr164f09HSEh4cjJSUFLVq0QHR0tGShbnJyMsTi/218bteuHTZv3ozJkyfju+++g6OjI3bv3o1mzZrJfU6R8D6WRBOpmLy8PMyePRsTJ04sc96XSFXx+03qgAkMERERqRzeyI6IiIhUDhMYIiIiUjlMYIiIiEjlMIEhtebt7S11nwGi6qKyvptr166FiYmJ0vslqm6YwBBVASZWtHPnTkyfPr2qw3hvmFiRsjGBIZWljNtlE1UVU1NTGBoayjwm67tdWFiIoqKiyg6LSGUwgSGV4e3tjREjRmD06NEwMzODr68vrl+/jk8//RQGBgawsLDAwIEDkZGRUWYfeXl5CAsLQ7169aCvrw8PDw/ExsYCKH4+jK6uLg4ePCjVZteuXTA0NERubi4AYMKECXBycoKenh7s7e0xZcoUvHr1SlJ/6tSpaNGiBTZs2AA7OzsYGxujf//+kodyDho0CCdOnMDixYshEokgEomQlJSk3A+Lqr3XR+Hs7Owwffp0BAUFwcjICEOHDpWMWOzduxfOzs7Q1tZGcnLyW7/DZdmzZw9atmwJHR0d2NvbIzIyEgUFBQCAAQMGoF+/flL1X716BTMzM6xfvx4AEB0djQ8//BAmJiaoU6cOunfvjnv37knqJyUlQSQSYefOnejYsSP09PTg6uqKuLg4AEBsbCxCQkLw7NkzyXe+Oj0UkFQTExhSKevWrYOWlhZOnz6NOXPm4OOPP4abmxsuXLiA6OhopKamom/fvmW2HzFiBOLi4rBlyxZcvXoVffr0QZcuXZCQkAAjIyN0794dmzdvlmqzadMm+Pv7Q09PDwBgaGiItWvX4ubNm1i8eDFWrlyJRYsWSbW5d+8edu/ejX379mHfvn04ceIE5syZAwBYvHgxPD09MWTIEDx69AiPHj0q9dRXqnnmz58PV1dXXLp0CVOmFD+ZOzc3F99//z1WrVqFGzduoG7dum/9Dsty6tQpBAUFYdSoUbh58yZ+/vlnrF27FjNnFj/dPjAwEL///juys7MlbQ4dOoTc3Fz07NkTAJCTk4PQ0FBcuHABMTExEIvF6NmzZ6kRoUmTJiEsLAyXL1+Gk5MTAgICUFBQgHbt2iEqKgpGRkaS73xYWFhlfIxUkwhEKsLLy0twc3OTvJ8+fbrQuXNnqToPHz4UAAi3b9+WtBk1apQgCILw4MEDQUNDQ/jnn3+k2nTq1EmYOHGiIAiCsGvXLsHAwEDIyckRBEEQnj17Jujo6AgHDx4sM6558+YJ7u7ukvcRERGCnp6ekJWVJSkbN26c4OHhIXUtJXFRzfT6d8DW1lbw9/eXOr5mzRoBgHD58mVJmTzf4TVr1gjGxsZSx2bNmiVVf8OGDYKVlZUgCILw6tUrwczMTFi/fr3keEBAgNCvX78yY09PTxcACNeuXRMEQRASExMFAMKqVaskdW7cuCEAEG7duiUzLqKK4rOQSKW4u7tL/nzlyhUcP34cBgYGperdu3cPTk5OUmXXrl1DYWFhqfK8vDzUqVMHANC1a1doampi79696N+/P3bs2AEjIyP4+PhI6m/duhVLlizBvXv3kJ2djYKCglJP9LWzs5Na32BlZYW0tLTyXzipvVatWpUq09LSQvPmzSXv5fkOv+nKlSs4ffq0ZMQFKF5P8/LlS+Tm5kJPTw99+/bFpk2bMHDgQOTk5GDPnj3YsmWLpH5CQgLCw8Nx9uxZZGRkSEZekpOTpZ5d83qsVlZWAIC0tDQ0adJEkY+CSC5MYEil6OvrS/6cnZ0NPz8/fP/996XqlfzyfF12djY0NDQQHx8PDQ0NqWMlSZCWlhZ69+6NzZs3o3///ti8eTP69euHWrWK/1OJi4tDYGAgIiMj4evrC2NjY2zZsgULFiyQ6k9TU1PqvUgk4gJMeqvXv9sldHV1IRKJJO/l+Q6/KTs7G5GRkejVq1epYzo6OgCKp5G8vLyQlpaGI0eOQFdXF126dJHU8/Pzg62tLVauXAlra2sUFRWhWbNmpRYbv/69L4mb33uqLExgSGW1bNkSO3bsgJ2dnSTBeBs3NzcUFhYiLS0NHTp0KLNeYGAgPvnkE9y4cQPHjh3DjBkzJMfOnDkDW1tbTJo0SVL24MEDhWPX0tJCYWGhwu2oZpP3O/y6li1b4vbt23BwcCizTrt27WBjY4OtW7fi4MGD6NOnjyQZyczMxO3bt7Fy5UrJOf/44w+FY+d3npSNi3hJZQ0fPhyPHz9GQEAAzp8/j3v37uHQoUMICQmR+YvSyckJgYGBCAoKws6dO5GYmIhz585h9uzZ2L9/v6TeRx99BEtLSwQGBqJhw4bw8PCQHHN0dERycjK2bNmCe/fuYcmSJdi1a5fCsdvZ2eHs2bNISkqSGpIneht5v8OvCw8Px/r16xEZGYkbN27g1q1b2LJlCyZPnixVb8CAAVi+fDmOHDmCwMBASXnt2rVRp04drFixAnfv3sWxY8cQGhqqcOx2dnbIzs5GTEwMMjIyJLv6iMqLCQypLGtra5w+fRqFhYXo3LkzXFxcMHr0aJiYmEAslv3VXrNmDYKCgjB27Fg0btwY/v7+OH/+PBo0aCCpIxKJEBAQgCtXrkj9IgeAzz77DGPGjMGIESPQokULnDlzRrJjRBFhYWHQ0NCAs7MzzM3NkZycrHAfVDPJ8x1+na+vL/bt24fDhw+jdevWaNu2LRYtWgRbW1upeoGBgbh58ybq1auH9u3bS8rFYjG2bNmC+Ph4NGvWDGPGjMG8efMUjrtdu3b4+uuv0a9fP5ibm2Pu3LkK90H0OpEgCEJVB0FERESkCI7AEBERkcphAkNEREQqhwkMERERqRwmMERERKRymMAQERGRymECQ0RERCqHCQwRERGpHCYwRIRBgwbB399f8t7b2xujR49+73HExsZCJBLh6dOn1aIfIqq+mMAQVVODBg2CSCSCSCSClpYWHBwcMG3aNBQUFFT6uXfu3Inp06fLVbcqkoVLly6hT58+sLCwgI6ODhwdHTFkyBDcuXPnvcVARFWLCQxRNdalSxc8evQICQkJGDt2LKZOnVrmbdzffDJwRZiamsLQ0FBp/SnTvn370LZtW+Tl5WHTpk24desWNm7cCGNj43I91oGIVBMTGKJqTFtbG5aWlrC1tcU333wDHx8f7N27F8D/pn1mzpwJa2trNG7cGADw8OFD9O3bFyYmJjA1NUWPHj2QlJQk6bOwsBChoaEwMTFBnTp1MH78eLz5RJE3p5Dy8vIwYcIE2NjYQFtbGw4ODvjll1+QlJSEjh07Aih+6J9IJMKgQYMAAEVFRZg9ezYaNmwIXV1duLq6Yvv27VLnOXDgAJycnKCrq4uOHTtKxSlLbm4uQkJC0LVrV+zduxc+Pj6SB27Onz8fP//8s8x2mZmZCAgIQL169aCnpwcXFxf8+uuvUnW2b98OFxcX6Orqok6dOvDx8UFOTg6A4lGmNm3aQF9fHyYmJmjfvr3UU8j37NmDli1bQkdHB/b29oiMjJSMlAmCgKlTp6JBgwbQ1taGtbU1Ro4c+dbrJKJ3q1XVARCR/HR1dZGZmSl5HxMTAyMjIxw5cgQA8OrVK/j6+sLT0xOnTp1CrVq1MGPGDHTp0gVXr16FlpYWFixYgLVr12L16tVo2rQpFixYgF27duHjjz8u87xBQUGIi4vDkiVL4OrqisTERGRkZMDGxgY7duzA559/jtu3b8PIyAi6uroAgNmzZ2Pjxo1Yvnw5HB0dcfLkSXzxxRcwNzeHl5cXHj58iF69emH48OEYOnQoLly4gLFjx771+g8dOoSMjAyMHz9e5nETExOZ5S9fvoS7uzsmTJgAIyMj7N+/HwMHDkSjRo3Qpk0bPHr0CAEBAZg7dy569uyJ58+f49SpUxAEAQUFBfD398eQIUPw66+/Ij8/H+fOnYNIJAIAnDp1CkFBQViyZAk6dOiAe/fuYejQoQCAiIgI7NixA4sWLcKWLVvwwQcfICUlBVeuXHnrdRKRHAQiqpaCg4OFHj16CIIgCEVFRcKRI0cEbW1tISwsTHLcwsJCyMvLk7TZsGGD0LhxY6GoqEhSlpeXJ+jq6gqHDh0SBEEQrKyshLlz50qOv3r1Sqhfv77kXIIgCF5eXsKoUaMEQRCE27dvCwCEI0eOyIzz+PHjAgDhyZMnkrKXL18Kenp6wpkzZ6TqDh48WAgICBAEQRAmTpwoODs7Sx2fMGFCqb5e9/333wsAhMePH8s8/raY3tStWzdh7NixgiAIQnx8vABASEpKKlUvMzNTACDExsbK7KdTp07CrFmzpMo2bNggWFlZCYIgCAsWLBCcnJyE/Pz8t8ZMRIrhCAxRNbZv3z4YGBjg1atXKCoqwoABAzB16lTJcRcXF2hpaUneX7lyBXfv3i21fuXly5e4d+8enj17hkePHsHDw0NyrFatWmjVqlWpaaQSly9fhoaGBry8vOSO++7du8jNzcUnn3wiVZ6fnw83NzcAwK1bt6TiAABPT8+39ltWjO9SWFiIWbNm4bfffsM///yD/Px85OXlQU9PDwDg6uqKTp06wcXFBb6+vujcuTN69+6N2rVrw9TUFIMGDYKvry8++eQT+Pj4oG/fvrCysgJQ/JmfPn0aM2fOlDrfy5cvkZubiz59+iAqKgr29vbo0qULunbtCj8/P9SqxV+/RBXB/4KIqrGOHTvip59+gpaWFqytrUv9paevry/1Pjs7G+7u7ti0aVOpvszNzcsVQ8mUkCKys7MBAPv370e9evWkjmlra5crDgBwcnICAPz111/vTHZeN2/ePCxevBhRUVFwcXGBvr4+Ro8eLVn4rKGhgSNHjuDMmTM4fPgwli5dikmTJuHs2bNo2LAh1qxZg5EjRyI6Ohpbt27F5MmTceTIEbRt2xbZ2dmIjIxEr169Sp1XR0cHNjY2uH37No4ePYojR47gP//5D+bNm4cTJ05AU1Oz3J8FUU3HRbxE1Zi+vj4cHBzQoEEDuf7F3rJlSyQkJKBu3bpwcHCQehkbG8PY2BhWVlY4e/aspE1BQQHi4+PL7NPFxQVFRUU4ceKEzOMlI0CFhYWSMmdnZ2hrayM5OblUHDY2NgCApk2b4ty5c1J9/fnnn2+9vs6dO8PMzAxz586VebysrdynT59Gjx498MUXX8DV1RX29valtlyLRCK0b98ekZGRuHTpErS0tLBr1y7JcTc3N0ycOBFnzpxBs2bNsHnzZgDFn/nt27dLXaeDgwPE4uJfsbq6uvDz88OSJUsQGxuLuLg4XLt27a3XSkRvxwSGSI0EBgbCzMwMPXr0wKlTp5CYmIjY2FiMHDkSf//9NwBg1KhRmDNnDnbv3o2//voL//nPf956Dxc7OzsEBwfjyy+/xO7duyV9/vbbbwAAW1tbiEQi7Nu3D+np6cjOzoahoSHCwsIwZswYrFu3Dvfu3cPFixexdOlSrFu3DgDw9ddfIyEhAePGjcPt27exefNmrF279q3Xp6+vj1WrVmH//v347LPPcPToUSQlJeHChQsYP348vv76a5ntHB0dJSMst27dwrBhw5Camio5fvbsWcyaNQsXLlxAcnIydu7cifT0dDRt2hSJiYmYOHEi4uLi8ODBAxw+fBgJCQlo2rQpACA8PBzr169HZGQkbty4gVu3bmHLli2YPHkyAGDt2rX45ZdfcP36ddy/fx8bN26Erq4ubG1t5fqZElEZqnoRDhHJ9voiXkWOP3r0SAgKChLMzMwEbW1twd7eXhgyZIjw7NkzQRCKF+2OGjVKMDIyEkxMTITQ0FAhKCiozEW8giAIL168EMaMGSNYWVkJWlpagoODg7B69WrJ8WnTpgmWlpaCSCQSgoODBUEoXngcFRUlNG7cWNDU1BTMzc0FX19f4cSJE5J2v//+u+Dg4CBoa2sLHTp0EFavXv3OxbeCIAjnz58XevXqJZibmwva2tqCg4ODMHToUCEhIUEQhNKLeDMzM4UePXoIBgYGQt26dYXJkydLXfPNmzcFX19fSX9OTk7C0qVLBUEQhJSUFMHf319y7ba2tkJ4eLhQWFgoiSc6Olpo166doKurKxgZGQlt2rQRVqxYIQiCIOzatUvw8PAQjIyMBH19faFt27bC0aNH33p9RPRuIkEo56o4IiIioirCKSQiIiJSOUxgiIiISOUwgSEiIiKVwwSGiIiIVA4TGCIiIlI5TGCIiIhI5TCBISIiIpXDBIaIiIhUDhMYIiIiUjlMYIiIiEjlMIEhIiIilcMEhoiIiFTO/wGa+amIjB+O2wAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]

From db3d876be31eb157167cc1ac282b1b20348daa15 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 22:21:53 -0700
Subject: [PATCH 07/59] fix llm_classify tests

---
 cspell.json                                   |   2 +
 pyproject.toml                                |   2 +
 .../experimental/evals/models/openai.py       |   3 +-
 .../evals/functions/test_classify.py          | 268 ++++++++++--------
 4 files changed, 153 insertions(+), 122 deletions(-)

diff --git a/cspell.json b/cspell.json
index cb2d614d2d..82418df616 100644
--- a/cspell.json
+++ b/cspell.json
@@ -11,6 +11,7 @@
         "Evals",
         "gitbook",
         "HDBSCAN",
+        "httpx",
         "Instrumentor",
         "langchain",
         "llamaindex",
@@ -19,6 +20,7 @@
         "pydantic",
         "quickstart",
         "RERANKER",
+        "respx",
         "rgba",
         "tracedataset",
         "UMAP"
diff --git a/pyproject.toml b/pyproject.toml
index 9851b6e075..9cb6c1f262 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -103,6 +103,8 @@ dependencies = [
   "responses",
   "tiktoken",
   "typing-extensions<4.6.0",  # for Colab
+  "httpx", # For OpenAI testing
+  "respx", # For OpenAI testing
 ]
 
 [tool.hatch.envs.type]
diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 91059a3542..6b6f3b855e 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -101,8 +101,7 @@ def _init_open_ai(self) -> None:
                     "or set it in your environment: 'export OPENAI_API_KEY=sk-****'"
                 )
             self.openai_api_key = api_key
-        client = self._openai.Client(api_key=self.openai_api_key)
-        self._client = client
+        self._client = self._openai.Client(api_key=self.openai_api_key)
         self.openai_api_type = self.openai_api_type or self._openai.api_type
         self.openai_api_version = self.openai_api_version or self._openai.api_version
         self.openai_organization = self.openai_organization or self._openai.organization
diff --git a/tests/experimental/evals/functions/test_classify.py b/tests/experimental/evals/functions/test_classify.py
index 4bc78b29bc..e9c22d4bf0 100644
--- a/tests/experimental/evals/functions/test_classify.py
+++ b/tests/experimental/evals/functions/test_classify.py
@@ -1,10 +1,11 @@
 from contextlib import ExitStack
 from unittest.mock import MagicMock, patch
 
+import httpx
 import numpy as np
 import pandas as pd
 import pytest
-import responses
+import respx
 from pandas.testing import assert_frame_equal
 from phoenix.experimental.evals import (
     NOT_PARSABLE,
@@ -16,10 +17,11 @@
 from phoenix.experimental.evals.functions.classify import _snap_to_rail
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
 
+response_labels = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
 
-@responses.activate
-def test_llm_classify(monkeypatch: pytest.MonkeyPatch):
-    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+
+def get_dataframe() -> (pd.DataFrame, list):
     dataframe = pd.DataFrame(
         [
             {
@@ -36,17 +38,26 @@ def test_llm_classify(monkeypatch: pytest.MonkeyPatch):
     )
     index = list(reversed(range(len(dataframe))))
     dataframe = dataframe.set_axis(index, axis=0)
+    return dataframe, index
+
+
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_llm_classify(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel()
 
-    # without function call in response
-    for message_content in ["relevant", "irrelevant", "\nrelevant ", "unparsable"]:
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={"choices": [{"message": {"content": message_content}}]},
-            status=200,
+    def route_side_effect(request, route):
+        return httpx.Response(
+            200, json={"choices": [{"message": {"content": response_labels[route.call_count]}}]}
         )
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
+    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -54,48 +65,65 @@ def test_llm_classify(monkeypatch: pytest.MonkeyPatch):
         rails=["relevant", "irrelevant"],
         use_function_calling_if_available=False,
     )
-    labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
-    assert result.iloc[:, 0].tolist() == labels
+    assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
         pd.DataFrame(
             index=index,
-            data={"label": ["relevant", "irrelevant", "relevant", NOT_PARSABLE]},
+            data={"label": expected_labels},
         ),
     )
     del result
 
-    # function call in response
-    for message_content in ["relevant", "irrelevant", "\nrelevant ", "unparsable"]:
-        message = {"function_call": {"arguments": f"{{\n  'response': {message_content}\n}}"}}
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={"choices": [{"message": message}]},
-            status=200,
+
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_llm_classify_with_fn_call(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(max_retries=0)
+
+    def route_side_effect(request, route):
+        label = response_labels[route.call_count]
+        return httpx.Response(
+            200,
+            json={"choices": [{"message": {"function_call": {"arguments": {"response": label}}}}]},
         )
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
+    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
         model=model,
         rails=["relevant", "irrelevant"],
     )
-    labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
-    assert result.iloc[:, 0].tolist() == labels
-    assert_frame_equal(result, pd.DataFrame(index=index, data={"label": labels}))
+
+    assert result.iloc[:, 0].tolist() == expected_labels
+    assert_frame_equal(result, pd.DataFrame(index=index, data={"label": expected_labels}))
     del result
 
-    # function call without explanation
-    for message_content in ["relevant", "irrelevant", "\nrelevant ", "unparsable"]:
-        message = {
-            "function_call": {
-                "arguments": f"{{\n  \042response\042: \042{message_content}\042\n}}",
-            }
-        }
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={"choices": [{"message": message}]},
-            status=200,
-        )
+
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_classify_fn_call_no_explain(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(max_retries=0)
+
+    def route_side_effect(request, route):
+        label = response_labels[route.call_count]
+        message = {"function_call": {"arguments": {"response": label}}}
+        return httpx.Response(201, json={"choices": [{"message": message}]})
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
+    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -103,26 +131,37 @@ def test_llm_classify(monkeypatch: pytest.MonkeyPatch):
         rails=["relevant", "irrelevant"],
         provide_explanation=True,
     )
-    labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
-    assert result.iloc[:, 0].tolist() == labels
+    assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
-        pd.DataFrame(index=index, data={"label": labels, "explanation": [None, None, None, None]}),
+        pd.DataFrame(
+            index=index, data={"label": expected_labels, "explanation": [None, None, None, None]}
+        ),
     )
     del result
 
-    # function call with explanation
-    for i, message_content in enumerate(["relevant", "irrelevant", "\nrelevant ", "unparsable"]):
+
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_classify_fn_call_explain(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(max_retries=0)
+
+    def route_side_effect(request, route):
+        label = response_labels[route.call_count]
         message = {
             "function_call": {
-                "arguments": f"{{\n  \042response\042: \042{message_content}\042, \042explanation\042: \042{i}\042\n}}"  # noqa E501
+                "arguments": f"{{\n  \042response\042: \042{label}\042, \042explanation\042: \042{route.call_count}\042\n}}"  # noqa E501
             }
         }
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={"choices": [{"message": message}]},
-            status=200,
-        )
+        return httpx.Response(200, json={"choices": [{"message": message}]})
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
+    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -130,60 +169,34 @@ def test_llm_classify(monkeypatch: pytest.MonkeyPatch):
         rails=["relevant", "irrelevant"],
         provide_explanation=True,
     )
-    labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
-    assert result.iloc[:, 0].tolist() == labels
+    assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
-        pd.DataFrame(index=index, data={"label": labels, "explanation": ["0", "1", "2", "3"]}),
+        pd.DataFrame(
+            index=index, data={"label": expected_labels, "explanation": ["0", "1", "2", "3"]}
+        ),
     )
     del result
 
 
-@responses.activate
-def test_llm_classify_prints_to_stdout_with_verbose_flag(monkeypatch: pytest.MonkeyPatch, capfd):
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_llm_classify_prints_to_stdout_with_verbose_flag(
+    monkeypatch: pytest.MonkeyPatch, capfd, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
-    dataframe = pd.DataFrame(
-        [
-            {
-                "query": "What is Python?",
-                "reference": "Python is a programming language.",
-            },
-            {
-                "query": "What is Python?",
-                "reference": "Ruby is a programming language.",
-            },
-            {
-                "query": "What is C++?",
-                "reference": "C++ is a programming language.",
-            },
-            {
-                "query": "What is C++?",
-                "reference": "irrelevant",
-            },
-        ]
-    )
-    for message_content in [
-        "relevant",
-        "irrelevant",
-        "\nrelevant ",
-        "unparsable",
-    ]:
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={
-                "choices": [
-                    {
-                        "message": {
-                            "content": message_content,
-                        },
-                    }
-                ],
-            },
-            status=200,
-        )
+
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
-        model = OpenAIModel()
+        model = OpenAIModel(max_retries=0)
 
+    def route_side_effect(request, route):
+        label = response_labels[route.call_count]
+        return httpx.Response(200, json={"choices": [{"message": {"content": label}}]})
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
+    dataframe, index = get_dataframe()
     llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -216,12 +229,25 @@ def test_llm_classify_shows_retry_info_with_verbose_flag(monkeypatch: pytest.Mon
 
     model = OpenAIModel(max_retries=5)
 
+    request = httpx.Request("POST", "https://api.openai.com/v1/chat/completions")
     openai_retry_errors = [
-        model._openai_error.Timeout("test timeout"),
-        model._openai_error.APIError("test api error"),
-        model._openai_error.APIConnectionError("test api connection error"),
-        model._openai_error.RateLimitError("test rate limit error"),
-        model._openai_error.ServiceUnavailableError("test service unavailable error"),
+        model._openai.APITimeoutError("test timeout"),
+        model._openai.APIError(
+            message="test api error",
+            request=httpx.request,
+            body={},
+        ),
+        model._openai.APIConnectionError(message="test api connection error", request=request),
+        model._openai.RateLimitError(
+            "test rate limit error",
+            response=httpx.Response(status_code=419, request=request),
+            body={},
+        ),
+        model._openai.InternalServerError(
+            "test internal server error",
+            response=httpx.Response(status_code=500, request=request),
+            body={},
+        ),
     ]
     mock_openai = MagicMock()
     mock_openai.side_effect = openai_retry_errors
@@ -231,7 +257,7 @@ def test_llm_classify_shows_retry_info_with_verbose_flag(monkeypatch: pytest.Mon
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
         stack.enter_context(patch.object(model._client.chat.completions, "create", mock_openai))
-        stack.enter_context(pytest.raises(model._openai.ServiceUnavailableError))
+        stack.enter_context(pytest.raises(model._openai.InternalServerError))
         llm_classify(
             dataframe=dataframe,
             template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -242,7 +268,7 @@ def test_llm_classify_shows_retry_info_with_verbose_flag(monkeypatch: pytest.Mon
 
     out, _ = capfd.readouterr()
     assert "Failed attempt 1" in out, "Retry information should be printed"
-    assert "test timeout" in out, "Retry information should be printed"
+    assert "Request timed out" in out, "Retry information should be printed"
     assert "Failed attempt 2" in out, "Retry information should be printed"
     assert "test api error" in out, "Retry information should be printed"
     assert "Failed attempt 3" in out, "Retry information should be printed"
@@ -265,9 +291,14 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
 
     model = OpenAIModel(max_retries=2)
 
+    request = httpx.Request("POST", "https://api.openai.com/v1/chat/completions")
     openai_retry_errors = [
         model._openai.APITimeoutError("test timeout"),
-        model._openai.APIError("test api error"),
+        model._openai.APIError(
+            message="test api error",
+            request=request,
+            body={},
+        ),
     ]
     mock_openai = MagicMock()
     mock_openai.side_effect = openai_retry_errors
@@ -276,9 +307,7 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
         waiting_fn = "phoenix.experimental.evals.models.base.wait_random_exponential"
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
-        stack.enter_context(
-            patch.object(model._openai.client.chat.completions, "create", mock_openai)
-        )
+        stack.enter_context(patch.object(model._client.chat.completions, "create", mock_openai))
         stack.enter_context(pytest.raises(model._openai.OpenAIError))
         llm_classify(
             dataframe=dataframe,
@@ -290,7 +319,7 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
 
     out, _ = capfd.readouterr()
     assert "Failed attempt 1" in out, "Retry information should be printed"
-    assert "test timeout" in out, "Retry information should be printed"
+    assert "Request timed out" in out, "Retry information should be printed"
     assert "Failed attempt 2" not in out, "Retry information should be printed"
 
     mock_openai.reset_mock()
@@ -301,7 +330,7 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
         stack.enter_context(patch(waiting_fn, return_value=False))
         stack.enter_context(patch.object(OpenAIModel, "_init_tiktoken", return_value=None))
         stack.enter_context(patch.object(model._client.chat.completions, "create", mock_openai))
-        stack.enter_context(pytest.raises(model._openai_error.APIError))
+        stack.enter_context(pytest.raises(model._openai.APIError))
         llm_classify(
             dataframe=dataframe,
             template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -311,10 +340,10 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
 
     out, _ = capfd.readouterr()
     assert "Failed attempt 1" not in out, "The `verbose` flag should not be persisted"
-    assert "test timeout" not in out, "The `verbose` flag should not be persisted"
+    assert "Request timed out" not in out, "The `verbose` flag should not be persisted"
 
 
-@responses.activate
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
 @pytest.mark.parametrize(
     "dataframe",
     [
@@ -433,9 +462,10 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
 def test_run_relevance_eval(
     monkeypatch: pytest.MonkeyPatch,
     dataframe: pd.DataFrame,
+    respx_mock: respx.mock,
 ):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
-    for message_content in [
+    responses = [
         "relevant",
         "irrelevant",
         "relevant",
@@ -443,20 +473,18 @@ def test_run_relevance_eval(
         "\nrelevant ",
         "unparsable",
         "relevant",
-    ]:
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={
-                "choices": [
-                    {
-                        "message": {
-                            "content": message_content,
-                        },
-                    }
-                ],
-            },
-            status=200,
+    ]
+
+    def route_side_effect(request, route):
+        return httpx.Response(
+            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
         )
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(
+        side_effect=route_side_effect,
+    )
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel()
     relevance_classifications = run_relevance_eval(dataframe, model=model)

From 82f13835b4ab6f5097d0af02f2673b08ffa1a377 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 22:27:17 -0700
Subject: [PATCH 08/59] fix llm generate tests

---
 .../evals/functions/test_generate.py          | 62 +++++++++----------
 1 file changed, 29 insertions(+), 33 deletions(-)

diff --git a/tests/experimental/evals/functions/test_generate.py b/tests/experimental/evals/functions/test_generate.py
index 1cad760197..b540468733 100644
--- a/tests/experimental/evals/functions/test_generate.py
+++ b/tests/experimental/evals/functions/test_generate.py
@@ -1,14 +1,15 @@
 from unittest.mock import patch
 
+import httpx
 import pandas as pd
 import pytest
-import responses
+import respx
 from phoenix.experimental.evals import OpenAIModel, llm_generate
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
 
 
-@responses.activate
-def test_llm_generate(monkeypatch: pytest.MonkeyPatch):
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_llm_generate(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     dataframe = pd.DataFrame(
         [
@@ -30,25 +31,22 @@ def test_llm_generate(monkeypatch: pytest.MonkeyPatch):
             },
         ]
     )
-    for message_content in [
+    responses = [
         "it's a dialect of french",
         "it's a music notation",
         "It's a crazy language",
         "it's a programming language",
-    ]:
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={
-                "choices": [
-                    {
-                        "message": {
-                            "content": message_content,
-                        },
-                    }
-                ],
-            },
-            status=200,
+    ]
+
+    def route_side_effect(request, route):
+        return httpx.Response(
+            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
         )
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
+
     template = (
         "Given {query} and a golden answer {reference}, generate an answer that is incorrect."
     )
@@ -65,8 +63,10 @@ def test_llm_generate(monkeypatch: pytest.MonkeyPatch):
     ]
 
 
-@responses.activate
-def test_llm_generate_prints_info_with_verbose_flag(monkeypatch: pytest.MonkeyPatch, capfd):
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
+def test_llm_generate_prints_info_with_verbose_flag(
+    monkeypatch: pytest.MonkeyPatch, capfd, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     dataframe = pd.DataFrame(
         [
@@ -88,25 +88,21 @@ def test_llm_generate_prints_info_with_verbose_flag(monkeypatch: pytest.MonkeyPa
             },
         ]
     )
-    for message_content in [
+    responses = [
         "it's a dialect of french",
         "it's a music notation",
         "It's a crazy language",
         "it's a programming language",
-    ]:
-        responses.post(
-            "https://api.openai.com/v1/chat/completions",
-            json={
-                "choices": [
-                    {
-                        "message": {
-                            "content": message_content,
-                        },
-                    }
-                ],
-            },
-            status=200,
+    ]
+
+    def route_side_effect(request, route):
+        return httpx.Response(
+            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
         )
+
+    respx_mock.post(
+        "/chat/completions",
+    ).mock(side_effect=route_side_effect)
     template = (
         "Given {query} and a golden answer {reference}, generate an answer that is incorrect."
     )

From a05ed61c276483ac45c99ab30486031415e1a647 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 22:36:29 -0700
Subject: [PATCH 09/59] minimal test for openai

---
 cspell.json                                    | 1 +
 tests/experimental/evals/models/test_openai.py | 6 +++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/cspell.json b/cspell.json
index 82418df616..3ead771e62 100644
--- a/cspell.json
+++ b/cspell.json
@@ -17,6 +17,7 @@
         "llamaindex",
         "NDJSON",
         "numpy",
+        "openai",
         "pydantic",
         "quickstart",
         "RERANKER",
diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
index f19e28ffe4..5a98f57b95 100644
--- a/tests/experimental/evals/models/test_openai.py
+++ b/tests/experimental/evals/models/test_openai.py
@@ -1,3 +1,5 @@
+from unittest.mock import patch
+
 from phoenix.experimental.evals.models.openai import OpenAIModel
 
 
@@ -7,5 +9,7 @@ def test_openai_model():
     NB: this is intentionally white-box testing since
     we cannot rely on the OpenAI API to be stable and don't
     """
-    model = OpenAIModel("gpt-4-1106-preview")
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(model_name="gpt-4-1106-preview")
+
     assert model.model_name == "gpt-4-1106-preview"

From 63f95f061958610c85681ce5ffb16b4871113a14 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 22:59:01 -0700
Subject: [PATCH 10/59] fix llama_index tests

---
 tests/trace/llama_index/test_callback.py | 54 +++++++++++++++---------
 1 file changed, 33 insertions(+), 21 deletions(-)

diff --git a/tests/trace/llama_index/test_callback.py b/tests/trace/llama_index/test_callback.py
index a77812b67b..137561e56e 100644
--- a/tests/trace/llama_index/test_callback.py
+++ b/tests/trace/llama_index/test_callback.py
@@ -3,8 +3,9 @@
 from unittest.mock import patch
 from uuid import uuid4
 
+import httpx
 import pytest
-import responses
+import respx
 from llama_index import ListIndex, ServiceContext, get_response_synthesizer
 from llama_index.callbacks import CallbackManager
 from llama_index.callbacks.schema import CBEventType
@@ -18,7 +19,7 @@
 from llama_index.llms.base import llm_completion_callback
 from llama_index.query_engine import RetrieverQueryEngine
 from llama_index.schema import Document, TextNode
-from openai import Client, RateLimitError
+from openai import RateLimitError
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
 from phoenix.trace.exporter import NoOpExporter
 from phoenix.trace.llama_index import OpenInferenceTraceCallbackHandler
@@ -77,9 +78,10 @@ def test_callback_llm(mock_service_context: ServiceContext) -> None:
     assert list(map(json_string_to_span, map(span_to_json, spans))) == spans
 
 
-@responses.activate
+@pytest.mark.respx(base_url="https://api.openai.com/v1")
 def test_callback_llm_span_contains_template_attributes(
     monkeypatch: pytest.MonkeyPatch,
+    respx_mock: respx.mock,
 ) -> None:
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     model_name = "gpt-3.5-turbo"
@@ -92,24 +94,28 @@ def test_callback_llm_span_contains_template_attributes(
     )
     query_engine = index.as_query_engine(service_context=service_context)
     expected_response = "The seven wonders of the world are: 1, 2, 3, 4, 5, 6, 7"
-    responses.post(
+    respx_mock.post(
         "https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-123",
-            "object": "chat.completion",
-            "created": 1677652288,
-            "model": model_name,
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {"role": "assistant", "content": expected_response},
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
-        },
-        status=200,
+    ).mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "id": "chatcmpl-123",
+                "object": "chat.completion",
+                "created": 1677652288,
+                "model": model_name,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": expected_response},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
+            },
+        )
     )
+
     response = query_engine.query(query)
 
     assert response.response == expected_response
@@ -137,8 +143,14 @@ def test_callback_llm_rate_limit_error_has_exception_event(
     )
     query_engine = index.as_query_engine(service_context=service_context)
 
-    with patch.object(Client.chat.completions, "create") as mocked_chat_completion_create:
-        mocked_chat_completion_create.side_effect = RateLimitError("message")
+    with patch.object(llm._client.chat.completions, "create") as mocked_chat_completion_create:
+        mocked_chat_completion_create.side_effect = RateLimitError(
+            "message",
+            response=httpx.Response(
+                429, request=httpx.Request(method="post", url="https://api.openai.com/")
+            ),
+            body={},
+        )
         with pytest.raises(RateLimitError):
             query_engine.query(query)
 

From 81e0f57a0e9ed21c8b258b7e592c0e231f5762a8 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 23:01:12 -0700
Subject: [PATCH 11/59] add back model

---
 src/phoenix/experimental/evals/models/openai.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 6b6f3b855e..e4ddeb7f79 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -17,6 +17,7 @@
     "gpt-3.5-turbo-16k-0613": 16385,
     "gpt-4-0314": 8192,
     "gpt-4-0613": 8192,  # Current gpt-4 default
+    "gpt-4-32k-0314": 32768,
     "gpt-4-32k-0613": 32768,
 }
 LEGACY_COMPLETION_API_MODELS = ("gpt-3.5-turbo-instruct",)

From 319a2e6d2f31a6c6c9a153ef5a9b6c8b9c2d0812 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Tue, 7 Nov 2023 23:06:12 -0700
Subject: [PATCH 12/59] fix openai

---
 pyproject.toml                                  | 4 ++--
 src/phoenix/experimental/evals/models/openai.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 9cb6c1f262..1d605f7c85 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -93,7 +93,7 @@ dependencies = [
   "arize",
   "langchain>=0.0.324",
   "llama-index>=0.8.63.post2",
-  "openai>1.0.0",
+  "openai>=1.0.0",
   "tenacity",
   "nltk==3.8.1",
   "sentence-transformers==2.2.2",
@@ -116,7 +116,7 @@ dependencies = [
   "types-tqdm",
   "types-requests",
   "types-protobuf",
-  "openai<1.0.0",
+  "openai>=1.0.0",
 ]
 
 [tool.hatch.envs.style]
diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index e4ddeb7f79..7a9ac97d34 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -9,7 +9,7 @@
     from tiktoken import Encoding
 
 OPENAI_API_KEY_ENVVAR_NAME = "OPENAI_API_KEY"
-MINIMUM_OPENAI_VERSION = "1.1.1"
+MINIMUM_OPENAI_VERSION = "1.0.0"
 MODEL_TOKEN_LIMIT_MAPPING = {
     "gpt-3.5-turbo-instruct": 4096,
     "gpt-3.5-turbo-0301": 4096,

From 7efd752c8839231e469687007ed2e489e57ab6be Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 11:21:11 -0700
Subject: [PATCH 13/59] fix openai tests

---
 tests/experimental/evals/models/test_openai.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
index 5a98f57b95..38bb87d247 100644
--- a/tests/experimental/evals/models/test_openai.py
+++ b/tests/experimental/evals/models/test_openai.py
@@ -7,7 +7,7 @@ def test_openai_model():
     """
     Sanity check of the initialization of OpenAI wrapper
     NB: this is intentionally white-box testing since
-    we cannot rely on the OpenAI API to be stable and don't
+    we have very little type safety in the OpenAI wrapper
     """
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(model_name="gpt-4-1106-preview")

From 25399e1dd2d90d4c42f34e71d8aa6587a188df82 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 11:56:46 -0700
Subject: [PATCH 14/59] Add explanations section for relevance

---
 .../evaluate_relevance_classifications.ipynb  | 214 ++++++++++++++++--
 1 file changed, 193 insertions(+), 21 deletions(-)

diff --git a/tutorials/evals/evaluate_relevance_classifications.ipynb b/tutorials/evals/evaluate_relevance_classifications.ipynb
index 8f4950d005..beda2ba152 100644
--- a/tutorials/evals/evaluate_relevance_classifications.ipynb
+++ b/tutorials/evals/evaluate_relevance_classifications.ipynb
@@ -379,13 +379,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a12a5284ad8c455aa6efcf0152100d43",
+       "model_id": "58f472bc3da8443a9986d7238deac426",
        "version_major": 2,
        "version_minor": 0
       },
@@ -421,7 +421,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -430,12 +430,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    relevant       0.72      0.89      0.80        44\n",
-      "  irrelevant       0.89      0.73      0.80        56\n",
+      "    relevant       0.73      0.80      0.76        46\n",
+      "  irrelevant       0.82      0.74      0.78        54\n",
       "\n",
-      "    accuracy                           0.80       100\n",
-      "   macro avg       0.81      0.81      0.80       100\n",
-      "weighted avg       0.82      0.80      0.80       100\n",
+      "    accuracy                           0.77       100\n",
+      "   macro avg       0.77      0.77      0.77       100\n",
+      "weighted avg       0.77      0.77      0.77       100\n",
       "\n"
      ]
     },
@@ -445,13 +445,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -477,6 +477,178 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Classifications with explanations\n",
+    "\n",
+    "When evaluating a dataset for relevance, it can be useful to know why the LLM classified a document as relevant or irrelevant. The following code block runs `llm_classify` with explanations turned on so that we can inspect why the LLM made the classification it did. There is speed tradeoff since more tokens is being generated but it can be highly informative when troubleshooting."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OpenAI invocation parameters: {'model': 'gpt-4', 'temperature': 0.0, 'max_tokens': 256, 'frequency_penalty': 0, 'presence_penalty': 0, 'top_p': 1, 'n': 1, 'timeout': None}\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7c722eb025774852b4608a61e8508a0f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/5 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "- Snapped 'irrelevant' to rail: irrelevant\n",
+      "- Snapped 'irrelevant' to rail: irrelevant\n",
+      "- Snapped 'irrelevant' to rail: irrelevant\n",
+      "- Snapped 'relevant' to rail: relevant\n",
+      "- Snapped 'relevant' to rail: relevant\n"
+     ]
+    }
+   ],
+   "source": [
+    "small_df_sample = df_sample.copy().sample(n=5).reset_index(drop=True)\n",
+    "relevance_classifications_df = llm_classify(\n",
+    "    dataframe=small_df_sample,\n",
+    "    template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,\n",
+    "    model=model,\n",
+    "    rails=rails,\n",
+    "    provide_explanation=True,\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>query</th>\n",
+       "      <th>reference</th>\n",
+       "      <th>label</th>\n",
+       "      <th>explanation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>when was Bandaranaike Airport built</td>\n",
+       "      <td>Bandaranaike International Airport (BIA) (also known as Katunayake International Airport and Colombo International Airport) is one of the two international airports serving the city of Colombo , the other is Ratmalana International Airport . Mattala Rajapaksa International Airport located in southern city of Hambantota is the other international airport in Sri Lanka . Bandaranaike International Airport is located in Katunayake , 22 miles (35 km) north of Colombo . It is administered by Airport and Aviation Services (Sri Lanka) Ltd. It is the hub of SriLankan Airlines , the national carrier of Sri Lanka, and Mihin Lanka , the budget airline of Sri Lanka.</td>\n",
+       "      <td>irrelevant</td>\n",
+       "      <td>The reference text provides information about the location, administration, and airlines of Bandaranaike International Airport, but it does not provide any information about when the airport was built.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>when was scooby doo created</td>\n",
+       "      <td>Scooby-Doo is an American animated cartoon franchise , comprising several animated television series produced from 1969 to the present day. The original series, Scooby-Doo, Where Are You! , was created for Hanna-Barbera Productions by writers Joe Ruby and Ken Spears in 1969. This Saturday morning cartoon series featured four teenagers— Fred Jones , Daphne Blake , Velma Dinkley , and Norville \"Shaggy\" Rogers — and their talking brown Great Dane dog named Scooby-Doo , who solve mysteries involving supposedly supernatural creatures through a series of antics and missteps. Following the success of the original series, Hanna-Barbera and its successor Warner Bros. Animation have produced numerous follow-up and spin-off animated series and several related works, including television specials and telefilms, a line of direct-to-video films, and two Warner Bros. –produced theatrical feature films. Some versions of Scooby-Doo feature different variations on the show's supernatural theme, and include characters such as Scooby's cousin Scooby-Dum and nephew Scrappy-Doo in addition to or instead of some of the original characters. Scooby-Doo was originally broadcast on CBS from 1969 to 1976, when it moved to ABC . ABC aired the show until canceling it in 1986, and presented a spin-off featuring the characters as children, A Pup Named Scooby-Doo , from 1988 until 1991. Two new Scooby-Doo series, What's New, Scooby-Doo? and Shaggy and Scooby-Doo Get a a Clue!]], aired as part of Kids WB on The WB network and its successor, The CW network, from 2002 until 2008. The most recent Scooby-Doo series, Scooby-Doo! Mystery Incorporated , aired on Cartoon Network from 2010 to 2013. Repeats of the various Scooby-Doo series are broadcast frequently on Cartoon Network and Boomerang in the United States and other countries.</td>\n",
+       "      <td>relevant</td>\n",
+       "      <td>The reference text mentions that Scooby-Doo was created in 1969, which directly answers the question.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>what time is it in tampa florida</td>\n",
+       "      <td>Tampa () is a city in the U.S. state of Florida . It serves as the county seat for Hillsborough County and is located on the west coast of Florida, on Tampa Bay near the Gulf of Mexico . The population of Tampa in 2011 was 346,037. The current location of Tampa was once inhabited by indigenous peoples of the Safety Harbor culture , most notably the Tocobaga and the Pohoy , who lived along the shores of Tampa Bay . It was briefly explored by Spanish explorers in the early 16th century, but there were no permanent American or European settlements within today's city limits until after the United States had acquired Florida from Spain in 1819. In 1824, the United States Army established a frontier outpost called Fort Brooke at the mouth of the Hillsborough River , near the site of today's Tampa Convention Center . The first civilian residents were pioneers who settled near the fort for protection from the nearby Seminole population. The town grew slowly until the 1880s, when railroad links, the discovery of phosphate, and the arrival of the cigar industry jump-started Tampa's development and helped it to grow into an important city by the early 1900s. Today, Tampa is a part of the metropolitan area most commonly referred to as the Tampa Bay Area . For U.S. Census purposes, Tampa is part of the Tampa-St. Petersburg-Clearwater, Florida Metropolitan Statistical Area . The four-county area is composed of roughly 2.7 million residents, making it the second largest metropolitan statistical area (MSA) in the state, and the fourth largest in the Southeastern United States , behind Miami , Washington, D.C. , and Atlanta . The Greater Tampa Bay area has just over 4 million residents and generally includes the Tampa and Sarasota metro areas. The Tampa Bay Partnership and U.S. Census data showed an average annual growth of 2.47 percent, or a gain of approximately 97,000 residents per year. Between 2000 and 2006, the Greater Tampa Bay Market experienced a combined growth rate of 14.8 percent, growing from 3.4 million to 3.9 million and hitting the 4 million people mark on April 1, 2007. A 2012 estimate shows the Tampa Bay area population to have 4,310,524 people and a 2017 projection of 4,536,854 people. Tampa has a number of sports teams, such as the Tampa Bay Buccaneers of the National Football League , the Tampa Bay Lightning of the National Hockey League , and the Tampa Bay Storm of the Arena Football League . The Tampa Bay Rays in Major League Baseball and the Tampa Bay Rowdies of the North American Soccer League play their home games in neighboring St. Petersburg, Florida . In 2008, Tampa was ranked as the 5th best outdoor city by Forbes . A 2004 survey by the NYU newspaper Washington Square News ranked Tampa as a top city for \"twenty-somethings.\" Tampa is now ranked as a \"Gamma\" world city by Loughborough University . According to Loughborough, Tampa ranks alongside other world cities such as Phoenix , Santo Domingo , and Osaka . In recent years Tampa has seen a notable upsurge in high-market demand from consumers, signaling more wealth concentrated in the area. Tampa hosted the 2012 Republican National Convention .</td>\n",
+       "      <td>irrelevant</td>\n",
+       "      <td>The reference text provides a detailed history and description of Tampa, Florida, but it does not provide any information about the current time in Tampa, Florida, which is what the question is asking for.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>what is the use of a sales invoice?</td>\n",
+       "      <td>An invoice or bill is a commercial document issued by a seller to a buyer , indicating the products , quantities, and agreed prices for products or services the seller has provided the buyer. An invoice indicates the sale transaction only. Payment terms are independent of the invoice and are negotiated by the buyer and the seller. Payment terms are usually included on the invoice. The buyer could have already paid for the products or services listed on the invoice. Buyer can also have a maximum number of days in which to pay for these goods and is sometimes offered a discount if paid before the due date. In the rental industry, an invoice must include a specific reference to the duration of the time being billed, so in addition to quantity, price and discount the invoicing amount is also based on duration. Generally each line of a rental invoice will refer to the actual hours, days, weeks, months, etc., being billed. From the point of view of a seller, an invoice is a sales invoice. From the point of view of a buyer, an invoice is a purchase invoice. The document indicates the buyer and seller, but the term invoice indicates money is owed or owing. In English, the context of the term invoice is usually used to clarify its meaning, such as \"We sent them an invoice\" (they owe us money) or \"We received an invoice from them\" (we owe them money).</td>\n",
+       "      <td>relevant</td>\n",
+       "      <td>The reference text provides a detailed explanation of what an invoice is, including its role in sales transactions. It mentions that from the point of view of a seller, an invoice is a sales invoice, which indicates the products, quantities, and agreed prices for products or services the seller has provided the buyer. This information is relevant to the question asking about the use of a sales invoice.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>what track and field event for me?</td>\n",
+       "      <td>Track and field is a sport comprising various competitive athletic contests based on running , jumping , and throwing. The name of the sport derives from the competition venue: a stadium with an oval running track around a grass field. The throwing and jumping events generally take place in the central enclosed area. Track and field falls under the umbrella sport of athletics , which also includes road running , cross country running , and race walking . The two most prestigious international track and field competitions are held under the banner of athletics: the athletics competition at the Olympic Games and the IAAF World Championships in Athletics . The International Association of Athletics Federations is the international governing body for track and field. Track and field events are generally individual sports with athletes challenging each other to decide a single victor. The racing events are won by the athlete with the fastest time, while the jumping and throwing events are won by the athlete who has achieved the greatest distance or height in the contest. The running events are categorised as sprints , middle and long-distance events , relays , and hurdling . Regular jumping events include long jump , triple jump , high jump and pole vault , while the most common throwing events are shot put , javelin , discus and hammer . There are also \"combined events\", such as heptathlon and decathlon , in which athletes compete in a number of the above events. Records are kept of the best performances in specific events, at world and national levels, right down to a personal level. However, if athletes are deemed to have violated the event's rules or regulations, they are disqualified from the competition and their marks are erased. In North America, the term track and field may be used to refer to athletics in general, rather than specifically track and field events.</td>\n",
+       "      <td>irrelevant</td>\n",
+       "      <td>The question 'what track and field event for me?' is asking for a personal recommendation based on unspecified criteria. The reference text provides a detailed description of track and field as a sport and its various events, but it does not provide any information that could be used to recommend a specific event for an individual.</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                 query  \\\n",
+       "0  when was Bandaranaike Airport built   \n",
+       "1          when was scooby doo created   \n",
+       "2     what time is it in tampa florida   \n",
+       "3  what is the use of a sales invoice?   \n",
+       "4   what track and field event for me?   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reference  \\\n",
+       "0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Bandaranaike International Airport (BIA) (also known as Katunayake International Airport and Colombo International Airport) is one of the two international airports serving the city of Colombo , the other is Ratmalana International Airport . Mattala Rajapaksa International Airport located in southern city of Hambantota is the other international airport in Sri Lanka . Bandaranaike International Airport is located in Katunayake , 22 miles (35 km) north of Colombo . It is administered by Airport and Aviation Services (Sri Lanka) Ltd. It is the hub of SriLankan Airlines , the national carrier of Sri Lanka, and Mihin Lanka , the budget airline of Sri Lanka.   \n",
+       "1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Scooby-Doo is an American animated cartoon franchise , comprising several animated television series produced from 1969 to the present day. The original series, Scooby-Doo, Where Are You! , was created for Hanna-Barbera Productions by writers Joe Ruby and Ken Spears in 1969. This Saturday morning cartoon series featured four teenagers— Fred Jones , Daphne Blake , Velma Dinkley , and Norville \"Shaggy\" Rogers — and their talking brown Great Dane dog named Scooby-Doo , who solve mysteries involving supposedly supernatural creatures through a series of antics and missteps. Following the success of the original series, Hanna-Barbera and its successor Warner Bros. Animation have produced numerous follow-up and spin-off animated series and several related works, including television specials and telefilms, a line of direct-to-video films, and two Warner Bros. –produced theatrical feature films. Some versions of Scooby-Doo feature different variations on the show's supernatural theme, and include characters such as Scooby's cousin Scooby-Dum and nephew Scrappy-Doo in addition to or instead of some of the original characters. Scooby-Doo was originally broadcast on CBS from 1969 to 1976, when it moved to ABC . ABC aired the show until canceling it in 1986, and presented a spin-off featuring the characters as children, A Pup Named Scooby-Doo , from 1988 until 1991. Two new Scooby-Doo series, What's New, Scooby-Doo? and Shaggy and Scooby-Doo Get a a Clue!]], aired as part of Kids WB on The WB network and its successor, The CW network, from 2002 until 2008. The most recent Scooby-Doo series, Scooby-Doo! Mystery Incorporated , aired on Cartoon Network from 2010 to 2013. Repeats of the various Scooby-Doo series are broadcast frequently on Cartoon Network and Boomerang in the United States and other countries.   \n",
+       "2  Tampa () is a city in the U.S. state of Florida . It serves as the county seat for Hillsborough County and is located on the west coast of Florida, on Tampa Bay near the Gulf of Mexico . The population of Tampa in 2011 was 346,037. The current location of Tampa was once inhabited by indigenous peoples of the Safety Harbor culture , most notably the Tocobaga and the Pohoy , who lived along the shores of Tampa Bay . It was briefly explored by Spanish explorers in the early 16th century, but there were no permanent American or European settlements within today's city limits until after the United States had acquired Florida from Spain in 1819. In 1824, the United States Army established a frontier outpost called Fort Brooke at the mouth of the Hillsborough River , near the site of today's Tampa Convention Center . The first civilian residents were pioneers who settled near the fort for protection from the nearby Seminole population. The town grew slowly until the 1880s, when railroad links, the discovery of phosphate, and the arrival of the cigar industry jump-started Tampa's development and helped it to grow into an important city by the early 1900s. Today, Tampa is a part of the metropolitan area most commonly referred to as the Tampa Bay Area . For U.S. Census purposes, Tampa is part of the Tampa-St. Petersburg-Clearwater, Florida Metropolitan Statistical Area . The four-county area is composed of roughly 2.7 million residents, making it the second largest metropolitan statistical area (MSA) in the state, and the fourth largest in the Southeastern United States , behind Miami , Washington, D.C. , and Atlanta . The Greater Tampa Bay area has just over 4 million residents and generally includes the Tampa and Sarasota metro areas. The Tampa Bay Partnership and U.S. Census data showed an average annual growth of 2.47 percent, or a gain of approximately 97,000 residents per year. Between 2000 and 2006, the Greater Tampa Bay Market experienced a combined growth rate of 14.8 percent, growing from 3.4 million to 3.9 million and hitting the 4 million people mark on April 1, 2007. A 2012 estimate shows the Tampa Bay area population to have 4,310,524 people and a 2017 projection of 4,536,854 people. Tampa has a number of sports teams, such as the Tampa Bay Buccaneers of the National Football League , the Tampa Bay Lightning of the National Hockey League , and the Tampa Bay Storm of the Arena Football League . The Tampa Bay Rays in Major League Baseball and the Tampa Bay Rowdies of the North American Soccer League play their home games in neighboring St. Petersburg, Florida . In 2008, Tampa was ranked as the 5th best outdoor city by Forbes . A 2004 survey by the NYU newspaper Washington Square News ranked Tampa as a top city for \"twenty-somethings.\" Tampa is now ranked as a \"Gamma\" world city by Loughborough University . According to Loughborough, Tampa ranks alongside other world cities such as Phoenix , Santo Domingo , and Osaka . In recent years Tampa has seen a notable upsurge in high-market demand from consumers, signaling more wealth concentrated in the area. Tampa hosted the 2012 Republican National Convention .   \n",
+       "3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           An invoice or bill is a commercial document issued by a seller to a buyer , indicating the products , quantities, and agreed prices for products or services the seller has provided the buyer. An invoice indicates the sale transaction only. Payment terms are independent of the invoice and are negotiated by the buyer and the seller. Payment terms are usually included on the invoice. The buyer could have already paid for the products or services listed on the invoice. Buyer can also have a maximum number of days in which to pay for these goods and is sometimes offered a discount if paid before the due date. In the rental industry, an invoice must include a specific reference to the duration of the time being billed, so in addition to quantity, price and discount the invoicing amount is also based on duration. Generally each line of a rental invoice will refer to the actual hours, days, weeks, months, etc., being billed. From the point of view of a seller, an invoice is a sales invoice. From the point of view of a buyer, an invoice is a purchase invoice. The document indicates the buyer and seller, but the term invoice indicates money is owed or owing. In English, the context of the term invoice is usually used to clarify its meaning, such as \"We sent them an invoice\" (they owe us money) or \"We received an invoice from them\" (we owe them money).   \n",
+       "4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Track and field is a sport comprising various competitive athletic contests based on running , jumping , and throwing. The name of the sport derives from the competition venue: a stadium with an oval running track around a grass field. The throwing and jumping events generally take place in the central enclosed area. Track and field falls under the umbrella sport of athletics , which also includes road running , cross country running , and race walking . The two most prestigious international track and field competitions are held under the banner of athletics: the athletics competition at the Olympic Games and the IAAF World Championships in Athletics . The International Association of Athletics Federations is the international governing body for track and field. Track and field events are generally individual sports with athletes challenging each other to decide a single victor. The racing events are won by the athlete with the fastest time, while the jumping and throwing events are won by the athlete who has achieved the greatest distance or height in the contest. The running events are categorised as sprints , middle and long-distance events , relays , and hurdling . Regular jumping events include long jump , triple jump , high jump and pole vault , while the most common throwing events are shot put , javelin , discus and hammer . There are also \"combined events\", such as heptathlon and decathlon , in which athletes compete in a number of the above events. Records are kept of the best performances in specific events, at world and national levels, right down to a personal level. However, if athletes are deemed to have violated the event's rules or regulations, they are disqualified from the competition and their marks are erased. In North America, the term track and field may be used to refer to athletics in general, rather than specifically track and field events.   \n",
+       "\n",
+       "        label  \\\n",
+       "0  irrelevant   \n",
+       "1    relevant   \n",
+       "2  irrelevant   \n",
+       "3    relevant   \n",
+       "4  irrelevant   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                                                                                                                                                             explanation  \n",
+       "0                                                                                                                                                                                                              The reference text provides information about the location, administration, and airlines of Bandaranaike International Airport, but it does not provide any information about when the airport was built.  \n",
+       "1                                                                                                                                                                                                                                                                                                                  The reference text mentions that Scooby-Doo was created in 1969, which directly answers the question.  \n",
+       "2                                                                                                                                                                                                          The reference text provides a detailed history and description of Tampa, Florida, but it does not provide any information about the current time in Tampa, Florida, which is what the question is asking for.  \n",
+       "3  The reference text provides a detailed explanation of what an invoice is, including its role in sales transactions. It mentions that from the point of view of a seller, an invoice is a sales invoice, which indicates the products, quantities, and agreed prices for products or services the seller has provided the buyer. This information is relevant to the question asking about the use of a sales invoice.  \n",
+       "4                                                                          The question 'what track and field event for me?' is asking for a personal recommendation based on unspecified criteria. The reference text provides a detailed description of track and field as a sport and its various events, but it does not provide any information that could be used to recommend a specific event for an individual.  "
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Let's view the data\n",
+    "merged_df = pd.merge(small_df_sample, relevance_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df[[\"query\", \"reference\", \"label\", \"explanation\"]].head()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -487,7 +659,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -496,13 +668,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3aa50b8a5cbe4c4cb109a44b24bd2fb2",
+       "model_id": "08645514386544008c07b731913c582f",
        "version_major": 2,
        "version_minor": 0
       },
@@ -523,7 +695,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -532,12 +704,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    relevant       0.47      0.98      0.63        44\n",
-      "  irrelevant       0.88      0.12      0.22        56\n",
+      "    relevant       0.49      1.00      0.66        46\n",
+      "  irrelevant       1.00      0.11      0.20        54\n",
       "\n",
-      "    accuracy                           0.50       100\n",
-      "   macro avg       0.67      0.55      0.43       100\n",
-      "weighted avg       0.70      0.50      0.40       100\n",
+      "    accuracy                           0.52       100\n",
+      "   macro avg       0.74      0.56      0.43       100\n",
+      "weighted avg       0.77      0.52      0.41       100\n",
       "\n"
      ]
     },
@@ -547,13 +719,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]

From 5a3faa9d4ad2bcf062a2551dba60f74dbc6818d2 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 12:34:51 -0700
Subject: [PATCH 15/59] run GPT4-Turbo

---
 .../evaluate_relevance_classifications.ipynb  | 104 +++++++++++++++++-
 1 file changed, 102 insertions(+), 2 deletions(-)

diff --git a/tutorials/evals/evaluate_relevance_classifications.ipynb b/tutorials/evals/evaluate_relevance_classifications.ipynb
index beda2ba152..63b9eba859 100644
--- a/tutorials/evals/evaluate_relevance_classifications.ipynb
+++ b/tutorials/evals/evaluate_relevance_classifications.ipynb
@@ -653,8 +653,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## LLM Evals: relevance Classifications GPT-3.5\n",
-    "Run relevance against a subset of the data."
+    "## LLM Evals: relevance Classifications GPT-3.5 Turbo\n",
+    "Run relevance against a subset of the data using GPT-3.5. GPT-3.5 can significantly speed up the classification process. However there are tradeoffs as  we will see below."
    ]
   },
   {
@@ -666,6 +666,11 @@
     "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, timeout=20)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": 23,
@@ -750,6 +755,101 @@
     "    normalized=True,\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preview: Running with GPT-4 Turbo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "61195c8ce06f4633bc31785ebaeeb725",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = OpenAIModel(model_name=\"gpt-4-1106-preview\")\n",
+    "relevance_classifications = llm_classify(\n",
+    "    dataframe=df_sample,\n",
+    "    template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,\n",
+    "    model=model,\n",
+    "    rails=list(RAG_RELEVANCY_PROMPT_RAILS_MAP.values()),\n",
+    ")[\"label\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "    relevant       0.72      0.83      0.77        46\n",
+      "  irrelevant       0.83      0.72      0.77        54\n",
+      "\n",
+      "    accuracy                           0.77       100\n",
+      "   macro avg       0.77      0.77      0.77       100\n",
+      "weighted avg       0.78      0.77      0.77       100\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "true_labels = df_sample[\"relevant\"].map(RAG_RELEVANCY_PROMPT_RAILS_MAP).tolist()\n",
+    "relevance_classifications = (\n",
+    "    pd.Series(relevance_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
+    ")\n",
+    "\n",
+    "print(classification_report(true_labels, relevance_classifications, labels=rails))\n",
+    "confusion_matrix = ConfusionMatrix(\n",
+    "    actual_vector=true_labels, predict_vector=relevance_classifications, classes=rails\n",
+    ")\n",
+    "confusion_matrix.plot(\n",
+    "    cmap=plt.colormaps[\"Blues\"],\n",
+    "    number_label=True,\n",
+    "    normalized=True,\n",
+    ")"
+   ]
   }
  ],
  "metadata": {

From b8055820f010394b8fef6dd5b16d699a25e23854 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 15:39:43 -0700
Subject: [PATCH 16/59] update notebooks

---
 .../experimental/evals/models/openai.py       |   4 +-
 .../evals/evaluate_QA_classifications.ipynb   |   2 +-
 ...ate_code_readability_classifications.ipynb | 842 ++++++------------
 ...aluate_hallucination_classifications.ipynb | 347 ++++++--
 .../evaluate_relevance_classifications.ipynb  |   2 +-
 ...aluate_summarization_classifications.ipynb |   2 +-
 .../evaluate_toxicity_classifications.ipynb   |   2 +-
 7 files changed, 585 insertions(+), 616 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 7a9ac97d34..71b2fcf0b2 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -53,7 +53,7 @@ class OpenAIModel(BaseEvalModel):
     batch_size: int = 20
     # TODO: IMPLEMENT BATCHING
     """Batch size to use when passing multiple documents to generate."""
-    timeout: Optional[Union[float, Tuple[float, float]]] = None
+    request_timeout: Optional[Union[float, Tuple[float, float]]] = None
     """Timeout for requests to OpenAI completion API. Default is 600 seconds."""
     max_retries: int = 20
     """Maximum number of retries to make when generating."""
@@ -248,7 +248,7 @@ def _default_params(self) -> Dict[str, Any]:
             "presence_penalty": self.presence_penalty,
             "top_p": self.top_p,
             "n": self.n,
-            "timeout": self.timeout,
+            "timeout": self.request_timeout,
         }
 
     @property
diff --git a/tutorials/evals/evaluate_QA_classifications.ipynb b/tutorials/evals/evaluate_QA_classifications.ipynb
index 5131795d8c..c7cac20dbe 100644
--- a/tutorials/evals/evaluate_QA_classifications.ipynb
+++ b/tutorials/evals/evaluate_QA_classifications.ipynb
@@ -47,7 +47,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {
diff --git a/tutorials/evals/evaluate_code_readability_classifications.ipynb b/tutorials/evals/evaluate_code_readability_classifications.ipynb
index 0c1ab0168f..6baeadf7bf 100644
--- a/tutorials/evals/evaluate_code_readability_classifications.ipynb
+++ b/tutorials/evals/evaluate_code_readability_classifications.ipynb
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -42,21 +42,21 @@
     "# 100 samples: GPT-4 ~ 80 sec / GPT-3.5 ~ 40 sec\n",
     "# 1,000 samples: GPT-4 ~15-17 min / GPT-3.5 ~ 6-7min (depending on retries)\n",
     "# 10,000 samples GPT-4 ~170 min / GPT-3.5 ~ 70min\n",
-    "N_EVAL_SAMPLE_SIZE = 100"
+    "N_EVAL_SAMPLE_SIZE = 10"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -95,15 +95,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "\n",
-       "  <div id=\"df-b9e35769-a656-4bcc-8c7a-9c2f9decf68e\" class=\"colab-df-container\">\n",
-       "    <div>\n",
+       "<div>\n",
        "<style scoped>\n",
        "    .dataframe tbody tr th:only-of-type {\n",
        "        vertical-align: middle;\n",
@@ -189,215 +187,7 @@
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "</div>\n",
-       "    <div class=\"colab-df-buttons\">\n",
-       "\n",
-       "  <div class=\"colab-df-container\">\n",
-       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b9e35769-a656-4bcc-8c7a-9c2f9decf68e')\"\n",
-       "            title=\"Convert this dataframe to an interactive table.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
-       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
-       "  </svg>\n",
-       "    </button>\n",
-       "\n",
-       "  <style>\n",
-       "    .colab-df-container {\n",
-       "      display:flex;\n",
-       "      gap: 12px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert {\n",
-       "      background-color: #E8F0FE;\n",
-       "      border: none;\n",
-       "      border-radius: 50%;\n",
-       "      cursor: pointer;\n",
-       "      display: none;\n",
-       "      fill: #1967D2;\n",
-       "      height: 32px;\n",
-       "      padding: 0 0 0 0;\n",
-       "      width: 32px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert:hover {\n",
-       "      background-color: #E2EBFA;\n",
-       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "      fill: #174EA6;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-buttons div {\n",
-       "      margin-bottom: 4px;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert {\n",
-       "      background-color: #3B4455;\n",
-       "      fill: #D2E3FC;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert:hover {\n",
-       "      background-color: #434B5C;\n",
-       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
-       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
-       "      fill: #FFFFFF;\n",
-       "    }\n",
-       "  </style>\n",
-       "\n",
-       "    <script>\n",
-       "      const buttonEl =\n",
-       "        document.querySelector('#df-b9e35769-a656-4bcc-8c7a-9c2f9decf68e button.colab-df-convert');\n",
-       "      buttonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "\n",
-       "      async function convertToInteractive(key) {\n",
-       "        const element = document.querySelector('#df-b9e35769-a656-4bcc-8c7a-9c2f9decf68e');\n",
-       "        const dataTable =\n",
-       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
-       "                                                    [key], {});\n",
-       "        if (!dataTable) return;\n",
-       "\n",
-       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
-       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
-       "          + ' to learn more about interactive tables.';\n",
-       "        element.innerHTML = '';\n",
-       "        dataTable['output_type'] = 'display_data';\n",
-       "        await google.colab.output.renderOutput(dataTable, element);\n",
-       "        const docLink = document.createElement('div');\n",
-       "        docLink.innerHTML = docLinkHtml;\n",
-       "        element.appendChild(docLink);\n",
-       "      }\n",
-       "    </script>\n",
-       "  </div>\n",
-       "\n",
-       "\n",
-       "<div id=\"df-cd170c51-247c-4931-a4f5-baf81ce6b884\">\n",
-       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-cd170c51-247c-4931-a4f5-baf81ce6b884')\"\n",
-       "            title=\"Suggest charts.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
-       "     width=\"24px\">\n",
-       "    <g>\n",
-       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
-       "    </g>\n",
-       "</svg>\n",
-       "  </button>\n",
-       "\n",
-       "<style>\n",
-       "  .colab-df-quickchart {\n",
-       "      --bg-color: #E8F0FE;\n",
-       "      --fill-color: #1967D2;\n",
-       "      --hover-bg-color: #E2EBFA;\n",
-       "      --hover-fill-color: #174EA6;\n",
-       "      --disabled-fill-color: #AAA;\n",
-       "      --disabled-bg-color: #DDD;\n",
-       "  }\n",
-       "\n",
-       "  [theme=dark] .colab-df-quickchart {\n",
-       "      --bg-color: #3B4455;\n",
-       "      --fill-color: #D2E3FC;\n",
-       "      --hover-bg-color: #434B5C;\n",
-       "      --hover-fill-color: #FFFFFF;\n",
-       "      --disabled-bg-color: #3B4455;\n",
-       "      --disabled-fill-color: #666;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart {\n",
-       "    background-color: var(--bg-color);\n",
-       "    border: none;\n",
-       "    border-radius: 50%;\n",
-       "    cursor: pointer;\n",
-       "    display: none;\n",
-       "    fill: var(--fill-color);\n",
-       "    height: 32px;\n",
-       "    padding: 0;\n",
-       "    width: 32px;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart:hover {\n",
-       "    background-color: var(--hover-bg-color);\n",
-       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "    fill: var(--button-hover-fill-color);\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart-complete:disabled,\n",
-       "  .colab-df-quickchart-complete:disabled:hover {\n",
-       "    background-color: var(--disabled-bg-color);\n",
-       "    fill: var(--disabled-fill-color);\n",
-       "    box-shadow: none;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-spinner {\n",
-       "    border: 2px solid var(--fill-color);\n",
-       "    border-color: transparent;\n",
-       "    border-bottom-color: var(--fill-color);\n",
-       "    animation:\n",
-       "      spin 1s steps(1) infinite;\n",
-       "  }\n",
-       "\n",
-       "  @keyframes spin {\n",
-       "    0% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "      border-left-color: var(--fill-color);\n",
-       "    }\n",
-       "    20% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    30% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    40% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    60% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    80% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "    90% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "  }\n",
-       "</style>\n",
-       "\n",
-       "  <script>\n",
-       "    async function quickchart(key) {\n",
-       "      const quickchartButtonEl =\n",
-       "        document.querySelector('#' + key + ' button');\n",
-       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
-       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
-       "      try {\n",
-       "        const charts = await google.colab.kernel.invokeFunction(\n",
-       "            'suggestCharts', [key], {});\n",
-       "      } catch (error) {\n",
-       "        console.error('Error during call to suggestCharts:', error);\n",
-       "      }\n",
-       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
-       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
-       "    }\n",
-       "    (() => {\n",
-       "      let quickchartButtonEl =\n",
-       "        document.querySelector('#df-cd170c51-247c-4931-a4f5-baf81ce6b884 button');\n",
-       "      quickchartButtonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "    })();\n",
-       "  </script>\n",
-       "</div>\n",
-       "    </div>\n",
-       "  </div>\n"
+       "</div>"
       ],
       "text/plain": [
        "   Unnamed: 0      task_id  \\\n",
@@ -443,7 +233,7 @@
        "4                                                                                                                                                                                                                                                                                                                                                   mean = sum(numbers) / len(numbers)\\n    return sum(abs(x - mean) for x in numbers) / len(numbers)\\n  "
       ]
      },
-     "execution_count": null,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -465,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [
     {
@@ -519,17 +309,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 50,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔑 Enter your OpenAI API key: ··········\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
@@ -556,7 +338,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -577,17 +359,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 52,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = OpenAIModel(\n",
     "    model_name=\"gpt-4\",\n",
@@ -597,26 +371,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-09 03:37:26.264202 |█████████████████████████████| 100.0% (1/1) [00:02<00:00,  2.03s/it]\n"
-     ]
-    },
     {
      "data": {
-      "application/vnd.google.colaboratory.intrinsic+json": {
-       "type": "string"
-      },
       "text/plain": [
        "\"Hello! I'm working perfectly. How can I assist you today?\""
       ]
      },
-     "execution_count": null,
+     "execution_count": 53,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -627,15 +391,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-09 03:42:00.556508 |█████████████████████████| 100.0% (100/100) [04:30<00:00,  2.70s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ee7c8c3563d246bba887ad657e320246",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -661,7 +432,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [
     {
@@ -670,12 +441,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    readable       0.91      0.73      0.81        44\n",
-      "  unreadable       0.82      0.95      0.88        56\n",
+      "    readable       0.83      0.71      0.77         7\n",
+      "  unreadable       0.50      0.67      0.57         3\n",
       "\n",
-      "    accuracy                           0.85       100\n",
-      "   macro avg       0.86      0.84      0.84       100\n",
-      "weighted avg       0.86      0.85      0.85       100\n",
+      "    accuracy                           0.70        10\n",
+      "   macro avg       0.67      0.69      0.67        10\n",
+      "weighted avg       0.73      0.70      0.71        10\n",
       "\n"
      ]
     },
@@ -685,13 +456,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": null,
+     "execution_count": 55,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -730,15 +501,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "\n",
-       "  <div id=\"df-c45a1f91-f938-47af-89fc-3b6530342a72\" class=\"colab-df-container\">\n",
-       "    <div>\n",
+       "<div>\n",
        "<style scoped>\n",
        "    .dataframe tbody tr th:only-of-type {\n",
        "        vertical-align: middle;\n",
@@ -769,31 +538,7 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>49</th>\n",
-       "      <td>30</td>\n",
-       "      <td>HumanEval/30</td>\n",
-       "      <td>\\n\\ndef get_positive(l: list):\\n    \"\"\"Return only positive numbers in the list.\\n    &gt;&gt;&gt; get_positive([-1, 2, -4, 5, 6])\\n    [2, 5, 6]\\n    &gt;&gt;&gt; get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\\n    [5, 3, 2, 3, 9, 123, 1]\\n    \"\"\"\\n</td>\n",
-       "      <td>return [e for e in l if e &gt; 0]\\n</td>\n",
-       "      <td>\\n\\nMETADATA = {}\\n\\n\\ndef check(candidate):\\n    assert candidate([-1, -2, 4, 5, 6]) == [4, 5, 6]\\n    assert candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]\\n    assert candidate([-1, -2]) == []\\n    assert candidate([]) == []\\n\\n</td>\n",
-       "      <td>get_positive</td>\n",
-       "      <td>False</td>\n",
-       "      <td>return list(filter(lambda e: e &gt; 0, l))</td>\n",
-       "      <td>readable</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>56</th>\n",
-       "      <td>79</td>\n",
-       "      <td>HumanEval/79</td>\n",
-       "      <td>\\ndef decimal_to_binary(decimal):\\n    \"\"\"You will be given a number in decimal form and your task is to convert it to\\n    binary format. The function should return a string, with each character representing a binary\\n    number. Each character in the string will be '0' or '1'.\\n\\n    There will be an extra couple of characters 'db' at the beginning and at the end of the string.\\n    The extra characters are there to help with the format.\\n\\n    Examples:\\n    decimal_to_binary(15)   # returns \"db1111db\"\\n    decimal_to_binary(32)   # returns \"db100000db\"\\n    \"\"\"\\n</td>\n",
-       "      <td>return \"db\" + bin(decimal)[2:] + \"db\"\\n</td>\n",
-       "      <td>def check(candidate):\\n\\n    # Check some simple cases\\n    assert candidate(0) == \"db0db\"\\n    assert candidate(32) == \"db100000db\"\\n    assert candidate(103) == \"db1100111db\"\\n    assert candidate(15) == \"db1111db\", \"This prints if this assert fails 1 (good for debugging!)\"\\n\\n    # Check some edge cases that are easy to work out by hand.\\n    assert True, \"This prints if this assert fails 2 (also good for debugging!)\"\\n\\n</td>\n",
-       "      <td>decimal_to_binary</td>\n",
-       "      <td>False</td>\n",
-       "      <td>def obscure_code(decimal):\\n    binary = bin(decimal)\\n    binary = binary[2:]\\n    prefix = \"db\"\\n    suffix = \"db\"\\n    result = prefix + binary + suffix\\n    return result\\n\\nprint(obscure_code(10))</td>\n",
-       "      <td>readable</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>92</th>\n",
+       "      <th>1</th>\n",
        "      <td>29</td>\n",
        "      <td>HumanEval/29</td>\n",
        "      <td>from typing import List\\n\\n\\ndef filter_by_prefix(strings: List[str], prefix: str) -&gt; List[str]:\\n    \"\"\" Filter an input list of strings only for ones that start with a given prefix.\\n    &gt;&gt;&gt; filter_by_prefix([], 'a')\\n    []\\n    &gt;&gt;&gt; filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\\n    ['abc', 'array']\\n    \"\"\"\\n</td>\n",
@@ -806,254 +551,32 @@
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "</div>\n",
-       "    <div class=\"colab-df-buttons\">\n",
-       "\n",
-       "  <div class=\"colab-df-container\">\n",
-       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c45a1f91-f938-47af-89fc-3b6530342a72')\"\n",
-       "            title=\"Convert this dataframe to an interactive table.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
-       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
-       "  </svg>\n",
-       "    </button>\n",
-       "\n",
-       "  <style>\n",
-       "    .colab-df-container {\n",
-       "      display:flex;\n",
-       "      gap: 12px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert {\n",
-       "      background-color: #E8F0FE;\n",
-       "      border: none;\n",
-       "      border-radius: 50%;\n",
-       "      cursor: pointer;\n",
-       "      display: none;\n",
-       "      fill: #1967D2;\n",
-       "      height: 32px;\n",
-       "      padding: 0 0 0 0;\n",
-       "      width: 32px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert:hover {\n",
-       "      background-color: #E2EBFA;\n",
-       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "      fill: #174EA6;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-buttons div {\n",
-       "      margin-bottom: 4px;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert {\n",
-       "      background-color: #3B4455;\n",
-       "      fill: #D2E3FC;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert:hover {\n",
-       "      background-color: #434B5C;\n",
-       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
-       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
-       "      fill: #FFFFFF;\n",
-       "    }\n",
-       "  </style>\n",
-       "\n",
-       "    <script>\n",
-       "      const buttonEl =\n",
-       "        document.querySelector('#df-c45a1f91-f938-47af-89fc-3b6530342a72 button.colab-df-convert');\n",
-       "      buttonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "\n",
-       "      async function convertToInteractive(key) {\n",
-       "        const element = document.querySelector('#df-c45a1f91-f938-47af-89fc-3b6530342a72');\n",
-       "        const dataTable =\n",
-       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
-       "                                                    [key], {});\n",
-       "        if (!dataTable) return;\n",
-       "\n",
-       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
-       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
-       "          + ' to learn more about interactive tables.';\n",
-       "        element.innerHTML = '';\n",
-       "        dataTable['output_type'] = 'display_data';\n",
-       "        await google.colab.output.renderOutput(dataTable, element);\n",
-       "        const docLink = document.createElement('div');\n",
-       "        docLink.innerHTML = docLinkHtml;\n",
-       "        element.appendChild(docLink);\n",
-       "      }\n",
-       "    </script>\n",
-       "  </div>\n",
-       "\n",
-       "\n",
-       "<div id=\"df-96edaa2e-bf61-4808-98c6-aa7f9b1e486c\">\n",
-       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-96edaa2e-bf61-4808-98c6-aa7f9b1e486c')\"\n",
-       "            title=\"Suggest charts.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
-       "     width=\"24px\">\n",
-       "    <g>\n",
-       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
-       "    </g>\n",
-       "</svg>\n",
-       "  </button>\n",
-       "\n",
-       "<style>\n",
-       "  .colab-df-quickchart {\n",
-       "      --bg-color: #E8F0FE;\n",
-       "      --fill-color: #1967D2;\n",
-       "      --hover-bg-color: #E2EBFA;\n",
-       "      --hover-fill-color: #174EA6;\n",
-       "      --disabled-fill-color: #AAA;\n",
-       "      --disabled-bg-color: #DDD;\n",
-       "  }\n",
-       "\n",
-       "  [theme=dark] .colab-df-quickchart {\n",
-       "      --bg-color: #3B4455;\n",
-       "      --fill-color: #D2E3FC;\n",
-       "      --hover-bg-color: #434B5C;\n",
-       "      --hover-fill-color: #FFFFFF;\n",
-       "      --disabled-bg-color: #3B4455;\n",
-       "      --disabled-fill-color: #666;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart {\n",
-       "    background-color: var(--bg-color);\n",
-       "    border: none;\n",
-       "    border-radius: 50%;\n",
-       "    cursor: pointer;\n",
-       "    display: none;\n",
-       "    fill: var(--fill-color);\n",
-       "    height: 32px;\n",
-       "    padding: 0;\n",
-       "    width: 32px;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart:hover {\n",
-       "    background-color: var(--hover-bg-color);\n",
-       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "    fill: var(--button-hover-fill-color);\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart-complete:disabled,\n",
-       "  .colab-df-quickchart-complete:disabled:hover {\n",
-       "    background-color: var(--disabled-bg-color);\n",
-       "    fill: var(--disabled-fill-color);\n",
-       "    box-shadow: none;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-spinner {\n",
-       "    border: 2px solid var(--fill-color);\n",
-       "    border-color: transparent;\n",
-       "    border-bottom-color: var(--fill-color);\n",
-       "    animation:\n",
-       "      spin 1s steps(1) infinite;\n",
-       "  }\n",
-       "\n",
-       "  @keyframes spin {\n",
-       "    0% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "      border-left-color: var(--fill-color);\n",
-       "    }\n",
-       "    20% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    30% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    40% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    60% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    80% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "    90% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "  }\n",
-       "</style>\n",
-       "\n",
-       "  <script>\n",
-       "    async function quickchart(key) {\n",
-       "      const quickchartButtonEl =\n",
-       "        document.querySelector('#' + key + ' button');\n",
-       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
-       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
-       "      try {\n",
-       "        const charts = await google.colab.kernel.invokeFunction(\n",
-       "            'suggestCharts', [key], {});\n",
-       "      } catch (error) {\n",
-       "        console.error('Error during call to suggestCharts:', error);\n",
-       "      }\n",
-       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
-       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
-       "    }\n",
-       "    (() => {\n",
-       "      let quickchartButtonEl =\n",
-       "        document.querySelector('#df-96edaa2e-bf61-4808-98c6-aa7f9b1e486c button');\n",
-       "      quickchartButtonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "    })();\n",
-       "  </script>\n",
-       "</div>\n",
-       "    </div>\n",
-       "  </div>\n"
+       "</div>"
       ],
       "text/plain": [
-       "    Unnamed: 0       task_id  \\\n",
-       "49          30  HumanEval/30   \n",
-       "56          79  HumanEval/79   \n",
-       "92          29  HumanEval/29   \n",
+       "   Unnamed: 0       task_id  \\\n",
+       "1          29  HumanEval/29   \n",
        "\n",
-       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            query  \\\n",
-       "49                                                                                                                                                                                                                                                                                                                                                \\n\\ndef get_positive(l: list):\\n    \"\"\"Return only positive numbers in the list.\\n    >>> get_positive([-1, 2, -4, 5, 6])\\n    [2, 5, 6]\\n    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\\n    [5, 3, 2, 3, 9, 123, 1]\\n    \"\"\"\\n   \n",
-       "56  \\ndef decimal_to_binary(decimal):\\n    \"\"\"You will be given a number in decimal form and your task is to convert it to\\n    binary format. The function should return a string, with each character representing a binary\\n    number. Each character in the string will be '0' or '1'.\\n\\n    There will be an extra couple of characters 'db' at the beginning and at the end of the string.\\n    The extra characters are there to help with the format.\\n\\n    Examples:\\n    decimal_to_binary(15)   # returns \"db1111db\"\\n    decimal_to_binary(32)   # returns \"db100000db\"\\n    \"\"\"\\n   \n",
-       "92                                                                                                                                                                                                                                                             from typing import List\\n\\n\\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\\n    \"\"\" Filter an input list of strings only for ones that start with a given prefix.\\n    >>> filter_by_prefix([], 'a')\\n    []\\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\\n    ['abc', 'array']\\n    \"\"\"\\n   \n",
+       "                                                                                                                                                                                                                                                                                                                                query  \\\n",
+       "1  from typing import List\\n\\n\\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\\n    \"\"\" Filter an input list of strings only for ones that start with a given prefix.\\n    >>> filter_by_prefix([], 'a')\\n    []\\n    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\\n    ['abc', 'array']\\n    \"\"\"\\n   \n",
        "\n",
-       "                                           canonical_solution  \\\n",
-       "49                           return [e for e in l if e > 0]\\n   \n",
-       "56                    return \"db\" + bin(decimal)[2:] + \"db\"\\n   \n",
-       "92      return [x for x in strings if x.startswith(prefix)]\\n   \n",
+       "                                          canonical_solution  \\\n",
+       "1      return [x for x in strings if x.startswith(prefix)]\\n   \n",
        "\n",
-       "                                                                                                                                                                                                                                                                                                                                                                                                                                            test  \\\n",
-       "49                                                                                                                                                                      \\n\\nMETADATA = {}\\n\\n\\ndef check(candidate):\\n    assert candidate([-1, -2, 4, 5, 6]) == [4, 5, 6]\\n    assert candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]\\n    assert candidate([-1, -2]) == []\\n    assert candidate([]) == []\\n\\n   \n",
-       "56  def check(candidate):\\n\\n    # Check some simple cases\\n    assert candidate(0) == \"db0db\"\\n    assert candidate(32) == \"db100000db\"\\n    assert candidate(103) == \"db1100111db\"\\n    assert candidate(15) == \"db1111db\", \"This prints if this assert fails 1 (good for debugging!)\"\\n\\n    # Check some edge cases that are easy to work out by hand.\\n    assert True, \"This prints if this assert fails 2 (also good for debugging!)\"\\n\\n   \n",
-       "92                                                                                                                                                                                             \\n\\nMETADATA = {\\n    'author': 'jt',\\n    'dataset': 'test'\\n}\\n\\n\\ndef check(candidate):\\n    assert candidate([], 'john') == []\\n    assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']\\n   \n",
+       "                                                                                                                                                                                                                                                test  \\\n",
+       "1  \\n\\nMETADATA = {\\n    'author': 'jt',\\n    'dataset': 'test'\\n}\\n\\n\\ndef check(candidate):\\n    assert candidate([], 'john') == []\\n    assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']\\n   \n",
        "\n",
-       "          entry_point  readable  \\\n",
-       "49       get_positive     False   \n",
-       "56  decimal_to_binary     False   \n",
-       "92   filter_by_prefix     False   \n",
+       "        entry_point  readable  \\\n",
+       "1  filter_by_prefix     False   \n",
        "\n",
-       "                                                                                                                                                                                                         code  \\\n",
-       "49                                                                                                                                                                    return list(filter(lambda e: e > 0, l))   \n",
-       "56  def obscure_code(decimal):\\n    binary = bin(decimal)\\n    binary = binary[2:]\\n    prefix = \"db\"\\n    suffix = \"db\"\\n    result = prefix + binary + suffix\\n    return result\\n\\nprint(obscure_code(10))   \n",
-       "92                                                                                                                                          return list(filter(lambda x: x[:len(prefix)] == prefix, strings))   \n",
+       "                                                                code  \\\n",
+       "1  return list(filter(lambda x: x[:len(prefix)] == prefix, strings))   \n",
        "\n",
-       "   readability  \n",
-       "49    readable  \n",
-       "56    readable  \n",
-       "92    readable  "
+       "  readability  \n",
+       "1    readable  "
       ]
      },
-     "execution_count": null,
+     "execution_count": 56,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1072,39 +595,201 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## LLM Evals: Code Readability Classifications GPT-3.5\n",
+    "## Classifications with explanations\n",
     "\n",
-    "Run readability classifications against a subset of the data."
+    "When evaluating a dataset for readability, it can be useful to know why the LLM classified text as readable or not. The following code block runs `llm_classify` with explanations turned on so that we can inspect why the LLM made the classification it did. There is speed tradeoff since more tokens is being generated but it can be highly informative when troubleshooting."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.\n"
+      "OpenAI invocation parameters: {'model': 'gpt-4', 'temperature': 0.0, 'max_tokens': 256, 'frequency_penalty': 0, 'presence_penalty': 0, 'top_p': 1, 'n': 1, 'timeout': None}\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b646c491fa3c44ea9b3804343e7649c6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/5 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "- Snapped 'unreadable' to rail: unreadable\n",
+      "- Snapped 'unreadable' to rail: unreadable\n",
+      "- Snapped 'readable' to rail: readable\n",
+      "- Snapped 'readable' to rail: readable\n",
+      "- Snapped 'unreadable' to rail: unreadable\n"
      ]
     }
    ],
    "source": [
-    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20)"
+    "small_df_sample = df.copy().sample(n=5).reset_index(drop=True)\n",
+    "readability_classifications_df = llm_classify(\n",
+    "    dataframe=small_df_sample,\n",
+    "    template=CODE_READABILITY_PROMPT_TEMPLATE_STR,\n",
+    "    model=model,\n",
+    "    rails=rails,\n",
+    "    provide_explanation=True,\n",
+    "    verbose=True,\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-09 03:57:47.927625 |█████████████████████████| 100.0% (100/100) [01:52<00:00,  1.12s/it]\n"
-     ]
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>query</th>\n",
+       "      <th>code</th>\n",
+       "      <th>label</th>\n",
+       "      <th>explanation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>\\n\\ndef common(l1: list, l2: list):\\n    \"\"\"Return sorted unique common elements for two lists.\\n    &gt;&gt;&gt; common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\\n    [1, 5, 653]\\n    &gt;&gt;&gt; common([5, 3, 2, 8], [3, 2])\\n    [2, 3]\\n\\n    \"\"\"\\n</td>\n",
+       "      <td>ret = set()\\n    for e1 in l1:\\n        for e2 in l2:\\n            if e1 == e2:\\n                ret.add(e1)\\n    return sorted(list(ret))\\n</td>\n",
+       "      <td>unreadable</td>\n",
+       "      <td>The code is unnecessarily complex for what it's trying to accomplish. It uses nested loops to find common elements between two lists, which is inefficient and makes the code harder to read. A simpler and more readable approach would be to convert the lists to sets and use the intersection method, then sort the result. This would accomplish the same task in a single line of code.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>\\ndef solve(s):\\n    \"\"\"You are given a string s.\\n    if s[i] is a letter, reverse its case from lower to upper or vise versa, \\n    otherwise keep it as it is.\\n    If the string contains no letters, reverse the string.\\n    The function should return the resulted string.\\n    Examples\\n    solve(\"1234\") = \"4321\"\\n    solve(\"ab\") = \"AB\"\\n    solve(\"#a@C\") = \"#A@c\"\\n    \"\"\"\\n</td>\n",
+       "      <td>flg,idx,new_str,s=[0,0,list(s),\"\"]\\nfor i in s:\\n    if i.isalpha():\\n        new_str[idx]=i.swapcase()\\n        flg=1\\n    idx+=1\\nfor i in new_str:\\n    s+=i\\nreturn s if flg else s[len(s)::-1]</td>\n",
+       "      <td>unreadable</td>\n",
+       "      <td>The code is not readable due to the use of unclear variable names such as 'flg', 'idx', and 's'. It's also not immediately clear what the purpose of the 'flg' variable is. The code could be simplified and made more readable by using more descriptive variable names and by using built-in Python functions to reverse the string and swap cases.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>\\ndef count_up_to(n):\\n    \"\"\"Implement a function that takes an non-negative integer and returns an array of the first n\\n    integers that are prime numbers and less than n.\\n    for example:\\n    count_up_to(5) =&gt; [2,3]\\n    count_up_to(11) =&gt; [2,3,5,7]\\n    count_up_to(0) =&gt; []\\n    count_up_to(20) =&gt; [2,3,5,7,11,13,17,19]\\n    count_up_to(1) =&gt; []\\n    count_up_to(18) =&gt; [2,3,5,7,11,13,17]\\n    \"\"\"\\n</td>\n",
+       "      <td>primes = []\\n    for i in range(2, n):\\n        is_prime = True\\n        for j in range(2, i):\\n            if i % j == 0:\\n                is_prime = False\\n                break\\n        if is_prime:\\n            primes.append(i)\\n    return primes\\n\\n</td>\n",
+       "      <td>readable</td>\n",
+       "      <td>The code is simple and straightforward. It uses two nested loops to check if a number is prime by checking if it has any divisors other than 1 and itself. If it doesn't, it's added to the list of primes. The variable names are clear and the logic is easy to follow.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>\\ndef can_arrange(arr):\\n    \"\"\"Create a function which returns the largest index of an element which\\n    is not greater than or equal to the element immediately preceding it. If\\n    no such element exists then return -1. The given array will not contain\\n    duplicate values.\\n\\n    Examples:\\n    can_arrange([1,2,4,3,5]) = 3\\n    can_arrange([1,2,3]) = -1\\n    \"\"\"\\n</td>\n",
+       "      <td>ind=-1\\n    i=1\\n    while i&lt;len(arr):\\n      if arr[i]&lt;arr[i-1]:\\n        ind=i\\n      i+=1\\n    return ind\\n</td>\n",
+       "      <td>readable</td>\n",
+       "      <td>The code is simple and straightforward. It uses a while loop to iterate through the array and checks if the current element is less than the previous one. If it is, it updates the index. The variable names could be more descriptive, but overall, the logic is easy to follow.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>\\ndef words_string(s):\\n    \"\"\"\\n    You will be given a string of words separated by commas or spaces. Your task is\\n    to split the string into words and return an array of the words.\\n    \\n    For example:\\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\\n    \"\"\"\\n</td>\n",
+       "      <td>if not s:\\n        return []\\n\\n    s_list = []\\n\\n    for letter in s:\\n        if letter == ',':\\n            s_list.append(' ')\\n        else:\\n            s_list.append(letter)\\n\\n    s_list = \"\".join(s_list)\\n    return s_list.split()\\n</td>\n",
+       "      <td>unreadable</td>\n",
+       "      <td>The code is unnecessarily complex for the task it's trying to accomplish. The task is to split a string into words, which can be done directly using the split() function in Python. The code provided first iterates through each character in the string, replaces commas with spaces, and then splits the string into words. This is an unnecessary step and makes the code harder to read and understand.</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                                                                                                                                                                                                                                                                                                                                                                                      query  \\\n",
+       "0                                                                                                                                                                      \\n\\ndef common(l1: list, l2: list):\\n    \"\"\"Return sorted unique common elements for two lists.\\n    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\\n    [1, 5, 653]\\n    >>> common([5, 3, 2, 8], [3, 2])\\n    [2, 3]\\n\\n    \"\"\"\\n   \n",
+       "1                               \\ndef solve(s):\\n    \"\"\"You are given a string s.\\n    if s[i] is a letter, reverse its case from lower to upper or vise versa, \\n    otherwise keep it as it is.\\n    If the string contains no letters, reverse the string.\\n    The function should return the resulted string.\\n    Examples\\n    solve(\"1234\") = \"4321\"\\n    solve(\"ab\") = \"AB\"\\n    solve(\"#a@C\") = \"#A@c\"\\n    \"\"\"\\n   \n",
+       "2  \\ndef count_up_to(n):\\n    \"\"\"Implement a function that takes an non-negative integer and returns an array of the first n\\n    integers that are prime numbers and less than n.\\n    for example:\\n    count_up_to(5) => [2,3]\\n    count_up_to(11) => [2,3,5,7]\\n    count_up_to(0) => []\\n    count_up_to(20) => [2,3,5,7,11,13,17,19]\\n    count_up_to(1) => []\\n    count_up_to(18) => [2,3,5,7,11,13,17]\\n    \"\"\"\\n   \n",
+       "3                                      \\ndef can_arrange(arr):\\n    \"\"\"Create a function which returns the largest index of an element which\\n    is not greater than or equal to the element immediately preceding it. If\\n    no such element exists then return -1. The given array will not contain\\n    duplicate values.\\n\\n    Examples:\\n    can_arrange([1,2,4,3,5]) = 3\\n    can_arrange([1,2,3]) = -1\\n    \"\"\"\\n   \n",
+       "4      \\ndef words_string(s):\\n    \"\"\"\\n    You will be given a string of words separated by commas or spaces. Your task is\\n    to split the string into words and return an array of the words.\\n    \\n    For example:\\n    words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\\n    words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\\n    \"\"\"\\n   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                 code  \\\n",
+       "0                                                                                                                        ret = set()\\n    for e1 in l1:\\n        for e2 in l2:\\n            if e1 == e2:\\n                ret.add(e1)\\n    return sorted(list(ret))\\n   \n",
+       "1                                                                 flg,idx,new_str,s=[0,0,list(s),\"\"]\\nfor i in s:\\n    if i.isalpha():\\n        new_str[idx]=i.swapcase()\\n        flg=1\\n    idx+=1\\nfor i in new_str:\\n    s+=i\\nreturn s if flg else s[len(s)::-1]   \n",
+       "2      primes = []\\n    for i in range(2, n):\\n        is_prime = True\\n        for j in range(2, i):\\n            if i % j == 0:\\n                is_prime = False\\n                break\\n        if is_prime:\\n            primes.append(i)\\n    return primes\\n\\n   \n",
+       "3                                                                                                                                                      ind=-1\\n    i=1\\n    while i<len(arr):\\n      if arr[i]<arr[i-1]:\\n        ind=i\\n      i+=1\\n    return ind\\n   \n",
+       "4                   if not s:\\n        return []\\n\\n    s_list = []\\n\\n    for letter in s:\\n        if letter == ',':\\n            s_list.append(' ')\\n        else:\\n            s_list.append(letter)\\n\\n    s_list = \"\".join(s_list)\\n    return s_list.split()\\n   \n",
+       "\n",
+       "        label  \\\n",
+       "0  unreadable   \n",
+       "1  unreadable   \n",
+       "2    readable   \n",
+       "3    readable   \n",
+       "4  unreadable   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                                                                                                                                                     explanation  \n",
+       "0                  The code is unnecessarily complex for what it's trying to accomplish. It uses nested loops to find common elements between two lists, which is inefficient and makes the code harder to read. A simpler and more readable approach would be to convert the lists to sets and use the intersection method, then sort the result. This would accomplish the same task in a single line of code.  \n",
+       "1                                                          The code is not readable due to the use of unclear variable names such as 'flg', 'idx', and 's'. It's also not immediately clear what the purpose of the 'flg' variable is. The code could be simplified and made more readable by using more descriptive variable names and by using built-in Python functions to reverse the string and swap cases.  \n",
+       "2                                                                                                                                      The code is simple and straightforward. It uses two nested loops to check if a number is prime by checking if it has any divisors other than 1 and itself. If it doesn't, it's added to the list of primes. The variable names are clear and the logic is easy to follow.  \n",
+       "3                                                                                                                             The code is simple and straightforward. It uses a while loop to iterate through the array and checks if the current element is less than the previous one. If it is, it updates the index. The variable names could be more descriptive, but overall, the logic is easy to follow.  \n",
+       "4  The code is unnecessarily complex for the task it's trying to accomplish. The task is to split a string into words, which can be done directly using the split() function in Python. The code provided first iterates through each character in the string, replaces commas with spaces, and then splits the string into words. This is an unnecessary step and makes the code harder to read and understand.  "
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Let's view the data\n",
+    "merged_df = pd.merge(small_df_sample, readability_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df[[\"query\", \"code\", \"label\", \"explanation\"]].head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LLM Evals: Code Readability Classifications GPT-3.5\n",
+    "\n",
+    "Run readability classifications against a subset of the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2fd4b3d966834f7b9c1bc23f41c4cc90",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/10 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -1115,14 +800,14 @@
     "readability_classifications = llm_classify(\n",
     "    dataframe=df,\n",
     "    template=CODE_READABILITY_PROMPT_TEMPLATE_STR,\n",
-    "    model=model,\n",
+    "    model=OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20, max_retries=0),\n",
     "    rails=rails,\n",
     ")[\"label\"]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [
     {
@@ -1131,12 +816,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "    readable       0.73      0.93      0.82        44\n",
-      "  unreadable       0.93      0.73      0.82        56\n",
+      "    readable       0.75      0.86      0.80         7\n",
+      "  unreadable       0.50      0.33      0.40         3\n",
       "\n",
-      "    accuracy                           0.82       100\n",
-      "   macro avg       0.83      0.83      0.82       100\n",
-      "weighted avg       0.84      0.82      0.82       100\n",
+      "    accuracy                           0.70        10\n",
+      "   macro avg       0.62      0.60      0.60        10\n",
+      "weighted avg       0.68      0.70      0.68        10\n",
       "\n"
      ]
     },
@@ -1146,13 +831,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": null,
+     "execution_count": 62,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -1163,6 +848,53 @@
    ],
    "source": [
     "true_labels = df[\"readable\"].map(CODE_READABILITY_PROMPT_RAILS_MAP).tolist()\n",
+    "readability_classifications = (\n",
+    "    pd.Series(readability_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
+    ")\n",
+    "\n",
+    "print(classification_report(true_labels, readability_classifications, labels=rails))\n",
+    "confusion_matrix = ConfusionMatrix(\n",
+    "    actual_vector=true_labels, predict_vector=readability_classifications, classes=rails\n",
+    ")\n",
+    "confusion_matrix.plot(\n",
+    "    cmap=plt.colormaps[\"Blues\"],\n",
+    "    number_label=True,\n",
+    "    normalized=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Preview: GPT-4 Turbo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rails = list(CODE_READABILITY_PROMPT_RAILS_MAP.values())\n",
+    "readability_classifications = llm_classify(\n",
+    "    dataframe=df,\n",
+    "    template=CODE_READABILITY_PROMPT_TEMPLATE_STR,\n",
+    "    model=OpenAIModel(model_name=\"gpt-4-1106-preview\", temperature=0.0),\n",
+    "    rails=rails,\n",
+    ")[\"label\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "true_labels = df[\"readable\"].map(CODE_READABILITY_PROMPT_RAILS_MAP).tolist()\n",
+    "readability_classifications = (\n",
+    "    pd.Series(readability_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
+    ")\n",
     "\n",
     "print(classification_report(true_labels, readability_classifications, labels=rails))\n",
     "confusion_matrix = ConfusionMatrix(\n",
diff --git a/tutorials/evals/evaluate_hallucination_classifications.ipynb b/tutorials/evals/evaluate_hallucination_classifications.ipynb
index 6d2d946326..c898c25407 100644
--- a/tutorials/evals/evaluate_hallucination_classifications.ipynb
+++ b/tutorials/evals/evaluate_hallucination_classifications.ipynb
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -43,16 +43,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -89,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -182,7 +182,7 @@
        "4                                                Moana             False  "
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -205,7 +205,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -259,7 +259,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -281,7 +281,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -305,7 +305,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -317,23 +317,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-11-07 13:06:18.277491 |█████████████████████████████| 100.0% (1/1) [00:01<00:00,  1.90s/it]\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
        "\"Hello! I'm working perfectly. How can I assist you today?\""
       ]
      },
-     "execution_count": 9,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -344,15 +337,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-11-07 13:09:04.536793 |█████████████████████████| 100.0% (100/100) [02:46<00:00,  1.66s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ab1a9eb61f5441a3bdcef768ebcb29a0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -376,7 +376,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -385,12 +385,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "hallucinated       0.91      0.81      0.86        53\n",
-      "     factual       0.81      0.91      0.86        47\n",
+      "hallucinated       0.94      0.77      0.85        57\n",
+      "     factual       0.75      0.93      0.83        43\n",
       "\n",
-      "    accuracy                           0.86       100\n",
-      "   macro avg       0.86      0.86      0.86       100\n",
-      "weighted avg       0.87      0.86      0.86       100\n",
+      "    accuracy                           0.84       100\n",
+      "   macro avg       0.85      0.85      0.84       100\n",
+      "weighted avg       0.86      0.84      0.84       100\n",
       "\n"
      ]
     },
@@ -400,13 +400,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -433,6 +433,197 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Classifications with explanations\n",
+    "\n",
+    "When evaluating a dataset for hallucinations, it can be useful to know why the LLM classified a response as a hallucination or not. The following code block runs `llm_classify` with explanations turned on so that we can inspect why the LLM made the classification it did. There is speed tradeoff since more tokens is being generated but it can be highly informative when troubleshooting."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OpenAI invocation parameters: {'model': 'gpt-3.5-turbo', 'temperature': 0.0, 'max_tokens': 256, 'frequency_penalty': 0, 'presence_penalty': 0, 'top_p': 1, 'n': 1, 'timeout': 20}\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2cb9167536a84d8a955cd567ff96e36a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/5 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "- Snapped 'factual' to rail: factual\n",
+      "- Snapped 'hallucinated' to rail: hallucinated\n",
+      "- Snapped 'hallucinated' to rail: hallucinated\n",
+      "- Snapped 'hallucinated' to rail: hallucinated\n",
+      "- Snapped 'hallucinated' to rail: hallucinated\n"
+     ]
+    }
+   ],
+   "source": [
+    "small_df_sample = df.copy().sample(n=5).reset_index(drop=True)\n",
+    "hallucination_classifications_df = llm_classify(\n",
+    "    dataframe=small_df_sample,\n",
+    "    template=HALLUCINATION_PROMPT_TEMPLATE_STR,\n",
+    "    model=model,\n",
+    "    rails=rails,\n",
+    "    provide_explanation=True,\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>query</th>\n",
+       "      <th>reference</th>\n",
+       "      <th>response</th>\n",
+       "      <th>is_hallucination</th>\n",
+       "      <th>label</th>\n",
+       "      <th>explanation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>The 2009 Baylor Bears football team represented Baylor University in the 2009 NCAA Division I FBS football season, the team was coached by Arthur Ray Briles, is an American football coach and former player, is an American football coach and former player, Briles was formerly the head coach at Baylor University from 2008 through what year, from which he was fired in the wake of a major sexual assault scandal?</td>\n",
+       "      <td>The team was coached by Art Briles. Briles was formerly the head coach at Baylor University from 2008 through 2015, from which he was fired in the wake of a major sexual assault scandal in his football program.</td>\n",
+       "      <td>2015</td>\n",
+       "      <td>False</td>\n",
+       "      <td>factual</td>\n",
+       "      <td>The answer '2015' is factual based on the reference text. The reference text states that Art Briles was the head coach at Baylor University from 2008 through 2015, and he was fired in the wake of a major sexual assault scandal.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>What was the name of the keyboardist and songwriter who formed the electronic music group whose fifth studio album was Invaders Must Die?</td>\n",
+       "      <td>Invaders Must Die is the fifth studio album by English electronic dance music group The Prodigy.The Prodigy are an English electronic music group from Braintree, Essex, formed in 1990 by keyboardist and songwriter Liam Howlett.</td>\n",
+       "      <td>Liam Howlett was the one who composed Electra Heart.</td>\n",
+       "      <td>True</td>\n",
+       "      <td>hallucinated</td>\n",
+       "      <td>The answer is hallucinated because it states that Liam Howlett composed Electra Heart, which is not mentioned in the reference text.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Which genus contains more species, Dacrydium or Araiostegia?</td>\n",
+       "      <td>Dacrydium is a genus of conifers belonging to the podocarp family Podocarpaceae. Sixteen species of evergreen dioecious trees and shrubs are presently recognized. The revisions of de Laubenfels and Quinn (see references), reclassified the former section A as the new genus \"Falcatifolium\", divided Section C into new genera \"Lepidothamnus, Lagarostrobos\" and \"Halocarpus\", and retained Section B as genus \"Dacrydium\".Araiostegia is a genus of twelve epiphytic or terrestrial ferns from tropical Asia belonging to the hares-foot fern family.</td>\n",
+       "      <td>Araiostegia has more species than Dacrydium.</td>\n",
+       "      <td>True</td>\n",
+       "      <td>hallucinated</td>\n",
+       "      <td>The reference text states that Dacrydium has 16 recognized species, while Araiostegia is described as a genus of twelve ferns. Therefore, the answer that Araiostegia has more species than Dacrydium is factually inaccurate.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Did both Battle of Chancellorsville and Battle of Pusan Perimeter take place on the same continent?</td>\n",
+       "      <td>The Battle of Chancellorsville was a major battle of the American Civil War (1861–1865), and the principal engagement of the Chancellorsville Campaign.The Battle of Pusan Perimeter was a large-scale battle between United Nations and North Korean forces lasting from August 4 to September 18, 1950.</td>\n",
+       "      <td>Yes, both battles occurred on different continents.</td>\n",
+       "      <td>True</td>\n",
+       "      <td>hallucinated</td>\n",
+       "      <td>The answer is hallucinated because the reference text states that the Battle of Chancellorsville took place during the American Civil War, which was fought in North America, while the Battle of Pusan Perimeter took place during the Korean War, which was fought in Asia. Therefore, the two battles occurred on the same continent, which contradicts the answer.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>The Bee Gees were a music group that was formed in 1958. Where was their album released in?</td>\n",
+       "      <td>Kitty Can was the compilation album released by the Bee Gees, released only in South America on RSO Records.were a pop music group formed in 1958.</td>\n",
+       "      <td>Kitty Can was released in Europe.</td>\n",
+       "      <td>True</td>\n",
+       "      <td>hallucinated</td>\n",
+       "      <td>The answer is hallucinated because the reference text states that the album 'Kitty Can' was released only in South America, not in Europe.</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                                                                                                                                                                                                                                                                                                                                                                                         query  \\\n",
+       "0  The 2009 Baylor Bears football team represented Baylor University in the 2009 NCAA Division I FBS football season, the team was coached by Arthur Ray Briles, is an American football coach and former player, is an American football coach and former player, Briles was formerly the head coach at Baylor University from 2008 through what year, from which he was fired in the wake of a major sexual assault scandal?   \n",
+       "1                                                                                                                                                                                                                                                                                    What was the name of the keyboardist and songwriter who formed the electronic music group whose fifth studio album was Invaders Must Die?   \n",
+       "2                                                                                                                                                                                                                                                                                                                                                                 Which genus contains more species, Dacrydium or Araiostegia?   \n",
+       "3                                                                                                                                                                                                                                                                                                                          Did both Battle of Chancellorsville and Battle of Pusan Perimeter take place on the same continent?   \n",
+       "4                                                                                                                                                                                                                                                                                                                                  The Bee Gees were a music group that was formed in 1958. Where was their album released in?   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reference  \\\n",
+       "0                                                                                                                                                                                                                                                                                                                                            The team was coached by Art Briles. Briles was formerly the head coach at Baylor University from 2008 through 2015, from which he was fired in the wake of a major sexual assault scandal in his football program.   \n",
+       "1                                                                                                                                                                                                                                                                                                                           Invaders Must Die is the fifth studio album by English electronic dance music group The Prodigy.The Prodigy are an English electronic music group from Braintree, Essex, formed in 1990 by keyboardist and songwriter Liam Howlett.   \n",
+       "2  Dacrydium is a genus of conifers belonging to the podocarp family Podocarpaceae. Sixteen species of evergreen dioecious trees and shrubs are presently recognized. The revisions of de Laubenfels and Quinn (see references), reclassified the former section A as the new genus \"Falcatifolium\", divided Section C into new genera \"Lepidothamnus, Lagarostrobos\" and \"Halocarpus\", and retained Section B as genus \"Dacrydium\".Araiostegia is a genus of twelve epiphytic or terrestrial ferns from tropical Asia belonging to the hares-foot fern family.   \n",
+       "3                                                                                                                                                                                                                                                     The Battle of Chancellorsville was a major battle of the American Civil War (1861–1865), and the principal engagement of the Chancellorsville Campaign.The Battle of Pusan Perimeter was a large-scale battle between United Nations and North Korean forces lasting from August 4 to September 18, 1950.   \n",
+       "4                                                                                                                                                                                                                                                                                                                                                                                                            Kitty Can was the compilation album released by the Bee Gees, released only in South America on RSO Records.were a pop music group formed in 1958.   \n",
+       "\n",
+       "                                               response  is_hallucination  \\\n",
+       "0                                                  2015             False   \n",
+       "1  Liam Howlett was the one who composed Electra Heart.              True   \n",
+       "2          Araiostegia has more species than Dacrydium.              True   \n",
+       "3   Yes, both battles occurred on different continents.              True   \n",
+       "4                     Kitty Can was released in Europe.              True   \n",
+       "\n",
+       "          label  \\\n",
+       "0       factual   \n",
+       "1  hallucinated   \n",
+       "2  hallucinated   \n",
+       "3  hallucinated   \n",
+       "4  hallucinated   \n",
+       "\n",
+       "                                                                                                                                                                                                                                                                                                                                                              explanation  \n",
+       "0                                                                                                                                     The answer '2015' is factual based on the reference text. The reference text states that Art Briles was the head coach at Baylor University from 2008 through 2015, and he was fired in the wake of a major sexual assault scandal.  \n",
+       "1                                                                                                                                                                                                                                    The answer is hallucinated because it states that Liam Howlett composed Electra Heart, which is not mentioned in the reference text.  \n",
+       "2                                                                                                                                          The reference text states that Dacrydium has 16 recognized species, while Araiostegia is described as a genus of twelve ferns. Therefore, the answer that Araiostegia has more species than Dacrydium is factually inaccurate.  \n",
+       "3  The answer is hallucinated because the reference text states that the Battle of Chancellorsville took place during the American Civil War, which was fought in North America, while the Battle of Pusan Perimeter took place during the Korean War, which was fought in Asia. Therefore, the two battles occurred on the same continent, which contradicts the answer.  \n",
+       "4                                                                                                                                                                                                                              The answer is hallucinated because the reference text states that the album 'Kitty Can' was released only in South America, not in Europe.  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Let's view the data\n",
+    "merged_df = pd.merge(small_df_sample, hallucination_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df[[\"query\", \"reference\", \"response\", \"is_hallucination\", \"label\", \"explanation\"]].head()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -443,7 +634,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -452,22 +643,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:1970-01-01 00:00:00 |                                            | 0.0% (0/100) [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-11-07 13:11:19.902750 |█████████████████████████| 100.0% (100/100) [02:15<00:00,  1.35s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0a9b1b4e2b9f45de8390202e91928e7d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -479,7 +670,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -488,12 +679,12 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "hallucinated       0.84      0.68      0.75        53\n",
-      "     factual       0.70      0.85      0.77        47\n",
+      "hallucinated       0.88      0.63      0.73        57\n",
+      "     factual       0.64      0.88      0.75        43\n",
       "\n",
-      "    accuracy                           0.76       100\n",
-      "   macro avg       0.77      0.77      0.76       100\n",
-      "weighted avg       0.77      0.76      0.76       100\n",
+      "    accuracy                           0.74       100\n",
+      "   macro avg       0.76      0.76      0.74       100\n",
+      "weighted avg       0.78      0.74      0.74       100\n",
       "\n"
      ]
     },
@@ -503,13 +694,13 @@
        "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -536,6 +727,52 @@
     "    normalized=True,\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Preview: GPT-4 Turbo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rails = list(HALLUCINATION_PROMPT_RAILS_MAP.values())\n",
+    "readability_classifications = llm_classify(\n",
+    "    dataframe=df,\n",
+    "    template=HALLUCINATION_PROMPT_TEMPLATE_STR,\n",
+    "    model=OpenAIModel(model_name=\"gpt-4-1106-preview\", temperature=0.0),\n",
+    "    rails=rails,\n",
+    ")[\"label\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "true_labels = df[\"is_hallucination\"].map(HALLUCINATION_PROMPT_RAILS_MAP).tolist()\n",
+    "hallucination_classifications = (\n",
+    "    pd.Series(hallucination_classifications)\n",
+    "    .map(lambda x: \"unparseable\" if x is None else x)\n",
+    "    .tolist()\n",
+    ")\n",
+    "\n",
+    "print(classification_report(true_labels, hallucination_classifications, labels=rails))\n",
+    "confusion_matrix = ConfusionMatrix(\n",
+    "    actual_vector=true_labels, predict_vector=hallucination_classifications, classes=rails\n",
+    ")\n",
+    "confusion_matrix.plot(\n",
+    "    cmap=plt.colormaps[\"Blues\"],\n",
+    "    number_label=True,\n",
+    "    normalized=True,\n",
+    ")"
+   ]
   }
  ],
  "metadata": {
diff --git a/tutorials/evals/evaluate_relevance_classifications.ipynb b/tutorials/evals/evaluate_relevance_classifications.ipynb
index 63b9eba859..84756c141c 100644
--- a/tutorials/evals/evaluate_relevance_classifications.ipynb
+++ b/tutorials/evals/evaluate_relevance_classifications.ipynb
@@ -663,7 +663,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, timeout=20)"
+    "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20)"
    ]
   },
   {
diff --git a/tutorials/evals/evaluate_summarization_classifications.ipynb b/tutorials/evals/evaluate_summarization_classifications.ipynb
index b8426ce5e4..5facef600c 100644
--- a/tutorials/evals/evaluate_summarization_classifications.ipynb
+++ b/tutorials/evals/evaluate_summarization_classifications.ipynb
@@ -47,7 +47,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {
diff --git a/tutorials/evals/evaluate_toxicity_classifications.ipynb b/tutorials/evals/evaluate_toxicity_classifications.ipynb
index c2aedfb549..8e482d400c 100644
--- a/tutorials/evals/evaluate_toxicity_classifications.ipynb
+++ b/tutorials/evals/evaluate_toxicity_classifications.ipynb
@@ -54,7 +54,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai<1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From 0e3d3f5b90591f9a6d4a5341dcfb4376bbdbb366 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 15:55:12 -0700
Subject: [PATCH 17/59] migrate find clusters notebook

---
 ..._cluster_export_and_explore_with_gpt.ipynb | 27 ++++++++++++-------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/tutorials/find_cluster_export_and_explore_with_gpt.ipynb b/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
index c22e0ef0dc..aadae4fcff 100644
--- a/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
+++ b/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
@@ -31,7 +31,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"openai<1\" ipywidgets pandas"
+    "!pip install -qq \"openai>1\" ipywidgets pandas"
    ]
   },
   {
@@ -104,7 +104,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install arize"
+    "!pip install -qq arize"
    ]
   },
   {
@@ -113,7 +113,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install 'arize[AutoEmbeddings]'"
+    "!pip install -qq 'arize[AutoEmbeddings]'"
    ]
   },
   {
@@ -174,7 +174,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install arize-phoenix"
+    "!pip install -qq arize-phoenix"
    ]
   },
   {
@@ -262,11 +262,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# @title OpenAI Key\n",
-    "import openai\n",
+    "# Make sure you have an openAI key setup\n",
+    "import getpass\n",
+    "import os\n",
     "\n",
-    "openai.api_key = \"YOUR_OPEN_AI_KEY\"\n",
-    "messages = []"
+    "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
+    "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
+    "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
   {
@@ -278,6 +280,11 @@
     "# @title Chat GPT - Cluster Analysis\n",
     "import ipywidgets as widgets\n",
     "from IPython.display import display\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "messages = []\n",
     "\n",
     "# Create the output widget\n",
     "output = widgets.Output(\n",
@@ -309,7 +316,7 @@
     "        messages.append(\n",
     "            {\"role\": \"user\", \"content\": message},\n",
     "        )\n",
-    "        chat = openai.ChatCompletion.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
+    "        chat = client.chat.completions.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
     "    reply = chat.choices[0].message.content\n",
     "    print(f\"ChatGPT RESPONSE: {reply}\")\n",
     "    print(\"\\n\")\n",
@@ -330,7 +337,7 @@
     "            messages.append(\n",
     "                {\"role\": \"user\", \"content\": user_input},\n",
     "            )\n",
-    "            chat = openai.ChatCompletion.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
+    "            chat = client.chat.completions.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
     "            reply = chat.choices[0].message.content\n",
     "            print(f\"ChatGPT RESPONSE: {reply}\")\n",
     "            messages.append({\"role\": \"assistant\", \"content\": reply})\n",

From 421b9a993de732b84053d1cdfd01a14c17e5bf56 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 16:27:22 -0700
Subject: [PATCH 18/59] update more notebooks

---
 .../langchain_pinecone_search_and_retrieval_tutorial.ipynb  | 3 +--
 tutorials/tracing/langchain_tracing_tutorial.ipynb          | 6 ++----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
index b9366a07d2..853dab9143 100644
--- a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
@@ -83,7 +83,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain<0.0.330\" \"openai<1\" arize-phoenix pinecone-client"
+    "!pip install \"langchain>=0.0.332\" \"openai>1\" arize-phoenix pinecone-client"
    ]
   },
   {
@@ -151,7 +151,6 @@
    "source": [
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "openai.api_key = openai_api_key\n",
     "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
diff --git a/tutorials/tracing/langchain_tracing_tutorial.ipynb b/tutorials/tracing/langchain_tracing_tutorial.ipynb
index 04fa9916f2..95ceb3f000 100644
--- a/tutorials/tracing/langchain_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain<=0.0.330\" \"openai<1\" arize-phoenix tiktoken"
+    "!pip install \"langchain>=0.0.332\" \"openai>1\" arize-phoenix tiktoken"
    ]
   },
   {
@@ -65,7 +65,6 @@
     "from urllib.request import urlopen\n",
     "\n",
     "import numpy as np\n",
-    "import openai\n",
     "import pandas as pd\n",
     "import phoenix as px\n",
     "from langchain.chains import RetrievalQA\n",
@@ -113,8 +112,7 @@
    "source": [
     "if os.environ.get(\"OPENAI_API_KEY\") is None:\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "    openai.api_key = openai_api_key\n",
-    "os.environ[\"OPENAI_API_KEY\"] = openai.api_key"
+    "    os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
   {

From e937d284ba5abbf49240ebed810be8c0637aeb05 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 17:45:24 -0700
Subject: [PATCH 19/59] fix relevance

---
 src/phoenix/experimental/evals/retrievals.py              | 3 ++-
 tutorials/llama_index_search_and_retrieval_tutorial.ipynb | 6 ++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/phoenix/experimental/evals/retrievals.py b/src/phoenix/experimental/evals/retrievals.py
index 127cca0973..f30458165d 100644
--- a/src/phoenix/experimental/evals/retrievals.py
+++ b/src/phoenix/experimental/evals/retrievals.py
@@ -90,6 +90,7 @@ def classify_relevance(query: str, document: str, model_name: str) -> Optional[b
         ],
         model=model_name,
     )
-    raw_response_text = str(response["choices"][0]["message"]["content"]).strip()
+
+    raw_response_text = str(response.choices[0].message.content).strip()
     relevance_classification = {"relevant": True, "irrelevant": False}.get(raw_response_text)
     return relevance_classification
diff --git a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
index a71a04cef8..9072a7143c 100644
--- a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"llama-index<=0.8.61\" \"openai<1\" \"langchain<=0.0.330\" gcsfs"
+    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>1\" \"langchain>=0.0.332\" gcsfs"
    ]
   },
   {
@@ -102,7 +102,6 @@
     "from getpass import getpass\n",
     "\n",
     "import numpy as np\n",
-    "import openai\n",
     "import pandas as pd\n",
     "import phoenix as px\n",
     "from gcsfs import GCSFileSystem\n",
@@ -143,8 +142,7 @@
    "source": [
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "openai.api_key = openai_api_key\n",
-    "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
+    "    os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
   {

From 2a764e1edb3110cb5519e2d5d28993d82642ab75 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 17:55:33 -0700
Subject: [PATCH 20/59] fix tutorials/llm_generative_gpt_4.ipynb

---
 tutorials/llm_generative_gpt_4.ipynb | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/tutorials/llm_generative_gpt_4.ipynb b/tutorials/llm_generative_gpt_4.ipynb
index 9c526312e0..873776c624 100644
--- a/tutorials/llm_generative_gpt_4.ipynb
+++ b/tutorials/llm_generative_gpt_4.ipynb
@@ -231,7 +231,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"openai<1\""
+    "!pip install \"openai>1\""
    ]
   },
   {
@@ -243,12 +243,9 @@
     "import getpass\n",
     "import os\n",
     "\n",
-    "import openai\n",
-    "\n",
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "    os.environ[\"OPENAI_API_KEY\"] = openai_api_key\n",
-    "openai.api_key = openai_api_key"
+    "    os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
    ]
   },
   {
@@ -260,6 +257,10 @@
     "import time\n",
     "import uuid\n",
     "\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
     "messages = []"
    ]
   },
@@ -301,7 +302,7 @@
     "            messages.append(\n",
     "                {\"role\": \"user\", \"content\": message},\n",
     "            )\n",
-    "            chat = openai.ChatCompletion.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
+    "            chat = client.chat.completions.create(model=\"gpt-3.5-turbo\", messages=messages)\n",
     "        end_time = time.time()\n",
     "        reply = chat.choices[0].message.content\n",
     "        data[\"prediction_id\"].append(str(uuid.uuid4())[:20])\n",
@@ -334,7 +335,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "conversations_df = conversations_df.reset_index(drop=True)"
+    "conversations_df = conversations_df.reset_index(drop=True)\n",
+    "conversations_df.head()"
    ]
   },
   {

From 36f1cdeb1e7e02cbf5d59c0e142e09214c99e808 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Wed, 8 Nov 2023 18:39:14 -0700
Subject: [PATCH 21/59] add more tutorials

---
 ...ain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb | 2 +-
 .../milvus_llamaindex_search_and_retrieval_tutorial.ipynb     | 4 ++--
 tutorials/ragas_retrieval_evals_tutorial.ipynb                | 2 +-
 tutorials/tracing/langchain_agent_tracing_tutorial.ipynb      | 2 +-
 .../tracing/llama_index_openai_agent_tracing_tutorial.ipynb   | 2 +-
 tutorials/tracing/llama_index_tracing_tutorial.ipynb          | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
index 996b49aad2..88aa0eca6b 100644
--- a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
+++ b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"langchain<=0.0.330\" \"openai<1\" chromadb tiktoken playwright asyncio nest_asyncio"
+    "!pip install \"arize-phoenix[experimental]\" \"langchain>=0.0.332\" \"openai>1\" chromadb tiktoken playwright asyncio nest_asyncio"
    ]
   },
   {
diff --git a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
index 9004a4576e..9792965555 100644
--- a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install gcsfs \"arize-phoenix[experimental]\" \"openai<1\""
+    "!pip install gcsfs \"arize-phoenix[experimental]\" \"openai>1\""
    ]
   },
   {
@@ -89,7 +89,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain<=0.0.330\" \"llama-index<=0.8.61\"\n",
+    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\"\n",
     "!pip install pymilvus==2.2.15\n",
     "!pip install --upgrade --force-reinstall grpcio==1.56.0"
    ]
diff --git a/tutorials/ragas_retrieval_evals_tutorial.ipynb b/tutorials/ragas_retrieval_evals_tutorial.ipynb
index 80d71fb010..b02d3612f9 100644
--- a/tutorials/ragas_retrieval_evals_tutorial.ipynb
+++ b/tutorials/ragas_retrieval_evals_tutorial.ipynb
@@ -79,7 +79,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain<=0.0.330\" \"llama-index<=0.8.61\" \"openai<1\" arize-phoenix gcsfs datasets ragas"
+    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\" \"openai>1\" arize-phoenix gcsfs datasets ragas"
    ]
   },
   {
diff --git a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
index 3408952ba6..be64cd50e2 100644
--- a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
@@ -41,7 +41,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain<=0.0.330\" \"openai<1\" numexpr arize-phoenix"
+    "!pip install \"langchain>=0.0.332\" \"openai>1\" numexpr arize-phoenix"
    ]
   },
   {
diff --git a/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb b/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
index d9c2cab1cc..f595a0e5d0 100644
--- a/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
+++ b/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"llama-index<=0.8.61\" \"openai<1\" arize-phoenix"
+    "!pip install \"llama-index==0.8.63.post2\" \"openai>1\" arize-phoenix"
    ]
   },
   {
diff --git a/tutorials/tracing/llama_index_tracing_tutorial.ipynb b/tutorials/tracing/llama_index_tracing_tutorial.ipynb
index 9d9850a7d9..7561cbde0b 100644
--- a/tutorials/tracing/llama_index_tracing_tutorial.ipynb
+++ b/tutorials/tracing/llama_index_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"llama-index>0.8.36\" \"openai<1\" gcsfs"
+    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>1\" gcsfs"
    ]
   },
   {

From 4e3f39abc05eabbd8e037fc1a10b41fccb7160c4 Mon Sep 17 00:00:00 2001
From: Dustin Ngo <dustin@arize.com>
Date: Thu, 9 Nov 2023 00:51:18 -0500
Subject: [PATCH 22/59] Start refactoring httpx tests to be order-agnostic

---
 .../evals/functions/test_classify.py          | 155 ++++++++++--------
 1 file changed, 84 insertions(+), 71 deletions(-)

diff --git a/tests/experimental/evals/functions/test_classify.py b/tests/experimental/evals/functions/test_classify.py
index e9c22d4bf0..e59d36ff05 100644
--- a/tests/experimental/evals/functions/test_classify.py
+++ b/tests/experimental/evals/functions/test_classify.py
@@ -16,13 +16,15 @@
 )
 from phoenix.experimental.evals.functions.classify import _snap_to_rail
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
+from respx.patterns import M
 
 response_labels = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
 expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
 
 
-def get_dataframe() -> (pd.DataFrame, list):
-    dataframe = pd.DataFrame(
+@pytest.fixture
+def classification_dataframe():
+    return pd.DataFrame(
         [
             {
                 "query": "What is Python?",
@@ -36,65 +38,72 @@ def get_dataframe() -> (pd.DataFrame, list):
             {"query": "What is C++?", "reference": "irrelevant"},
         ],
     )
-    index = list(reversed(range(len(dataframe))))
-    dataframe = dataframe.set_axis(index, axis=0)
-    return dataframe, index
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
-def test_llm_classify(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
+def test_llm_classify(
+    classification_dataframe, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = classification_dataframe
+    keys = list(zip(dataframe["query"], dataframe["reference"]))
+    responses = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "content": response,
+                    },
+                }
+            ],
+        }
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel()
 
-    def route_side_effect(request, route):
-        return httpx.Response(
-            200, json={"choices": [{"message": {"content": response_labels[route.call_count]}}]}
-        )
-
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
-
-    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
         model=model,
         rails=["relevant", "irrelevant"],
-        use_function_calling_if_available=False,
+        verbose=True,
     )
+
+    expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
     assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
         pd.DataFrame(
-            index=index,
             data={"label": expected_labels},
         ),
     )
-    del result
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
-def test_llm_classify_with_fn_call(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
+def test_llm_classify_with_fn_call(
+    classification_dataframe, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = classification_dataframe
+    keys = list(zip(dataframe["query"], dataframe["reference"]))
+    responses = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        response = {
+            "choices": [{"message": {"function_call": {"arguments": {"response": response}}}}]
+        }
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(max_retries=0)
 
-    def route_side_effect(request, route):
-        label = response_labels[route.call_count]
-        return httpx.Response(
-            200,
-            json={"choices": [{"message": {"function_call": {"arguments": {"response": label}}}}]},
-        )
-
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
-
-    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -102,28 +111,31 @@ def route_side_effect(request, route):
         rails=["relevant", "irrelevant"],
     )
 
+    expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
     assert result.iloc[:, 0].tolist() == expected_labels
-    assert_frame_equal(result, pd.DataFrame(index=index, data={"label": expected_labels}))
-    del result
+    assert_frame_equal(result, pd.DataFrame(data={"label": expected_labels}))
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
-def test_classify_fn_call_no_explain(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
+def test_classify_fn_call_no_explain(
+    classification_dataframe, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = classification_dataframe
+    keys = list(zip(dataframe["query"], dataframe["reference"]))
+    responses = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        response = {
+            "choices": [{"message": {"function_call": {"arguments": {"response": response}}}}]
+        }
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(max_retries=0)
 
-    def route_side_effect(request, route):
-        label = response_labels[route.call_count]
-        message = {"function_call": {"arguments": {"response": label}}}
-        return httpx.Response(201, json={"choices": [{"message": message}]})
-
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
-
-    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -131,37 +143,39 @@ def route_side_effect(request, route):
         rails=["relevant", "irrelevant"],
         provide_explanation=True,
     )
+
+    expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
     assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
-        pd.DataFrame(
-            index=index, data={"label": expected_labels, "explanation": [None, None, None, None]}
-        ),
+        pd.DataFrame(data={"label": expected_labels, "explanation": [None, None, None, None]}),
     )
-    del result
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
-def test_classify_fn_call_explain(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
+def test_classify_fn_call_explain(
+    classification_dataframe, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock
+):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = classification_dataframe
+    keys = list(zip(dataframe["query"], dataframe["reference"]))
+    responses = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+    response_mapping = {key: response for key, response in zip(keys, responses)}
 
-    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
-        model = OpenAIModel(max_retries=0)
-
-    def route_side_effect(request, route):
-        label = response_labels[route.call_count]
+    for ii, ((query, reference), response) in enumerate(response_mapping.items()):
+        matcher = M(content__contains=query) & M(content__contains=reference)
         message = {
             "function_call": {
-                "arguments": f"{{\n  \042response\042: \042{label}\042, \042explanation\042: \042{route.call_count}\042\n}}"  # noqa E501
+                "arguments": f"{{\n  \042response\042: \042{response}\042, \042explanation\042: \042{ii}\042\n}}"  # noqa E501
             }
         }
-        return httpx.Response(200, json={"choices": [{"message": message}]})
+        respx_mock.route(matcher).mock(
+            return_value=httpx.Response(200, json={"choices": [{"message": message}]})
+        )
 
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(max_retries=0)
 
-    dataframe, index = get_dataframe()
     result = llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -169,17 +183,16 @@ def route_side_effect(request, route):
         rails=["relevant", "irrelevant"],
         provide_explanation=True,
     )
+
+    expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
     assert result.iloc[:, 0].tolist() == expected_labels
     assert_frame_equal(
         result,
-        pd.DataFrame(
-            index=index, data={"label": expected_labels, "explanation": ["0", "1", "2", "3"]}
-        ),
+        pd.DataFrame(data={"label": expected_labels, "explanation": ["0", "1", "2", "3"]}),
     )
-    del result
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
 def test_llm_classify_prints_to_stdout_with_verbose_flag(
     monkeypatch: pytest.MonkeyPatch, capfd, respx_mock: respx.mock
 ):
@@ -343,7 +356,7 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
     assert "Request timed out" not in out, "The `verbose` flag should not be persisted"
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
 @pytest.mark.parametrize(
     "dataframe",
     [

From 75effa4b67e664dbd1e55b6f836dc9faa7ec68bc Mon Sep 17 00:00:00 2001
From: Dustin Ngo <dustin@arize.com>
Date: Thu, 9 Nov 2023 01:18:03 -0500
Subject: [PATCH 23/59] Finish refactoring classification tests

---
 .../evals/functions/test_classify.py          | 351 ++++++++++--------
 1 file changed, 206 insertions(+), 145 deletions(-)

diff --git a/tests/experimental/evals/functions/test_classify.py b/tests/experimental/evals/functions/test_classify.py
index e59d36ff05..a9225dada5 100644
--- a/tests/experimental/evals/functions/test_classify.py
+++ b/tests/experimental/evals/functions/test_classify.py
@@ -1,4 +1,5 @@
 from contextlib import ExitStack
+from itertools import product
 from unittest.mock import MagicMock, patch
 
 import httpx
@@ -18,9 +19,6 @@
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
 from respx.patterns import M
 
-response_labels = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
-expected_labels = ["relevant", "irrelevant", "relevant", NOT_PARSABLE]
-
 
 @pytest.fixture
 def classification_dataframe():
@@ -52,7 +50,7 @@ def test_llm_classify(
 
     for (query, reference), response in response_mapping.items():
         matcher = M(content__contains=query) & M(content__contains=reference)
-        response = {
+        payload = {
             "choices": [
                 {
                     "message": {
@@ -61,7 +59,7 @@ def test_llm_classify(
                 }
             ],
         }
-        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel()
@@ -96,10 +94,10 @@ def test_llm_classify_with_fn_call(
 
     for (query, reference), response in response_mapping.items():
         matcher = M(content__contains=query) & M(content__contains=reference)
-        response = {
+        payload = {
             "choices": [{"message": {"function_call": {"arguments": {"response": response}}}}]
         }
-        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(max_retries=0)
@@ -128,10 +126,10 @@ def test_classify_fn_call_no_explain(
 
     for (query, reference), response in response_mapping.items():
         matcher = M(content__contains=query) & M(content__contains=reference)
-        response = {
+        payload = {
             "choices": [{"message": {"function_call": {"arguments": {"response": response}}}}]
         }
-        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=response))
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(max_retries=0)
@@ -194,22 +192,22 @@ def test_classify_fn_call_explain(
 
 @pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
 def test_llm_classify_prints_to_stdout_with_verbose_flag(
-    monkeypatch: pytest.MonkeyPatch, capfd, respx_mock: respx.mock
+    classification_dataframe, monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock, capfd
 ):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = classification_dataframe
+    keys = list(zip(dataframe["query"], dataframe["reference"]))
+    responses = ["relevant", "irrelevant", "\nrelevant ", "unparsable"]
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        payload = {"choices": [{"message": {"content": response}}]}
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
 
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel(max_retries=0)
 
-    def route_side_effect(request, route):
-        label = response_labels[route.call_count]
-        return httpx.Response(200, json={"choices": [{"message": {"content": label}}]})
-
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
-
-    dataframe, index = get_dataframe()
     llm_classify(
         dataframe=dataframe,
         template=RAG_RELEVANCY_PROMPT_TEMPLATE_STR,
@@ -357,127 +355,71 @@ def test_llm_classify_does_not_persist_verbose_flag(monkeypatch: pytest.MonkeyPa
 
 
 @pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
-@pytest.mark.parametrize(
-    "dataframe",
-    [
-        pytest.param(
-            pd.DataFrame(
-                [
-                    {
-                        "attributes.input.value": "What is Python?",
-                        "attributes.retrieval.documents": [
-                            "Python is a programming language.",
-                            "Ruby is a programming language.",
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is Python?",
-                        "attributes.retrieval.documents": np.array(
-                            [
-                                "Python is a programming language.",
-                                "Ruby is a programming language.",
-                            ]
-                        ),
-                    },
-                    {
-                        "attributes.input.value": "What is Ruby?",
-                        "attributes.retrieval.documents": [
-                            "Ruby is a programming language.",
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is C++?",
-                        "attributes.retrieval.documents": [
-                            "Ruby is a programming language.",
-                            "C++ is a programming language.",
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is C#?",
-                        "attributes.retrieval.documents": [],
-                    },
-                    {
-                        "attributes.input.value": "What is Golang?",
-                        "attributes.retrieval.documents": None,
-                    },
-                    {
-                        "attributes.input.value": None,
-                        "attributes.retrieval.documents": [
-                            "Python is a programming language.",
-                            "Ruby is a programming language.",
-                        ],
-                    },
-                    {
-                        "attributes.input.value": None,
-                        "attributes.retrieval.documents": None,
-                    },
-                ]
-            ),
-            id="standard-dataframe",
-        ),
-        pytest.param(
-            pd.DataFrame(
-                [
-                    {
-                        "attributes.input.value": "What is Python?",
-                        "attributes.retrieval.documents": [
-                            {"document.content": "Python is a programming language."},
-                            {"document.content": "Ruby is a programming language."},
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is Python?",
-                        "attributes.retrieval.documents": np.array(
-                            [
-                                {"document.content": "Python is a programming language."},
-                                {"document.content": "Ruby is a programming language."},
-                            ]
-                        ),
-                    },
-                    {
-                        "attributes.input.value": "What is Ruby?",
-                        "attributes.retrieval.documents": [
-                            {"document.content": "Ruby is a programming language."},
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is C++?",
-                        "attributes.retrieval.documents": [
-                            {"document.content": "Ruby is a programming language."},
-                            {"document.content": "C++ is a programming language."},
-                        ],
-                    },
-                    {
-                        "attributes.input.value": "What is C#?",
-                        "attributes.retrieval.documents": [],
-                    },
-                    {
-                        "attributes.input.value": "What is Golang?",
-                        "attributes.retrieval.documents": None,
-                    },
-                    {
-                        "attributes.input.value": None,
-                        "attributes.retrieval.documents": [
-                            {"document.content": "Python is a programming language."},
-                            {"document.content": "Ruby is a programming language."},
-                        ],
-                    },
-                    {
-                        "attributes.input.value": None,
-                        "attributes.retrieval.documents": None,
-                    },
-                ]
-            ),
-            id="openinference-dataframe",
-        ),
-    ],
-)
-def test_run_relevance_eval(
+def test_run_relevance_eval_standard_dataframe(
     monkeypatch: pytest.MonkeyPatch,
-    dataframe: pd.DataFrame,
     respx_mock: respx.mock,
 ):
-    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    dataframe = pd.DataFrame(
+        [
+            {
+                "query": "What is Python?",
+                "reference": [
+                    "Python is a programming language.",
+                    "Ruby is a programming language.",
+                ],
+            },
+            {
+                "query": "Can you explain Python to me?",
+                "reference": np.array(
+                    [
+                        "Python is a programming language.",
+                        "Ruby is a programming language.",
+                    ]
+                ),
+            },
+            {
+                "query": "What is Ruby?",
+                "reference": [
+                    "Ruby is a programming language.",
+                ],
+            },
+            {
+                "query": "What is C++?",
+                "reference": [
+                    "Ruby is a programming language.",
+                    "C++ is a programming language.",
+                ],
+            },
+            {
+                "query": "What is C#?",
+                "reference": [],
+            },
+            {
+                "query": "What is Golang?",
+                "reference": None,
+            },
+            {
+                "query": None,
+                "reference": [
+                    "Python is a programming language.",
+                    "Ruby is a programming language.",
+                ],
+            },
+            {
+                "query": None,
+                "reference": None,
+            },
+        ]
+    )
+
+    queries = list(dataframe["query"])
+    references = list(dataframe["reference"])
+    keys = []
+    for query, refs in zip(queries, references):
+        refs = refs if refs is None else list(refs)
+        if query and refs:
+            keys.extend(product([query], refs))
+
     responses = [
         "relevant",
         "irrelevant",
@@ -488,18 +430,137 @@ def test_run_relevance_eval(
         "relevant",
     ]
 
-    def route_side_effect(request, route):
-        return httpx.Response(
-            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
-        )
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        payload = {
+            "choices": [
+                {
+                    "message": {
+                        "content": response,
+                    },
+                }
+            ],
+            "usage": {
+                "total_tokens": 1,
+            },
+        }
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
 
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(
-        side_effect=route_side_effect,
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel()
+
+    relevance_classifications = run_relevance_eval(dataframe, model=model)
+    assert relevance_classifications == [
+        ["relevant", "irrelevant"],
+        ["relevant", "irrelevant"],
+        ["relevant"],
+        [NOT_PARSABLE, "relevant"],
+        [],
+        [],
+        [],
+        [],
+    ]
+
+
+def test_run_relevance_eval_openinference_dataframe(
+    monkeypatch: pytest.MonkeyPatch,
+    respx_mock: respx.mock,
+):
+    dataframe = pd.DataFrame(
+        [
+            {
+                "attributes.input.value": "What is Python?",
+                "attributes.retrieval.documents": [
+                    {"document.content": "Python is a programming language."},
+                    {"document.content": "Ruby is a programming language."},
+                ],
+            },
+            {
+                "attributes.input.value": "Can you explain Python to me?",
+                "attributes.retrieval.documents": np.array(
+                    [
+                        {"document.content": "Python is a programming language."},
+                        {"document.content": "Ruby is a programming language."},
+                    ]
+                ),
+            },
+            {
+                "attributes.input.value": "What is Ruby?",
+                "attributes.retrieval.documents": [
+                    {"document.content": "Ruby is a programming language."},
+                ],
+            },
+            {
+                "attributes.input.value": "What is C++?",
+                "attributes.retrieval.documents": [
+                    {"document.content": "Ruby is a programming language."},
+                    {"document.content": "C++ is a programming language."},
+                ],
+            },
+            {
+                "attributes.input.value": "What is C#?",
+                "attributes.retrieval.documents": [],
+            },
+            {
+                "attributes.input.value": "What is Golang?",
+                "attributes.retrieval.documents": None,
+            },
+            {
+                "attributes.input.value": None,
+                "attributes.retrieval.documents": [
+                    {"document.content": "Python is a programming language."},
+                    {"document.content": "Ruby is a programming language."},
+                ],
+            },
+            {
+                "attributes.input.value": None,
+                "attributes.retrieval.documents": None,
+            },
+        ]
     )
+
+    queries = list(dataframe["attributes.input.value"])
+    references = list(dataframe["attributes.retrieval.documents"])
+    keys = []
+    for query, refs in zip(queries, references):
+        refs = refs if refs is None else list(refs)
+        if query and refs:
+            keys.extend(product([query], refs))
+    keys = [(query, ref["document.content"]) for query, ref in keys]
+
+    responses = [
+        "relevant",
+        "irrelevant",
+        "relevant",
+        "irrelevant",
+        "\nrelevant ",
+        "unparsable",
+        "relevant",
+    ]
+
+    response_mapping = {key: response for key, response in zip(keys, responses)}
+    for (query, reference), response in response_mapping.items():
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        payload = {
+            "choices": [
+                {
+                    "message": {
+                        "content": response,
+                    },
+                }
+            ],
+            "usage": {
+                "total_tokens": 1,
+            },
+        }
+        respx_mock.route(matcher).mock(return_value=httpx.Response(200, json=payload))
+
+    monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
         model = OpenAIModel()
+
     relevance_classifications = run_relevance_eval(dataframe, model=model)
     assert relevance_classifications == [
         ["relevant", "irrelevant"],

From 800c9489cb889553ae9318281b7b6e8c35a5a364 Mon Sep 17 00:00:00 2001
From: Dustin Ngo <dustin@arize.com>
Date: Thu, 9 Nov 2023 01:34:22 -0500
Subject: [PATCH 24/59] Refactor `generate` tests to be order-agnostic

---
 .../evals/functions/test_generate.py          | 32 +++++++++----------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/tests/experimental/evals/functions/test_generate.py b/tests/experimental/evals/functions/test_generate.py
index b540468733..9da3cf6549 100644
--- a/tests/experimental/evals/functions/test_generate.py
+++ b/tests/experimental/evals/functions/test_generate.py
@@ -6,9 +6,10 @@
 import respx
 from phoenix.experimental.evals import OpenAIModel, llm_generate
 from phoenix.experimental.evals.models.openai import OPENAI_API_KEY_ENVVAR_NAME
+from respx.patterns import M
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
 def test_llm_generate(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     dataframe = pd.DataFrame(
@@ -37,16 +38,14 @@ def test_llm_generate(monkeypatch: pytest.MonkeyPatch, respx_mock: respx.mock):
         "It's a crazy language",
         "it's a programming language",
     ]
-
-    def route_side_effect(request, route):
-        return httpx.Response(
-            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
+    queries = dataframe["query"].tolist()
+    references = dataframe["reference"].tolist()
+    for query, reference, response in zip(queries, references, responses):
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        respx_mock.route(matcher).mock(
+            return_value=httpx.Response(200, json={"choices": [{"message": {"content": response}}]})
         )
 
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
-
     template = (
         "Given {query} and a golden answer {reference}, generate an answer that is incorrect."
     )
@@ -63,7 +62,7 @@ def route_side_effect(request, route):
     ]
 
 
-@pytest.mark.respx(base_url="https://api.openai.com/v1")
+@pytest.mark.respx(base_url="https://api.openai.com/v1/chat/completions")
 def test_llm_generate_prints_info_with_verbose_flag(
     monkeypatch: pytest.MonkeyPatch, capfd, respx_mock: respx.mock
 ):
@@ -94,15 +93,14 @@ def test_llm_generate_prints_info_with_verbose_flag(
         "It's a crazy language",
         "it's a programming language",
     ]
-
-    def route_side_effect(request, route):
-        return httpx.Response(
-            200, json={"choices": [{"message": {"content": responses[route.call_count]}}]}
+    queries = dataframe["query"].tolist()
+    references = dataframe["reference"].tolist()
+    for query, reference, response in zip(queries, references, responses):
+        matcher = M(content__contains=query) & M(content__contains=reference)
+        respx_mock.route(matcher).mock(
+            return_value=httpx.Response(200, json={"choices": [{"message": {"content": response}}]})
         )
 
-    respx_mock.post(
-        "/chat/completions",
-    ).mock(side_effect=route_side_effect)
     template = (
         "Given {query} and a golden answer {reference}, generate an answer that is incorrect."
     )

From 8526d81981faf401e7d417dd74940cfb1959f5e4 Mon Sep 17 00:00:00 2001
From: Dustin Ngo <dustin@arize.com>
Date: Thu, 9 Nov 2023 01:49:13 -0500
Subject: [PATCH 25/59] Migrate to respx for langchain tracer tests

---
 tests/trace/langchain/test_tracer.py | 81 ++++++++++++++--------------
 1 file changed, 42 insertions(+), 39 deletions(-)

diff --git a/tests/trace/langchain/test_tracer.py b/tests/trace/langchain/test_tracer.py
index e4cff40b08..eed6e85b5a 100644
--- a/tests/trace/langchain/test_tracer.py
+++ b/tests/trace/langchain/test_tracer.py
@@ -2,9 +2,10 @@
 from typing import List
 from uuid import UUID
 
+import httpx
 import numpy as np
 import pytest
-import responses
+import respx
 from langchain.chains import RetrievalQA
 from langchain.chains.retrieval_qa.prompt import PROMPT as RETRIEVAL_QA_PROMPT
 from langchain.chat_models import ChatOpenAI
@@ -133,7 +134,7 @@ def test_tracer_llm() -> None:
         assert json_string_to_span(span_to_json(span)) == span
 
 
-@responses.activate
+@respx.mock
 @pytest.mark.parametrize(
     "messages",
     [
@@ -165,23 +166,24 @@ def test_tracer_llm_message_attributes_with_chat_completions_api(
     model_name = "gpt-4"
     llm = ChatOpenAI(model_name=model_name)
     expected_response = "response-text"
-    responses.post(
-        "https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-123",
-            "object": "chat.completion",
-            "created": 1677652288,
-            "model": model_name,
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {"role": "assistant", "content": expected_response},
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
-        },
-        status=200,
+    respx.post("https://api.openai.com/v1/chat/completions").mock(
+        return_value=httpx.Response(
+            status_code=200,
+            json={
+                "id": "chatcmpl-123",
+                "object": "chat.completion",
+                "created": 1677652288,
+                "model": model_name,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": expected_response},
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
+            },
+        )
     )
     response = llm(messages, callbacks=[tracer])
 
@@ -204,7 +206,7 @@ def test_tracer_llm_message_attributes_with_chat_completions_api(
     assert LLM_PROMPTS not in attributes
 
 
-@responses.activate
+@respx.mock
 def test_tracer_llm_prompt_attributes_with_completions_api(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setenv(OPENAI_API_KEY_ENVVAR_NAME, "sk-0123456789")
     tracer = OpenInferenceTracer(exporter=NoOpExporter())
@@ -218,25 +220,26 @@ def test_tracer_llm_prompt_attributes_with_completions_api(monkeypatch: pytest.M
         "prompt-1-response-1",
         "prompt-1-response-2",
     ]
-    responses.post(
-        "https://api.openai.com/v1/completions",
-        json={
-            "id": "cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7",
-            "object": "text_completion",
-            "created": 1589478378,
-            "model": model_name,
-            "choices": [
-                {
-                    "text": response_text,
-                    "index": index,
-                    "logprobs": None,
-                    "finish_reason": "stop",
-                }
-                for index, response_text in enumerate(expected_response_texts)
-            ],
-            "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
-        },
-        status=200,
+    respx.post("https://api.openai.com/v1/chat/completions").mock(
+        return_value=httpx.Response(
+            status_code=200,
+            json={
+                "id": "cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7",
+                "object": "text_completion",
+                "created": 1589478378,
+                "model": model_name,
+                "choices": [
+                    {
+                        "text": response_text,
+                        "index": index,
+                        "logprobs": None,
+                        "finish_reason": "stop",
+                    }
+                    for index, response_text in enumerate(expected_response_texts)
+                ],
+                "usage": {"prompt_tokens": 1, "completion_tokens": 2, "total_tokens": 3},
+            },
+        )
     )
     input_prompts = ["prompt-0", "prompt-1"]
     result = llm.generate(input_prompts, callbacks=[tracer])

From 8e137bb37cf9e04f863e581c1fadb9ae53ba9eda Mon Sep 17 00:00:00 2001
From: Dustin Ngo <dustin@arize.com>
Date: Thu, 9 Nov 2023 01:58:55 -0500
Subject: [PATCH 26/59] Update openai tracing tests to use respx

---
 tests/trace/langchain/test_tracer.py    |   4 +-
 tests/trace/openai/test_instrumentor.py | 251 ++++++++++++------------
 2 files changed, 131 insertions(+), 124 deletions(-)

diff --git a/tests/trace/langchain/test_tracer.py b/tests/trace/langchain/test_tracer.py
index eed6e85b5a..ed3c8dd402 100644
--- a/tests/trace/langchain/test_tracer.py
+++ b/tests/trace/langchain/test_tracer.py
@@ -166,7 +166,7 @@ def test_tracer_llm_message_attributes_with_chat_completions_api(
     model_name = "gpt-4"
     llm = ChatOpenAI(model_name=model_name)
     expected_response = "response-text"
-    respx.post("https://api.openai.com/v1/chat/completions").mock(
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
         return_value=httpx.Response(
             status_code=200,
             json={
@@ -220,7 +220,7 @@ def test_tracer_llm_prompt_attributes_with_completions_api(monkeypatch: pytest.M
         "prompt-1-response-1",
         "prompt-1-response-2",
     ]
-    respx.post("https://api.openai.com/v1/chat/completions").mock(
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
         return_value=httpx.Response(
             status_code=200,
             json={
diff --git a/tests/trace/openai/test_instrumentor.py b/tests/trace/openai/test_instrumentor.py
index 0c250571e3..36eff54151 100644
--- a/tests/trace/openai/test_instrumentor.py
+++ b/tests/trace/openai/test_instrumentor.py
@@ -3,7 +3,8 @@
 
 import openai
 import pytest
-import responses
+import respx
+from httpx import Response
 from openai import AuthenticationError, OpenAI
 from phoenix.trace.openai.instrumentor import OpenAIInstrumentor
 from phoenix.trace.schemas import SpanException, SpanKind, SpanStatusCode
@@ -50,7 +51,7 @@ def client(openai_api_key) -> OpenAI:
     return OpenAI(api_key=openai_api_key)
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     reload_openai_api_requestor, client
 ) -> None:
@@ -60,26 +61,27 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
     temperature = 0.23
     expected_response_text = "France won the World Cup in 2018."
-    responses.post(
-        url="https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-85eo7phshROhvmDvNeMVatGolg9JV",
-            "object": "chat.completion",
-            "created": 1696359195,
-            "model": "gpt-4-0613",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": expected_response_text,
-                    },
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 17, "completion_tokens": 10, "total_tokens": 27},
-        },
-        status=200,
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+        return_value=Response(
+            status_code=200,
+            json={
+                "id": "chatcmpl-85eo7phshROhvmDvNeMVatGolg9JV",
+                "object": "chat.completion",
+                "created": 1696359195,
+                "model": "gpt-4-0613",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": expected_response_text,
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 17, "completion_tokens": 10, "total_tokens": 27},
+            },
+        )
     )
     response = client.chat.completions.create(
         model=model, messages=messages, temperature=temperature
@@ -120,7 +122,7 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     assert attributes[OUTPUT_MIME_TYPE] == MimeType.JSON
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_includes_function_call_attributes(
     reload_openai_api_requestor, openai_api_key
 ) -> None:
@@ -147,30 +149,31 @@ def test_openai_instrumentor_includes_function_call_attributes(
         }
     ]
     model = "gpt-4"
-    responses.post(
-        url="https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-85eqK3CCNTHQcTN0ZoWqL5B0OO5ip",
-            "object": "chat.completion",
-            "created": 1696359332,
-            "model": "gpt-4-0613",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": None,
-                        "function_call": {
-                            "name": "get_current_weather",
-                            "arguments": '{\n  "location": "Boston, MA"\n}',
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+        return_value=Response(
+            status=200,
+            json={
+                "id": "chatcmpl-85eqK3CCNTHQcTN0ZoWqL5B0OO5ip",
+                "object": "chat.completion",
+                "created": 1696359332,
+                "model": "gpt-4-0613",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": None,
+                            "function_call": {
+                                "name": "get_current_weather",
+                                "arguments": '{\n  "location": "Boston, MA"\n}',
+                            },
                         },
-                    },
-                    "finish_reason": "function_call",
-                }
-            ],
-            "usage": {"prompt_tokens": 84, "completion_tokens": 18, "total_tokens": 102},
-        },
-        status=200,
+                        "finish_reason": "function_call",
+                    }
+                ],
+                "usage": {"prompt_tokens": 84, "completion_tokens": 18, "total_tokens": 102},
+            },
+        )
     )
     response = client.chat.completions.create(model=model, messages=messages, functions=functions)
 
@@ -210,7 +213,7 @@ def test_openai_instrumentor_includes_function_call_attributes(
     assert span.events == []
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_includes_function_call_message_attributes(
     reload_openai_api_requestor, client
 ) -> None:
@@ -250,29 +253,30 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
         }
     ]
     model = "gpt-4"
-    responses.post(
-        url="https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-85euCH0n5RuhAWEmogmak8cDwyQcb",
-            "object": "chat.completion",
-            "created": 1696359572,
-            "model": "gpt-4-0613",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": (
-                            "The current weather in Boston is sunny "
-                            "with a temperature of 22 degrees Celsius."
-                        ),
-                    },
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 126, "completion_tokens": 17, "total_tokens": 143},
-        },
-        status=200,
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+        return_value=Response(
+            status=200,
+            json={
+                "id": "chatcmpl-85euCH0n5RuhAWEmogmak8cDwyQcb",
+                "object": "chat.completion",
+                "created": 1696359572,
+                "model": "gpt-4-0613",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": (
+                                "The current weather in Boston is sunny "
+                                "with a temperature of 22 degrees Celsius."
+                            ),
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 126, "completion_tokens": 17, "total_tokens": 143},
+            },
+        )
     )
 
     response = client.chat.completions.create(model=model, messages=messages, functions=functions)
@@ -310,23 +314,24 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
     assert LLM_FUNCTION_CALL not in attributes
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_records_authentication_error(
     reload_openai_api_requestor, openai_api_key
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
-    responses.post(
-        "https://api.openai.com/v1/chat/completions",
-        json={
-            "error": {
-                "message": "error-message",
-                "type": "invalid_request_error",
-                "param": None,
-                "code": "invalid_api_key",
-            }
-        },
-        status=401,
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+        return_value=Response(
+            status=401,
+            json={
+                "error": {
+                    "message": "error-message",
+                    "type": "invalid_request_error",
+                    "param": None,
+                    "code": "invalid_api_key",
+                }
+            },
+        )
     )
     model = "gpt-4"
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
@@ -347,7 +352,7 @@ def test_openai_instrumentor_records_authentication_error(
     assert "Traceback" in attributes[EXCEPTION_STACKTRACE]
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_does_not_interfere_with_completions_api(
     reload_openai_api_requestor, client
 ) -> None:
@@ -355,24 +360,25 @@ def test_openai_instrumentor_does_not_interfere_with_completions_api(
     OpenAIInstrumentor(tracer).instrument()
     model = "gpt-3.5-turbo-instruct"
     prompt = "Who won the World Cup in 2018?"
-    responses.post(
-        url="https://api.openai.com/v1/completions",
-        json={
-            "id": "cmpl-85hqvKwCud3s3DWc80I0OeNmkfjSM",
-            "object": "text_completion",
-            "created": 1696370901,
-            "model": "gpt-3.5-turbo-instruct",
-            "choices": [
-                {
-                    "text": "\n\nFrance won the 2018 World Cup.",
-                    "index": 0,
-                    "logprobs": None,
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 10, "completion_tokens": 10, "total_tokens": 20},
-        },
-        status=200,
+    respx.post(url="https://api.openai.com/v1/completions").mock(
+        return_value=Response(
+            status=200,
+            json={
+                "id": "cmpl-85hqvKwCud3s3DWc80I0OeNmkfjSM",
+                "object": "text_completion",
+                "created": 1696370901,
+                "model": "gpt-3.5-turbo-instruct",
+                "choices": [
+                    {
+                        "text": "\n\nFrance won the 2018 World Cup.",
+                        "index": 0,
+                        "logprobs": None,
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 10, "completion_tokens": 10, "total_tokens": 20},
+            },
+        )
     )
     response = client.completions.create(model=model, prompt=prompt)
     response_text = response.choices[0]["text"]
@@ -382,7 +388,7 @@ def test_openai_instrumentor_does_not_interfere_with_completions_api(
     assert spans == []
 
 
-@responses.activate
+@respx.mock
 def test_openai_instrumentor_instrument_method_is_idempotent(
     reload_openai_api_requestor, openai_api_key
 ) -> None:
@@ -391,26 +397,27 @@ def test_openai_instrumentor_instrument_method_is_idempotent(
     OpenAIInstrumentor(tracer).instrument()  # second call
     model = "gpt-4"
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
-    responses.post(
-        url="https://api.openai.com/v1/chat/completions",
-        json={
-            "id": "chatcmpl-85evOVGg6afU8iqiUsRtYQ5lYnGwn",
-            "object": "chat.completion",
-            "created": 1696359646,
-            "model": "gpt-4-0613",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": "France won the World Cup in 2018.",
-                    },
-                    "finish_reason": "stop",
-                }
-            ],
-            "usage": {"prompt_tokens": 17, "completion_tokens": 10, "total_tokens": 27},
-        },
-        status=200,
+    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+        return_value=Response(
+            status=200,
+            json={
+                "id": "chatcmpl-85evOVGg6afU8iqiUsRtYQ5lYnGwn",
+                "object": "chat.completion",
+                "created": 1696359646,
+                "model": "gpt-4-0613",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": "France won the World Cup in 2018.",
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+                "usage": {"prompt_tokens": 17, "completion_tokens": 10, "total_tokens": 27},
+            },
+        )
     )
     response = client.chat.completions.create(model=model, messages=messages)
     response_text = response.choices[0]["message"]["content"]

From 01385480b7fbbda6352b6aa22627062152c2f313 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 13:28:51 -0700
Subject: [PATCH 27/59] feat(evals): azure openai support

---
 cspell.json                                   |   1 +
 .../experimental/evals/models/openai.py       | 117 ++++++++++++------
 .../experimental/evals/models/test_openai.py  |  33 +++++
 3 files changed, 114 insertions(+), 37 deletions(-)

diff --git a/cspell.json b/cspell.json
index 3ead771e62..d3daa1a306 100644
--- a/cspell.json
+++ b/cspell.json
@@ -23,6 +23,7 @@
         "RERANKER",
         "respx",
         "rgba",
+        "tiktoken",
         "tracedataset",
         "UMAP"
     ],
diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 71b2fcf0b2..2bf7751fc7 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -1,7 +1,7 @@
 import logging
 import os
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
 
 from phoenix.experimental.evals.models.base import BaseEvalModel
 
@@ -24,16 +24,44 @@
 logger = logging.getLogger(__name__)
 
 
+AZURE_REQUIRED_OPTIONS = ["api_version", "azure_endpoint"]
+AZURE_ADDITIONAL_OPTIONS = [
+    "azure_endpoint",
+    "azure_deployment",
+    "azure_ad_token",
+    "azure_ad_token_provider",
+]
+
+
+@dataclass
+class AzureOptions:
+    api_version: str
+    azure_endpoint: str
+    azure_deployment: Optional[str]
+    azure_ad_token: Optional[str]
+    azure_ad_token_provider: Optional[Callable[[], str]]
+
+
 @dataclass
 class OpenAIModel(BaseEvalModel):
-    openai_api_type: Optional[str] = field(default=None)
-    openai_api_version: Optional[str] = field(default=None)
-    openai_api_key: Optional[str] = field(repr=False, default=None)
-    openai_organization: Optional[str] = field(repr=False, default=None)
-    engine: str = ""
-    """Azure engine (the Deployment Name of your model)"""
+    # openai_api_type: Optional[str] = field(default=None)
+    api_key: Optional[str] = field(repr=False, default=None)
+    """Your OpenAI key. If not provided, will be read from the environment variable"""
+    organization: Optional[str] = field(repr=False, default=None)
+    """
+    The organization to use for the OpenAI API. If not provided, will default
+    to what's configured in OpenAI
+    """
+    # Azure options
+    api_version: Optional[str] = field(default=None)
+    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning"""
+    azure_endpoint: Optional[str] = field(default=None)
+    """https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource"""
+    azure_deployment: Optional[str] = field(default=None)
+    azure_ad_token: Optional[str] = field(default=None)
+    azure_ad_token_provider: Optional[Callable[[], str]] = field(default=None)
     model_name: str = "gpt-4"
-    """Model name to use."""
+    """Model name to use. In of azure, this is the deployment name such as gpt-35-instant"""
     temperature: float = 0.0
     """What sampling temperature to use."""
     max_tokens: int = 256
@@ -90,33 +118,46 @@ def _init_environment(self) -> None:
             )
 
     def _init_open_ai(self) -> None:
+        # For Azure, you need to provide the azure_endpoint
+        self._is_azure = self.azure_endpoint is not None
+
         self._model_uses_legacy_completion_api = self.model_name.startswith(
             LEGACY_COMPLETION_API_MODELS
         )
-        if self.openai_api_key is None:
+        if self.api_key is None:
             api_key = os.getenv(OPENAI_API_KEY_ENVVAR_NAME)
             if api_key is None:
                 # TODO: Create custom AuthenticationError
                 raise RuntimeError(
-                    "OpenAI's API key not provided. Pass it as an argument to 'openai_api_key' "
+                    "OpenAI's API key not provided. Pass it as an argument to 'api_key' "
                     "or set it in your environment: 'export OPENAI_API_KEY=sk-****'"
                 )
-            self.openai_api_key = api_key
-        self._client = self._openai.Client(api_key=self.openai_api_key)
-        self.openai_api_type = self.openai_api_type or self._openai.api_type
-        self.openai_api_version = self.openai_api_version or self._openai.api_version
-        self.openai_organization = self.openai_organization or self._openai.organization
-
-        self._is_azure = (self._openai.api_type or "").lower().startswith("azure")
+            self.api_key = api_key
 
+        self.api_version = self.api_version or self._openai.api_version
+        self.organization = self.organization or self._openai.organization
+        # Initialize specific clients depending on the API backend
+        # Set the type first
+        self._client: Union[self._openai.OpenAI, self._openai.AzureOpenAI]  # type: ignore
         if self._is_azure:
-            if not self.engine:
-                raise ValueError(
-                    "You must provide the deployment name in the 'engine' parameter "
-                    "to access the Azure OpenAI service"
-                )
-            self._openai_api_model_name = self.engine
-        elif self.model_name in MODEL_TOKEN_LIMIT_MAPPING.keys():
+            # Validate the azure options and construct a client
+            azure_options = self._get_azure_options()
+            self._client = self._openai.AzureOpenAI(
+                azure_endpoint=azure_options.azure_endpoint,
+                azure_deployment=azure_options.azure_deployment,
+                api_version=azure_options.api_version,
+                azure_ad_token=azure_options.azure_ad_token,
+                azure_ad_token_provider=azure_options.azure_ad_token_provider,
+                api_key=self.api_key,
+                organization=self.organization,
+            )
+        else:
+            self._client = self._openai.OpenAI(
+                api_key=self.api_key,
+                organization=self.organization,
+            )
+
+        if self.model_name in MODEL_TOKEN_LIMIT_MAPPING.keys():
             self._openai_api_model_name = self.model_name
         elif "gpt-3.5-turbo" in self.model_name:
             self._openai_api_model_name = "gpt-3.5-turbo-0613"
@@ -135,6 +176,18 @@ def _init_tiktoken(self) -> None:
             encoding = self._tiktoken.get_encoding("cl100k_base")
         self._tiktoken_encoding = encoding
 
+    def _get_azure_options(self) -> AzureOptions:
+        options = {}
+        for option in AZURE_REQUIRED_OPTIONS:
+            value = getattr(self, option)
+            if value is None:
+                raise ValueError(f"Option '{option}' must be set when using Azure OpenAI API")
+            options[option] = value
+        for option in AZURE_ADDITIONAL_OPTIONS:
+            value = getattr(self, option)
+            options[option] = value
+        return AzureOptions(**options)
+
     @staticmethod
     def _build_messages(
         prompt: str, system_instruction: Optional[str] = None
@@ -217,7 +270,7 @@ def max_context_size(self) -> int:
     @property
     def public_invocation_params(self) -> Dict[str, Any]:
         return {
-            **({"engine": self.engine} if self._is_azure else {"model": self.model_name}),
+            **({"model": self.model_name}),
             **self._default_params,
             **self.model_kwargs,
         }
@@ -228,16 +281,6 @@ def invocation_params(self) -> Dict[str, Any]:
             **self.public_invocation_params,
         }
 
-    @property
-    def _credentials(self) -> Dict[str, Any]:
-        """Get the default parameters for calling OpenAI API."""
-        return {
-            "api_key": self.openai_api_key,
-            "api_type": self.openai_api_type,
-            "api_version": self.openai_api_version,
-            "organization": self.openai_organization,
-        }
-
     @property
     def _default_params(self) -> Dict[str, Any]:
         """Get the default parameters for calling OpenAI API."""
@@ -293,10 +336,10 @@ def get_text_from_tokens(self, tokens: List[int]) -> str:
     def supports_function_calling(self) -> bool:
         if (
             self._is_azure
-            and self.openai_api_version
+            and self.api_version
             # The first api version supporting function calling is 2023-07-01-preview.
             # See https://github.com/Azure/azure-rest-api-specs/blob/58e92dd03733bc175e6a9540f4bc53703b57fcc9/specification/cognitiveservices/data-plane/AzureOpenAI/inference/preview/2023-07-01-preview/inference.json#L895 # noqa E501
-            and self.openai_api_version[:10] < "2023-07-01"
+            and self.api_version[:10] < "2023-07-01"
         ):
             return False
         if self._model_uses_legacy_completion_api:
diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
index 38bb87d247..900cad9766 100644
--- a/tests/experimental/evals/models/test_openai.py
+++ b/tests/experimental/evals/models/test_openai.py
@@ -1,5 +1,7 @@
 from unittest.mock import patch
 
+import pytest
+from openai import AzureOpenAI, OpenAI
 from phoenix.experimental.evals.models.openai import OpenAIModel
 
 
@@ -13,3 +15,34 @@ def test_openai_model():
         model = OpenAIModel(model_name="gpt-4-1106-preview")
 
     assert model.model_name == "gpt-4-1106-preview"
+    assert isinstance(model._client, OpenAI)
+
+
+def test_azure_openai_model():
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(
+            model_name="gpt-4-1106-preview",
+            api_version="2023-07-01-preview",
+            azure_endpoint="https://example-endpoint.openai.azure.com",
+        )
+    assert isinstance(model._client, AzureOpenAI)
+
+
+def test_azure_fails_when_missing_options():
+    # Test missing api_version
+    with pytest.raises(
+        ValueError, match="Option 'api_version' must be set when using Azure OpenAI"
+    ):
+        OpenAIModel(
+            model_name="gpt-4-1106-preview",
+            azure_endpoint="https://example-endpoint.openai.azure.com",
+        )
+
+    # Test missing azure_endpoint
+    with pytest.raises(
+        ValueError, match="Option 'azure_endpoint' must be set when using Azure OpenAI"
+    ):
+        OpenAIModel(
+            model_name="gpt-4-1106-preview",
+            api_version="2023-07-01-preview",
+        )

From 98110bca2f4cda1c75f23d963b6d642cbf746c29 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 15:09:26 -0700
Subject: [PATCH 28/59] address pr comments

---
 .../experimental/evals/models/openai.py       | 35 ++++++++++++-------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 2bf7751fc7..858fcd3a7d 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -26,7 +26,6 @@
 
 AZURE_REQUIRED_OPTIONS = ["api_version", "azure_endpoint"]
 AZURE_ADDITIONAL_OPTIONS = [
-    "azure_endpoint",
     "azure_deployment",
     "azure_ad_token",
     "azure_ad_token_provider",
@@ -44,7 +43,6 @@ class AzureOptions:
 
 @dataclass
 class OpenAIModel(BaseEvalModel):
-    # openai_api_type: Optional[str] = field(default=None)
     api_key: Optional[str] = field(repr=False, default=None)
     """Your OpenAI key. If not provided, will be read from the environment variable"""
     organization: Optional[str] = field(repr=False, default=None)
@@ -52,14 +50,11 @@ class OpenAIModel(BaseEvalModel):
     The organization to use for the OpenAI API. If not provided, will default
     to what's configured in OpenAI
     """
-    # Azure options
-    api_version: Optional[str] = field(default=None)
-    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning"""
-    azure_endpoint: Optional[str] = field(default=None)
-    """https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource"""
-    azure_deployment: Optional[str] = field(default=None)
-    azure_ad_token: Optional[str] = field(default=None)
-    azure_ad_token_provider: Optional[Callable[[], str]] = field(default=None)
+    base_url: Optional[str] = field(repr=False, default=None)
+    """
+    An optional base URL to use for the OpenAI API. If not provided, will default
+    to what's configured in OpenAI
+    """
     model_name: str = "gpt-4"
     """Model name to use. In of azure, this is the deployment name such as gpt-35-instant"""
     temperature: float = 0.0
@@ -90,6 +85,19 @@ class OpenAIModel(BaseEvalModel):
     retry_max_seconds: int = 60
     """Maximum number of seconds to wait when retrying."""
 
+    # Azure options
+    api_version: Optional[str] = field(default=None)
+    """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning"""
+    azure_endpoint: Optional[str] = field(default=None)
+    """
+    The endpoint to use for the OpenAI API.
+    Note, this field is required when using Azure OpenAI API.
+    https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
+    """
+    azure_deployment: Optional[str] = field(default=None)
+    azure_ad_token: Optional[str] = field(default=None)
+    azure_ad_token_provider: Optional[Callable[[], str]] = field(default=None)
+
     def __post_init__(self) -> None:
         self._init_environment()
         self._init_open_ai()
@@ -118,8 +126,8 @@ def _init_environment(self) -> None:
             )
 
     def _init_open_ai(self) -> None:
-        # For Azure, you need to provide the azure_endpoint
-        self._is_azure = self.azure_endpoint is not None
+        # For Azure, you need to provide the endpoint and the endpoint
+        self._is_azure = bool(self.azure_endpoint)
 
         self._model_uses_legacy_completion_api = self.model_name.startswith(
             LEGACY_COMPLETION_API_MODELS
@@ -134,8 +142,10 @@ def _init_open_ai(self) -> None:
                 )
             self.api_key = api_key
 
+        # Set the version, organization, and base_url - default to openAI
         self.api_version = self.api_version or self._openai.api_version
         self.organization = self.organization or self._openai.organization
+
         # Initialize specific clients depending on the API backend
         # Set the type first
         self._client: Union[self._openai.OpenAI, self._openai.AzureOpenAI]  # type: ignore
@@ -155,6 +165,7 @@ def _init_open_ai(self) -> None:
             self._client = self._openai.OpenAI(
                 api_key=self.api_key,
                 organization=self.organization,
+                base_url=(self.base_url or self._openai.base_url),
             )
 
         if self.model_name in MODEL_TOKEN_LIMIT_MAPPING.keys():

From 9feca67a9090af811640bffd3b97a03b49b4c2e7 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 15:20:56 -0700
Subject: [PATCH 29/59] return early  for azure

---
 src/phoenix/experimental/evals/models/openai.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 858fcd3a7d..5d39f2d799 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -161,12 +161,15 @@ def _init_open_ai(self) -> None:
                 api_key=self.api_key,
                 organization=self.organization,
             )
-        else:
-            self._client = self._openai.OpenAI(
-                api_key=self.api_key,
-                organization=self.organization,
-                base_url=(self.base_url or self._openai.base_url),
-            )
+            # return early since we don't need to check the model
+            return
+
+        # The client is not azure, so it must be openai
+        self._client = self._openai.OpenAI(
+            api_key=self.api_key,
+            organization=self.organization,
+            base_url=(self.base_url or self._openai.base_url),
+        )
 
         if self.model_name in MODEL_TOKEN_LIMIT_MAPPING.keys():
             self._openai_api_model_name = self.model_name

From 063e6def2887b8a995d9cdc8e4a82630eb66b06a Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 16:25:08 -0700
Subject: [PATCH 30/59] fix tiktoken failures

---
 .../experimental/evals/models/openai.py       | 63 +++++++++----------
 .../experimental/evals/models/test_openai.py  | 21 +++++--
 2 files changed, 46 insertions(+), 38 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 5d39f2d799..002592e0e7 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -1,7 +1,18 @@
 import logging
 import os
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+from dataclasses import dataclass, field, fields
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+)
 
 from phoenix.experimental.evals.models.base import BaseEvalModel
 
@@ -24,14 +35,6 @@
 logger = logging.getLogger(__name__)
 
 
-AZURE_REQUIRED_OPTIONS = ["api_version", "azure_endpoint"]
-AZURE_ADDITIONAL_OPTIONS = [
-    "azure_deployment",
-    "azure_ad_token",
-    "azure_ad_token_provider",
-]
-
-
 @dataclass
 class AzureOptions:
     api_version: str
@@ -90,8 +93,7 @@ class OpenAIModel(BaseEvalModel):
     """https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning"""
     azure_endpoint: Optional[str] = field(default=None)
     """
-    The endpoint to use for the OpenAI API.
-    Note, this field is required when using Azure OpenAI API.
+    The endpoint to use for azure openai. Available in the azure portal.
     https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
     """
     azure_deployment: Optional[str] = field(default=None)
@@ -171,20 +173,9 @@ def _init_open_ai(self) -> None:
             base_url=(self.base_url or self._openai.base_url),
         )
 
-        if self.model_name in MODEL_TOKEN_LIMIT_MAPPING.keys():
-            self._openai_api_model_name = self.model_name
-        elif "gpt-3.5-turbo" in self.model_name:
-            self._openai_api_model_name = "gpt-3.5-turbo-0613"
-        elif "gpt-4" in self.model_name:
-            self._openai_api_model_name = "gpt-4-0613"
-        else:
-            raise NotImplementedError(
-                f"openai_api_model_name not available for model {self.model_name}. "
-            )
-
     def _init_tiktoken(self) -> None:
         try:
-            encoding = self._tiktoken.encoding_for_model(self.openai_api_model_name)
+            encoding = self._tiktoken.encoding_for_model(self.model_name)
         except KeyError:
             logger.warning("Warning: model not found. Using cl100k_base encoding.")
             encoding = self._tiktoken.get_encoding("cl100k_base")
@@ -192,14 +183,20 @@ def _init_tiktoken(self) -> None:
 
     def _get_azure_options(self) -> AzureOptions:
         options = {}
-        for option in AZURE_REQUIRED_OPTIONS:
-            value = getattr(self, option)
-            if value is None:
-                raise ValueError(f"Option '{option}' must be set when using Azure OpenAI API")
-            options[option] = value
-        for option in AZURE_ADDITIONAL_OPTIONS:
-            value = getattr(self, option)
-            options[option] = value
+        for option in fields(AzureOptions):
+            if (value := getattr(self, option.name)) is not None:
+                options[option.name] = value
+            else:
+                # raise ValueError if field is not optional
+                # See if the field is optional - e.g. get_origin(Optional[T])  = typing.Union
+                option_is_optional = get_origin(option.type) is Union and type(None) in get_args(
+                    option.type
+                )
+                if not option_is_optional:
+                    raise ValueError(
+                        f"Option '{option.name}' must be set when using Azure OpenAI API"
+                    )
+                options[option.name] = None
         return AzureOptions(**options)
 
     @staticmethod
@@ -265,7 +262,7 @@ def _completion_with_retry(**kwargs: Any) -> Any:
 
     @property
     def max_context_size(self) -> int:
-        model_name = self.openai_api_model_name
+        model_name = self.model_name
         # handling finetuned models
         if "ft-" in model_name:
             model_name = self.model_name.split(":")[0]
diff --git a/tests/experimental/evals/models/test_openai.py b/tests/experimental/evals/models/test_openai.py
index 900cad9766..967765ca3d 100644
--- a/tests/experimental/evals/models/test_openai.py
+++ b/tests/experimental/evals/models/test_openai.py
@@ -38,11 +38,22 @@ def test_azure_fails_when_missing_options():
             azure_endpoint="https://example-endpoint.openai.azure.com",
         )
 
-    # Test missing azure_endpoint
-    with pytest.raises(
-        ValueError, match="Option 'azure_endpoint' must be set when using Azure OpenAI"
-    ):
-        OpenAIModel(
+
+def test_azure_supports_function_calling():
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(
             model_name="gpt-4-1106-preview",
             api_version="2023-07-01-preview",
+            azure_endpoint="https://example-endpoint.openai.azure.com",
         )
+    assert isinstance(model._client, AzureOpenAI)
+    assert model.supports_function_calling is True
+
+    with patch.object(OpenAIModel, "_init_tiktoken", return_value=None):
+        model = OpenAIModel(
+            model_name="gpt-4-1106-preview",
+            api_version="2023-06-01-preview",
+            azure_endpoint="https://example-endpoint.openai.azure.com",
+        )
+    assert isinstance(model._client, AzureOpenAI)
+    assert model.supports_function_calling is False

From da18411b39ba56e5dad9e6b79912d7a984ba2a27 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 16:33:36 -0700
Subject: [PATCH 31/59] remove model name aliasing

---
 src/phoenix/experimental/evals/models/openai.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 002592e0e7..d701468532 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -305,10 +305,6 @@ def _default_params(self) -> Dict[str, Any]:
             "timeout": self.request_timeout,
         }
 
-    @property
-    def openai_api_model_name(self) -> str:
-        return self._openai_api_model_name
-
     @property
     def encoder(self) -> "Encoding":
         return self._tiktoken_encoding
@@ -318,7 +314,7 @@ def get_token_count_from_messages(self, messages: List[Dict[str, str]]) -> int:
 
         Official documentation: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb
         """  # noqa
-        model_name = self.openai_api_model_name
+        model_name = self.model_name
         if model_name == "gpt-3.5-turbo-0301":
             tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
             tokens_per_name = -1  # if there's a name, the role is omitted

From 7a08e91eda26d98d1f8d49b3e74f11102065900c Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 17:12:37 -0700
Subject: [PATCH 32/59] make gpt-4 point to latest

---
 src/phoenix/experimental/evals/models/openai.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index d701468532..7cb5c83324 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -266,6 +266,9 @@ def max_context_size(self) -> int:
         # handling finetuned models
         if "ft-" in model_name:
             model_name = self.model_name.split(":")[0]
+        if model_name == "gpt-4":
+            # Map gpt-4 to the current default
+            model_name = "gpt-4-0613"
 
         context_size = MODEL_TOKEN_LIMIT_MAPPING.get(model_name, None)
 

From 097532cc7bedfd31776d8505d9b3a92ce6073cdd Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 18:10:12 -0700
Subject: [PATCH 33/59] ruff format

---
 .../evals/evaluate_code_readability_classifications.ipynb | 8 ++++++--
 .../evals/evaluate_hallucination_classifications.ipynb    | 4 +++-
 tutorials/evals/evaluate_relevance_classifications.ipynb  | 4 +++-
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/tutorials/evals/evaluate_code_readability_classifications.ipynb b/tutorials/evals/evaluate_code_readability_classifications.ipynb
index 6baeadf7bf..17ade2ff26 100644
--- a/tutorials/evals/evaluate_code_readability_classifications.ipynb
+++ b/tutorials/evals/evaluate_code_readability_classifications.ipynb
@@ -759,7 +759,9 @@
    ],
    "source": [
     "# Let's view the data\n",
-    "merged_df = pd.merge(small_df_sample, readability_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df = pd.merge(\n",
+    "    small_df_sample, readability_classifications_df, left_index=True, right_index=True\n",
+    ")\n",
     "merged_df[[\"query\", \"code\", \"label\", \"explanation\"]].head()"
    ]
   },
@@ -800,7 +802,9 @@
     "readability_classifications = llm_classify(\n",
     "    dataframe=df,\n",
     "    template=CODE_READABILITY_PROMPT_TEMPLATE_STR,\n",
-    "    model=OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20, max_retries=0),\n",
+    "    model=OpenAIModel(\n",
+    "        model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20, max_retries=0\n",
+    "    ),\n",
     "    rails=rails,\n",
     ")[\"label\"]"
    ]
diff --git a/tutorials/evals/evaluate_hallucination_classifications.ipynb b/tutorials/evals/evaluate_hallucination_classifications.ipynb
index c898c25407..fca1206364 100644
--- a/tutorials/evals/evaluate_hallucination_classifications.ipynb
+++ b/tutorials/evals/evaluate_hallucination_classifications.ipynb
@@ -620,7 +620,9 @@
    ],
    "source": [
     "# Let's view the data\n",
-    "merged_df = pd.merge(small_df_sample, hallucination_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df = pd.merge(\n",
+    "    small_df_sample, hallucination_classifications_df, left_index=True, right_index=True\n",
+    ")\n",
     "merged_df[[\"query\", \"reference\", \"response\", \"is_hallucination\", \"label\", \"explanation\"]].head()"
    ]
   },
diff --git a/tutorials/evals/evaluate_relevance_classifications.ipynb b/tutorials/evals/evaluate_relevance_classifications.ipynb
index 84756c141c..33a50339ed 100644
--- a/tutorials/evals/evaluate_relevance_classifications.ipynb
+++ b/tutorials/evals/evaluate_relevance_classifications.ipynb
@@ -645,7 +645,9 @@
    ],
    "source": [
     "# Let's view the data\n",
-    "merged_df = pd.merge(small_df_sample, relevance_classifications_df, left_index=True, right_index=True)\n",
+    "merged_df = pd.merge(\n",
+    "    small_df_sample, relevance_classifications_df, left_index=True, right_index=True\n",
+    ")\n",
     "merged_df[[\"query\", \"reference\", \"label\", \"explanation\"]].head()"
    ]
   },

From 5c7d3276fc9f27da9f19d9aa397a8a52ea68ab6d Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Thu, 9 Nov 2023 18:25:25 -0700
Subject: [PATCH 34/59] docs: update documentation

---
 docs/api/evaluation-models.md | 89 +++++++++++++++++++++++++----------
 1 file changed, 65 insertions(+), 24 deletions(-)

diff --git a/docs/api/evaluation-models.md b/docs/api/evaluation-models.md
index 7bcb976ecb..caa8f9fb99 100644
--- a/docs/api/evaluation-models.md
+++ b/docs/api/evaluation-models.md
@@ -16,32 +16,51 @@ Need to install the extra dependencies `openai>=0.26.4` and `tiktoken`
 
 ```python
 class OpenAIModel:
-    openai_api_key: Optional[str] = None
-    openai_api_base: Optional[str] = None
-    openai_api_type: Optional[str] = None
-    openai_api_version: Optional[str] = None
-    openai_organization: Optional[str] = None
-    engine: str = ""
+    api_key: Optional[str] = field(repr=False, default=None)
+    """Your OpenAI key. If not provided, will be read from the environment variable"""
+    organization: Optional[str] = field(repr=False, default=None)
+    """
+    The organization to use for the OpenAI API. If not provided, will default
+    to what's configured in OpenAI
+    """
+    base_url: Optional[str] = field(repr=False, default=None)
+    """
+    An optional base URL to use for the OpenAI API. If not provided, will default
+    to what's configured in OpenAI
+    """
     model_name: str = "gpt-4"
+    """Model name to use. In of azure, this is the deployment name such as gpt-35-instant"""
     temperature: float = 0.0
+    """What sampling temperature to use."""
     max_tokens: int = 256
+    """The maximum number of tokens to generate in the completion.
+    -1 returns as many tokens as possible given the prompt and
+    the models maximal context size."""
     top_p: float = 1
+    """Total probability mass of tokens to consider at each step."""
     frequency_penalty: float = 0
+    """Penalizes repeated tokens according to frequency."""
     presence_penalty: float = 0
+    """Penalizes repeated tokens."""
     n: int = 1
-    model_kwargs: Dict[str, Any] = {}
-    batch_size: int = 20
+    """How many completions to generate for each prompt."""
+    model_kwargs: Dict[str, Any] = field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not explicitly specified."""
     request_timeout: Optional[Union[float, Tuple[float, float]]] = None
-    max_retries: int = 6
+    """Timeout for requests to OpenAI completion API. Default is 600 seconds."""
+    max_retries: int = 20
+    """Maximum number of retries to make when generating."""
     retry_min_seconds: int = 10
+    """Minimum number of seconds to wait when retrying."""
     retry_max_seconds: int = 60
+    """Maximum number of seconds to wait when retrying."""
 ```
 
-To authenticate with OpenAI you will need, at a minimum, an API key. Our classes will look for it in your environment, or you can pass it via argument as shown above. In addition, you can choose the specific name of the model you want to use and its configuration parameters. The default values specified above are common default values from OpenAI. Quickly instantiate your model as follows:
+To authenticate with OpenAI you will need, at a minimum, an API key. The model class will look for it in your environment, or you can pass it via argument as shown above. In addition, you can choose the specific name of the model you want to use and its configuration parameters. The default values specified above are common default values from OpenAI. Quickly instantiate your model as follows:
 
 ```python
 model = OpenAI()
-model("Hello there, this is a tesst if you are working?")
+model("Hello there, this is a test if you are working?")
 # Output: "Hello! I'm working perfectly. How can I assist you today?"
 ```
 
@@ -49,16 +68,38 @@ model("Hello there, this is a tesst if you are working?")
 
 The code snippet below shows how to initialize `OpenAIModel` for Azure. Refer to the Azure [docs](https://microsoftlearning.github.io/mslearn-openai/Instructions/Labs/02-natural-language-azure-openai.html) on how to obtain these value from your Azure deployment.
 
+Here is an example of how to initialize `OpenAIModel` for Azure:
+
 ```python
 model = OpenAIModel(
-    openai_api_key=YOUR_AZURE_OPENAI_API_KEY,
-    openai_api_base="https://YOUR_RESOURCE_NAME.openai.azure.com",
-    openai_api_type="azure",
-    openai_api_version="2023-05-15",  # See Azure docs for more
-    engine="YOUR_MODEL_DEPLOYMENT_NAME",
+    model = OpenAIModel(
+    model_name="gpt-4-32k",
+    azure_endpoint="https://YOUR_SUBDOMAIN.openai.azure.com/",
+    api_version="2023-03-15-preview"
 )
 ```
 
+Azure OpenAI supports specific options:
+
+```python
+api_version: str = field(default=None)
+"""
+The verion of the API that is provisioned
+https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#rest-api-versioning
+"""
+azure_endpoint: Optional[str] = field(default=None)
+"""
+The endpoint to use for azure openai. Available in the azure portal.
+https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
+"""
+azure_deployment: Optional[str] = field(default=None)
+azure_ad_token: Optional[str] = field(default=None)
+azure_ad_token_provider: Optional[Callable[[], str]] = field(default=None)
+
+```
+
+For full details on Azure OpenAI, check out the [OpenAI Documentation](https://github.com/openai/openai-python#microsoft-azure-openai)
+
 Find more about the functionality available in our EvalModels in the [#usage](evaluation-models.md#usage "mention") section.
 
 ### phoenix.experimental.evals.VertexAI
@@ -95,7 +136,7 @@ model("Hello there, this is a tesst if you are working?")
 ### phoenix.experimental.evals.BedrockModel
 
 ```python
-class BedrockModel:    
+class BedrockModel:
     model_id: str = "anthropic.claude-v2"
     """The model name to use."""
     temperature: float = 0.0
@@ -219,15 +260,15 @@ responses = await model.agenerate(
 )
 print(responses)
 # Output: [
-#     "As an artificial intelligence, I don't have feelings, but I'm here and ready 
+#     "As an artificial intelligence, I don't have feelings, but I'm here and ready
 #         to assist you. How can I help you today?",
-#     "The Mediterranean region is known for its hot, dry summers and mild, wet 
+#     "The Mediterranean region is known for its hot, dry summers and mild, wet
 #         winters. This climate is characterized by warm temperatures throughout the
-#         year, with the highest temperatures usually occurring in July and August. 
-#         Rainfall is scarce during the summer months but more frequent during the 
-#         winter months. The region also experiences a lot of sunshine, with some 
+#         year, with the highest temperatures usually occurring in July and August.
+#         Rainfall is scarce during the summer months but more frequent during the
+#         winter months. The region also experiences a lot of sunshine, with some
 #         areas receiving about 300 sunny days per year.",
-#     "You're welcome! Don't hesitate to reach out if you need anything else. 
+#     "You're welcome! Don't hesitate to reach out if you need anything else.
 #         Goodbye!"
 #    ]
 ```
@@ -252,7 +293,7 @@ print(text)
 
 ### `model.max_context_size`
 
-Furthermore, LLM models have a limited number of tokens that they can pay attention to. We call this limit the _context size_ or _context window_. You can access the context size of your model via the  property `max_context_size`. In the following example, we used the model `gpt-4-0613` and the context size is
+Furthermore, LLM models have a limited number of tokens that they can pay attention to. We call this limit the _context size_ or _context window_. You can access the context size of your model via the property `max_context_size`. In the following example, we used the model `gpt-4-0613` and the context size is
 
 ```python
 print(model.max_context_size)

From 3ae48377683316473aacbd3070dd4c3616dddbaf Mon Sep 17 00:00:00 2001
From: Xander Song <axiomofjoy@gmail.com>
Date: Thu, 9 Nov 2023 21:01:36 -0800
Subject: [PATCH 35/59] feat: update OpenAIInstrumentor to support
 openai>=1.0.0 and deprecate support for openai<1.0.0 (#1723)

---
 src/phoenix/trace/openai/instrumentor.py      | 89 ++++++++++--------
 tests/trace/openai/test_instrumentor.py       | 92 +++++++++++--------
 .../tracing/openai_tracing_tutorial.ipynb     | 23 +++--
 3 files changed, 115 insertions(+), 89 deletions(-)

diff --git a/src/phoenix/trace/openai/instrumentor.py b/src/phoenix/trace/openai/instrumentor.py
index 9a812a7dee..b4661b05a4 100644
--- a/src/phoenix/trace/openai/instrumentor.py
+++ b/src/phoenix/trace/openai/instrumentor.py
@@ -10,9 +10,10 @@
     List,
     Mapping,
     Optional,
-    cast,
 )
 
+from typing_extensions import TypeGuard
+
 from phoenix.trace.schemas import (
     SpanAttributes,
     SpanEvent,
@@ -44,7 +45,7 @@
 from ..tracer import Tracer
 
 if TYPE_CHECKING:
-    from openai.openai_response import OpenAIResponse
+    from openai.types.chat import ChatCompletion
 
 
 Parameters = Mapping[str, Any]
@@ -75,21 +76,21 @@ def instrument(self) -> None:
         """
         openai = import_package("openai")
         is_instrumented = hasattr(
-            openai.api_requestor.APIRequestor.request,
+            openai.OpenAI,
             INSTRUMENTED_ATTRIBUTE_NAME,
         )
         if not is_instrumented:
-            openai.api_requestor.APIRequestor.request = _wrap_openai_api_requestor(
-                openai.api_requestor.APIRequestor.request, self._tracer
+            openai.OpenAI.request = _wrapped_openai_client_request_function(
+                openai.OpenAI.request, self._tracer
             )
             setattr(
-                openai.api_requestor.APIRequestor.request,
+                openai.OpenAI,
                 INSTRUMENTED_ATTRIBUTE_NAME,
                 True,
             )
 
 
-def _wrap_openai_api_requestor(
+def _wrapped_openai_client_request_function(
     request_fn: Callable[..., Any], tracer: Tracer
 ) -> Callable[..., Any]:
     """Wraps the OpenAI APIRequestor.request method to create spans for each API call.
@@ -105,9 +106,10 @@ def _wrap_openai_api_requestor(
     def wrapped(*args: Any, **kwargs: Any) -> Any:
         call_signature = signature(request_fn)
         bound_arguments = call_signature.bind(*args, **kwargs)
-        parameters = bound_arguments.arguments["params"]
-        is_streaming = parameters.get("stream", False)
-        url = bound_arguments.arguments["url"]
+        is_streaming = bound_arguments.arguments["stream"]
+        options = bound_arguments.arguments["options"]
+        parameters = options.json_data
+        url = options.url
         current_status_code = SpanStatusCode.UNSET
         events: List[SpanEvent] = []
         attributes: SpanAttributes = dict()
@@ -118,13 +120,13 @@ def wrapped(*args: Any, **kwargs: Any) -> Any:
             ) in _PARAMETER_ATTRIBUTE_FUNCTIONS.items():
                 if (attribute_value := get_parameter_attribute_fn(parameters)) is not None:
                     attributes[attribute_name] = attribute_value
-            outputs = None
+            response = None
             try:
                 start_time = datetime.now()
-                outputs = request_fn(*args, **kwargs)
+                response = request_fn(*args, **kwargs)
                 end_time = datetime.now()
                 current_status_code = SpanStatusCode.OK
-                return outputs
+                return response
             except Exception as error:
                 end_time = datetime.now()
                 current_status_code = SpanStatusCode.ERROR
@@ -138,16 +140,17 @@ def wrapped(*args: Any, **kwargs: Any) -> Any:
                 )
                 raise
             finally:
-                if outputs:
-                    response = outputs[0]
+                if _is_chat_completion(response):
                     for (
                         attribute_name,
-                        get_response_attribute_fn,
-                    ) in _RESPONSE_ATTRIBUTE_FUNCTIONS.items():
-                        if (attribute_value := get_response_attribute_fn(response)) is not None:
+                        get_chat_completion_attribute_fn,
+                    ) in _CHAT_COMPLETION_ATTRIBUTE_FUNCTIONS.items():
+                        if (
+                            attribute_value := get_chat_completion_attribute_fn(response)
+                        ) is not None:
                             attributes[attribute_name] = attribute_value
                 tracer.create_span(
-                    name="openai.ChatCompletion.create",
+                    name="OpenAI Chat Completion",
                     span_kind=SpanKind.LLM,
                     start_time=start_time,
                     end_time=end_time,
@@ -182,48 +185,46 @@ def _llm_invocation_parameters(
     return json.dumps(parameters)
 
 
-def _output_value(response: "OpenAIResponse") -> str:
-    return json.dumps(response.data)
+def _output_value(chat_completion: "ChatCompletion") -> str:
+    return chat_completion.json()
 
 
 def _output_mime_type(_: Any) -> MimeType:
     return MimeType.JSON
 
 
-def _llm_output_messages(response: "OpenAIResponse") -> List[OpenInferenceMessage]:
+def _llm_output_messages(chat_completion: "ChatCompletion") -> List[OpenInferenceMessage]:
     return [
-        _to_openinference_message(choice["message"], expects_name=False)
-        for choice in response.data["choices"]
+        _to_openinference_message(choice.message.dict(), expects_name=False)
+        for choice in chat_completion.choices
     ]
 
 
-def _llm_token_count_prompt(response: "OpenAIResponse") -> Optional[int]:
-    if token_usage := response.data.get("usage"):
-        return cast(int, token_usage["prompt_tokens"])
+def _llm_token_count_prompt(chat_completion: "ChatCompletion") -> Optional[int]:
+    if completion_usage := chat_completion.usage:
+        return completion_usage.prompt_tokens
     return None
 
 
-def _llm_token_count_completion(response: "OpenAIResponse") -> Optional[int]:
-    if token_usage := response.data.get("usage"):
-        return cast(int, token_usage["completion_tokens"])
+def _llm_token_count_completion(chat_completion: "ChatCompletion") -> Optional[int]:
+    if completion_usage := chat_completion.usage:
+        return completion_usage.completion_tokens
     return None
 
 
-def _llm_token_count_total(response: "OpenAIResponse") -> Optional[int]:
-    if token_usage := response.data.get("usage"):
-        return cast(int, token_usage["total_tokens"])
+def _llm_token_count_total(chat_completion: "ChatCompletion") -> Optional[int]:
+    if completion_usage := chat_completion.usage:
+        return completion_usage.total_tokens
     return None
 
 
 def _llm_function_call(
-    response: "OpenAIResponse",
+    chat_completion: "ChatCompletion",
 ) -> Optional[str]:
-    choices = response.data["choices"]
+    choices = chat_completion.choices
     choice = choices[0]
-    if choice.get("finish_reason") == "function_call" and (
-        function_call_data := choice["message"].get("function_call")
-    ):
-        return json.dumps(function_call_data)
+    if choice.finish_reason == "function_call" and (function_call := choice.message.function_call):
+        return function_call.json()
     return None
 
 
@@ -274,7 +275,7 @@ def _to_openinference_message(
     LLM_INPUT_MESSAGES: _llm_input_messages,
     LLM_INVOCATION_PARAMETERS: _llm_invocation_parameters,
 }
-_RESPONSE_ATTRIBUTE_FUNCTIONS: Dict[str, Callable[["OpenAIResponse"], Any]] = {
+_CHAT_COMPLETION_ATTRIBUTE_FUNCTIONS: Dict[str, Callable[["ChatCompletion"], Any]] = {
     OUTPUT_VALUE: _output_value,
     OUTPUT_MIME_TYPE: _output_mime_type,
     LLM_OUTPUT_MESSAGES: _llm_output_messages,
@@ -283,3 +284,11 @@ def _to_openinference_message(
     LLM_TOKEN_COUNT_TOTAL: _llm_token_count_total,
     LLM_FUNCTION_CALL: _llm_function_call,
 }
+
+
+def _is_chat_completion(response: Any) -> TypeGuard["ChatCompletion"]:
+    """
+    Type guard for ChatCompletion.
+    """
+    openai = import_package("openai")
+    return isinstance(response, openai.types.chat.ChatCompletion)
diff --git a/tests/trace/openai/test_instrumentor.py b/tests/trace/openai/test_instrumentor.py
index 36eff54151..e18b0e0959 100644
--- a/tests/trace/openai/test_instrumentor.py
+++ b/tests/trace/openai/test_instrumentor.py
@@ -1,9 +1,10 @@
 import json
+import sys
 from importlib import reload
+from types import ModuleType
 
 import openai
 import pytest
-import respx
 from httpx import Response
 from openai import AuthenticationError, OpenAI
 from phoenix.trace.openai.instrumentor import OpenAIInstrumentor
@@ -31,29 +32,43 @@
     MimeType,
 )
 from phoenix.trace.tracer import Tracer
+from respx import MockRouter
 
 
 @pytest.fixture
-def reload_openai_api_requestor() -> None:
-    """Reloads openai.api_requestor to reset the instrumented class method."""
-    reload(openai.api_requestor)
+def openai_module() -> ModuleType:
+    """
+    Reloads openai module to reset patched class. Both the top-level module and
+    the sub-module containing the patched client class must be reloaded.
+    """
+    # Cannot be reloaded with reload(openai._client) due to a naming conflict with a variable.
+    reload(sys.modules["openai._client"])
+    return reload(openai)
 
 
 @pytest.fixture
-def openai_api_key(monkeypatch) -> None:
+def openai_api_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    """
+    Monkeypatches the environment variable for the OpenAI API key.
+    """
     api_key = "sk-0123456789"
     monkeypatch.setenv("OPENAI_API_KEY", api_key)
     return api_key
 
 
 @pytest.fixture
-def client(openai_api_key) -> OpenAI:
-    return OpenAI(api_key=openai_api_key)
+def client(openai_api_key: str, openai_module: ModuleType) -> OpenAI:
+    """
+    Instantiates the OpenAI client using the reloaded openai module, which is
+    necessary when running multiple tests at once due to the patch applied by
+    the OpenAIInstrumentor.
+    """
+    return openai_module.OpenAI(api_key=openai_api_key)
 
 
-@respx.mock
 def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
-    reload_openai_api_requestor, client
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -61,7 +76,7 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
     temperature = 0.23
     expected_response_text = "France won the World Cup in 2018."
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/chat/completions").mock(
         return_value=Response(
             status_code=200,
             json={
@@ -86,7 +101,7 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     response = client.chat.completions.create(
         model=model, messages=messages, temperature=temperature
     )
-    response_text = response.choices[0]["message"]["content"]
+    response_text = response.choices[0].message.content
 
     assert response_text == expected_response_text
 
@@ -122,9 +137,9 @@ def test_openai_instrumentor_includes_llm_attributes_on_chat_completion_success(
     assert attributes[OUTPUT_MIME_TYPE] == MimeType.JSON
 
 
-@respx.mock
 def test_openai_instrumentor_includes_function_call_attributes(
-    reload_openai_api_requestor, openai_api_key
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -149,9 +164,9 @@ def test_openai_instrumentor_includes_function_call_attributes(
         }
     ]
     model = "gpt-4"
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/chat/completions").mock(
         return_value=Response(
-            status=200,
+            status_code=200,
             json={
                 "id": "chatcmpl-85eqK3CCNTHQcTN0ZoWqL5B0OO5ip",
                 "object": "chat.completion",
@@ -177,10 +192,9 @@ def test_openai_instrumentor_includes_function_call_attributes(
     )
     response = client.chat.completions.create(model=model, messages=messages, functions=functions)
 
-    function_call_data = response.choices[0]["message"]["function_call"]
-    assert set(function_call_data.keys()) == {"name", "arguments"}
-    assert function_call_data["name"] == "get_current_weather"
-    assert json.loads(function_call_data["arguments"]) == {"location": "Boston, MA"}
+    function_call = response.choices[0].message.function_call
+    assert function_call.name == "get_current_weather"
+    assert json.loads(function_call.arguments) == {"location": "Boston, MA"}
 
     spans = list(tracer.get_spans())
     assert len(spans) == 1
@@ -213,9 +227,9 @@ def test_openai_instrumentor_includes_function_call_attributes(
     assert span.events == []
 
 
-@respx.mock
 def test_openai_instrumentor_includes_function_call_message_attributes(
-    reload_openai_api_requestor, client
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
@@ -253,9 +267,9 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
         }
     ]
     model = "gpt-4"
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/chat/completions").mock(
         return_value=Response(
-            status=200,
+            status_code=200,
             json={
                 "id": "chatcmpl-85euCH0n5RuhAWEmogmak8cDwyQcb",
                 "object": "chat.completion",
@@ -280,7 +294,7 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
     )
 
     response = client.chat.completions.create(model=model, messages=messages, functions=functions)
-    response_text = response.choices[0]["message"]["content"]
+    response_text = response.choices[0].message.content
     spans = list(tracer.get_spans())
     span = spans[0]
     attributes = span.attributes
@@ -314,15 +328,15 @@ def test_openai_instrumentor_includes_function_call_message_attributes(
     assert LLM_FUNCTION_CALL not in attributes
 
 
-@respx.mock
 def test_openai_instrumentor_records_authentication_error(
-    reload_openai_api_requestor, openai_api_key
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/chat/completions").mock(
         return_value=Response(
-            status=401,
+            status_code=401,
             json={
                 "error": {
                     "message": "error-message",
@@ -348,21 +362,21 @@ def test_openai_instrumentor_records_authentication_error(
     assert isinstance(event, SpanException)
     attributes = event.attributes
     assert attributes[EXCEPTION_TYPE] == "AuthenticationError"
-    assert attributes[EXCEPTION_MESSAGE] == "error-message"
+    assert "error-message" in attributes[EXCEPTION_MESSAGE]
     assert "Traceback" in attributes[EXCEPTION_STACKTRACE]
 
 
-@respx.mock
 def test_openai_instrumentor_does_not_interfere_with_completions_api(
-    reload_openai_api_requestor, client
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()
     model = "gpt-3.5-turbo-instruct"
     prompt = "Who won the World Cup in 2018?"
-    respx.post(url="https://api.openai.com/v1/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/completions").mock(
         return_value=Response(
-            status=200,
+            status_code=200,
             json={
                 "id": "cmpl-85hqvKwCud3s3DWc80I0OeNmkfjSM",
                 "object": "text_completion",
@@ -381,25 +395,25 @@ def test_openai_instrumentor_does_not_interfere_with_completions_api(
         )
     )
     response = client.completions.create(model=model, prompt=prompt)
-    response_text = response.choices[0]["text"]
+    response_text = response.choices[0].text
     spans = list(tracer.get_spans())
 
     assert "france" in response_text.lower() or "french" in response_text.lower()
     assert spans == []
 
 
-@respx.mock
 def test_openai_instrumentor_instrument_method_is_idempotent(
-    reload_openai_api_requestor, openai_api_key
+    client: OpenAI,
+    respx_mock: MockRouter,
 ) -> None:
     tracer = Tracer()
     OpenAIInstrumentor(tracer).instrument()  # first call
     OpenAIInstrumentor(tracer).instrument()  # second call
     model = "gpt-4"
     messages = [{"role": "user", "content": "Who won the World Cup in 2018?"}]
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx_mock.post("https://api.openai.com/v1/chat/completions").mock(
         return_value=Response(
-            status=200,
+            status_code=200,
             json={
                 "id": "chatcmpl-85evOVGg6afU8iqiUsRtYQ5lYnGwn",
                 "object": "chat.completion",
@@ -420,7 +434,7 @@ def test_openai_instrumentor_instrument_method_is_idempotent(
         )
     )
     response = client.chat.completions.create(model=model, messages=messages)
-    response_text = response.choices[0]["message"]["content"]
+    response_text = response.choices[0].message.content
     spans = list(tracer.get_spans())
     span = spans[0]
 
diff --git a/tutorials/tracing/openai_tracing_tutorial.ipynb b/tutorials/tracing/openai_tracing_tutorial.ipynb
index c12e2365e4..53849d4bed 100644
--- a/tutorials/tracing/openai_tracing_tutorial.ipynb
+++ b/tutorials/tracing/openai_tracing_tutorial.ipynb
@@ -50,7 +50,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"openai<1\" arize-phoenix jsonschema"
+    "!pip install \"openai>=1.0.0\" arize-phoenix jsonschema"
    ]
   },
   {
@@ -72,9 +72,9 @@
     "from typing import Any, Dict, Literal, TypedDict\n",
     "\n",
     "import jsonschema\n",
-    "import openai\n",
     "import pandas as pd\n",
     "import phoenix as px\n",
+    "from openai import OpenAI\n",
     "from phoenix.trace.exporter import HttpExporter\n",
     "from phoenix.trace.openai import OpenAIInstrumentor\n",
     "from phoenix.trace.tracer import Tracer\n",
@@ -91,7 +91,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 2. Configure Your OpenAI API Key\n",
+    "## 2. Configure Your OpenAI API Key and Instantiate Your OpenAI Client\n",
     "\n",
     "Set your OpenAI API key if it is not already set as an environment variable."
    ]
@@ -104,8 +104,7 @@
    "source": [
     "if not (openai_api_key := os.getenv(\"OPENAI_API_KEY\")):\n",
     "    openai_api_key = getpass(\"🔑 Enter your OpenAI API key: \")\n",
-    "openai.api_key = openai_api_key\n",
-    "os.environ[\"OPENAI_API_KEY\"] = openai_api_key"
+    "client = OpenAI(api_key=openai_api_key)"
    ]
   },
   {
@@ -225,9 +224,13 @@
     "\n",
     "@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))\n",
     "def extract_raw_travel_request_attributes_string(\n",
-    "    travel_request: str, function_schema: Dict[str, Any], system_message: str, model: str = \"gpt-4\"\n",
+    "    travel_request: str,\n",
+    "    function_schema: Dict[str, Any],\n",
+    "    system_message: str,\n",
+    "    client: OpenAI,\n",
+    "    model: str = \"gpt-4\",\n",
     ") -> str:\n",
-    "    response = openai.ChatCompletion.create(\n",
+    "    chat_completion = client.chat.completions.create(\n",
     "        model=model,\n",
     "        messages=[\n",
     "            {\"role\": \"system\", \"content\": system_message},\n",
@@ -238,8 +241,8 @@
     "        # The line below forces the LLM to call the function so that the output conforms to the schema.\n",
     "        function_call={\"name\": function_schema[\"name\"]},\n",
     "    )\n",
-    "    function_call_data = response[\"choices\"][0][\"message\"][\"function_call\"]\n",
-    "    return function_call_data[\"arguments\"]"
+    "    function_call = chat_completion.choices[0].message.function_call\n",
+    "    return function_call.arguments"
    ]
   },
   {
@@ -262,7 +265,7 @@
     "    print(travel_request)\n",
     "    print()\n",
     "    raw_travel_attributes = extract_raw_travel_request_attributes_string(\n",
-    "        travel_request, function_schema, system_message\n",
+    "        travel_request, function_schema, system_message, client\n",
     "    )\n",
     "    raw_travel_attributes_column.append(raw_travel_attributes)\n",
     "    print(\"Raw Travel Attributes:\")\n",

From 1bdb58705598cca5a09d2d396b97b99abae9f373 Mon Sep 17 00:00:00 2001
From: Xander Song <axiomofjoy@gmail.com>
Date: Thu, 9 Nov 2023 22:16:54 -0800
Subject: [PATCH 36/59] correct unit test to mock completions endpoint (#1730)

---
 tests/trace/langchain/test_tracer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/trace/langchain/test_tracer.py b/tests/trace/langchain/test_tracer.py
index ed3c8dd402..e60cc05b18 100644
--- a/tests/trace/langchain/test_tracer.py
+++ b/tests/trace/langchain/test_tracer.py
@@ -220,7 +220,7 @@ def test_tracer_llm_prompt_attributes_with_completions_api(monkeypatch: pytest.M
         "prompt-1-response-1",
         "prompt-1-response-2",
     ]
-    respx.post(url="https://api.openai.com/v1/chat/completions").mock(
+    respx.post(url="https://api.openai.com/v1/completions").mock(
         return_value=httpx.Response(
             status_code=200,
             json={

From 6f8ae91e8c217f3742bd50f257dc1a3cd6f2cafb Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:37:52 -0700
Subject: [PATCH 37/59] Update
 langchain_pinecone_search_and_retrieval_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 .../langchain_pinecone_search_and_retrieval_tutorial.ipynb      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
index 853dab9143..ef1308da7c 100644
--- a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
@@ -83,7 +83,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>1\" arize-phoenix pinecone-client"
+    "!pip install \"langchain>=0.0.332\" \"openai>=1\" arize-phoenix pinecone-client"
    ]
   },
   {

From 5328688785ad25fdfcfa4029081c2c1a012d3546 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:02 -0700
Subject: [PATCH 38/59] Update llama_index_search_and_retrieval_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/llama_index_search_and_retrieval_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
index 9072a7143c..3268aeefe8 100644
--- a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>1\" \"langchain>=0.0.332\" gcsfs"
+    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>=1\" \"langchain>=0.0.332\" gcsfs"
    ]
   },
   {

From 9cfa308262cf6784b7214a7cf0a4b4a9e4a07da4 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:10 -0700
Subject: [PATCH 39/59] Update llm_generative_gpt_4.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/llm_generative_gpt_4.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/llm_generative_gpt_4.ipynb b/tutorials/llm_generative_gpt_4.ipynb
index 873776c624..1d3195c008 100644
--- a/tutorials/llm_generative_gpt_4.ipynb
+++ b/tutorials/llm_generative_gpt_4.ipynb
@@ -231,7 +231,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"openai>1\""
+    "!pip install \"openai>=1\""
    ]
   },
   {

From 8ba258da9e53d4f34d9114c10fd3c9f19c9c64bf Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:19 -0700
Subject: [PATCH 40/59] Update
 milvus_llamaindex_search_and_retrieval_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
index 9792965555..dc5fcfc408 100644
--- a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install gcsfs \"arize-phoenix[experimental]\" \"openai>1\""
+    "!pip install gcsfs \"arize-phoenix[experimental]\" \"openai>=1\""
    ]
   },
   {

From de98e67a0922e207d55fc1fc634a3707c2d61a82 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:31 -0700
Subject: [PATCH 41/59] Update ragas_retrieval_evals_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/ragas_retrieval_evals_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/ragas_retrieval_evals_tutorial.ipynb b/tutorials/ragas_retrieval_evals_tutorial.ipynb
index b02d3612f9..87cd0d57fe 100644
--- a/tutorials/ragas_retrieval_evals_tutorial.ipynb
+++ b/tutorials/ragas_retrieval_evals_tutorial.ipynb
@@ -79,7 +79,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\" \"openai>1\" arize-phoenix gcsfs datasets ragas"
+    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\" \"openai>=1\" arize-phoenix gcsfs datasets ragas"
    ]
   },
   {

From e9de0a9029df8665009c83f5fe41deb32760ceea Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:40 -0700
Subject: [PATCH 42/59] Update langchain_agent_tracing_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/tracing/langchain_agent_tracing_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
index be64cd50e2..170f112cfd 100644
--- a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
@@ -41,7 +41,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>1\" numexpr arize-phoenix"
+    "!pip install \"langchain>=0.0.332\" \"openai>=1\" numexpr arize-phoenix"
    ]
   },
   {

From 4e59ba90f485ee4c402426a8adf0a47957fefe27 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:47 -0700
Subject: [PATCH 43/59] Update langchain_tracing_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/tracing/langchain_tracing_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/tracing/langchain_tracing_tutorial.ipynb b/tutorials/tracing/langchain_tracing_tutorial.ipynb
index 95ceb3f000..25b00bed51 100644
--- a/tutorials/tracing/langchain_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>1\" arize-phoenix tiktoken"
+    "!pip install \"langchain>=0.0.332\" \"openai>=1\" arize-phoenix tiktoken"
    ]
   },
   {

From 31cd16b6d361c5bac6d8f215daf8c85c8168911d Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:38:54 -0700
Subject: [PATCH 44/59] Update llama_index_openai_agent_tracing_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 .../tracing/llama_index_openai_agent_tracing_tutorial.ipynb     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb b/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
index f595a0e5d0..cfc9d8ae4b 100644
--- a/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
+++ b/tutorials/tracing/llama_index_openai_agent_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"llama-index==0.8.63.post2\" \"openai>1\" arize-phoenix"
+    "!pip install \"llama-index==0.8.63.post2\" \"openai>=1\" arize-phoenix"
    ]
   },
   {

From 0730ade13661964c08eafb2b02ef74a15edfbf57 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:01 -0700
Subject: [PATCH 45/59] Update llama_index_tracing_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/tracing/llama_index_tracing_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/tracing/llama_index_tracing_tutorial.ipynb b/tutorials/tracing/llama_index_tracing_tutorial.ipynb
index 7561cbde0b..66ea1eeca5 100644
--- a/tutorials/tracing/llama_index_tracing_tutorial.ipynb
+++ b/tutorials/tracing/llama_index_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>1\" gcsfs"
+    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>=1\" gcsfs"
    ]
   },
   {

From 4d6847fd6a8c25f607b841dd47c83bc4af1ae925 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:08 -0700
Subject: [PATCH 46/59] Update
 langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 ...chain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
index 88aa0eca6b..b3b384e672 100644
--- a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
+++ b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"langchain>=0.0.332\" \"openai>1\" chromadb tiktoken playwright asyncio nest_asyncio"
+    "!pip install \"arize-phoenix[experimental]\" \"langchain>=0.0.332\" \"openai>=1\" chromadb tiktoken playwright asyncio nest_asyncio"
    ]
   },
   {

From 2ea9ccc578490c40491fd07c05fafc1bf83d51e6 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:15 -0700
Subject: [PATCH 47/59] Update find_cluster_export_and_explore_with_gpt.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/find_cluster_export_and_explore_with_gpt.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/find_cluster_export_and_explore_with_gpt.ipynb b/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
index aadae4fcff..df95a57700 100644
--- a/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
+++ b/tutorials/find_cluster_export_and_explore_with_gpt.ipynb
@@ -31,7 +31,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"openai>1\" ipywidgets pandas"
+    "!pip install -qq \"openai>=1\" ipywidgets pandas"
    ]
   },
   {

From c6383220ba67817cf97b75920c85bda78dd6f4a1 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:21 -0700
Subject: [PATCH 48/59] Update evaluate_toxicity_classifications.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/evals/evaluate_toxicity_classifications.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/evals/evaluate_toxicity_classifications.ipynb b/tutorials/evals/evaluate_toxicity_classifications.ipynb
index 8e482d400c..b6ccf6c67a 100644
--- a/tutorials/evals/evaluate_toxicity_classifications.ipynb
+++ b/tutorials/evals/evaluate_toxicity_classifications.ipynb
@@ -54,7 +54,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From a57cf864190728342e3d04eeda578da01acd3678 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:27 -0700
Subject: [PATCH 49/59] Update evaluate_summarization_classifications.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/evals/evaluate_summarization_classifications.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/evals/evaluate_summarization_classifications.ipynb b/tutorials/evals/evaluate_summarization_classifications.ipynb
index 5facef600c..8f77ca136e 100644
--- a/tutorials/evals/evaluate_summarization_classifications.ipynb
+++ b/tutorials/evals/evaluate_summarization_classifications.ipynb
@@ -47,7 +47,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From 729f269eb520763320c8194876e17855c362a22b Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:35 -0700
Subject: [PATCH 50/59] Update evaluate_QA_classifications.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/evals/evaluate_QA_classifications.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/evals/evaluate_QA_classifications.ipynb b/tutorials/evals/evaluate_QA_classifications.ipynb
index c7cac20dbe..b419d8fc78 100644
--- a/tutorials/evals/evaluate_QA_classifications.ipynb
+++ b/tutorials/evals/evaluate_QA_classifications.ipynb
@@ -47,7 +47,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From 54e95f7d04a7136198499ba45a0d1171e91ac955 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:41 -0700
Subject: [PATCH 51/59] Update evaluate_hallucination_classifications.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/evals/evaluate_hallucination_classifications.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/evals/evaluate_hallucination_classifications.ipynb b/tutorials/evals/evaluate_hallucination_classifications.ipynb
index fca1206364..94fe230293 100644
--- a/tutorials/evals/evaluate_hallucination_classifications.ipynb
+++ b/tutorials/evals/evaluate_hallucination_classifications.ipynb
@@ -47,7 +47,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From a22844d016a64340af2ed1cab864fbbdde9334f3 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 07:39:50 -0700
Subject: [PATCH 52/59] Update evaluate_code_readability_classifications.ipynb

Co-authored-by: Xander Song <axiomofjoy@gmail.com>
---
 tutorials/evals/evaluate_code_readability_classifications.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tutorials/evals/evaluate_code_readability_classifications.ipynb b/tutorials/evals/evaluate_code_readability_classifications.ipynb
index 17ade2ff26..480db40f5c 100644
--- a/tutorials/evals/evaluate_code_readability_classifications.ipynb
+++ b/tutorials/evals/evaluate_code_readability_classifications.ipynb
@@ -51,7 +51,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>1\" ipython matplotlib pycm scikit-learn tiktoken"
+    "!pip install -qq \"arize-phoenix[experimental]\" \"openai>=1\" ipython matplotlib pycm scikit-learn tiktoken"
    ]
   },
   {

From 72209494a478880193100233a3a6ddc68692bd23 Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 10:43:32 -0700
Subject: [PATCH 53/59] document breaking changes, bump langchain

---
 README.md      | 5 +++++
 pyproject.toml | 4 ++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 8e8a173978..6b873a6ff7 100644
--- a/README.md
+++ b/README.md
@@ -47,6 +47,7 @@ Phoenix provides MLOps and LLMOps insights at lightning speed with zero-config o
     -   [Exportable Clusters](#exportable-clusters)
 -   [Retrieval-Augmented Generation Analysis](#retrieval-augmented-generation-analysis)
 -   [Structured Data Analysis](#structured-data-analysis)
+-   [Breaking Changes](#breaking-changes)
 -   [Community](#community)
 -   [Thanks](#thanks)
 -   [Copyright, Patent, and License](#copyright-patent-and-license)
@@ -364,6 +365,10 @@ train_ds = px.Dataset(dataframe=train_df, schema=schema, name="training")
 session = px.launch_app(primary=prod_ds, reference=train_ds)
 ```
 
+## Breaking Changes
+
+-   **v1.0.0** - Phoenix now exclusively supports the `openai>=1.1.1` sdk. If you are using an older version of the OpenAI SDK, you can continue to use `arize-phoenix==0.1.1`. However, we recommend upgrading to the latest version of the OpenAI SDK as it contains many improvements.
+
 ## Community
 
 Join our community to connect with thousands of machine learning practitioners and ML observability enthusiasts.
diff --git a/pyproject.toml b/pyproject.toml
index dbbd04ab38..9594b8061f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -56,7 +56,7 @@ dev = [
   "pre-commit",
   "arize[AutoEmbeddings, LLM_Evaluation]",
   "llama-index>=0.8.64",
-  "langchain>=0.0.324",
+  "langchain>=0.0.333",
 ]
 experimental = [
   "tenacity",
@@ -91,7 +91,7 @@ dependencies = [
   "pytest-cov",
   "pytest-lazy-fixture",
   "arize",
-  "langchain>=0.0.324",
+  "langchain>=0.0.333",
   "llama-index>=0.8.63.post2",
   "openai>=1.0.0",
   "tenacity",

From dfec0e2e56064e08041a40ad92ecfea763a3222e Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 10:50:16 -0700
Subject: [PATCH 54/59] add more details to the breaking changes

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6b873a6ff7..c2cc8c14a8 100644
--- a/README.md
+++ b/README.md
@@ -367,7 +367,7 @@ session = px.launch_app(primary=prod_ds, reference=train_ds)
 
 ## Breaking Changes
 
--   **v1.0.0** - Phoenix now exclusively supports the `openai>=1.1.1` sdk. If you are using an older version of the OpenAI SDK, you can continue to use `arize-phoenix==0.1.1`. However, we recommend upgrading to the latest version of the OpenAI SDK as it contains many improvements.
+-   **v1.0.0** - Phoenix now exclusively supports the `openai>=1.0.0` sdk. If you are using an older version of the OpenAI SDK, you can continue to use `arize-phoenix==0.1.1`. However, we recommend upgrading to the latest version of the OpenAI SDK as it contains many improvements. If you are using Phoenix with LlamaIndex and and LangChain, you will have to upgrade to the versions of these packages that support the OpenAI `1.0.0` SDK as well (`llama-index>=0.8.64`, `langchain>=0.0.333`)
 
 ## Community
 

From 86e75e5e408c622444431e3b77ba37b87c29e2bc Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 10:58:32 -0700
Subject: [PATCH 55/59] langchain bump

---
 README.md                                                     | 2 +-
 pyproject.toml                                                | 4 ++--
 ...ain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb | 2 +-
 .../langchain_pinecone_search_and_retrieval_tutorial.ipynb    | 2 +-
 tutorials/llama_index_search_and_retrieval_tutorial.ipynb     | 2 +-
 .../milvus_llamaindex_search_and_retrieval_tutorial.ipynb     | 2 +-
 tutorials/ragas_retrieval_evals_tutorial.ipynb                | 2 +-
 tutorials/tracing/langchain_agent_tracing_tutorial.ipynb      | 2 +-
 tutorials/tracing/langchain_tracing_tutorial.ipynb            | 2 +-
 9 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index c2cc8c14a8..d0e8f5a534 100644
--- a/README.md
+++ b/README.md
@@ -367,7 +367,7 @@ session = px.launch_app(primary=prod_ds, reference=train_ds)
 
 ## Breaking Changes
 
--   **v1.0.0** - Phoenix now exclusively supports the `openai>=1.0.0` sdk. If you are using an older version of the OpenAI SDK, you can continue to use `arize-phoenix==0.1.1`. However, we recommend upgrading to the latest version of the OpenAI SDK as it contains many improvements. If you are using Phoenix with LlamaIndex and and LangChain, you will have to upgrade to the versions of these packages that support the OpenAI `1.0.0` SDK as well (`llama-index>=0.8.64`, `langchain>=0.0.333`)
+-   **v1.0.0** - Phoenix now exclusively supports the `openai>=1.0.0` sdk. If you are using an older version of the OpenAI SDK, you can continue to use `arize-phoenix==0.1.1`. However, we recommend upgrading to the latest version of the OpenAI SDK as it contains many improvements. If you are using Phoenix with LlamaIndex and and LangChain, you will have to upgrade to the versions of these packages that support the OpenAI `1.0.0` SDK as well (`llama-index>=0.8.64`, `langchain>=0.0.334`)
 
 ## Community
 
diff --git a/pyproject.toml b/pyproject.toml
index 9594b8061f..7a85b56967 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -56,7 +56,7 @@ dev = [
   "pre-commit",
   "arize[AutoEmbeddings, LLM_Evaluation]",
   "llama-index>=0.8.64",
-  "langchain>=0.0.333",
+  "langchain>=0.0.334",
 ]
 experimental = [
   "tenacity",
@@ -91,7 +91,7 @@ dependencies = [
   "pytest-cov",
   "pytest-lazy-fixture",
   "arize",
-  "langchain>=0.0.333",
+  "langchain>=0.0.334",
   "llama-index>=0.8.63.post2",
   "openai>=1.0.0",
   "tenacity",
diff --git a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
index b3b384e672..e53e68bf9d 100644
--- a/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
+++ b/tutorials/internal/langchain_retrieval_qa_with_sources_chain_tracing_tutorial.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"langchain>=0.0.332\" \"openai>=1\" chromadb tiktoken playwright asyncio nest_asyncio"
+    "!pip install \"arize-phoenix[experimental]\" \"langchain>=0.0.334\" \"openai>=1\" chromadb tiktoken playwright asyncio nest_asyncio"
    ]
   },
   {
diff --git a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
index ef1308da7c..a3b81392d2 100644
--- a/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/langchain_pinecone_search_and_retrieval_tutorial.ipynb
@@ -83,7 +83,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>=1\" arize-phoenix pinecone-client"
+    "!pip install \"langchain>=0.0.334\" \"openai>=1\" arize-phoenix pinecone-client"
    ]
   },
   {
diff --git a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
index 3268aeefe8..35210e4c07 100644
--- a/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/llama_index_search_and_retrieval_tutorial.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>=1\" \"langchain>=0.0.332\" gcsfs"
+    "!pip install \"arize-phoenix[experimental]\" \"llama-index==0.8.63.post2\" \"openai>=1\" \"langchain>=0.0.334\" gcsfs"
    ]
   },
   {
diff --git a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
index dc5fcfc408..942d330c05 100644
--- a/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
+++ b/tutorials/milvus_llamaindex_search_and_retrieval_tutorial.ipynb
@@ -89,7 +89,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\"\n",
+    "!pip install \"langchain>=0.0.334\" \"llama-index==0.8.63.post2\"\n",
     "!pip install pymilvus==2.2.15\n",
     "!pip install --upgrade --force-reinstall grpcio==1.56.0"
    ]
diff --git a/tutorials/ragas_retrieval_evals_tutorial.ipynb b/tutorials/ragas_retrieval_evals_tutorial.ipynb
index 87cd0d57fe..3c171da425 100644
--- a/tutorials/ragas_retrieval_evals_tutorial.ipynb
+++ b/tutorials/ragas_retrieval_evals_tutorial.ipynb
@@ -79,7 +79,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"llama-index==0.8.63.post2\" \"openai>=1\" arize-phoenix gcsfs datasets ragas"
+    "!pip install \"langchain>=0.0.334\" \"llama-index==0.8.63.post2\" \"openai>=1\" arize-phoenix gcsfs datasets ragas"
    ]
   },
   {
diff --git a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
index 170f112cfd..1b5b8e0617 100644
--- a/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_agent_tracing_tutorial.ipynb
@@ -41,7 +41,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>=1\" numexpr arize-phoenix"
+    "!pip install \"langchain>=0.0.334\" \"openai>=1\" numexpr arize-phoenix"
    ]
   },
   {
diff --git a/tutorials/tracing/langchain_tracing_tutorial.ipynb b/tutorials/tracing/langchain_tracing_tutorial.ipynb
index 25b00bed51..2667407f7c 100644
--- a/tutorials/tracing/langchain_tracing_tutorial.ipynb
+++ b/tutorials/tracing/langchain_tracing_tutorial.ipynb
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install \"langchain>=0.0.332\" \"openai>=1\" arize-phoenix tiktoken"
+    "!pip install \"langchain>=0.0.334\" \"openai>=1\" arize-phoenix tiktoken"
    ]
   },
   {

From a6eb191ed7b34dd03f17e920dcd0284c4e462dc4 Mon Sep 17 00:00:00 2001
From: Alexander Song <axiomofjoy@gmail.com>
Date: Fri, 10 Nov 2023 11:11:35 -0800
Subject: [PATCH 56/59] fix qa evals notebook

---
 .../evals/evaluate_QA_classifications.ipynb   | 372 +++++-------------
 1 file changed, 88 insertions(+), 284 deletions(-)

diff --git a/tutorials/evals/evaluate_QA_classifications.ipynb b/tutorials/evals/evaluate_QA_classifications.ipynb
index b419d8fc78..68e6c88941 100644
--- a/tutorials/evals/evaluate_QA_classifications.ipynb
+++ b/tutorials/evals/evaluate_QA_classifications.ipynb
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -66,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -99,11 +99,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = download_benchmark_dataset(task=\"qa-classification\", dataset_name=\"qa_generated_dataset\")"
+    "df = download_benchmark_dataset(\n",
+    "    task=\"qa-classification\", dataset_name=\"qa_generated_dataset\"\n",
+    ")"
    ]
   },
   {
@@ -121,15 +123,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "\n",
-       "  <div id=\"df-78cb1f50-c997-49d7-8386-f912c081b3f4\" class=\"colab-df-container\">\n",
-       "    <div>\n",
+       "<div>\n",
        "<style scoped>\n",
        "    .dataframe tbody tr th:only-of-type {\n",
        "        vertical-align: middle;\n",
@@ -221,215 +221,7 @@
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "</div>\n",
-       "    <div class=\"colab-df-buttons\">\n",
-       "\n",
-       "  <div class=\"colab-df-container\">\n",
-       "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-78cb1f50-c997-49d7-8386-f912c081b3f4')\"\n",
-       "            title=\"Convert this dataframe to an interactive table.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
-       "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
-       "  </svg>\n",
-       "    </button>\n",
-       "\n",
-       "  <style>\n",
-       "    .colab-df-container {\n",
-       "      display:flex;\n",
-       "      gap: 12px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert {\n",
-       "      background-color: #E8F0FE;\n",
-       "      border: none;\n",
-       "      border-radius: 50%;\n",
-       "      cursor: pointer;\n",
-       "      display: none;\n",
-       "      fill: #1967D2;\n",
-       "      height: 32px;\n",
-       "      padding: 0 0 0 0;\n",
-       "      width: 32px;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-convert:hover {\n",
-       "      background-color: #E2EBFA;\n",
-       "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "      fill: #174EA6;\n",
-       "    }\n",
-       "\n",
-       "    .colab-df-buttons div {\n",
-       "      margin-bottom: 4px;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert {\n",
-       "      background-color: #3B4455;\n",
-       "      fill: #D2E3FC;\n",
-       "    }\n",
-       "\n",
-       "    [theme=dark] .colab-df-convert:hover {\n",
-       "      background-color: #434B5C;\n",
-       "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
-       "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
-       "      fill: #FFFFFF;\n",
-       "    }\n",
-       "  </style>\n",
-       "\n",
-       "    <script>\n",
-       "      const buttonEl =\n",
-       "        document.querySelector('#df-78cb1f50-c997-49d7-8386-f912c081b3f4 button.colab-df-convert');\n",
-       "      buttonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "\n",
-       "      async function convertToInteractive(key) {\n",
-       "        const element = document.querySelector('#df-78cb1f50-c997-49d7-8386-f912c081b3f4');\n",
-       "        const dataTable =\n",
-       "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
-       "                                                    [key], {});\n",
-       "        if (!dataTable) return;\n",
-       "\n",
-       "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
-       "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
-       "          + ' to learn more about interactive tables.';\n",
-       "        element.innerHTML = '';\n",
-       "        dataTable['output_type'] = 'display_data';\n",
-       "        await google.colab.output.renderOutput(dataTable, element);\n",
-       "        const docLink = document.createElement('div');\n",
-       "        docLink.innerHTML = docLinkHtml;\n",
-       "        element.appendChild(docLink);\n",
-       "      }\n",
-       "    </script>\n",
-       "  </div>\n",
-       "\n",
-       "\n",
-       "<div id=\"df-7480b7bb-99bc-473e-9784-dcc587e77d69\">\n",
-       "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-7480b7bb-99bc-473e-9784-dcc587e77d69')\"\n",
-       "            title=\"Suggest charts.\"\n",
-       "            style=\"display:none;\">\n",
-       "\n",
-       "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
-       "     width=\"24px\">\n",
-       "    <g>\n",
-       "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
-       "    </g>\n",
-       "</svg>\n",
-       "  </button>\n",
-       "\n",
-       "<style>\n",
-       "  .colab-df-quickchart {\n",
-       "      --bg-color: #E8F0FE;\n",
-       "      --fill-color: #1967D2;\n",
-       "      --hover-bg-color: #E2EBFA;\n",
-       "      --hover-fill-color: #174EA6;\n",
-       "      --disabled-fill-color: #AAA;\n",
-       "      --disabled-bg-color: #DDD;\n",
-       "  }\n",
-       "\n",
-       "  [theme=dark] .colab-df-quickchart {\n",
-       "      --bg-color: #3B4455;\n",
-       "      --fill-color: #D2E3FC;\n",
-       "      --hover-bg-color: #434B5C;\n",
-       "      --hover-fill-color: #FFFFFF;\n",
-       "      --disabled-bg-color: #3B4455;\n",
-       "      --disabled-fill-color: #666;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart {\n",
-       "    background-color: var(--bg-color);\n",
-       "    border: none;\n",
-       "    border-radius: 50%;\n",
-       "    cursor: pointer;\n",
-       "    display: none;\n",
-       "    fill: var(--fill-color);\n",
-       "    height: 32px;\n",
-       "    padding: 0;\n",
-       "    width: 32px;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart:hover {\n",
-       "    background-color: var(--hover-bg-color);\n",
-       "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
-       "    fill: var(--button-hover-fill-color);\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-quickchart-complete:disabled,\n",
-       "  .colab-df-quickchart-complete:disabled:hover {\n",
-       "    background-color: var(--disabled-bg-color);\n",
-       "    fill: var(--disabled-fill-color);\n",
-       "    box-shadow: none;\n",
-       "  }\n",
-       "\n",
-       "  .colab-df-spinner {\n",
-       "    border: 2px solid var(--fill-color);\n",
-       "    border-color: transparent;\n",
-       "    border-bottom-color: var(--fill-color);\n",
-       "    animation:\n",
-       "      spin 1s steps(1) infinite;\n",
-       "  }\n",
-       "\n",
-       "  @keyframes spin {\n",
-       "    0% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "      border-left-color: var(--fill-color);\n",
-       "    }\n",
-       "    20% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    30% {\n",
-       "      border-color: transparent;\n",
-       "      border-left-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    40% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-top-color: var(--fill-color);\n",
-       "    }\n",
-       "    60% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "    }\n",
-       "    80% {\n",
-       "      border-color: transparent;\n",
-       "      border-right-color: var(--fill-color);\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "    90% {\n",
-       "      border-color: transparent;\n",
-       "      border-bottom-color: var(--fill-color);\n",
-       "    }\n",
-       "  }\n",
-       "</style>\n",
-       "\n",
-       "  <script>\n",
-       "    async function quickchart(key) {\n",
-       "      const quickchartButtonEl =\n",
-       "        document.querySelector('#' + key + ' button');\n",
-       "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
-       "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
-       "      try {\n",
-       "        const charts = await google.colab.kernel.invokeFunction(\n",
-       "            'suggestCharts', [key], {});\n",
-       "      } catch (error) {\n",
-       "        console.error('Error during call to suggestCharts:', error);\n",
-       "      }\n",
-       "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
-       "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
-       "    }\n",
-       "    (() => {\n",
-       "      let quickchartButtonEl =\n",
-       "        document.querySelector('#df-7480b7bb-99bc-473e-9784-dcc587e77d69 button');\n",
-       "      quickchartButtonEl.style.display =\n",
-       "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
-       "    })();\n",
-       "  </script>\n",
-       "</div>\n",
-       "    </div>\n",
-       "  </div>\n"
+       "</div>"
       ],
       "text/plain": [
        "                         id           title  \\\n",
@@ -489,7 +281,7 @@
        "4         True  "
       ]
      },
-     "execution_count": null,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -509,7 +301,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -551,7 +343,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -573,7 +365,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -597,17 +389,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = OpenAIModel(\n",
     "    model_name=\"gpt-4\",\n",
@@ -617,26 +401,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-10 03:35:40.385001 |█████████████████████████████| 100.0% (1/1) [00:01<00:00,  1.05s/it]\n"
-     ]
-    },
     {
      "data": {
-      "application/vnd.google.colaboratory.intrinsic+json": {
-       "type": "string"
-      },
       "text/plain": [
        "\"Hello! I'm working perfectly. How can I assist you today?\""
       ]
      },
-     "execution_count": null,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -654,15 +428,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-10 03:41:12.808630 |█████████████████████████| 100.0% (100/100) [05:25<00:00,  3.26s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e48848017db547c18a0255a7162d74d5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -689,7 +470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -698,18 +479,28 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "     correct       1.00      0.96      0.98        49\n",
-      "   incorrect       0.96      1.00      0.98        51\n",
+      "     correct       1.00      1.00      1.00        52\n",
+      "   incorrect       1.00      1.00      1.00        48\n",
       "\n",
-      "    accuracy                           0.98       100\n",
-      "   macro avg       0.98      0.98      0.98       100\n",
-      "weighted avg       0.98      0.98      0.98       100\n",
+      "    accuracy                           1.00       100\n",
+      "   macro avg       1.00      1.00      1.00       100\n",
+      "weighted avg       1.00      1.00      1.00       100\n",
       "\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "text/plain": [
+       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -721,7 +512,9 @@
    "source": [
     "true_labels = df_sample[\"answer_true\"].map(templates.QA_PROMPT_RAILS_MAP).tolist()\n",
     "Q_and_A_classifications = (\n",
-    "    pd.Series(Q_and_A_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
+    "    pd.Series(Q_and_A_classifications)\n",
+    "    .map(lambda x: \"unparseable\" if x is None else x)\n",
+    "    .tolist()\n",
     ")\n",
     "\n",
     "print(classification_report(true_labels, Q_and_A_classifications, labels=rails))\n",
@@ -747,32 +540,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING:phoenix.experimental.evals.models.openai:gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = OpenAIModel(model_name=\"gpt-3.5-turbo\", temperature=0.0, request_timeout=20)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Eta:2023-10-10 03:14:30.673234 |█████████████████████████| 100.0% (100/100) [03:04<00:00,  1.85s/it]\n"
-     ]
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "128aa17440494a74bcb0db8d41098eff",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -780,13 +572,13 @@
     "    dataframe=df_sample,\n",
     "    template=templates.QA_PROMPT_TEMPLATE_STR,\n",
     "    model=model,\n",
-    "    rails=templates.QA_PROMPT_RAILS_MAP.values(),\n",
+    "    rails=list(templates.QA_PROMPT_RAILS_MAP.values()),\n",
     ")[\"label\"]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -795,18 +587,28 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "     correct       0.98      0.81      0.89        59\n",
-      "   incorrect       0.78      0.98      0.87        41\n",
+      "     correct       0.93      0.98      0.95        52\n",
+      "   incorrect       0.98      0.92      0.95        48\n",
       "\n",
-      "    accuracy                           0.88       100\n",
-      "   macro avg       0.88      0.89      0.88       100\n",
-      "weighted avg       0.90      0.88      0.88       100\n",
+      "    accuracy                           0.95       100\n",
+      "   macro avg       0.95      0.95      0.95       100\n",
+      "weighted avg       0.95      0.95      0.95       100\n",
       "\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "text/plain": [
+       "<Axes: title={'center': 'Confusion Matrix (Normalized)'}, xlabel='Predicted Classes', ylabel='Actual Classes'>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -819,7 +621,9 @@
     "true_labels = df_sample[\"answer_true\"].map(templates.QA_PROMPT_RAILS_MAP).tolist()\n",
     "classes = list(templates.QA_PROMPT_RAILS_MAP.values())\n",
     "Q_and_A_classifications = (\n",
-    "    pd.Series(Q_and_A_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
+    "    pd.Series(Q_and_A_classifications)\n",
+    "    .map(lambda x: \"unparseable\" if x is None else x)\n",
+    "    .tolist()\n",
     ")\n",
     "\n",
     "print(classification_report(true_labels, Q_and_A_classifications, labels=classes))\n",
@@ -850,7 +654,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.3"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

From d58aeed2088bf18670a2e79203066adbd1c367d8 Mon Sep 17 00:00:00 2001
From: Alexander Song <axiomofjoy@gmail.com>
Date: Fri, 10 Nov 2023 11:17:29 -0800
Subject: [PATCH 57/59] fix style

---
 tutorials/evals/evaluate_QA_classifications.ipynb | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/tutorials/evals/evaluate_QA_classifications.ipynb b/tutorials/evals/evaluate_QA_classifications.ipynb
index 68e6c88941..5001c98620 100644
--- a/tutorials/evals/evaluate_QA_classifications.ipynb
+++ b/tutorials/evals/evaluate_QA_classifications.ipynb
@@ -103,9 +103,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = download_benchmark_dataset(\n",
-    "    task=\"qa-classification\", dataset_name=\"qa_generated_dataset\"\n",
-    ")"
+    "df = download_benchmark_dataset(task=\"qa-classification\", dataset_name=\"qa_generated_dataset\")"
    ]
   },
   {
@@ -512,9 +510,7 @@
    "source": [
     "true_labels = df_sample[\"answer_true\"].map(templates.QA_PROMPT_RAILS_MAP).tolist()\n",
     "Q_and_A_classifications = (\n",
-    "    pd.Series(Q_and_A_classifications)\n",
-    "    .map(lambda x: \"unparseable\" if x is None else x)\n",
-    "    .tolist()\n",
+    "    pd.Series(Q_and_A_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
     ")\n",
     "\n",
     "print(classification_report(true_labels, Q_and_A_classifications, labels=rails))\n",
@@ -621,9 +617,7 @@
     "true_labels = df_sample[\"answer_true\"].map(templates.QA_PROMPT_RAILS_MAP).tolist()\n",
     "classes = list(templates.QA_PROMPT_RAILS_MAP.values())\n",
     "Q_and_A_classifications = (\n",
-    "    pd.Series(Q_and_A_classifications)\n",
-    "    .map(lambda x: \"unparseable\" if x is None else x)\n",
-    "    .tolist()\n",
+    "    pd.Series(Q_and_A_classifications).map(lambda x: \"unparseable\" if x is None else x).tolist()\n",
     ")\n",
     "\n",
     "print(classification_report(true_labels, Q_and_A_classifications, labels=classes))\n",

From 94e15efa2175ff72a59d198706073cd6f3087de9 Mon Sep 17 00:00:00 2001
From: Alexander Song <axiomofjoy@gmail.com>
Date: Fri, 10 Nov 2023 11:50:40 -0800
Subject: [PATCH 58/59] update major version

---
 src/phoenix/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/phoenix/__init__.py b/src/phoenix/__init__.py
index 6938ee1cd8..1b9377dc2e 100644
--- a/src/phoenix/__init__.py
+++ b/src/phoenix/__init__.py
@@ -5,7 +5,7 @@
 from .trace.fixtures import load_example_traces
 from .trace.trace_dataset import TraceDataset
 
-__version__ = "0.1.1"
+__version__ = "1.0.0"
 
 # module level doc-string
 __doc__ = """

From 140cc6cd7a8fe06b7f032a8311ed09a4ad49e36e Mon Sep 17 00:00:00 2001
From: Mikyo King <mikyo@arize.com>
Date: Fri, 10 Nov 2023 14:08:09 -0700
Subject: [PATCH 59/59] remove logging token count warnings

---
 src/phoenix/experimental/evals/models/openai.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/phoenix/experimental/evals/models/openai.py b/src/phoenix/experimental/evals/models/openai.py
index 7cb5c83324..f9c647461c 100644
--- a/src/phoenix/experimental/evals/models/openai.py
+++ b/src/phoenix/experimental/evals/models/openai.py
@@ -177,7 +177,6 @@ def _init_tiktoken(self) -> None:
         try:
             encoding = self._tiktoken.encoding_for_model(self.model_name)
         except KeyError:
-            logger.warning("Warning: model not found. Using cl100k_base encoding.")
             encoding = self._tiktoken.get_encoding("cl100k_base")
         self._tiktoken_encoding = encoding