Client

@classmethod
def __validate(cls, model_type, result):
    try:
        validated = model_type.model_validate(result)
        return validated
    except Exception as e:
        # introduced to deal with API changes
        _logger.error('result', resp=e)

def answer(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> Answer:  # noqa: A002
    """Returns a specific answer"""
    return self._endpoint_id(Answer, event_slug, 'answers', id, params=params)

def answers(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Answer]]:
    """Lists all answers and their details"""
    return self._endpoint_lst(Answer, event_slug, 'answers', params=params)

def clear_caches(self) -> None:
    """Clear all session caches.

    This is useful if you want to force fresh data to be fetched from the API.
    Note that caches are session-only and are not persisted between client instances.
    """
    self._speaker_cache.clear()
    self._submission_type_cache.clear()
    self._track_cache.clear()
    self._answer_cache.clear()
    self._question_cache.clear()
    self._caches_populated.clear()
    _logger.info('All caches cleared')

def event(self, event_slug: str, *, params: QueryParams | dict | None = None) -> Event:
    """Returns detailed information about a specific event"""
    endpoint = f'/api/events/{event_slug}/'
    result = self._get_one(endpoint, params)
    _logger.debug('result', resp=result)
    return self.__validate(Event, result)

def events(self, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Event]]:
    """Lists all events and their details"""
    count, results = self._get_many('/api/events/', params)
    events = iter(_logger.debug('result', resp=r) or Event.model_validate(r) for r in results)
    return count, events

def me(self) -> Me:
    """Returns what Pretalx knows about myself"""
    result = self._get_one('/api/me/')
    return self.__validate(Me, result)

def question(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> Question:  # noqa: A002
    """Returns a specific question"""
    return self._endpoint_id(Question, event_slug, 'questions', id, params=params)

def questions(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Question]]:
    """Lists all questions and their details"""
    return self._endpoint_lst(Question, event_slug, 'questions', params=params)

def review(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> Review:  # noqa: A002
    """Returns a specific review"""
    return self._endpoint_id(Review, event_slug, 'reviews', id, params=params)

def reviews(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Review]]:
    """Lists all reviews and their details"""
    return self._endpoint_lst(Review, event_slug, 'reviews', params=params)

def room(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> Room:  # noqa: A002
    """Returns a specific room"""
    return self._endpoint_id(Room, event_slug, 'rooms', id, params=params)

def rooms(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Room]]:
    """Lists all rooms and their details"""
    return self._endpoint_lst(Room, event_slug, 'rooms', params=params)

def set_cache_prepopulation(self, enabled: bool) -> None:  # noqa: FBT001
    """Enable or disable automatic cache pre-population for submissions.

    When enabled (default), the client will fetch all speakers, submission types,
    and tracks in bulk on the first submission to minimize API calls.
    Disable this if you're only fetching a few submissions.

    Args:
        enabled: Whether to enable cache pre-population
    """
    self._use_cache_prepopulation = enabled
    _logger.info(f'Cache pre-population {"enabled" if enabled else "disabled"}')

def set_throttling(self, calls: int, seconds: int):
    """Throttle the number of calls per seconds to the Pretalx API"""
    _logger.info('throttling', calls=calls, seconds=seconds)
    self._get_throttled = throttle(calls, seconds)(self._get)

def speaker(self, event_slug: str, code: str, *, params: QueryParams | dict | None = None) -> Speaker:
    """Returns a specific speaker"""
    return self._endpoint_id(Speaker, event_slug, 'speakers', code, params=params)

def speakers(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Speaker]]:
    """Lists all speakers and their details"""
    return self._endpoint_lst(Speaker, event_slug, 'speakers', params=params)

def submission(self, event_slug: str, code: str, *, params: QueryParams | dict | None = None) -> Submission:
    """Returns a specific submission"""
    return self._endpoint_id(Submission, event_slug, 'submissions', code, params=params)

def submission_type(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> SubmissionType:  # noqa: A002
    """Returns a specific submission type"""
    return self._endpoint_id(SubmissionType, event_slug, 'submission-types', id, params=params)

def submission_types(
    self, event_slug: str, *, params: QueryParams | dict | None = None
) -> tuple[int, Iterator[SubmissionType]]:
    """Lists all submission types and their details"""
    return self._endpoint_lst(SubmissionType, event_slug, 'submission-types', params=params)

def submissions(
    self, event_slug: str, *, params: QueryParams | dict | None = None
) -> tuple[int, Iterator[Submission]]:
    """Lists all submissions and their details"""
    return self._endpoint_lst(Submission, event_slug, 'submissions', params=params)

def tag(self, event_slug: str, tag: str, *, params: QueryParams | dict | None = None) -> Tag:
    """Returns a specific tag"""
    return self._endpoint_id(Tag, event_slug, 'tags', tag, params=params)

def tags(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Tag]]:
    """Lists all tags and their details"""
    return self._endpoint_lst(Tag, event_slug, 'tags', params=params)

def talk(self, event_slug: str, code: str, *, params: QueryParams | dict | None = None) -> Talk:
    """Returns a specific talk"""
    try:
        return self._endpoint_id(Talk, event_slug, 'talks', code, params=params)
    except httpx.HTTPStatusError as e:
        if e.response.status_code == HTTP_NOT_FOUND:
            _logger.info('talk endpoint not available, using submission endpoint')
            # Use submission endpoint but validate as Talk object
            return self._endpoint_id(Talk, event_slug, 'submissions', code, params=params)
        raise

def talks(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Talk]]:
    """Lists all talks and their details"""
    try:
        return self._endpoint_lst(Talk, event_slug, 'talks', params=params)
    except httpx.HTTPStatusError as e:
        if e.response.status_code == HTTP_NOT_FOUND:
            _logger.info('talks endpoint not available, using submissions endpoint')
            # Use submissions endpoint but validate as Talk objects
            return self._endpoint_lst(Talk, event_slug, 'submissions', params=params)
        raise

def track(self, event_slug: str, id: int, *, params: QueryParams | dict | None = None) -> Track:  # noqa: A002
    """Returns a specific track"""
    return self._endpoint_id(Track, event_slug, 'tracks', id, params=params)

def tracks(self, event_slug: str, *, params: QueryParams | dict | None = None) -> tuple[int, Iterator[Track]]:
    """Lists all tracks and their details"""
    return self._endpoint_lst(Track, event_slug, 'tracks', params=params)