How to use the cassiopeia.type.core function in cassiopeia

if ids is not None:
        items = {item.id: item for item in get_items()}
        results = []
        for id_ in ids:
            try:
                item = items[id_]
            except KeyError:
                item = None
            results.append(item)
        return results
    else:
        if cassiopeia.core.requests.data_store.has_all(cassiopeia.type.core.staticdata.Item):
            return cassiopeia.core.requests.data_store.get_all(cassiopeia.type.core.staticdata.Item)

        items = cassiopeia.dto.staticdataapi.get_items()
        items = [cassiopeia.type.core.staticdata.Item(item[1]) for item in items.data.items()]

        cassiopeia.core.requests.data_store.store(items, [item.id for item in items], [cassiopeia.type.core.staticdata.Item])
        return items

def _sa_bind_banned_champion():
    global BannedChampion

    @cassiopeia.type.core.common.inheritdocs
    class BannedChampion(BannedChampion, cassiopeia.type.dto.common.BaseDB):
        __tablename__ = "FeaturedGameBannedChampion"
        championId = sqlalchemy.Column(sqlalchemy.Integer)
        pickTurn = sqlalchemy.Column(sqlalchemy.Integer)
        teamId = sqlalchemy.Column(sqlalchemy.Integer)
        _id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
        _game_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("FeaturedGameInfo.gameId", ondelete="CASCADE"))

def _sa_bind_basic_data_stats():
    global BasicDataStats

    @cassiopeia.type.core.common.inheritdocs
    class BasicDataStats(BasicDataStats, cassiopeia.type.dto.common.BaseDB):
        __tablename__ = "ItemStats"
        FlatArmorMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatAttackSpeedMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatBlockMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatCritChanceMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatCritDamageMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatEXPBonus = sqlalchemy.Column(sqlalchemy.Float)
        FlatEnergyPoolMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatEnergyRegenMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatHPPoolMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatHPRegenMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatMPPoolMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatMPRegenMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatMagicDamageMod = sqlalchemy.Column(sqlalchemy.Float)
        FlatMovementSpeedMod = sqlalchemy.Column(sqlalchemy.Float)

def set_region(region):
    """
    Set the region to run API queries against

    Args:
        region (str | cassiopeia.type.core.common.Region): the region to query against
    """
    if not isinstance(region, cassiopeia.type.core.common.Region):
        region = cassiopeia.type.core.common.Region(region.lower())
    cassiopeia.dto.requests.region = region.value

def create_tournament_provider(region, url):
    """
    Creates a tournament provider

    Args:
        region (str | TournamentRegion): the region in which the provider will be running tournaments
        url (str): the provider's callback URL to which tournament game results in this region should be posted. The URL must be well-formed, use the http or https protocol, and use the default port for the protocol (http URLs must use port 80, https URLs must use port 443).

    Returns:
        int: the tournament provider ID
    """
    if isinstance(region, cassiopeia.type.core.common.Region):
        region = cassiopeia.type.core.tournament.TournamentRegion(region.value.upper())
    elif not isinstance(region, cassiopeia.type.core.tournament.TournamentRegion):
        region = cassiopeia.type.core.tournament.TournamentRegion(region.upper())

    parameters = cassiopeia.type.dto.tournament.ProviderRegistrationParameters(region.value, url)
    return cassiopeia.dto.tournamentapi.create_tournament_provider(parameters)

Args:
        summoner (Summoner): the summoner to get recent games for

    Returns:
        list: the summoner's recent games
    """
    games = cassiopeia.dto.gameapi.get_recent_games(summoner.id)

    # Load required data if loading policy is eager
    if cassiopeia.core.requests.load_policy is cassiopeia.type.core.common.LoadPolicy.eager:
        summoner_ids = games.summoner_ids
        cassiopeia.riotapi.get_summoners_by_id(list(summoner_ids)) if summoner_ids else None
        cassiopeia.riotapi.get_summoner_spells() if games.summoner_spell_ids else None

    return [cassiopeia.type.core.game.Game(game, games.summonerId) for game in games.games]

def get_champion_mastery_score(summoner_id):
    """
    https://developer.riotgames.com/api/methods#!/1034/3546

    Args:
        summoner_id (int): the summoner ID to get champion masteries for

    Returns:
        int: the summoner's total champion mastery score
    """
    region = cassiopeia.type.core.common.Region(cassiopeia.dto.requests.region)
    platform = cassiopeia.type.core.common.Platform[region.name]

    # Get JSON response
    request = "https://{server}.api.pvp.net/championmastery/location/{platform}/player/{summonerId}/score".format(server=cassiopeia.dto.requests.region, platform=platform.value, summonerId=summoner_id)
    return cassiopeia.dto.requests.get(request, include_base=False)

import datetime

import cassiopeia.riotapi
import cassiopeia.type.core.common
import cassiopeia.type.dto.summoner


@cassiopeia.type.core.common.inheritdocs
class RunePage(cassiopeia.type.core.common.CassiopeiaObject):
    dto_type = cassiopeia.type.dto.summoner.RunePage

    def __str__(self):
        return "Rune Page ({name})".format(name=self.name)

    def __iter__(self):
        return iter(self.runes)

    def __len__(self):
        return len(self.runes)

    def __getitem__(self, index):
        return self.runes[index]

    def __eq__(self, other):
        return self.id == other.id

def __get_rune_pages_by_id(ids):
    pages = cassiopeia.core.requests.call_with_ensured_size(cassiopeia.dto.summonerapi.get_summoner_runes, 40, ids)

    # Load required data if loading policy is eager
    if cassiopeia.core.requests.load_policy is cassiopeia.type.core.common.LoadPolicy.eager:
        rune_ids = set()
        for page in pages.values():
            rune_ids |= page.rune_ids
        cassiopeia.riotapi.get_runes() if rune_ids else None

    if not isinstance(ids, list):
        return [cassiopeia.type.core.summoner.RunePage(page) for page in pages[str(ids)].pages]
    else:
        return [[cassiopeia.type.core.summoner.RunePage(page) for page in pages[str(id_)].pages] for id_ in ids]

def get_champion_mastery(summoner, champion):
    """
    Gets the ChampionMastery object for the specified summoner and champion

    Args:
        summoner (Summoner): the summoner to get champion mastery for
        champion (Champion): the desired champion

    Returns:
        ChampionMastery: the summoner's champion mastery value for the specified champion
    """
    champion_mastery = cassiopeia.dto.championmasteryapi.get_champion_mastery(summoner.id, champion.id)
    return cassiopeia.type.core.championmastery.ChampionMastery(champion_mastery)