Reference

def clear_gsheet(self, spreadsheet_id: str, worksheet_name: str):
    """Clear the worksheet including values, formatting, filtering, etc."""
    worksheet = self.gsheet(spreadsheet_id, worksheet_name, create_ws=False)
    default_fmt = get_default_format(worksheet.spreadsheet)
    wrange = worksheet_range(worksheet)
    try:
        worksheet.clear()
        worksheet.clear_basic_filter()
        format_cell_range(worksheet, wrange, default_fmt)
        rules = get_conditional_format_rules(worksheet)
        rules.clear()
        rules.save()
        set_data_validation_for_cell_range(worksheet, wrange, None)
    except APIError as error:
        self._exception_feedback(error)

def gsheet(
    self, spreadsheet_id: str, worksheet_name: str | None = None, *, create_ws: bool = False
) -> Worksheet | Spreadsheet:
    """Retrieve a Google sheet by its id and the name

    Open a Google sheet in your browser and check the URL to retrieve the id, e.g.:
    https://docs.google.com/spreadsheets/d/SPREEDSHEET_ID/edit...

    If the spreadsheet as several worksheets (check the lower bar) then `worksheet_name` can be used to
    specify a specific one.
    """
    spreadsheet = self.gc.open_by_key(spreadsheet_id)
    if worksheet_name is None:
        return spreadsheet
    elif worksheet_name in [ws.title for ws in spreadsheet.worksheets()]:
        return spreadsheet.worksheet(worksheet_name)
    elif create_ws:
        worksheet = spreadsheet.add_worksheet(title=worksheet_name, rows=100, cols=20)
        self._wait_for_worksheet(spreadsheet_id, worksheet_name)
        return worksheet
    else:
        return spreadsheet.worksheet(worksheet_name)  # raises exception

def gsheet_as_df(self, spreadsheet_id: str, worksheet_name: str, **kwargs: str | (bool | int)) -> pd.DataFrame:
    """Returns a worksheet as dataframe"""
    worksheet = self.gsheet(spreadsheet_id, worksheet_name)
    df = get_as_dataframe(worksheet, **kwargs)
    # remove Nan rows & columns as they are exported by default
    df.dropna(how='all', inplace=True, axis=0)
    df.dropna(how='all', inplace=True, axis=1)
    return df

def recreate_token(self):
    """Recreate the current token using the scopes given at initialization"""
    self._config.Google.token_json.unlink(missing_ok=True)
    self.gc = gspread_client(self._scopes, self._config)

def save_df_as_gsheet(
    self,
    df: pd.DataFrame,
    spreadsheet_id: str,
    worksheet_name: str,
    *,
    create_ws: bool = False,
    default_fmt: bool = True,
    **kwargs: str | (bool | int),
):
    """Save the given dataframe as worksheet in a spreadsheet

    Make sure that the scope passed gives you write permissions

    Args:
        df: dataframe to save
        spreadsheet_id: id of the Google spreadsheet
        worksheet_name: name of the worksheet within the spreadsheet
        create_ws: create the worksheet if non-existent
        default_fmt: apply default formatter `BasicFormatter`
        **kwargs: extra keyword arguments passed to `set_with_dataframe`
    """
    worksheet = self.gsheet(spreadsheet_id, worksheet_name, create_ws=create_ws)
    # make sure it's really only the dataframe, not some residue
    self.clear_gsheet(spreadsheet_id, worksheet_name)
    params = {'resize': True} | dict(**kwargs)  # set sane defaults
    try:
        set_with_dataframe(worksheet, df, **params)
        if default_fmt:
            format_with_dataframe(worksheet, df)
    except APIError as error:
        self._exception_feedback(error)

def create_ticket(self, ticket: NewTicket):
    return self.post('tickets', data=ticket.model_dump())

def get(self, endpoint: str, params: QueryParams | None = None) -> JSON:
    """Retrieve data via throttled GET request and return the JSON"""
    resp = self._get_throttled(endpoint, params)
    resp.raise_for_status()
    return resp.json()

def list_agents(self) -> list[Agent]:
    agents = self.get('agents')
    if not isinstance(agents, list):
        msg = 'Received JSON is not a list object'
        raise ValueError(msg)
    return [Agent.model_validate(dct) for dct in agents]

def list_teams(self) -> list[Team]:
    teams = self.get('teams')
    if not isinstance(teams, list):
        msg = 'Received JSON is not a list object'
        raise ValueError(msg)
    return [Team.model_validate(dct) for dct in teams]

def post(self, endpoint: str, data: dict[str, Any], params: QueryParams | None = None) -> JSON:
    resp = self._post_throttled(endpoint, data, params)
    resp.raise_for_status()
    return resp.json()

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

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

def event(self, event_slug: str, *, params: QueryParams | 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 Event.model_validate(result)

def events(self, *, params: QueryParams | 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 Me.model_validate(result)

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

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 | 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 | 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 | None = None) -> Submission:
    """Returns a specific submission"""
    return self._endpoint_id(Submission, event_slug, 'submissions', code, params=params)

def submissions(self, event_slug: str, *, params: QueryParams | 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 | 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 | 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 | None = None) -> Talk:
    """Returns a specific talk"""
    return self._endpoint_id(Talk, event_slug, 'talks', code, params=params)

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