bacommon package

Subpackages

• bacommon.workspace package
  • Submodules
  • bacommon.workspace.assetsv1 module
    • AssetsV1GlobalVals
      • AssetsV1GlobalVals.base_assets
      • AssetsV1GlobalVals.base_assets_filter
    • AssetsV1PathVals
      • AssetsV1PathVals.get_type()
      • AssetsV1PathVals.get_type_id()
      • AssetsV1PathVals.get_type_id_storage_name()
    • AssetsV1PathValsTexV1
      • AssetsV1PathValsTexV1.TextureQuality
      • AssetsV1PathValsTexV1.get_type_id()
      • AssetsV1PathValsTexV1.texture_quality
    • AssetsV1PathValsTypeID
      • AssetsV1PathValsTypeID.TEX_V1
  • Module contents

Submodules

bacommon.app module

Common high level values/functionality related to apps.

class bacommon.app.AppArchitecture(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Processor architecture the App is running on.

ARM = 'arm'

ARM64 = 'arm64'

X86 = 'x86'

X86_64 = 'x86_64'

class bacommon.app.AppExperience(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

A particular experience that can be provided by a Ballistica app.

This is one metric used to isolate different playerbases from each other where there might be no technical barriers doing so. For example, a casual one-hand-playable phone game and an augmented reality tabletop game may both use the same scene-versions and networking-protocols and whatnot, but it would make no sense to allow players of one to join servers of the other. AppExperience can be used to keep these player bases separate.

Generally a single Ballistica app targets a single AppExperience. This is not a technical requirement, however. A single app may support multiple experiences, or there may be multiple apps targeting one experience. Cloud components such as leagues are generally associated with an AppExperience so that they are only visible to client apps designed for that play style.

EMPTY = 'empty'

MELEE = 'melee'

REMOTE = 'remote'

class bacommon.app.AppInstanceInfo(interface_idiom: ~typing.Annotated[~bacommon.app.AppInterfaceIdiom, <efro.dataclassio.IOAttrs object at 0x7fd90cf7f560>], locale: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cf7fb30>], device: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90cf7fe30>])

Bases: object

General info about an individual running app.

architecture

alias of Annotated[AppArchitecture, <efro.dataclassio.IOAttrs object at 0x7fd90e4fe300>]

device: IOAttrs object at 0x7fd90cf7e270>]

engine_build

alias of Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90e4fd040>]

engine_version

alias of Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90e4fd370>]

interface_idiom: IOAttrs object at 0x7fd90cfb87d0>]

locale: IOAttrs object at 0x7fd90cfb8950>]

name

alias of Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ee88a70>]

os_version

alias of Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90e4fe750>]

platform

alias of Annotated[AppPlatform, <efro.dataclassio.IOAttrs object at 0x7fd90e4fd280>]

variant

alias of Annotated[AppVariant, <efro.dataclassio.IOAttrs object at 0x7fd90e4fe1b0>]

class bacommon.app.AppInterfaceIdiom(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

A general form-factor or method of experiencing a Ballistica app.

Note that it is possible for a running app to switch idioms (for instance if a mobile device or computer is connected to a TV).

DESKTOP = 'desktop'

PHONE = 'phone'

TABLET = 'tablet'

TV = 'tv'

XR = 'xr'

class bacommon.app.AppPlatform(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Overall platform a Ballistica build is targeting.

Each distinct flavor of an app has a unique combination of AppPlatform and AppVariant. Generally platform describes a set of hardware, while variant describes a destination or purpose for the build.

ANDROID = 'android'

IOS = 'ios'

LINUX = 'linux'

MAC = 'mac'

TVOS = 'tvos'

WINDOWS = 'windows'

class bacommon.app.AppVariant(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

A unique Ballistica build type within a single platform.

Each distinct flavor of an app has a unique combination of AppPlatform and AppVariant. Generally platform describes a set of hardware, while variant describes a destination or purpose for the build.

AMAZON_APPSTORE = 'amazon_appstore'

APP_STORE = 'app_store'

ARCADE = 'arcade'

DEMO = 'demo'

EPIC_GAMES_STORE = 'epic_games_store'

GENERIC = 'generic'

GOOGLE_PLAY = 'google_play'

META = 'meta'

STEAM = 'steam'

TEST = 'test'

WINDOWS_STORE = 'windows_store'

bacommon.assets module

Functionality related to cloud based assets.

class bacommon.assets.AssetPackageBuildState(in_progress_builds: ~typing.Annotated[list[str], <efro.dataclassio.IOAttrs object at 0x7fd90cdb8ef0>] = <factory>, initial_build_count: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90cdb9220>] = 0, error: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90cdb9310>] = None)

Bases: object

Contains info about an in-progress asset cloud build.

error: IOAttrs object at 0x7fd90cdba4e0>] = None

in_progress_builds: IOAttrs object at 0x7fd90cdbacf0>]

initial_build_count: IOAttrs object at 0x7fd90cdbb3e0>] = 0

