SYMBOL INDEX (971 symbols across 127 files)

FILE: athina/cli/cli.py
  function main (line 12) | def main():
  function init (line 93) | def init(args):
  function config (line 111) | def config(args):
  function list (line 117) | def list(args):
  function run_delegator (line 125) | def run_delegator(args):
  function run_batch (line 163) | def run_batch(
  function run_datapoint (line 180) | def run_datapoint(eval_name: str, model: str, **kwargs):

FILE: athina/constants/messages.py
  class AthinaMessages (line 1) | class AthinaMessages:

FILE: athina/datasets/dataset.py
  class DatasetRow (line 7) | class DatasetRow:
  class Dataset (line 15) | class Dataset:
    method create (line 25) | def create(
    method add_rows (line 73) | def add_rows(dataset_id: str, rows: List[DatasetRow]):
    method fetch_dataset_rows (line 93) | def fetch_dataset_rows(dataset_id: str, number_of_rows: Optional[int] ...
    method dataset_link (line 103) | def dataset_link(dataset_id: str):

FILE: athina/errors/exceptions.py
  class CustomException (line 5) | class CustomException(Exception):
    method __init__ (line 6) | def __init__(
    method __str__ (line 13) | def __str__(self):
  class NoAthinaApiKeyException (line 19) | class NoAthinaApiKeyException(CustomException):
    method __init__ (line 20) | def __init__(self, message: str = AthinaMessages.SIGN_UP_FOR_BEST_EXPE...
  class NoOpenAiApiKeyException (line 24) | class NoOpenAiApiKeyException(CustomException):
    method __init__ (line 25) | def __init__(self, message: str = AthinaMessages.NO_OPENAI_API_KEY):

FILE: athina/evals/base_evaluator.py
  class BaseEvaluator (line 17) | class BaseEvaluator(ABC):
    method name (line 22) | def name(self) -> str:
    method display_name (line 28) | def display_name(self) -> str:
    method metric_ids (line 34) | def metric_ids(self) -> List[str]:
    method required_args (line 40) | def required_args(self) -> List[str]:
    method examples (line 46) | def examples(self):
    method is_failure (line 51) | def is_failure(self, *args) -> Optional[bool]:
    method _evaluate (line 56) | def _evaluate(self, **kwargs) -> EvalResult:
    method to_config (line 60) | def to_config(self) -> Optional[Dict]:
    method _examples_str (line 64) | def _examples_str(self) -> str:
    method validate_args (line 67) | def validate_args(self, **kwargs) -> None:
    method _validate_batch_args (line 77) | def _validate_batch_args(self, data: List[DataPoint]) -> bool:
    method _log_evaluation_request (line 94) | def _log_evaluation_request(self, data) -> Optional[str]:
    method _log_evaluation_results (line 107) | def _log_evaluation_results(
    method run (line 128) | def run(self, **kwargs) -> BatchRunResult:
    method guard (line 147) | def guard(self, **kwargs):
    method _run_batch_generator_async (line 157) | def _run_batch_generator_async(
    method _run_batch_generator (line 182) | def _run_batch_generator(self, data: List[DataPoint]):
    method _log_dataset_to_athina (line 195) | def _log_dataset_to_athina(self, data: List[DataPoint]) -> Optional[str]:
    method _log_eval_results_to_athina (line 206) | def _log_eval_results_to_athina(
    method run_batch (line 233) | def run_batch(

FILE: athina/evals/conversation/conversation_coherence/evaluator.py
  class ConversationCoherence (line 13) | class ConversationCoherence(LlmEvaluator):
    method __init__ (line 20) | def __init__(self, failure_threshold: Optional[float] = None, *args, *...
    method name (line 28) | def name(self):
    method display_name (line 32) | def display_name(self):
    method metric_ids (line 36) | def metric_ids(self) -> List[str]:
    method default_model (line 40) | def default_model(self):
    method required_args (line 44) | def required_args(self):
    method examples (line 50) | def examples(self):
    method _user_message (line 53) | def _user_message(self, **kwargs) -> str:
    method is_failure (line 56) | def is_failure(self, score) -> Optional[bool]:
    method score (line 63) | def score(self, details):
    method reason (line 72) | def reason(self, details):
    method _evaluate (line 86) | def _evaluate(self, messages: List[str]) -> EvalResult:

FILE: athina/evals/conversation/conversation_resolution/evaluator.py
  class ConversationResolution (line 13) | class ConversationResolution(LlmEvaluator):
    method __init__ (line 20) | def __init__(self, failure_threshold: Optional[float] = None, *args, *...
    method name (line 28) | def name(self):
    method display_name (line 32) | def display_name(self):
    method metric_ids (line 36) | def metric_ids(self) -> List[str]:
    method default_model (line 40) | def default_model(self):
    method required_args (line 44) | def required_args(self):
    method examples (line 50) | def examples(self):
    method is_failure (line 53) | def is_failure(self, score) -> Optional[bool]:
    method _user_message (line 60) | def _user_message(self, **kwargs) -> str:
    method reason (line 63) | def reason(self, messages_with_resolution_status: List[dict]) -> str:
    method _evaluate (line 77) | def _evaluate(self, messages: List[str]) -> EvalResult:

FILE: athina/evals/eval_type.py
  class ConversationEvalTypeId (line 4) | class ConversationEvalTypeId(Enum):
  class LlmEvalTypeId (line 9) | class LlmEvalTypeId(Enum):
  class RagasEvalTypeId (line 19) | class RagasEvalTypeId(Enum):
  class FunctionEvalTypeId (line 33) | class FunctionEvalTypeId(Enum):
  class GroundedEvalTypeId (line 74) | class GroundedEvalTypeId(Enum):
  function is_llm_eval (line 79) | def is_llm_eval(evaluator_type: str) -> bool:
  function is_ragas_eval (line 83) | def is_ragas_eval(evaluator_type: str) -> bool:
  function is_function_eval (line 87) | def is_function_eval(evaluator_type: str) -> bool:
  function is_grounded_eval (line 91) | def is_grounded_eval(evaluator_type: str) -> bool:
  function is_conversation_eval (line 95) | def is_conversation_eval(evaluator_type: str) -> bool:

FILE: athina/evals/function/function_evaluator.py
  class FunctionEvaluator (line 12) | class FunctionEvaluator(BaseEvaluator):
    method _model (line 22) | def _model(self):
    method name (line 26) | def name(self):
    method display_name (line 30) | def display_name(self):
    method metric_ids (line 34) | def metric_ids(self) -> List[str]:
    method default_function_arguments (line 38) | def default_function_arguments(self):
    method required_args (line 42) | def required_args(self):
    method examples (line 46) | def examples(self):
    method validate_args (line 49) | def validate_args(self, **kwargs) -> None:
    method __init__ (line 52) | def __init__(
    method is_failure (line 69) | def is_failure(self, eval_response) -> Optional[bool]:
    method to_config (line 76) | def to_config(self) -> Optional[Dict]:
    method _evaluate (line 82) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/function/functions.py
  function _standardize_url (line 19) | def _standardize_url(url):
  function _preprocess_strings (line 35) | def _preprocess_strings(keywords, text, case_sensitive):
  function regex (line 61) | def regex(pattern, text, **kwargs):
  function contains_any (line 82) | def contains_any(keywords, text: str, case_sensitive=False, **kwargs):
  function contains_all (line 112) | def contains_all(keywords, text, case_sensitive=False, **kwargs):
  function contains (line 140) | def contains(keyword, text, case_sensitive=False, **kwargs):
  function contains_none (line 165) | def contains_none(keywords, text, case_sensitive=False, **kwargs):
  function contains_json (line 195) | def contains_json(text, **kwargs):
  function contains_email (line 239) | def contains_email(text, **kwargs):
  function is_json (line 252) | def is_json(text, **kwargs):
  function is_email (line 279) | def is_email(text, **kwargs):
  function contains_link (line 292) | def contains_link(text, **kwargs):
  function contains_valid_link (line 310) | def contains_valid_link(text, **kwargs):
  function no_invalid_links (line 346) | def no_invalid_links(text, **kwargs):
  function api_call (line 382) | def api_call(
  function equals (line 450) | def equals(expected_text, text, case_sensitive=False, **kwargs):
  function starts_with (line 474) | def starts_with(substring, text, case_sensitive=False, **kwargs):
  function ends_with (line 496) | def ends_with(substring, text, case_sensitive=False, **kwargs):
  function length_less_than (line 518) | def length_less_than(max_length, text, **kwargs):
  function length_greater_than (line 541) | def length_greater_than(min_length, text, **kwargs):
  function length_between (line 564) | def length_between(min_length, max_length, text, **kwargs):
  function one_line (line 588) | def one_line(text, **kwargs):
  function json_schema (line 604) | def json_schema(actual_json: Union[dict, str], **kwargs) -> Dict[str, Any]:
  function json_validation (line 635) | def json_validation(
  function _bandit_check (line 666) | def _bandit_check(code: str) -> None:
  function custom_code_eval (line 686) | def custom_code_eval(code, **kwargs):
  function _load_json (line 719) | def _load_json(json_data: Union[dict, str]) -> dict:
  function _get_schema (line 725) | def _get_schema(kwargs: Dict[str, Any]) -> dict:
  function _validate_json_with_schema (line 732) | def _validate_json_with_schema(json_data: dict, schema: dict) -> Tuple[b...
  function _apply_validation (line 736) | def _apply_validation(actual_json: dict, expected_json: dict, validation...
  function _validate_equals (line 758) | def _validate_equals(
  function _validate_cosine_similarity (line 776) | def _validate_cosine_similarity(
  function _validate_llm_similarity (line 790) | def _validate_llm_similarity(
  function _get_messages (line 827) | def _get_messages(validation: dict, actual_value: Any, expected_value: A...

FILE: athina/evals/function/wrapper.py
  class ContainsAny (line 6) | class ContainsAny(FunctionEvaluator):
    method __init__ (line 7) | def __init__(
  class Regex (line 27) | class Regex(FunctionEvaluator):
    method __init__ (line 28) | def __init__(
  class ContainsNone (line 46) | class ContainsNone(FunctionEvaluator):
    method __init__ (line 47) | def __init__(
  class Contains (line 70) | class Contains(FunctionEvaluator):
    method __init__ (line 71) | def __init__(
  class ContainsAll (line 94) | class ContainsAll(FunctionEvaluator):
    method __init__ (line 95) | def __init__(
  class ContainsJson (line 118) | class ContainsJson(FunctionEvaluator):
    method __init__ (line 119) | def __init__(self, display_name: Optional[str] = None):
  class ContainsEmail (line 129) | class ContainsEmail(FunctionEvaluator):
    method __init__ (line 130) | def __init__(self, display_name: Optional[str] = None):
  class IsJson (line 141) | class IsJson(FunctionEvaluator):
    method __init__ (line 142) | def __init__(self, display_name: Optional[str] = None):
  class IsEmail (line 153) | class IsEmail(FunctionEvaluator):
    method __init__ (line 154) | def __init__(self, display_name: Optional[str] = None):
  class NoInvalidLinks (line 165) | class NoInvalidLinks(FunctionEvaluator):
    method __init__ (line 166) | def __init__(self, display_name: Optional[str] = None):
  class ContainsLink (line 177) | class ContainsLink(FunctionEvaluator):
    method __init__ (line 178) | def __init__(self, display_name: Optional[str] = None):
  class ContainsValidLink (line 189) | class ContainsValidLink(FunctionEvaluator):
    method __init__ (line 190) | def __init__(self, display_name: Optional[str] = None):
  class Equals (line 201) | class Equals(FunctionEvaluator):
    method __init__ (line 202) | def __init__(
  class StartsWith (line 222) | class StartsWith(FunctionEvaluator):
    method __init__ (line 223) | def __init__(
  class EndsWith (line 246) | class EndsWith(FunctionEvaluator):
    method __init__ (line 247) | def __init__(
  class LengthLessThan (line 270) | class LengthLessThan(FunctionEvaluator):
    method __init__ (line 271) | def __init__(self, max_length: int, display_name: Optional[str] = None):
  class LengthGreaterThan (line 287) | class LengthGreaterThan(FunctionEvaluator):
    method __init__ (line 288) | def __init__(self, min_length: int, display_name: Optional[str] = None):
  class ApiCall (line 304) | class ApiCall(FunctionEvaluator):
    method __init__ (line 305) | def __init__(
  class LengthBetween (line 331) | class LengthBetween(FunctionEvaluator):
    method __init__ (line 332) | def __init__(
  class OneLine (line 352) | class OneLine(FunctionEvaluator):
    method __init__ (line 353) | def __init__(self, display_name: Optional[str] = None):
  class CustomCodeEval (line 364) | class CustomCodeEval(FunctionEvaluator):
    method __init__ (line 365) | def __init__(self, code: str, display_name: Optional[str] = None):
  class JsonSchema (line 381) | class JsonSchema(FunctionEvaluator):
    method __init__ (line 382) | def __init__(self, schema: str, display_name: Optional[str] = None):
  class JsonValidation (line 393) | class JsonValidation(FunctionEvaluator):
    method __init__ (line 394) | def __init__(self, validations=None, display_name: Optional[str] = None):

FILE: athina/evals/grounded/grounded_evaluator.py
  class GroundedEvaluator (line 12) | class GroundedEvaluator(BaseEvaluator):
    method _model (line 22) | def _model(self):
    method name (line 26) | def name(self):
    method display_name (line 30) | def display_name(self):
    method metric_ids (line 34) | def metric_ids(self) -> List[str]:
    method examples (line 38) | def examples(self):
    method __init__ (line 41) | def __init__(
    method _process_kwargs (line 53) | def _process_kwargs(self, required_args, **kwargs):
    method to_config (line 72) | def to_config(self):
    method is_failure (line 80) | def is_failure(self, score) -> Optional[bool]:
    method _evaluate (line 87) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/grounded/similarity.py
  class Comparator (line 6) | class Comparator(ABC):
    method compare (line 8) | def compare(self, string1, string2):
  class CosineSimilarity (line 12) | class CosineSimilarity(Comparator):
    method compare (line 13) | def compare(self, string1, string2):
    method _tokenize (line 27) | def _tokenize(self, string):
    method _create_combined_set (line 39) | def _create_combined_set(self, string1, string2):
    method _vectorize (line 42) | def _vectorize(self, string, combined_set):
  class NormalisedLevenshteinSimilarity (line 48) | class NormalisedLevenshteinSimilarity(Comparator):
    method compare (line 49) | def compare(self, string1, string2):
    method _normalised_levenshtein_distance (line 52) | def _normalised_levenshtein_distance(self, str1, str2):
  class JaroWincklerSimilarity (line 74) | class JaroWincklerSimilarity(Comparator):
    method compare (line 75) | def compare(self, string1, string2):
    method _jaro_winckler_similarity (line 78) | def _jaro_winckler_similarity(self, str1, str2):
  class JaccardSimilarity (line 109) | class JaccardSimilarity(Comparator):
    method compare (line 110) | def compare(self, string1, string2):
    method _jaccard_similarity (line 113) | def _jaccard_similarity(self, str1, str2):
  class SorensenDiceSimilarity (line 121) | class SorensenDiceSimilarity(Comparator):
    method compare (line 122) | def compare(self, string1, string2):
    method _sorensen_dice_similarity (line 125) | def _sorensen_dice_similarity(self, str1, str2):

FILE: athina/evals/grounded/wrapper.py
  class AnswerSimilarity (line 5) | class AnswerSimilarity(GroundedEvaluator):
    method required_args (line 8) | def required_args(self):
    method name (line 12) | def name(self):
    method __init__ (line 15) | def __init__(self, comparator: Comparator, failure_threshold: float = ...
  class ContextSimilarity (line 30) | class ContextSimilarity(GroundedEvaluator):
    method required_args (line 33) | def required_args(self):
    method name (line 37) | def name(self):
    method __init__ (line 40) | def __init__(self, comparator: Comparator, failure_threshold: float = ...

FILE: athina/evals/guardrails/correct_language/evaluator.py
  class CorrectLanguage (line 13) | class CorrectLanguage(BaseEvaluator):
    method __init__ (line 17) | def __init__(
    method name (line 35) | def name(self) -> str:
    method display_name (line 39) | def display_name(self) -> str:
    method metric_ids (line 43) | def metric_ids(self) -> List[str]:
    method required_args (line 47) | def required_args(self) -> List[str]:
    method examples (line 51) | def examples(self):
    method to_config (line 54) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 57) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 60) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/detect_pii/evaluator.py
  class DetectPII (line 13) | class DetectPII(BaseEvaluator):
    method __init__ (line 23) | def __init__(
    method name (line 35) | def name(self) -> str:
    method display_name (line 39) | def display_name(self) -> str:
    method metric_ids (line 43) | def metric_ids(self) -> List[str]:
    method required_args (line 47) | def required_args(self) -> List[str]:
    method examples (line 51) | def examples(self):
    method to_config (line 54) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 57) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 60) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/gibberish_text/evaluator.py
  class NotGibberishText (line 13) | class NotGibberishText(BaseEvaluator):
    method __init__ (line 17) | def __init__(
    method name (line 34) | def name(self) -> str:
    method display_name (line 38) | def display_name(self) -> str:
    method metric_ids (line 42) | def metric_ids(self) -> List[str]:
    method required_args (line 46) | def required_args(self) -> List[str]:
    method examples (line 50) | def examples(self):
    method to_config (line 53) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 56) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 59) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/no_secrets_present/evaluator.py
  class NoSecretsPresent (line 13) | class NoSecretsPresent(BaseEvaluator):
    method __init__ (line 15) | def __init__(
    method name (line 26) | def name(self) -> str:
    method display_name (line 30) | def display_name(self) -> str:
    method metric_ids (line 34) | def metric_ids(self) -> List[str]:
    method required_args (line 38) | def required_args(self) -> List[str]:
    method examples (line 42) | def examples(self):
    method to_config (line 45) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 48) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 51) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/politeness_check/evaluator.py
  class PolitenessCheck (line 16) | class PolitenessCheck(BaseEvaluator):
    method __init__ (line 19) | def __init__(
    method name (line 37) | def name(self) -> str:
    method display_name (line 41) | def display_name(self) -> str:
    method metric_ids (line 45) | def metric_ids(self) -> List[str]:
    method required_args (line 49) | def required_args(self) -> List[str]:
    method examples (line 53) | def examples(self):
    method to_config (line 56) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 59) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 62) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/profanity_free/evaluator.py
  class ProfanityFree (line 13) | class ProfanityFree(BaseEvaluator):
    method __init__ (line 15) | def __init__(
    method name (line 26) | def name(self) -> str:
    method display_name (line 30) | def display_name(self) -> str:
    method metric_ids (line 34) | def metric_ids(self) -> List[str]:
    method required_args (line 38) | def required_args(self) -> List[str]:
    method examples (line 42) | def examples(self):
    method to_config (line 45) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 48) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 51) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/reading_time/evaluator.py
  class ReadingTime (line 13) | class ReadingTime(BaseEvaluator):
    method __init__ (line 14) | def __init__(self, reading_time: float):  # Time in seconds
    method name (line 24) | def name(self) -> str:
    method display_name (line 28) | def display_name(self) -> str:
    method metric_ids (line 32) | def metric_ids(self) -> List[str]:
    method required_args (line 36) | def required_args(self) -> List[str]:
    method examples (line 40) | def examples(self):
    method to_config (line 43) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 46) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 49) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/restrict_to_topic/evaluator.py
  class RestrictToTopic (line 16) | class RestrictToTopic(BaseEvaluator):
    method __init__ (line 20) | def __init__(
    method name (line 47) | def name(self) -> str:
    method display_name (line 51) | def display_name(self) -> str:
    method metric_ids (line 55) | def metric_ids(self) -> List[str]:
    method required_args (line 59) | def required_args(self) -> List[str]:
    method examples (line 63) | def examples(self):
    method to_config (line 66) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 69) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 72) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/sensitive_topics/evaluator.py
  class ContainsNoSensitiveTopics (line 16) | class ContainsNoSensitiveTopics(BaseEvaluator):
    method __init__ (line 26) | def __init__(
    method name (line 48) | def name(self) -> str:
    method display_name (line 52) | def display_name(self) -> str:
    method metric_ids (line 56) | def metric_ids(self) -> List[str]:
    method required_args (line 60) | def required_args(self) -> List[str]:
    method examples (line 64) | def examples(self):
    method to_config (line 67) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 70) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 73) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/sfw/evaluator.py
  class SafeForWorkText (line 13) | class SafeForWorkText(BaseEvaluator):
    method __init__ (line 17) | def __init__(
    method name (line 34) | def name(self) -> str:
    method display_name (line 38) | def display_name(self) -> str:
    method metric_ids (line 42) | def metric_ids(self) -> List[str]:
    method required_args (line 46) | def required_args(self) -> List[str]:
    method examples (line 50) | def examples(self):
    method to_config (line 53) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 56) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 59) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/toxic_language/evaluator.py
  class ToxicLanguage (line 13) | class ToxicLanguage(BaseEvaluator):
    method __init__ (line 18) | def __init__(
    method name (line 37) | def name(self) -> str:
    method display_name (line 41) | def display_name(self) -> str:
    method metric_ids (line 45) | def metric_ids(self) -> List[str]:
    method required_args (line 49) | def required_args(self) -> List[str]:
    method examples (line 53) | def examples(self):
    method to_config (line 56) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 59) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 62) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/guardrails/unusual_prompt/evaluator.py
  class NotUnusualPrompt (line 16) | class NotUnusualPrompt(BaseEvaluator):
    method __init__ (line 19) | def __init__(
    method name (line 37) | def name(self) -> str:
    method display_name (line 41) | def display_name(self) -> str:
    method metric_ids (line 45) | def metric_ids(self) -> List[str]:
    method required_args (line 49) | def required_args(self) -> List[str]:
    method examples (line 53) | def examples(self):
    method to_config (line 56) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 59) | def is_failure(self, result: bool) -> bool:
    method _evaluate (line 62) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/llm/context_contains_enough_information/evaluator.py
  class ContextContainsEnoughInformation (line 8) | class ContextContainsEnoughInformation(LlmEvaluator):
    method __init__ (line 34) | def __init__(self, *args, **kwargs):
    method name (line 38) | def name(self):
    method display_name (line 42) | def display_name(self):
    method metric_ids (line 46) | def metric_ids(self) -> List[str]:
    method default_model (line 50) | def default_model(self):
    method required_args (line 54) | def required_args(self):
    method examples (line 58) | def examples(self):
    method is_failure (line 61) | def is_failure(self, result) -> Optional[bool]:
    method _user_message (line 64) | def _user_message(self, query: str, context: List[str], **kwargs) -> str:

FILE: athina/evals/llm/custom_prompt/evaluator.py
  class CustomPrompt (line 16) | class CustomPrompt(LlmEvaluator):
    method __init__ (line 29) | def __init__(
    method name (line 80) | def name(self):
    method metric_ids (line 84) | def metric_ids(self) -> List[str]:
    method display_name (line 88) | def display_name(self):
    method default_model (line 92) | def default_model(self):
    method required_args (line 96) | def required_args(self):
    method examples (line 100) | def examples(self):
    method to_config (line 103) | def to_config(self) -> Optional[Dict]:
    method is_failure (line 108) | def is_failure(self, result) -> Optional[bool]:
    method _user_message (line 111) | def _user_message(self, **kwargs) -> str:
    method _system_message (line 117) | def _system_message(self) -> str:
    method _evaluate (line 149) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/llm/does_response_answer_query/evaluator.py
  class DoesResponseAnswerQuery (line 8) | class DoesResponseAnswerQuery(LlmEvaluator):
    method __init__ (line 32) | def __init__(self, *args, **kwargs):
    method name (line 36) | def name(self):
    method display_name (line 40) | def display_name(self):
    method default_model (line 44) | def default_model(self):
    method required_args (line 48) | def required_args(self):
    method examples (line 52) | def examples(self):
    method metric_ids (line 56) | def metric_ids(self) -> List[str]:
    method is_failure (line 59) | def is_failure(self, result) -> Optional[bool]:
    method _user_message (line 62) | def _user_message(

FILE: athina/evals/llm/example.py
  class FewShotExampleInputParam (line 6) | class FewShotExampleInputParam:
    method __str__ (line 10) | def __str__(self) -> str:
  class FewShotExample (line 14) | class FewShotExample:
    method __init__ (line 26) | def __init__(
    method __str__ (line 39) | def __str__(self):

FILE: athina/evals/llm/faithfulness/evaluator.py
  class Faithfulness (line 8) | class Faithfulness(LlmEvaluator):
    method __init__ (line 34) | def __init__(self, *args, **kwargs):
    method name (line 38) | def name(self):
    method display_name (line 42) | def display_name(self):
    method metric_ids (line 46) | def metric_ids(self) -> List[str]:
    method default_model (line 50) | def default_model(self):
    method required_args (line 54) | def required_args(self):
    method examples (line 58) | def examples(self):
    method is_failure (line 61) | def is_failure(self, result) -> Optional[bool]:
    method _user_message (line 64) | def _user_message(

FILE: athina/evals/llm/grading_criteria/evaluator.py
  class GradingCriteria (line 9) | class GradingCriteria(LlmEvaluator):
    method __init__ (line 27) | def __init__(
    method name (line 41) | def name(self):
    method metric_ids (line 45) | def metric_ids(self) -> List[str]:
    method display_name (line 49) | def display_name(self):
    method default_model (line 53) | def default_model(self):
    method required_args (line 57) | def required_args(self):
    method examples (line 61) | def examples(self):
    method to_config (line 64) | def to_config(self) -> Optional[dict]:
    method is_failure (line 67) | def is_failure(self, result) -> Optional[bool]:
    method _user_message (line 70) | def _user_message(self, response, **kwargs) -> str:

FILE: athina/evals/llm/groundedness/evaluator.py
  class Groundedness (line 19) | class Groundedness(LlmEvaluator):
    method __init__ (line 22) | def __init__(self, failure_threshold: Optional[float] = None, **kwargs):
    method name (line 32) | def name(self) -> str:
    method display_name (line 36) | def display_name(self) -> str:
    method default_model (line 40) | def default_model(self) -> str:
    method metric_ids (line 44) | def metric_ids(self) -> List[str]:
    method required_args (line 48) | def required_args(self) -> List[str]:
    method examples (line 52) | def examples(self):
    method is_failure (line 55) | def is_failure(self, score) -> Optional[bool]:
    method reason (line 62) | def reason(self, unsupported_sentences: List[str]) -> str:
    method datapoint_field_annotations (line 69) | def datapoint_field_annotations(
    method _evaluate (line 97) | def _evaluate(self, **kwargs) -> EvalResult:
    method _user_message (line 157) | def _user_message(

FILE: athina/evals/llm/llm_evaluator.py
  class LlmEvaluator (line 18) | class LlmEvaluator(BaseEvaluator):
    method __init__ (line 54) | def __init__(
    method default_model (line 86) | def default_model(self):
    method __str__ (line 90) | def __str__(self):
    method _system_message (line 94) | def _system_message(self) -> str:
    method _prompt_messages (line 97) | def _prompt_messages(self, **kwargs) -> List[dict]:
    method _evaluate (line 109) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/llm/summary_accuracy/evaluator.py
  class SummaryAccuracy (line 17) | class SummaryAccuracy(LlmEvaluator):
    method __init__ (line 28) | def __init__(
    method name (line 80) | def name(self):
    method metric_ids (line 84) | def metric_ids(self) -> List[str]:
    method display_name (line 92) | def display_name(self):
    method default_model (line 96) | def default_model(self):
    method required_args (line 100) | def required_args(self):
    method examples (line 104) | def examples(self):
    method reason (line 107) | def reason(self) -> str:
    method is_failure (line 118) | def is_failure(self, metrics) -> Optional[bool]:
    method _evaluate (line 149) | def _evaluate(self, **instance) -> EvalResult:
    method _disagreement_answers (line 184) | def _disagreement_answers(self):
    method _evaluate_element (line 194) | def _evaluate_element(self, instance: SummaryDataPoint):
    method update_metric_aggregated_score (line 263) | def update_metric_aggregated_score(self, metric, label, aggr_score):
    method get_metric_aggr (line 270) | def get_metric_aggr(self, metric, label):
    method get_average_scores (line 275) | def get_average_scores(self, score_dict):
    method compute_average_scores (line 287) | def compute_average_scores(self):

FILE: athina/evals/ragas/answer_correctness/evaluator.py
  class RagasAnswerCorrectness (line 15) | class RagasAnswerCorrectness(RagasEvaluator):
    method name (line 21) | def name(self):
    method display_name (line 25) | def display_name(self):
    method metric_ids (line 29) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 33) | def ragas_metric(self):
    method ragas_metric_name (line 37) | def ragas_metric_name(self):
    method default_model (line 41) | def default_model(self):
    method required_args (line 45) | def required_args(self):
    method examples (line 49) | def examples(self):
    method grade_reason (line 53) | def grade_reason(self) -> str:
    method is_failure (line 56) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 63) | def generate_data_to_evaluate(

FILE: athina/evals/ragas/answer_relevancy/evaluator.py
  class RagasAnswerRelevancy (line 15) | class RagasAnswerRelevancy(RagasEvaluator):
    method name (line 22) | def name(self):
    method display_name (line 26) | def display_name(self):
    method metric_ids (line 30) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 34) | def ragas_metric(self):
    method ragas_metric_name (line 38) | def ragas_metric_name(self):
    method default_model (line 42) | def default_model(self):
    method required_args (line 46) | def required_args(self):
    method examples (line 50) | def examples(self):
    method grade_reason (line 54) | def grade_reason(self) -> str:
    method is_failure (line 57) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 64) | def generate_data_to_evaluate(self, query, context, response, **kwargs...

FILE: athina/evals/ragas/answer_semantic_similarity/evaluator.py
  class RagasAnswerSemanticSimilarity (line 14) | class RagasAnswerSemanticSimilarity(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 36) | def ragas_metric_name(self):
    method default_model (line 40) | def default_model(self):
    method required_args (line 44) | def required_args(self):
    method examples (line 48) | def examples(self):
    method grade_reason (line 52) | def grade_reason(self) -> str:
    method is_failure (line 55) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 62) | def generate_data_to_evaluate(self, response, expected_response, **kwa...

FILE: athina/evals/ragas/coherence/evaluator.py
  class RagasCoherence (line 14) | class RagasCoherence(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 40) | def ragas_metric_name(self):
    method default_model (line 44) | def default_model(self):
    method required_args (line 48) | def required_args(self):
    method examples (line 52) | def examples(self):
    method grade_reason (line 56) | def grade_reason(self) -> str:
    method is_failure (line 59) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 66) | def generate_data_to_evaluate(self, response, **kwargs) -> dict:

FILE: athina/evals/ragas/conciseness/evaluator.py
  class RagasConciseness (line 14) | class RagasConciseness(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 40) | def ragas_metric_name(self):
    method default_model (line 44) | def default_model(self):
    method required_args (line 48) | def required_args(self):
    method examples (line 52) | def examples(self):
    method grade_reason (line 56) | def grade_reason(self) -> str:
    method is_failure (line 59) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 66) | def generate_data_to_evaluate(self, response, **kwargs) -> dict:

FILE: athina/evals/ragas/context_precision/evaluator.py
  class RagasContextPrecision (line 14) | class RagasContextPrecision(RagasEvaluator):
    method name (line 22) | def name(self):
    method display_name (line 26) | def display_name(self):
    method metric_ids (line 30) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 34) | def ragas_metric(self):
    method ragas_metric_name (line 38) | def ragas_metric_name(self):
    method default_model (line 42) | def default_model(self):
    method required_args (line 46) | def required_args(self):
    method examples (line 50) | def examples(self):
    method grade_reason (line 54) | def grade_reason(self) -> str:
    method is_failure (line 57) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 64) | def generate_data_to_evaluate(

FILE: athina/evals/ragas/context_recall/evaluator.py
  class RagasContextRecall (line 14) | class RagasContextRecall(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 36) | def ragas_metric_name(self):
    method default_model (line 40) | def default_model(self):
    method required_args (line 44) | def required_args(self):
    method examples (line 48) | def examples(self):
    method grade_reason (line 52) | def grade_reason(self) -> str:
    method is_failure (line 55) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 62) | def generate_data_to_evaluate(

FILE: athina/evals/ragas/faithfulness/evaluator.py
  class RagasFaithfulness (line 14) | class RagasFaithfulness(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 36) | def ragas_metric_name(self):
    method default_model (line 40) | def default_model(self):
    method required_args (line 44) | def required_args(self):
    method examples (line 48) | def examples(self):
    method grade_reason (line 52) | def grade_reason(self) -> str:
    method is_failure (line 55) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 62) | def generate_data_to_evaluate(self, context, query, response, **kwargs...

FILE: athina/evals/ragas/harmfulness/evaluator.py
  class RagasHarmfulness (line 14) | class RagasHarmfulness(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 40) | def ragas_metric_name(self):
    method default_model (line 44) | def default_model(self):
    method required_args (line 48) | def required_args(self):
    method examples (line 52) | def examples(self):
    method grade_reason (line 56) | def grade_reason(self) -> str:
    method is_failure (line 59) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 66) | def generate_data_to_evaluate(self, response, **kwargs) -> dict:

FILE: athina/evals/ragas/maliciousness/evaluator.py
  class RagasMaliciousness (line 14) | class RagasMaliciousness(RagasEvaluator):
    method name (line 20) | def name(self):
    method display_name (line 24) | def display_name(self):
    method metric_ids (line 28) | def metric_ids(self) -> List[str]:
    method ragas_metric (line 32) | def ragas_metric(self):
    method ragas_metric_name (line 40) | def ragas_metric_name(self):
    method default_model (line 44) | def default_model(self):
    method required_args (line 48) | def required_args(self):
    method examples (line 52) | def examples(self):
    method grade_reason (line 56) | def grade_reason(self) -> str:
    method is_failure (line 59) | def is_failure(self, score) -> Optional[bool]:
    method generate_data_to_evaluate (line 66) | def generate_data_to_evaluate(self, response, **kwargs) -> dict:

FILE: athina/evals/ragas/ragas_evaluator.py
  class RagasEvaluator (line 18) | class RagasEvaluator(BaseEvaluator):
    method __init__ (line 26) | def __init__(
    method default_model (line 43) | def default_model(self) -> str:
    method generate_data_to_evaluate (line 46) | def generate_data_to_evaluate(self, **kwargs):
    method ragas_metric (line 50) | def ragas_metric(self) -> Any:
    method grade_reason (line 54) | def grade_reason(self) -> str:
    method _get_model (line 57) | def _get_model(self):
    method _evaluate (line 84) | def _evaluate(self, **kwargs) -> EvalResult:

FILE: athina/evals/safety/content_moderation/evaluator.py
  class OpenAiContentModeration (line 12) | class OpenAiContentModeration(BaseEvaluator):
    method name (line 14) | def name(self):
    method display_name (line 18) | def display_name(self):
    method metric_ids (line 22) | def metric_ids(self) -> List[str]:
    method required_args (line 26) | def required_args(self):
    method examples (line 30) | def examples(self):
    method __init__ (line 33) | def __init__(self, open_ai_api_key: Optional[str] = None):
    method is_failure (line 41) | def is_failure(self, content_moderation_response: dict) -> Optional[bo...
    method get_reason (line 49) | def get_reason(self, content_moderation_response: dict) -> Optional[str]:
    method _evaluate (line 64) | def _evaluate(self, **kwargs) -> EvalResult:
    method get_content_moderation_result (line 126) | def get_content_moderation_result(self, text: str):

FILE: athina/evals/safety/pii_detection/evaluator.py
  class PiiDetection (line 9) | class PiiDetection(BaseEvaluator):
    method _model (line 11) | def _model(self):
    method name (line 15) | def name(self):
    method display_name (line 19) | def display_name(self):
    method metric_ids (line 23) | def metric_ids(self) -> List[str]:
    method default_function_arguments (line 27) | def default_function_arguments(self):
    method required_args (line 31) | def required_args(self):
    method examples (line 35) | def examples(self):
    method is_failure (line 38) | def is_failure(self, detected_pii_response) -> Optional[bool]:
    method _evaluate (line 41) | def _evaluate(self, **kwargs) -> EvalResult:
    method detect_pii (line 87) | def detect_pii(self, text: str):

FILE: athina/evals/safety/prompt_injection/evaluator.py
  class PromptInjection (line 9) | class PromptInjection(BaseEvaluator):
    method __init__ (line 22) | def __init__(self, failure_threshold: float = 0.8, **kwargs):
    method _model (line 27) | def _model(self):
    method name (line 31) | def name(self):
    method display_name (line 35) | def display_name(self):
    method metric_ids (line 39) | def metric_ids(self) -> List[str]:
    method default_function_arguments (line 43) | def default_function_arguments(self):
    method required_args (line 47) | def required_args(self):
    method examples (line 51) | def examples(self):
    method reason (line 54) | def reason(self, check_response: List[dict]) -> str:
    method is_failure (line 67) | def is_failure(self, check_response: List[dict]) -> bool:
    method _evaluate (line 78) | def _evaluate(self, **kwargs) -> EvalResult:
    method detect_prompt_injection (line 115) | def detect_prompt_injection(self, text: str):

FILE: athina/guard/exception.py
  class AthinaGuardException (line 1) | class AthinaGuardException(Exception):
    method __init__ (line 2) | def __init__(self, message):

FILE: athina/guard/guard.py
  function guard (line 8) | def guard(suite: List[BaseEvaluator], **kwargs):

FILE: athina/helpers/athina_logging_helper.py
  class AthinaLoggingHelper (line 17) | class AthinaLoggingHelper:
    method log_eval_performance_report (line 19) | def log_eval_performance_report(*args, **kwargs):
    method log_experiment (line 27) | def log_experiment(*args, **kwargs):
    method create_eval_request (line 35) | def create_eval_request(eval_name: str, request_data: dict, request_ty...
    method log_eval_results (line 58) | def log_eval_results(
    method log_eval_results_with_config (line 134) | def log_eval_results_with_config(eval_results_with_config: dict, datas...

FILE: athina/helpers/config.py
  class ConfigHelper (line 6) | class ConfigHelper:
    method load_config (line 8) | def load_config():
    method load_config_field (line 20) | def load_config_field(field: str):
    method load_openai_api_key (line 28) | def load_openai_api_key():
    method load_athina_api_key (line 32) | def load_athina_api_key():
    method load_llm_engine (line 36) | def load_llm_engine():
    method save_config (line 40) | def save_config(config_data):
    method is_set (line 45) | def is_set():

FILE: athina/helpers/dataset_helper.py
  function generate_unique_dataset_name (line 6) | def generate_unique_dataset_name(prefix="Dataset-", separator="-"):
  function generate_eval_display_name (line 26) | def generate_eval_display_name(eval_display_name: str) -> str:

FILE: athina/helpers/eval_helper.py
  class EvalHelper (line 4) | class EvalHelper:
    method is_supported (line 6) | def is_supported(eval_name: str):

FILE: athina/helpers/function_eval_util.py
  function get_named_parameters (line 4) | def get_named_parameters(func):
  function get_named_non_default_parameters (line 17) | def get_named_non_default_parameters(func):

FILE: athina/helpers/get_evaluator.py
  function get_evaluator (line 149) | def get_evaluator(evaluator_type):
  function get_comparator (line 167) | def get_comparator(comparator_name):
  function create_grounded_evaluator (line 183) | def create_grounded_evaluator(grounded_eval_name, comparator, failure_th...

FILE: athina/helpers/jinja_helper.py
  class PreserveUndefined (line 4) | class PreserveUndefined(Undefined):
    method __str__ (line 5) | def __str__(self):

FILE: athina/helpers/json.py
  class JsonHelper (line 8) | class JsonHelper:
    method _extract_json (line 10) | def _extract_json(data_string: str) -> str:
    method _load_json_from_text (line 24) | def _load_json_from_text(text):
    method extract_json_from_text (line 35) | def extract_json_from_text(text):
  function validate_json (line 44) | def validate_json(json_data, schema):
  function extract_json_path (line 52) | def extract_json_path(json_data, json_path):
  class JsonExtractor (line 64) | class JsonExtractor:
    method extract_first_json_entity (line 66) | def extract_first_json_entity(text: str) -> Optional[Any]:

FILE: athina/helpers/kwparser.py
  class KeyValueAction (line 4) | class KeyValueAction(argparse.Action):
    method __call__ (line 7) | def __call__(self, parser, namespace, values, option_string=None):

FILE: athina/helpers/loader_helper.py
  class LoaderHelper (line 5) | class LoaderHelper:
    method get_loader (line 9) | def get_loader(eval_name, loader_name: Optional[str] = None):
    method load (line 26) | def load(eval_name, format, **kwargs):

FILE: athina/helpers/logger.py
  class Singleton (line 6) | class Singleton(type):
    method __call__ (line 9) | def __call__(cls, *args, **kwargs):
  class AppLogger (line 15) | class AppLogger(logging.Logger, metaclass=Singleton):
    method __init__ (line 20) | def __init__(self, name, level=logging.NOTSET):
    method args_str (line 39) | def args_str(self, *args):
    method debug (line 42) | def debug(self, message, *args):
    method info (line 46) | def info(self, message, *args):
    method success (line 50) | def success(self, message, *args):
    method error (line 55) | def error(self, message, *args):
    method warning (line 59) | def warning(self, message, *args):
    method log_with_color (line 63) | def log_with_color(self, level, message, color, *args, **kwargs):
    method to_file (line 79) | def to_file(self, output: str, log_file):
    method to_file_and_console (line 84) | def to_file_and_console(self, output: str, log_file=None, color=None):
  function setup_logger (line 93) | def setup_logger():

FILE: athina/helpers/package_helper.py
  class PackageHelper (line 4) | class PackageHelper:
    method get_package_version (line 6) | def get_package_version(package_name):

FILE: athina/helpers/run_helper.py
  class RunHelper (line 11) | class RunHelper:
    method all_evals (line 13) | def all_evals():
    method get_evaluator (line 30) | def get_evaluator(eval_name, **kwargs):
    method validate_eval_args (line 43) | def validate_eval_args(eval_name, model, kwargs):
    method _set_keys (line 80) | def _set_keys():
    method run_eval (line 90) | def run_eval(eval_name, model, kwargs):
    method run_eval_on_batch (line 107) | def run_eval_on_batch(eval_name, model, format, **kwargs):
    method run_eval_on_dataset (line 120) | def run_eval_on_dataset(eval_name, model, dataset, **kwargs):

FILE: athina/helpers/step_helper.py
  class StepHelper (line 3) | class StepHelper:
    method prepare_input_data (line 6) | def prepare_input_data(data):

FILE: athina/interfaces/athina.py
  class AthinaInference (line 10) | class AthinaInference:
  class AthinaFilters (line 23) | class AthinaFilters:
    method to_dict (line 30) | def to_dict(self) -> str:
  class AthinaEvalRunResult (line 34) | class AthinaEvalRunResult(TypedDict):
  class AthinaEvalResult (line 41) | class AthinaEvalResult(TypedDict):
  class AthinaEvalRequestSource (line 53) | class AthinaEvalRequestSource(Enum):
  class AthinaEvalRequestCreateRequest (line 59) | class AthinaEvalRequestCreateRequest(TypedDict):
  class AthinaEvalResultCreateRequest (line 66) | class AthinaEvalResultCreateRequest(TypedDict):
  class AthinaJobType (line 86) | class AthinaJobType(Enum):
  class AthinaInterfaceHelper (line 90) | class AthinaInterfaceHelper:
    method eval_result_to_create_request (line 92) | def eval_result_to_create_request(
  class AthinaExperiment (line 124) | class AthinaExperiment(TypedDict):

FILE: athina/interfaces/custom_model_config.py
  class CustomModelConfig (line 5) | class CustomModelConfig(BaseModel):

FILE: athina/interfaces/data.py
  class DataPoint (line 4) | class DataPoint(TypedDict):

FILE: athina/interfaces/model.py
  class Model (line 4) | class Model(Enum):
    method is_supported (line 45) | def is_supported(model_name: str) -> bool:
    method supports_json_mode (line 52) | def supports_json_mode(model_name: str) -> bool:

FILE: athina/interfaces/openai.py
  class OpenAiPromptMessage (line 4) | class OpenAiPromptMessage(TypedDict):

FILE: athina/interfaces/result.py
  class EvalResultMetric (line 8) | class EvalResultMetric(TypedDict):
  class DatapointFieldAnnotation (line 17) | class DatapointFieldAnnotation(TypedDict):
  class EvalResult (line 28) | class EvalResult(TypedDict):
  class BatchRunResult (line 46) | class BatchRunResult:
    method to_df (line 54) | def to_df(self):
  class EvalPerformanceReport (line 97) | class EvalPerformanceReport(TypedDict):
  class GuardResult (line 114) | class GuardResult(BaseModel):

FILE: athina/keys/athina_api_key.py
  class AthinaApiKey (line 4) | class AthinaApiKey(ABC):
    method set_key (line 8) | def set_key(cls, api_key):
    method get_key (line 12) | def get_key(cls):
    method is_set (line 16) | def is_set(cls):

FILE: athina/keys/openai_api_key.py
  class OpenAiApiKey (line 4) | class OpenAiApiKey(ABC):
    method set_key (line 8) | def set_key(cls, api_key):
    method get_key (line 12) | def get_key(cls):

FILE: athina/llms/abstract_llm_service.py
  class AbstractLlmService (line 4) | class AbstractLlmService(ABC):
    method embeddings (line 10) | def embeddings(self, text: str) -> list:
    method chat_completion (line 18) | def chat_completion(self, messages, model, **kwargs):
    method chat_completion_json (line 26) | def chat_completion_json(self, messages, model, **kwargs) -> str:
    method json_completion (line 34) | def json_completion(self, messages, model, **kwargs):
    method chat_stream_completion (line 42) | async def chat_stream_completion(self, messages, model, **kwargs):

FILE: athina/llms/litellm_service.py
  class LitellmService (line 12) | class LitellmService(AbstractLlmService):
    method __new__ (line 16) | def __new__(cls, *args, **kwargs):
    method __init__ (line 21) | def __init__(self, api_key):
    method embeddings (line 24) | def embeddings(self, text: str) -> list:
    method chat_completion (line 31) | def chat_completion(
    method chat_completion_json (line 60) | def chat_completion_json(
    method json_completion (line 65) | def json_completion(
    method chat_stream_completion (line 70) | async def chat_stream_completion(

FILE: athina/llms/openai_service.py
  class OpenAiService (line 16) | class OpenAiService(AbstractLlmService):
    method __new__ (line 19) | def __new__(cls):
    method __init__ (line 24) | def __init__(self):
    method embeddings (line 30) | def embeddings(self, text: str, model: str) -> list:
    method _process_response (line 43) | def _process_response(self, response, start_time, model):
    method chat_completion (line 105) | def chat_completion(self, messages, model, **kwargs) -> str:
    method chat_completion_json (line 122) | def chat_completion_json(self, messages, model, **kwargs) -> str:
    method chat_stream_completion (line 141) | async def chat_stream_completion(self, messages, model, **kwargs):
    method json_completion (line 156) | def json_completion(self, messages, model, **kwargs):

FILE: athina/llms/question_answerer.py
  class QuestionAnswererResponse (line 5) | class QuestionAnswererResponse(TypedDict):
  class QuestionAnswerer (line 10) | class QuestionAnswerer(ABC):
    method answer (line 13) | def answer(self, questions: List[str], context: str) -> QuestionAnswer...

FILE: athina/llms/question_answerer_bulk.py
  class QuestionAnswererBulk (line 7) | class QuestionAnswererBulk(QuestionAnswerer):
    method __init__ (line 34) | def __init__(
    method answer (line 48) | def answer(self, questions: List[str], context: str) -> Tuple[dict, di...

FILE: athina/llms/question_answerer_cot.py
  class QuestionAnswererChainOfThought (line 7) | class QuestionAnswererChainOfThought(QuestionAnswerer):
    method __init__ (line 33) | def __init__(
    method answer (line 48) | def answer(self, questions: List[str], context: str) -> Tuple[dict, di...
    method answer_question (line 68) | def answer_question(self, question: str, context: str) -> QuestionAnsw...

FILE: athina/llms/question_answerer_with_retrieval.py
  class ContextFinderStrategy (line 11) | class ContextFinderStrategy(ABC):
    method find_relevant_context_index (line 14) | def find_relevant_context_index(self, question, context_chunks):
  class EmbeddingBasedContextFinder (line 18) | class EmbeddingBasedContextFinder(ContextFinderStrategy):
    method __init__ (line 20) | def __init__(self, preprocessed_context_embeddings):
    method cosine_similarity (line 24) | def cosine_similarity(vec_a, vec_b):
    method find_relevant_context_indices (line 38) | def find_relevant_context_indices(
    method find_relevant_context_index (line 56) | def find_relevant_context_index(self, question_embedding, context_embe...
  class QuestionAnswererWithRetrieval (line 62) | class QuestionAnswererWithRetrieval(QuestionAnswerer):
    method __init__ (line 82) | def __init__(
    method _preprocess_context (line 99) | def _preprocess_context(self, context, chunk_size):
    method _get_relevant_chunks (line 112) | def _get_relevant_chunks(self, question):
    method _answer_question (line 128) | def _answer_question(self, question) -> QuestionAnswererResponse:
    method answer (line 161) | def answer(self, questions: List[str], **kwargs) -> Tuple[dict, dict]:

FILE: athina/llms/question_generator.py
  class QuestionGenerator (line 7) | class QuestionGenerator:
    method __init__ (line 31) | def __init__(
    method generate (line 48) | def generate(self, text: str) -> List[str]:

FILE: athina/loaders/base_loader.py
  class LoadFormat (line 8) | class LoadFormat(Enum):
  class BaseLoader (line 16) | class BaseLoader(ABC):
    method processed_dataset (line 20) | def processed_dataset(self) -> List[DataPoint]:
    method raw_dataset (line 27) | def raw_dataset(self):
    method process (line 34) | def process(self) -> List[DataPoint]:
    method load (line 38) | def load(self, format: str, **kwargs) -> List[DataPoint]:
    method load_json (line 51) | def load_json(self, filename: str) -> List[DataPoint]:
    method load_dict (line 67) | def load_dict(self, data: list) -> List[DataPoint]:
    method load_athina_inferences (line 76) | def load_athina_inferences(self, data: dict) -> List[DataPoint]:

FILE: athina/loaders/conversation_loader.py
  class ConversationLoader (line 5) | class ConversationLoader:
    method __init__ (line 14) | def __init__(
    method load_athina_inferences (line 23) | def load_athina_inferences(
    method load_from_string_array (line 34) | def load_from_string_array(self, strings: List[str]):
    method load_from_openai_messages (line 45) | def load_from_openai_messages(self, messages: List[List[Dict[str, str]...

FILE: athina/loaders/json_loader.py
  class JsonLoader (line 10) | class JsonLoader(BaseLoader):
    method __init__ (line 21) | def __init__(
    method process (line 34) | def process(self) -> None:
    method load_athina_inferences (line 67) | def load_athina_inferences(

FILE: athina/loaders/loader.py
  class DataPoint (line 9) | class DataPoint(BaseDataPoint):
  class Loader (line 18) | class Loader(BaseLoader):
    method __init__ (line 31) | def __init__(
    method process (line 48) | def process(self) -> None:
    method load_athina_inferences (line 88) | def load_athina_inferences(

FILE: athina/loaders/response_loader.py
  class ResponseLoader (line 9) | class ResponseLoader(BaseLoader):
    method __init__ (line 19) | def __init__(
    method process (line 36) | def process(self) -> None:
    method load_athina_inferences (line 75) | def load_athina_inferences(

FILE: athina/loaders/summary_loader.py
  class SummaryDataPoint (line 9) | class SummaryDataPoint(DataPoint):
  class SummaryLoader (line 16) | class SummaryLoader(BaseLoader):
    method __init__ (line 27) | def __init__(
    method process (line 40) | def process(self) -> None:
    method load_athina_inferences (line 62) | def load_athina_inferences(

FILE: athina/loaders/text_loader.py
  class TextLoader (line 9) | class TextLoader(BaseLoader):
    method __init__ (line 19) | def __init__(
    method process (line 32) | def process(self) -> None:
    method load_athina_inferences (line 58) | def load_athina_inferences(

FILE: athina/metrics/agreement_score.py
  class AgreementScore (line 4) | class AgreementScore(Metric):
    method _compute_metric (line 13) | def _compute_metric(answers_src, answers_sum, questions):
    method compute (line 36) | def compute(answers_src, answers_sum, questions, n_questions):

FILE: athina/metrics/contradiction_score.py
  class ContradictionScore (line 4) | class ContradictionScore(Metric):
    method _compute_metric (line 19) | def _compute_metric(answers_src, answers_sum, questions):
    method compute (line 49) | def compute(answers_src, answers_sum, questions, n_questions):

FILE: athina/metrics/groundedness.py
  class GroundednessEvidence (line 5) | class GroundednessEvidence(TypedDict):
  class GroundednessScore (line 10) | class GroundednessScore(ABC):
    method compute (line 16) | def compute(sentences_with_evidence: List[GroundednessEvidence]):

FILE: athina/metrics/hallucination_score.py
  class HallucinationScore (line 4) | class HallucinationScore(Metric):
    method _compute_metric (line 15) | def _compute_metric(answers_src, answers_sum, questions):
    method compute (line 44) | def compute(answers_src, answers_sum, questions, n_questions):

FILE: athina/metrics/metric.py
  class Metric (line 4) | class Metric(ABC):
    method compute (line 10) | def compute(self, *args, **kwargs):

FILE: athina/metrics/metric_type.py
  class MetricType (line 13) | class MetricType(Enum):
    method get_class (line 39) | def get_class(metric_type):

FILE: athina/metrics/passed.py
  class Passed (line 5) | class Passed(Metric):
    method compute (line 11) | def compute(passed: Union[int, bool]):

FILE: athina/metrics/ragas_metric.py
  class RagasMetric (line 4) | class RagasMetric(Metric):
    method compute (line 10) | def compute(value: float):

FILE: athina/metrics/similarity_score.py
  class SimilarityScore (line 6) | class SimilarityScore(Metric):
    method compute (line 12) | def compute(similarity_score: Union[int, float, Decimal]) -> Decimal:

FILE: athina/runner/run.py
  class DataPointWithEvalResults (line 19) | class DataPointWithEvalResults(TypedDict):
  class LlmEvaluatorDescription (line 26) | class LlmEvaluatorDescription(TypedDict):
  class LlmBatchEvalResult (line 33) | class LlmBatchEvalResult(TypedDict):
  class EvalRunner (line 44) | class EvalRunner:
    method eval_results_link (line 46) | def eval_results_link(eval_request_id: str):
    method flatten_eval_results (line 50) | def flatten_eval_results(batch_eval_results) -> List:
    method _create_eval_request (line 60) | def _create_eval_request(eval_suite_name: str, data) -> Optional[str]:
    method _log_experiment (line 72) | def _log_experiment(experiment, eval_request_id: Optional[str]):
    method _log_evaluation_results (line 83) | def _log_evaluation_results(
    method to_df (line 96) | def to_df(batch_eval_results):
    method _log_eval_results_with_config (line 131) | def _log_eval_results_with_config(
    method _log_dataset_to_athina (line 159) | def _log_dataset_to_athina(data: List[DataPoint]) -> Optional[str]:
    method _fetch_dataset_rows (line 171) | def _fetch_dataset_rows(
    method run_suite (line 187) | def run_suite(

FILE: athina/runner/run_wrapper.py
  function run (line 4) | def run(evals, data=None, max_parallel_evals=5, dataset_id=None, number_...

FILE: athina/scripts/guardrails.py
  function install (line 4) | def install():

FILE: athina/services/athina_api_service.py
  class AthinaApiService (line 22) | class AthinaApiService:
    method _headers (line 24) | def _headers():
    method fetch_inferences (line 31) | def fetch_inferences(
    method log_usage (line 69) | def log_usage(eval_name: str, run_type: str):
    method log_eval_results (line 92) | def log_eval_results(
    method create_dataset (line 127) | def create_dataset(dataset: Dict):
    method fetch_dataset_rows (line 155) | def fetch_dataset_rows(dataset_id: str, number_of_rows: Optional[int] ...
    method add_dataset_rows (line 182) | def add_dataset_rows(dataset_id: str, rows: List[Dict]):
    method create_eval_request (line 220) | def create_eval_request(
    method log_eval_performance_report (line 253) | def log_eval_performance_report(
    method log_experiment (line 299) | def log_experiment(
    method log_eval_results_with_config (line 343) | def log_eval_results_with_config(eval_results_with_config: dict):

FILE: athina/steps/api.py
  function prepare_template_data (line 11) | def prepare_template_data(
  function debug_json_structure (line 26) | def debug_json_structure(body_str: str, error: json.JSONDecodeError) -> ...
  function prepare_body (line 39) | def prepare_body(
  class ApiCall (line 49) | class ApiCall(Step):
    class Config (line 71) | class Config:
    method process_binary_response (line 74) | def process_binary_response(
    method process_response (line 147) | def process_response(
    method execute_async (line 178) | async def execute_async(self, input_data: Any) -> Union[Dict[str, Any]...
    method execute (line 263) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/base.py
  class StepError (line 23) | class StepError(Exception):
  class StepResult (line 29) | class StepResult(TypedDict):
  function step (line 35) | def step(func: Callable) -> Callable:
  class Step (line 58) | class Step(BaseModel):
    method to_dict (line 73) | def to_dict(self) -> Dict[str, Any]:
    method extract_input_data (line 77) | def extract_input_data(self, context: Dict[str, Any]) -> Any:
    method prepare_dict (line 94) | def prepare_dict(
    method _create_step_result (line 119) | def _create_step_result(
    method _create_jinja_env (line 148) | def _create_jinja_env(
    method run (line 161) | def run(
    method execute (line 174) | def execute(self, input_data: Any) -> Any:
    method execute_async (line 178) | async def execute_async(self, input_data: Any) -> Any:
  class Debug (line 183) | class Debug(Step):
    method run (line 193) | def run(self, context: Dict[str, Any], history: List[Dict[str, Any]]) ...
    method execute (line 200) | def execute(self, input_data: Any) -> None:
  class Fn (line 206) | class Fn(Step):
    method execute (line 216) | def execute(self, input_data: Any) -> Any:

FILE: athina/steps/browser_use_step.py
  class BrowserUseStep (line 16) | class BrowserUseStep(Step):
    method execute (line 39) | def execute(self, input_data: Any) -> StepResult:
    method _run_browser_agent (line 86) | async def _run_browser_agent(self, llm: ChatOpenAI, task: str) -> str:

FILE: athina/steps/chain.py
  class Chain (line 8) | class Chain(BaseModel):
    method run (line 20) | def run(self, inputs: Dict[str, Any]) -> "Chain":
    method get_context (line 34) | def get_context(self) -> Dict[str, Any]:
    method get_output (line 38) | def get_output(self, key: Optional[str] = None) -> Any:
    method execute (line 53) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/chroma_retrieval.py
  class AuthType (line 14) | class AuthType(str, Enum):
  class ChromaRetrieval (line 20) | class ChromaRetrieval(Step):
    class Config (line 48) | class Config:
    method __init__ (line 51) | def __init__(self, *args, **kwargs):
    method execute (line 81) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:
    method close (line 124) | def close(self):

FILE: athina/steps/classify_text.py
  class ClassifyText (line 8) | class ClassifyText(Step):
    method execute (line 24) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/code_execution.py
  class CodeExecution (line 11) | class CodeExecution(Step):
    method format_bandit_result (line 22) | def format_bandit_result(self, stdout: str) -> str:
    method bandit_check (line 68) | def bandit_check(self, code: str) -> Optional[str]:
    method execute (line 89) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/code_execution_v2.py
  class StepResult (line 33) | class StepResult(TypedDict):
  function _serialize_variable (line 40) | def _serialize_variable(name: str, value: Any) -> Optional[str]:
  function generate_variable_capture (line 60) | def generate_variable_capture(step_name: str) -> str:
  class CodeExecutionV2 (line 89) | class CodeExecutionV2(Step):
    method __init__ (line 114) | def __init__(
    method _create_or_initialize_sandbox (line 124) | def _create_or_initialize_sandbox(self, session_id: Optional[str] = No...
    method _create_step_result (line 156) | def _create_step_result(
    method _execute_local (line 186) | def _execute_local(self, input_data: dict, start_time: float) -> StepR...
    method _prepare_input_variables (line 208) | def _prepare_input_variables(self, input_data: dict) -> list[str]:
    method _extract_exported_vars (line 227) | def _extract_exported_vars(self, stdout: str) -> dict:
    method _execute_e2b (line 245) | def _execute_e2b(self, input_data: dict, start_time: float) -> StepRes...
    method execute (line 350) | def execute(self, input_data: Any) -> StepResult:
    method _execute_e2b_stream (line 396) | async def _execute_e2b_stream(self, input_data: dict, start_time: float):
    method execute_stream (line 550) | async def execute_stream(self, input_data: Any):

FILE: athina/steps/conditional.py
  class ConditionalStep (line 7) | class ConditionalStep(Step):
    method _evaluate_condition (line 14) | def _evaluate_condition(self, condition: str, context: Dict) -> bool:
    method _execute_branch_steps (line 37) | def _execute_branch_steps(self, steps: List[Step], inputs: Dict) -> Dict:
    method execute (line 58) | def execute(self, input_data: Dict) -> Dict:

FILE: athina/steps/extract_entities.py
  class ExtractEntities (line 8) | class ExtractEntities(Step):
    method execute (line 24) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/extract_json_path.py
  class ExtractJsonPath (line 8) | class ExtractJsonPath(Step):
    method execute (line 20) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/iterator.py
  class Map (line 6) | class Map(Step):
    method execute (line 16) | def execute(self, input_data: Any) -> List[Any]:

FILE: athina/steps/llm.py
  class TextContent (line 18) | class TextContent(BaseModel):
  class ImageContent (line 23) | class ImageContent(BaseModel):
    method to_api_format (line 27) | def to_api_format(self):
  class PromptMessage (line 36) | class PromptMessage(BaseModel):
    method to_api_format (line 41) | def to_api_format(self) -> dict:
  class ModelOptions (line 82) | class ModelOptions(BaseModel):
    method model_dump (line 91) | def model_dump(self, *args, **kwargs):
  class ToolConfig (line 111) | class ToolConfig(BaseModel):
  class PromptTemplate (line 116) | class PromptTemplate(BaseModel):
    class Config (line 120) | class Config:
    method simple (line 124) | def simple(message: str) -> "PromptTemplate":
    method resolve (line 129) | def resolve(self, **kwargs) -> List[PromptMessage]:
  class PromptExecution (line 213) | class PromptExecution(Step):
    method __init__ (line 232) | def __init__(self, *args, **kwargs):
    class Config (line 239) | class Config:
    method simple (line 243) | def simple(
    method execute (line 258) | def execute(self, input_data: dict, **kwargs) -> str:
    method execute_async (line 346) | async def execute_async(self, input_data: dict, **kwargs) -> dict:
    method execute_stream (line 432) | async def execute_stream(self, input_data: dict, **kwargs):

FILE: athina/steps/loop.py
  class Loop (line 10) | class Loop(Step):
    method _execute_single_step (line 18) | async def _execute_single_step(self, step: Step, context: Dict) -> Dict:
    method _execute_sequence (line 28) | async def _execute_sequence(self, inputs: Dict, semaphore: asyncio.Sem...
    method _execute_loop (line 50) | async def _execute_loop(self, inputs: Dict) -> Dict:
    method execute (line 96) | def execute(self, inputs: Dict) -> Dict:

FILE: athina/steps/open_ai_assistant.py
  class OpenAiAssistant (line 9) | class OpenAiAssistant(Step):
    class Config (line 24) | class Config:
    method __init__ (line 27) | def __init__(self, assistant_id: str, openai_api_key: str, input_colum...
    method execute (line 35) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/parse_document.py
  class ParseDocument (line 10) | class ParseDocument(Step):
    method execute (line 27) | def execute(self, input_data) -> Union[Dict[str, Any], None]:

FILE: athina/steps/pinecone_retrieval.py
  class PineconeRetrieval (line 13) | class PineconeRetrieval(Step):
    method __init__ (line 41) | def __init__(self, *args, **kwargs):
    class Config (line 70) | class Config:
    method execute (line 73) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/qdrant_retrieval.py
  class QdrantRetrieval (line 14) | class QdrantRetrieval(Step):
    method __init__ (line 38) | def __init__(self, *args, **kwargs):
    class Config (line 54) | class Config:
    method execute (line 57) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/research_agent_step.py
  class StreamLogHandler (line 19) | class StreamLogHandler(logging.Handler):
    method __init__ (line 20) | def __init__(self):
    method emit (line 24) | def emit(self, record):
    method get_logs (line 28) | def get_logs(self):
  function get_token_count (line 54) | def get_token_count(text: str, model: str = DEFAULT_MODEL) -> int:
  function truncate_to_token_limit (line 65) | def truncate_to_token_limit(
  function prepare_for_llm (line 93) | def prepare_for_llm(
  class ResearchAgent (line 128) | class ResearchAgent(Step):
    class Config (line 155) | class Config:
    method __init__ (line 158) | def __init__(self, **data):
    method _create_jinja_env (line 193) | def _create_jinja_env(self) -> Environment:
    method _create_step_result (line 197) | def _create_step_result(
    method _extract_evaluation_criteria (line 214) | def _extract_evaluation_criteria(self, prompt: str) -> Dict[str, Any]:
    method _execute_search (line 305) | def _execute_search(self, query: str) -> List[Dict[str, Any]]:
    method _execute_exa_search (line 316) | def _execute_exa_search(self, query: str) -> List[Dict[str, Any]]:
    method _execute_perplexity_search (line 348) | def _execute_perplexity_search(self, query: str) -> List[Dict[str, Any]]:
    method _evaluate_progress (line 424) | def _evaluate_progress(
    method _synthesize_findings (line 475) | def _synthesize_findings(self, prompt: str, context: str) -> str:
    method execute (line 560) | def execute(self, input_data: Any) -> Dict[str, Any]:
    method execute_stream (line 761) | async def execute_stream(self, input_data: Any) -> AsyncGenerator[str,...

FILE: athina/steps/search.py
  function prepare_input_data (line 11) | def prepare_input_data(data):
  class Search (line 18) | class Search(Step):
    class Config (line 56) | class Config:
    method execute (line 59) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/spider_crawl.py
  function prepare_input_data (line 10) | def prepare_input_data(data):
  class SpiderCrawl (line 17) | class SpiderCrawl(Step):
    class Config (line 36) | class Config:
    method execute (line 39) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:

FILE: athina/steps/tool_call_agent.py
  class ToolCallAgent (line 14) | class ToolCallAgent(Step):
    method execute (line 33) | def execute(self, input_data: Any) -> StepResult:

FILE: athina/steps/transcribe_speech_to_text.py
  class TranscribeSpeechToText (line 7) | class TranscribeSpeechToText(Step):
    method execute (line 41) | def execute(self, input_data: Any) -> Dict[str, Any]:

FILE: athina/steps/transform.py
  class ExtractJsonFromString (line 6) | class ExtractJsonFromString(Step):
    method execute (line 11) | def execute(
  class ExtractNumberFromString (line 30) | class ExtractNumberFromString(Step):
    method execute (line 35) | def execute(self, input_data: str) -> Union[int, float]:

FILE: athina/steps/utils/metadata.py
  function get_filtered_metadata (line 17) | def get_filtered_metadata(data: Union[Dict[str, Any], str]) -> Dict[str,...

FILE: athina/steps/weaviate_retrieval.py
  class WeaviateRetrieval (line 13) | class WeaviateRetrieval(Step):
    method __init__ (line 41) | def __init__(self, *args, **kwargs):
    class Config (line 51) | class Config:
    method execute (line 54) | def execute(self, input_data: Any) -> Union[Dict[str, Any], None]:
    method close (line 129) | def close(self):