class bacommon.assets.AssetPackageFlavor(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Flavors for asset package outputs for different platforms/etc.

DESKTOP = 'desktop'

MOBILE = 'mobile'

class bacommon.assets.AssetPackageFlavorManifest(cloudfiles: ~typing.Annotated[dict[str, str], <efro.dataclassio.IOAttrs object at 0x7fd90cdbbbc0>] = <factory>)

Bases: object

A manifest of asset info for a specific flavor of an asset package.

cloudfiles: IOAttrs object at 0x7fd90cdd8830>]

class bacommon.assets.AssetType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Types for individual assets within a package.

COLLISION_MESH = 'collision_mesh'

CUBE_TEXTURE = 'cube_texture'

DATA = 'data'

MESH = 'mesh'

SOUND = 'sound'

TEXTURE = 'texture'

bacommon.bacloud module

Functionality related to the bacloud tool.

class bacommon.bacloud.RequestData(command: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ce1d430>], token: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce1d520>], payload: ~typing.Annotated[dict, <efro.dataclassio.IOAttrs object at 0x7fd90ce1d6a0>], tzoffset: ~typing.Annotated[float, <efro.dataclassio.IOAttrs object at 0x7fd90ce1d700>], isatty: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90ce1d7f0>])

Bases: object

Request sent to bacloud server.

command: IOAttrs object at 0x7fd90ce1ee10>]

isatty: IOAttrs object at 0x7fd90ce1ff20>]

payload: IOAttrs object at 0x7fd90ce689e0>]

token: IOAttrs object at 0x7fd90ce1ff80>]

tzoffset: IOAttrs object at 0x7fd90cf967b0>]

class bacommon.bacloud.ResponseData(message: Annotated[str | None, IOAttrs('m', store_default=False)] = None, message_end: Annotated[str, IOAttrs('m_end', store_default=False)] = '\n', error: Annotated[str | None, IOAttrs('e', store_default=False)] = None, delay_seconds: Annotated[float, IOAttrs('d', store_default=False)] = 0.0, login: Annotated[str | None, IOAttrs('l', store_default=False)] = None, logout: Annotated[bool, IOAttrs('lo', store_default=False)] = False, dir_manifest: Annotated[str | None, IOAttrs('man', store_default=False)] = None, uploads: Annotated[tuple[list[str], str, dict] | None, IOAttrs('u', store_default=False)] = None, uploads_inline: Annotated[list[str] | None, IOAttrs('uinl', store_default=False)] = None, deletes: Annotated[list[str] | None, IOAttrs('dlt', store_default=False)] = None, downloads: Annotated[Downloads | None, IOAttrs('dl', store_default=False)] = None, downloads_inline: Annotated[dict[str, bytes] | None, IOAttrs('dinl', store_default=False)] = None, dir_prune_empty: Annotated[str | None, IOAttrs('dpe', store_default=False)] = None, open_url: Annotated[str | None, IOAttrs('url', store_default=False)] = None, input_prompt: Annotated[tuple[str, bool] | None, IOAttrs('inp', store_default=False)] = None, end_message: Annotated[str | None, IOAttrs('em', store_default=False)] = None, end_message_end: Annotated[str, IOAttrs('eme', store_default=False)] = '\n', end_command: Annotated[tuple[str, dict] | None, IOAttrs('ec', store_default=False)] = None)

Bases: object

Response sent from the bacloud server to the client.

message

If present, client should print this message before any other response processing (including error handling) occurs.

Type:

Annotated[str | None, IOAttrs(‘m’, store_default=False)]

message_end

end arg for message print() call.

Type:

Annotated[str, IOAttrs(‘m_end’, store_default=False)]

error

If present, client should abort with this error message.

Type:

Annotated[str | None, IOAttrs(‘e’, store_default=False)]

delay_seconds

How long to wait before proceeding with remaining response (can be useful when waiting for server progress in a loop).

Type:

Annotated[float, IOAttrs(‘d’, store_default=False)]

login

If present, a token that should be stored client-side and passed with subsequent commands.

Type:

Annotated[str | None, IOAttrs(‘l’, store_default=False)]

logout

If True, any existing client-side token should be discarded.

Type:

Annotated[bool, IOAttrs(‘lo’, store_default=False)]

dir_manifest

If present, client should generate a manifest of this dir. It should be added to end_command args as ‘manifest’.

Type:

Annotated[str | None, IOAttrs(‘man’, store_default=False)]

uploads

If present, client should upload the requested files (arg1) individually to a server command (arg2) with provided args (arg3).

Type:

Annotated[tuple[list[str], str, dict] | None, IOAttrs(‘u’, store_default=False)]

uploads_inline

If present, a list of pathnames that should be gzipped and uploaded to an ‘uploads_inline’ bytes dict in end_command args. This should be limited to relatively small files.

Type:

Annotated[list[str] | None, IOAttrs(‘uinl’, store_default=False)]

deletes

If present, file paths that should be deleted on the client.

Type:

Annotated[list[str] | None, IOAttrs(‘dlt’, store_default=False)]

downloads

If present, describes files the client should individually request from the server if not already present on the client.

Type:

Annotated[Downloads | None, IOAttrs(‘dl’, store_default=False)]

downloads_inline

If present, pathnames mapped to gzipped data to be written to the client. This should only be used for relatively small files as they are all included inline as part of the response.

Type:

Annotated[dict[str, bytes] | None, IOAttrs(‘dinl’, store_default=False)]

dir_prune_empty

If present, all empty dirs under this one should be removed.

Type:

Annotated[str | None, IOAttrs(‘dpe’, store_default=False)]

open_url

If present, url to display to the user.

Type:

Annotated[str | None, IOAttrs(‘url’, store_default=False)]

input_prompt

If present, a line of input is read and placed into end_command args as ‘input’. The first value is the prompt printed before reading and the second is whether it should be read as a password (without echoing to the terminal).

Type:

Annotated[tuple[str, bool] | None, IOAttrs(‘inp’, store_default=False)]

end_message

If present, a message that should be printed after all other response processing is done.

Type:

Annotated[str | None, IOAttrs(‘em’, store_default=False)]

end_message_end

end arg for end_message print() call.

Type:

Annotated[str, IOAttrs(‘eme’, store_default=False)]

end_command

If present, this command is run with these args at the end of response processing.

Type:

Annotated[tuple[str, dict] | None, IOAttrs(‘ec’, store_default=False)]

class Downloads(basepath: Annotated[str | None, IOAttrs('p')], cmd: Annotated[str, IOAttrs('c')], baseargs: Annotated[dict[str, str], IOAttrs('a')], entries: Annotated[list[Entry], IOAttrs('e')])

Bases: object

Info about downloads included in a response.

class Entry(path: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ce848c0>], args: ~typing.Annotated[dict[str, str], <efro.dataclassio.IOAttrs object at 0x7fd90ce84860>])

Bases: object

Individual download.

args: IOAttrs object at 0x7fd90ce85700>]

path: IOAttrs object at 0x7fd90ce85d00>]

baseargs: Annotated[dict[str, str], IOAttrs('a')]

basepath: Annotated[str | None, IOAttrs('p')]

cmd: Annotated[str, IOAttrs('c')]

entries: Annotated[list[Entry], IOAttrs('e')]

delay_seconds: Annotated[float, IOAttrs('d', store_default=False)] = 0.0

deletes: Annotated[list[str] | None, IOAttrs('dlt', store_default=False)] = None

dir_manifest: Annotated[str | None, IOAttrs('man', store_default=False)] = None

dir_prune_empty: Annotated[str | None, IOAttrs('dpe', store_default=False)] = None

downloads: Annotated[Downloads | None, IOAttrs('dl', store_default=False)] = None

downloads_inline: Annotated[dict[str, bytes] | None, IOAttrs('dinl', store_default=False)] = None

end_command: Annotated[tuple[str, dict] | None, IOAttrs('ec', store_default=False)] = None

end_message: Annotated[str | None, IOAttrs('em', store_default=False)] = None

end_message_end: Annotated[str, IOAttrs('eme', store_default=False)] = '\n'

error: Annotated[str | None, IOAttrs('e', store_default=False)] = None

input_prompt: Annotated[tuple[str, bool] | None, IOAttrs('inp', store_default=False)] = None

login: Annotated[str | None, IOAttrs('l', store_default=False)] = None

logout: Annotated[bool, IOAttrs('lo', store_default=False)] = False

message: Annotated[str | None, IOAttrs('m', store_default=False)] = None

message_end: Annotated[str, IOAttrs('m_end', store_default=False)] = '\n'

open_url: Annotated[str | None, IOAttrs('url', store_default=False)] = None

uploads: Annotated[tuple[list[str], str, dict] | None, IOAttrs('u', store_default=False)] = None

uploads_inline: Annotated[list[str] | None, IOAttrs('uinl', store_default=False)] = None

bacommon.bacloud.asset_file_cache_path(filehash: str) → str

Given a sha256 hex file hash, return a storage path.

bacommon.build module

Functionality related to game builds.

class bacommon.build.BuildInfoSet(builds: Annotated[list[Entry], IOAttrs('builds')] = <factory>)

Bases: object

Set of build infos.

class Entry(filename: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ca0b470>], size: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90ca0b440>], version: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ce98140>], build_number: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90cf97ec0>], checksum: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cfb87d0>], createtime: ~typing.Annotated[~datetime.datetime, <efro.dataclassio.IOAttrs object at 0x7fd90cfb89b0>])

Bases: object

Info about a particular app build.

build_number: IOAttrs object at 0x7fd90ce6a0c0>]

checksum: IOAttrs object at 0x7fd90ce99820>]

createtime: IOAttrs object at 0x7fd90ce86000>]

filename: IOAttrs object at 0x7fd90ca40080>]

size: IOAttrs object at 0x7fd90ce20a10>]

version: IOAttrs object at 0x7fd90cdda8d0>]

builds: Annotated[list[Entry], IOAttrs('builds')]

bacommon.cloud module

Functionality related to cloud functionality.

class bacommon.cloud.BSClassicAccountLiveData(tickets: Annotated[int, IOAttrs('ti')], tokens: Annotated[int, IOAttrs('to')], gold_pass: Annotated[bool, IOAttrs('g')], achievements: Annotated[int, IOAttrs('a')], achievements_total: Annotated[int, IOAttrs('at')], league_type: Annotated[LeagueType | None, IOAttrs('lt')], league_num: Annotated[int | None, IOAttrs('ln')], league_rank: Annotated[int | None, IOAttrs('lr')], level: Annotated[int, IOAttrs('lv')], xp: Annotated[int, IOAttrs('xp')], xpmax: Annotated[int, IOAttrs('xpm')], inbox_count: Annotated[int, IOAttrs('ibc')], inbox_count_is_max: Annotated[bool, IOAttrs('ibcm')], chests: Annotated[dict[str, Chest], IOAttrs('c')])

Bases: object

Account related data kept up to date live for classic app mode.

class Chest(appearance: ~typing.Annotated[~bacommon.cloud.BSClassicChestAppearance, <efro.dataclassio.IOAttrs object at 0x7fd90ca74dd0>], create_time: ~typing.Annotated[~datetime.datetime, <efro.dataclassio.IOAttrs object at 0x7fd90ca748c0>], unlock_tokens: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90ce1fe90>], unlock_time: ~typing.Annotated[~datetime.datetime, <efro.dataclassio.IOAttrs object at 0x7fd90ce1ff50>], ad_allow_time: ~typing.Annotated[~datetime.datetime | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce68290>])

Bases: object

A lovely chest.

ad_allow_time: IOAttrs object at 0x7fd90cea5370>]

appearance: IOAttrs object at 0x7fd90ca769f0>]

create_time: IOAttrs object at 0x7fd90ca76de0>]

unlock_time: IOAttrs object at 0x7fd90ca40140>]

unlock_tokens: IOAttrs object at 0x7fd90ca403b0>]

class LeagueType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Type of league we are in.

BRONZE = 'b'

DIAMOND = 'd'

GOLD = 'g'

SILVER = 's'

achievements: Annotated[int, IOAttrs('a')]

achievements_total: Annotated[int, IOAttrs('at')]

chests: Annotated[dict[str, Chest], IOAttrs('c')]

gold_pass: Annotated[bool, IOAttrs('g')]

inbox_count: Annotated[int, IOAttrs('ibc')]

inbox_count_is_max: Annotated[bool, IOAttrs('ibcm')]

league_num: Annotated[int | None, IOAttrs('ln')]

league_rank: Annotated[int | None, IOAttrs('lr')]

league_type: Annotated[LeagueType | None, IOAttrs('lt')]

level: Annotated[int, IOAttrs('lv')]

tickets: Annotated[int, IOAttrs('ti')]

tokens: Annotated[int, IOAttrs('to')]

xp: Annotated[int, IOAttrs('xp')]

xpmax: Annotated[int, IOAttrs('xpm')]

class bacommon.cloud.BSClassicChestAppearance(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Appearances bombsquad classic chests can have.

DEFAULT = 'd'

UNKNOWN = 'u'

class bacommon.cloud.BSInboxEntry(type: ~typing.Annotated[~bacommon.cloud.BSInboxEntryType, <efro.dataclassio.IOAttrs object at 0x7fd90cab6330>], id: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cab6210>], createtime: ~typing.Annotated[~datetime.datetime, <efro.dataclassio.IOAttrs object at 0x7fd90ce99250>], format_version: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90ce85310>], message: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ce847a0>], subs: ~typing.Annotated[list[str], <efro.dataclassio.IOAttrs object at 0x7fd90ce85610>])

Bases: object

Single message in an inbox.

createtime: IOAttrs object at 0x7fd90ce9aab0>]

format_version: IOAttrs object at 0x7fd90ce20a40>]

id: IOAttrs object at 0x7fd90ca41340>]

message: IOAttrs object at 0x7fd90ca75520>]

subs: IOAttrs object at 0x7fd90ce68320>]

type: IOAttrs object at 0x7fd90ca75ca0>]

class bacommon.cloud.BSInboxEntryProcessMessage(id: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cab7410>], process_type: ~typing.Annotated[~bacommon.cloud.BSInboxEntryProcessType, <efro.dataclassio.IOAttrs object at 0x7fd90cab74d0>])

Bases: Message

Do something to an inbox entry.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

id: IOAttrs object at 0x7fd90cab5640>]

process_type: IOAttrs object at 0x7fd90cddaab0>]

class bacommon.cloud.BSInboxEntryProcessResponse(error: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c8f0140>] = None)

Bases: Response

Did something to that inbox entry, boss.

error: IOAttrs object at 0x7fd90c8f0b60>] = None

class bacommon.cloud.BSInboxEntryProcessType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Types of processing we can ask for.

NEGATIVE = 'n'

POSITIVE = 'p'

class bacommon.cloud.BSInboxEntryType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Types of entries that can be in an inbox.

CLAIM = 'c'

CLAIM_DISCARD = 'cd'

SIMPLE = 's'

UNKNOWN = 'u'

class bacommon.cloud.BSInboxRequestMessage

Bases: Message

Message requesting our inbox.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.BSInboxRequestResponse(entries: ~typing.Annotated[list[~bacommon.cloud.BSInboxEntry], <efro.dataclassio.IOAttrs object at 0x7fd90c8f25a0>], error: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c8f1e20>] = None)

Bases: Response

Here’s that inbox contents you asked for, boss.

entries: IOAttrs object at 0x7fd90c8f2e40>]

error: IOAttrs object at 0x7fd90c8f31a0>] = None

class bacommon.cloud.BSPrivatePartyMessage(need_datacode: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90c8f3620>])

Bases: Message

Message asking about info we need for private-party UI.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

need_datacode: IOAttrs object at 0x7fd90cab7d10>]

class bacommon.cloud.BSPrivatePartyResponse(success: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90ce99400>], tokens: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90ca77a10>], gold_pass: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90ca402f0>], datacode: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce99040>])

Bases: Response

Here’s that private party UI info you asked for, boss.

datacode: IOAttrs object at 0x7fd90ca08b30>]

gold_pass: IOAttrs object at 0x7fd90cab65d0>]

success: IOAttrs object at 0x7fd90ca0a630>]

tokens: IOAttrs object at 0x7fd90ce9a240>]

class bacommon.cloud.LoginProxyCompleteMessage(proxyid: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ca77050>])

Bases: Message

Just so you know, we’re done with this proxy.

proxyid: IOAttrs object at 0x7fd90c91d4c0>]

class bacommon.cloud.LoginProxyRequestMessage

Bases: Message

Request send to the cloud to ask for a login-proxy.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.LoginProxyRequestResponse(url: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c91e030>], url_overlay: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c91e000>], proxyid: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cab4d70>], proxykey: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90cab4bc0>])

Bases: Response

Response to a request for a login proxy.

proxyid: IOAttrs object at 0x7fd90cab4950>]

proxykey: IOAttrs object at 0x7fd90cab5250>]

url: IOAttrs object at 0x7fd90ce1f6e0>]

url_overlay: IOAttrs object at 0x7fd90cab6450>]

class bacommon.cloud.LoginProxyStateQueryMessage(proxyid: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c91e9f0>], proxykey: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c91e9c0>])

Bases: Message

Soo.. how is that login proxy going?

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

proxyid: IOAttrs object at 0x7fd90c91f680>]

proxykey: IOAttrs object at 0x7fd90ca404a0>]

class bacommon.cloud.LoginProxyStateQueryResponse(state: Annotated[State, IOAttrs('s')], credentials: Annotated[str | None, IOAttrs('tk')])

Bases: Response

Here’s the info on that login-proxy you asked about, boss.

class State(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

States a login-proxy can be in.

FAIL = 'fail'

SUCCESS = 'success'

WAITING = 'waiting'

credentials: Annotated[str | None, IOAttrs('tk')]

state: Annotated[State, IOAttrs('s')]

class bacommon.cloud.ManageAccountMessage(weblocation: ~typing.Annotated[~bacommon.cloud.WebLocation, <efro.dataclassio.IOAttrs object at 0x7fd90c94d070>] = WebLocation.ACCOUNT_EDITOR)

Bases: Message

Message asking for a manage-account url.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

weblocation: IOAttrs object at 0x7fd90c94d1f0>] = 'e'

class bacommon.cloud.ManageAccountResponse(url: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c94d6a0>])

Bases: Response

Here’s that sign-in result you asked for, boss.

url: IOAttrs object at 0x7fd90cab5a30>]

class bacommon.cloud.MerchAvailabilityMessage

Bases: Message

Can we show merch link?

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.MerchAvailabilityResponse(url: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c94e510>])

Bases: Response

About that merch…

url: IOAttrs object at 0x7fd90c94efc0>]

class bacommon.cloud.PingMessage

Bases: Message

Standard ping.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.PingResponse

Bases: Response

pong.

class bacommon.cloud.SendInfoMessage(description: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c96c110>])

Bases: Message

User is using the send-info function

description: IOAttrs object at 0x7fd90c96cb60>]

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.SendInfoResponse(handled: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90c94ff20>], message: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c94f680>] = None, legacy_code: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c8f01d0>] = None)

Bases: Response

Response to sending into the server.

handled: IOAttrs object at 0x7fd90c96d5e0>]

legacy_code: IOAttrs object at 0x7fd90c96d940>] = None

message: IOAttrs object at 0x7fd90c96de50>] = None

class bacommon.cloud.SignInMessage(login_type: ~typing.Annotated[~bacommon.login.LoginType, <efro.dataclassio.IOAttrs object at 0x7fd90c96e330>], sign_in_token: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c96e300>], description: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90ca77470>], apptime: ~typing.Annotated[float, <efro.dataclassio.IOAttrs object at 0x7fd90ce99010>])

Bases: Message

Can I sign in please?

apptime: IOAttrs object at 0x7fd90ca0b2c0>]

description: IOAttrs object at 0x7fd90c94fec0>]

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

login_type: IOAttrs object at 0x7fd90c96e1b0>]

sign_in_token: IOAttrs object at 0x7fd90ce9a4b0>]

class bacommon.cloud.SignInResponse(credentials: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c96ee70>])

Bases: Response

Here’s that sign-in result you asked for, boss.

credentials: IOAttrs object at 0x7fd90c96f860>]

class bacommon.cloud.StoreQueryMessage

Bases: Message

Message asking about purchasable stuff and store related state.

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

class bacommon.cloud.StoreQueryResponse(result: Annotated[Result, IOAttrs('r')], tokens: Annotated[int, IOAttrs('t')], gold_pass: Annotated[bool, IOAttrs('g')], available_purchases: Annotated[list[Purchase], IOAttrs('p')], token_info_url: Annotated[str, IOAttrs('tiu')])

Bases: Response

Here’s that store info you asked for, boss.

class Purchase(purchaseid: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c990560>])

Bases: object

Info about a purchasable thing.

purchaseid: IOAttrs object at 0x7fd90c990f80>]

class Result(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Our overall result.

ERROR = 'e'

SUCCESS = 's'

available_purchases: Annotated[list[Purchase], IOAttrs('p')]

gold_pass: Annotated[bool, IOAttrs('g')]

result: Annotated[Result, IOAttrs('r')]

token_info_url: Annotated[str, IOAttrs('tiu')]

tokens: Annotated[int, IOAttrs('t')]

class bacommon.cloud.TestMessage(testfoo: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c992330>])

Bases: Message

Can I get some of that workspace action?

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

testfoo: IOAttrs object at 0x7fd90c992510>]

class bacommon.cloud.TestResponse(testfoo: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c992840>])

Bases: Response

Here’s that workspace you asked for, boss.

testfoo: IOAttrs object at 0x7fd90c993260>]

class bacommon.cloud.WebLocation(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Set of places we can be directed on ballistica.net.

ACCOUNT_DELETE_SECTION = 'd'

ACCOUNT_EDITOR = 'e'

class bacommon.cloud.WorkspaceFetchMessage(workspaceid: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c9937d0>], state: ~typing.Annotated[~bacommon.cloud.WorkspaceFetchState, <efro.dataclassio.IOAttrs object at 0x7fd90c993770>])

Bases: Message

Can I get some of that workspace action?

classmethod get_response_types() → list[type[Response] | None]

Return all Response types this Message can return when sent.

The default implementation specifies a None return type.

state: IOAttrs object at 0x7fd90c9b8650>]

workspaceid: IOAttrs object at 0x7fd90c991370>]

class bacommon.cloud.WorkspaceFetchResponse(state: ~typing.Annotated[~bacommon.cloud.WorkspaceFetchState, <efro.dataclassio.IOAttrs object at 0x7fd90cab5e80>], deletes: ~typing.Annotated[list[str], <efro.dataclassio.IOAttrs object at 0x7fd90cab5280>] = <factory>, downloads_inline: ~typing.Annotated[dict[str, bytes], <efro.dataclassio.IOAttrs object at 0x7fd90c91c2f0>] = <factory>, done: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90ce86ae0>] = False)

Bases: Response

Here’s that workspace you asked for, boss.

deletes: IOAttrs object at 0x7fd90cab6f60>]

done: IOAttrs object at 0x7fd90ce68320>] = False

downloads_inline: IOAttrs object at 0x7fd90c91f7d0>]

state: IOAttrs object at 0x7fd90c94d190>]

class bacommon.cloud.WorkspaceFetchState(manifest: ~typing.Annotated[~bacommon.transfer.DirectoryManifest, <efro.dataclassio.IOAttrs object at 0x7fd90c9b9a60>], iteration: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c94ef00>] = 0, total_deletes: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c94edb0>] = 0, total_downloads: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c94eed0>] = 0, total_up_to_date: ~typing.Annotated[int | None, <efro.dataclassio.IOAttrs object at 0x7fd90c96c170>] = None)

Bases: object

Common state data for a workspace fetch.

iteration: IOAttrs object at 0x7fd90c8f0200>] = 0

manifest: IOAttrs object at 0x7fd90c91fb90>]

total_deletes: IOAttrs object at 0x7fd90c96e300>] = 0

total_downloads: IOAttrs object at 0x7fd90c8f2ff0>] = 0

total_up_to_date: IOAttrs object at 0x7fd90ca407a0>] = None

bacommon.loggercontrol module

System for managing loggers.

class bacommon.loggercontrol.LoggerControlConfig(levels: ~typing.Annotated[dict[str, int], <efro.dataclassio.IOAttrs object at 0x7fd90c526120>] = <factory>)

Bases: object

A logging level configuration that applies to all loggers.

Any loggers not explicitly contained in the configuration will be set to NOTSET.

apply(*, warn_unexpected_loggers: bool = False, warn_missing_loggers: bool = False, ignore_log_prefixes: list[str] | None = None) → None

Apply the config to all Python loggers.

If ‘warn_unexpected_loggers’ is True, warnings will be issues for any loggers not explicitly covered by the config. This is useful to help ensure controls for all possible loggers are present in a UI/etc.

If ‘warn_missing_loggers’ is True, warnings will be issued for any loggers present in the config that are not found at apply time. This can be useful for pruning settings for no longer used loggers.

Warnings for any log names beginning with any strings in ‘ignore_log_prefixes’ will be suppressed. This can allow ignoring loggers associated with submodules for a given package and instead presenting only a top level logger (or none at all).

apply_diff(diffconfig: LoggerControlConfig) → LoggerControlConfig

Apply a diff config to ourself.

Note that values that resolve to NOTSET are left intact in the output config. This is so all loggers expected by either the base or diff config to exist can be created if desired/etc.

diff(baseconfig: LoggerControlConfig) → LoggerControlConfig

Return a config containing only changes compared to a base config.

Note that this omits all NOTSET values that resolve to NOTSET in the base config.

This diffed config can later be used with apply_diff() against the base config to recreate the state represented by self.

classmethod from_current_loggers() → Self

Build a config from the current set of loggers.

get_effective_level(logname: str) → int

Given a log name, predict its level if this config is applied.

levels: IOAttrs object at 0x7fd90c524230>]

sanity_check_effective_levels() → None

Checks existing loggers to make sure they line up with us.

This can be called periodically to ensure that a control-config is properly driving log levels and that nothing else is changing them behind our back.

would_make_changes() → bool

Return whether calling apply would change anything.

bacommon.logging module

Logging functionality.

bacommon.logging.get_base_logger_control_config_client() → LoggerControlConfig

Return the logger-control-config used by the ballistica client.

This should remain consistent since local logger configurations are stored relative to this.

bacommon.login module

Functionality related to cloud based assets.

class bacommon.login.LoginType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Types of logins available.

EMAIL = 'email'

GAME_CENTER = 'game_center'

GPGS = 'gpgs'

property displayname: str

Human readable name for this value.

property displaynameshort: str

Human readable name for this value.

bacommon.net module

Network related data and functionality.

class bacommon.net.PrivateHostingConfig(session_type: str = 'ffa', playlist_name: str = 'Unknown', randomize: bool = False, tutorial: bool = False, custom_team_names: tuple[str, str] | None = None, custom_team_colors: tuple[tuple[float, float, float], tuple[float, float, float]] | None = None, playlist: list[dict[str, Any]] | None = None, exit_minutes: float = 120.0, exit_minutes_unclean: float = 180.0, exit_minutes_idle: float = 10.0)

Bases: object

Config provided when hosting a private party.

custom_team_colors: tuple[tuple[float, float, float], tuple[float, float, float]] | None = None

custom_team_names: tuple[str, str] | None = None

exit_minutes: float = 120.0

exit_minutes_idle: float = 10.0

exit_minutes_unclean: float = 180.0

playlist: list[dict[str, Any]] | None = None

playlist_name: str = 'Unknown'

randomize: bool = False

session_type: str = 'ffa'

tutorial: bool = False

class bacommon.net.PrivateHostingState(unavailable_error: str | None = None, party_code: str | None = None, tickets_to_host_now: int = 0, tokens_to_host_now: int = 0, minutes_until_free_host: float | None = None, free_host_minutes_remaining: float | None = None)

Bases: object

Combined state of whether we’re hosting, whether we can, etc.

free_host_minutes_remaining: float | None = None

minutes_until_free_host: float | None = None

party_code: str | None = None

tickets_to_host_now: int = 0

tokens_to_host_now: int = 0

unavailable_error: str | None = None

class bacommon.net.PrivatePartyConnectResult(error: str | None = None, address4: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce1f230>] = None, address6: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce1f710>] = None, port: int | None = None, password: str | None = None)

Bases: object

Info about a server we get back when connecting.

address4: IOAttrs object at 0x7fd90ce1d0a0>] = None

address6: IOAttrs object at 0x7fd90ce69220>] = None

error: str | None = None

password: str | None = None

port: int | None = None

class bacommon.net.ServerNodeEntry(zone: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c524530>], latlong: ~typing.Annotated[tuple[float, float] | None, <efro.dataclassio.IOAttrs object at 0x7fd90c524650>], address: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c992360>], port: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c992390>])

Bases: object

Information about a specific server.

address: IOAttrs object at 0x7fd90c8e26f0>]

latlong: IOAttrs object at 0x7fd90c527a40>]

port: IOAttrs object at 0x7fd90c91e810>]

zone: IOAttrs object at 0x7fd90c96e4b0>]

class bacommon.net.ServerNodeQueryResponse(time: ~typing.Annotated[~datetime.datetime, <efro.dataclassio.IOAttrs object at 0x7fd90c9b87d0>], latlong: ~typing.Annotated[tuple[float, float] | None, <efro.dataclassio.IOAttrs object at 0x7fd90c9b9520>], ping_per_dist: ~typing.Annotated[float, <efro.dataclassio.IOAttrs object at 0x7fd90c9b9580>], max_dist: ~typing.Annotated[float, <efro.dataclassio.IOAttrs object at 0x7fd90c9b8770>], debug_log_seconds: ~typing.Annotated[float | None, <efro.dataclassio.IOAttrs object at 0x7fd90ce68a70>] = None, error: ~typing.Annotated[str | None, <efro.dataclassio.IOAttrs object at 0x7fd90c91f5c0>] = None, servers: ~typing.Annotated[list[~bacommon.net.ServerNodeEntry], <efro.dataclassio.IOAttrs object at 0x7fd90c91f890>] = <factory>)

Bases: object

A response to a query about server-nodes.

debug_log_seconds: IOAttrs object at 0x7fd90c94ef00>] = None

error: IOAttrs object at 0x7fd90c96cb30>] = None

latlong: IOAttrs object at 0x7fd90c8f2ea0>]

max_dist: IOAttrs object at 0x7fd90ce87020>]

ping_per_dist: IOAttrs object at 0x7fd90ce9a840>]

servers: IOAttrs object at 0x7fd90ce9a630>]

time: IOAttrs object at 0x7fd90ce9aff0>]

bacommon.servermanager module

Functionality related to the server manager script.

class bacommon.servermanager.ChatMessageCommand(message: str, clients: list[int] | None)

Bases: ServerCommand

Chat message from the server.

clients: list[int] | None

message: str

class bacommon.servermanager.ClientListCommand

Bases: ServerCommand

Print a list of clients.

class bacommon.servermanager.KickCommand(client_id: int, ban_time: int | None)

Bases: ServerCommand

Kick a client.

ban_time: int | None

client_id: int

class bacommon.servermanager.ScreenMessageCommand(message: str, color: tuple[float, float, float] | None, clients: list[int] | None)

Bases: ServerCommand

Screen-message from the server.

clients: list[int] | None

color: tuple[float, float, float] | None

message: str

class bacommon.servermanager.ServerCommand

Bases: object

Base class for commands that can be sent to the server.

class bacommon.servermanager.ServerConfig(party_name: str = 'FFA', party_is_public: bool = True, authenticate_clients: bool = True, admins: list[str] = <factory>, enable_default_kick_voting: bool = True, public_ipv4_address: str | None = None, public_ipv6_address: str | None = None, port: int = 43210, max_party_size: int = 6, session_max_players_override: int | None = None, session_type: str = 'ffa', playlist_code: int | None = None, playlist_inline: list[dict[str, ~typing.Any]] | None = None, playlist_shuffle: bool = True, auto_balance_teams: bool = True, coop_campaign: str = 'Easy', coop_level: str = 'Onslaught Training', enable_telnet: bool = False, teams_series_length: int = 7, ffa_series_length: int = 24, stats_url: str | None = None, clean_exit_minutes: float | None = None, unclean_exit_minutes: float | None = None, idle_exit_minutes: float | None = None, show_tutorial: bool = False, team_names: tuple[str, str] | None = None, team_colors: tuple[tuple[float, float, float], tuple[float, float, float]] | None = None, enable_queue: bool = True, protocol_version: int | None = None, stress_test_players: int | None = None, player_rejoin_cooldown: float = 10.0, log_levels: dict[str, str] | None = None)

Bases: object

Configuration for the server manager app (<appname>_server).

admins: list[str]

authenticate_clients: bool = True

auto_balance_teams: bool = True

clean_exit_minutes: float | None = None

coop_campaign: str = 'Easy'

coop_level: str = 'Onslaught Training'

enable_default_kick_voting: bool = True

enable_queue: bool = True

enable_telnet: bool = False

ffa_series_length: int = 24

idle_exit_minutes: float | None = None

log_levels: dict[str, str] | None = None

max_party_size: int = 6

party_is_public: bool = True

party_name: str = 'FFA'

player_rejoin_cooldown: float = 10.0

playlist_code: int | None = None

playlist_inline: list[dict[str, Any]] | None = None

playlist_shuffle: bool = True

port: int = 43210

protocol_version: int | None = None

public_ipv4_address: str | None = None

public_ipv6_address: str | None = None

session_max_players_override: int | None = None

session_type: str = 'ffa'

show_tutorial: bool = False

stats_url: str | None = None

stress_test_players: int | None = None

team_colors: tuple[tuple[float, float, float], tuple[float, float, float]] | None = None

team_names: tuple[str, str] | None = None

teams_series_length: int = 7

unclean_exit_minutes: float | None = None

class bacommon.servermanager.ShutdownCommand(reason: ShutdownReason, immediate: bool)

Bases: ServerCommand

Tells the server to shut down.

immediate: bool

reason: ShutdownReason

class bacommon.servermanager.ShutdownReason(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Reason a server is shutting down.

NONE = 'none'

RESTARTING = 'restarting'

class bacommon.servermanager.StartServerModeCommand(config: ServerConfig)

Bases: ServerCommand

Tells the app to switch into ‘server’ mode.

config: ServerConfig

bacommon.transfer module

Functionality related to transferring files/data.

class bacommon.transfer.DirectoryManifest(files: ~typing.Annotated[dict[str, ~bacommon.transfer.DirectoryManifestFile], <efro.dataclassio.IOAttrs object at 0x7fd90c38d9d0>], exists: ~typing.Annotated[bool, <efro.dataclassio.IOAttrs object at 0x7fd90c38d8b0>])

Bases: object

Contains a summary of files in a directory.

classmethod create_from_disk(path: Path) → DirectoryManifest

Create a manifest from a directory on disk.

exists: IOAttrs object at 0x7fd90c526ea0>]

files: IOAttrs object at 0x7fd90c3e26c0>]

validate() → None

Log any odd data in the manifest; for debugging.

class bacommon.transfer.DirectoryManifestFile(hash_sha256: ~typing.Annotated[str, <efro.dataclassio.IOAttrs object at 0x7fd90c3e29f0>], size: ~typing.Annotated[int, <efro.dataclassio.IOAttrs object at 0x7fd90c3e1f10>])

Bases: object

Describes a file in a manifest.

hash_sha256: IOAttrs object at 0x7fd90c9935c0>]

size: IOAttrs object at 0x7fd90c96ecc0>]

Module contents

Functionality and data common to ballistica client and server components.