piqueserver package

Module contents

Subpackages

• piqueserver.core_commands package
  • Submodules
  • piqueserver.core_commands.game module
  • piqueserver.core_commands.info module
  • piqueserver.core_commands.map module
  • piqueserver.core_commands.moderation module
  • piqueserver.core_commands.movement module
  • piqueserver.core_commands.player module
  • piqueserver.core_commands.server module
  • piqueserver.core_commands.social module
  • Module contents
• piqueserver.web package
  • Module contents

Submodules

piqueserver.banpublish module

class piqueserver.banpublish.PublishResource(factory)

Bases: twisted.web.resource.Resource

getChild(name, request)

Retrieve a ‘child’ resource from me.

Implement this to create dynamic resource generation – resources which are always available may be registered with self.putChild().

This will not be called if the class-level variable ‘isLeaf’ is set in your subclass; instead, the ‘postpath’ attribute of the request will be left as a list of the remaining path elements.

For example, the URL /foo/bar/baz will normally be:

| site.resource.getChild('foo').getChild('bar').getChild('baz').

However, if the resource returned by ‘bar’ has isLeaf set to true, then the getChild call will never be made on it.

Parameters and return value have the same meaning and requirements as those defined by L{IResource.getChildWithDefault}.

render_GET(request)

class piqueserver.banpublish.PublishServer(protocol, port)

Bases: object

update()

piqueserver.bansubscribe module

class piqueserver.bansubscribe.BanManager(protocol)

Bases: object

bans = None

fetch_filtered_bans(url: str, whitelist: List[str])

get_ban(ip)

start()

update_bans()

piqueserver.bansubscribe.validate_bansub_config(c)

piqueserver.commands module

exception piqueserver.commands.CommandError

Bases: Exception

class piqueserver.commands.CommandHelp(description, usage, info)

Bases: tuple

description

Alias for field number 0

info

Alias for field number 2

usage

Alias for field number 1

exception piqueserver.commands.PermissionDenied

Bases: Exception

piqueserver.commands.add(func: Callable) → None

Function to add a command from scripts. Deprecated

piqueserver.commands.add_rights(user_type: str, command_name: str) → None

Give the user type a new right

>>> add_rights("knights", "say_ni")

piqueserver.commands.admin(func: Callable) → Callable

Shorthand for @restrict(“admin”). Mainly exists for backwards compatibility with pyspades scripts.

>>> @admin
... @command()
... def some_command(x):
...     pass

piqueserver.commands.alias(name: str) → Callable

add a new alias to a command. Deprecated

piqueserver.commands.command(name=None, *aliases, admin_only=False) → Callable[[Callable], Callable]

Register a new command.

The command will be accessible as /function_name unless a name or alias is specified.

>>> @command()
... def some_command(x):
...     pass

Optional names and aliases:

>>> @command("name", "alias1", "alias2")
... def some_command(x):
...     pass

piqueserver.commands.format_command_error(command_func: Callable, message: str, exception: Exception = None) → str

format a help message for a given command

piqueserver.commands.get_command_help(command_func: Callable) → piqueserver.commands.CommandHelp

piqueserver.commands.get_player(protocol, value: str, spectators=True)

Get a player connection object by name or ID.

IDs are formatted as: “#12”

If no player with the specified name is found, it will try to find a player who’s name contains the string

piqueserver.commands.get_rights(user_type: str) → List[str]

Get a list of rights a specific user type has.

>>> add_rights("knights", "say_ni")
>>> get_rights("knights")
["say_ni"]
>>> get_rights("arthur")
[]

piqueserver.commands.get_team(connection, value)

piqueserver.commands.get_truthy(value)

piqueserver.commands.handle_command(connection, command, parameters)

Public facing function to run a command, given the connection, a command name, and a list of parameters.

Will log the command.

piqueserver.commands.handle_input(connection, user_input)

piqueserver.commands.has_permission(f, connection)

piqueserver.commands.join_arguments(arg, default=None)

piqueserver.commands.name(name: str) → Callable

Give the command a new name. Deprecated

piqueserver.commands.parse_maps(pre_maps)

piqueserver.commands.player_only(func: Callable)

This recorator restricts a command to only be runnable by players connected to the server, not via other places such as, say, the console.

>>> @command()
... @player_only
... def some_command(x):
...     pass

piqueserver.commands.restrict(*user_types) → Callable

restrict the command to only be used by a specific type of user

>>> @restrict("admin", "guard")
... @command()
... def some_command(x):
...     pass

piqueserver.commands.target_player(func: Callable)

This decorator converts first argument of a command to a piqueserver.FeatureConnection.

It’s intended for commands which accept single argument for target player eg. /fly [player]. It implicitly uses invoker as target if no arguments are provided. It uses first argument are player name or id for targetting. It forces non-player invokers to provide player argument.

>>> @command()
... @target_player
... def fly(connection, target):
...     target.fly = True
...     pass

piqueserver.commands.update_rights(rights: Dict[KT, VT])

Update the rights of all users according to the input dictionary. This is currently only here for when the config needs to be reloaded.

>>> update_rights({"knights": ["say_ni"]})
>>> get_rights("knights")
["say_ni"]

piqueserver.config module

class piqueserver.config.ConfigStore

Bases: object

Configuration store that manages global configuration.

Usage example:

>>> config = ConfigStore()
>>> config.load_from_dict({'key1': 'value1'})

>>> option1 = config.option('key1', default='nothing',
...                         validate=lambda x: len(x) > 0)
>>> section1 = config.section('section1')
>>> nested_option = section1.option('key1', default=0)

>>> print(nested_option.get())
>>> option1.set('hello')

>>> # underlying dictionary structure will look like
>>> # {
>>> #   'key1': 'hello',
>>> #   'section1': {
>>> #     'key1': 0
>>> #   }
>>> # }

check_unused()

Return the subset of the underlying dictionary that doesn’t have any corresponding registered options.

dump_to_file(fobj, format_='TOML')

Writes the current configuration to a file-like objection, with the format specified by format_.

get_dict()

load_from_dict(config)

Load from a dictionary object directly.

load_from_file(fobj, format_='TOML')

Clear the current configuration and load new configuration from a file-like object in a supported format.

option(name, default=None, cast=None, validate=None)

Register and return a new option object.

section(name)

Register and return a new section object.

update_from_dict(config)

Load from a dictionary object directly.

update_from_file(fobj, format_='TOML')

Updates the configuration from a file-like object. Useful for overwriting/updating part of the config without touching the rest.

piqueserver.config.cast_duration(d) → int

casts duration(1min, 1hr) into seconds. If input is an int it returns that unmodified.

piqueserver.console module

class piqueserver.console.ConsoleInput(protocol)

Bases: twisted.protocols.basic.LineReceiver

admin = True

delimiter = b'\n'

lineReceived(line)

Override this for when each line is received.

@param line: The line which was received with the delimiter removed. @type line: C{bytes}

name = 'Console'

send_chat(value: str, _)

send_lines(lines: List[str], type: str = None)

piqueserver.console.create_console(protocol)

piqueserver.irc module

class piqueserver.irc.IRCBot

Bases: twisted.words.protocols.irc.IRCClient

admin

colors

irc_NICK(prefix, params)

Called when a user changes their nickname.

irc_RPL_NAMREPLY(*arg)

joined(irc_channel)

Called when I finish joining a channel.

channel has the starting character (C{‘#’}, C{’&’}, C{‘!’}, or C{‘+’}) intact.

left(irc_channel)

Called when I have left a channel.

channel has the starting character (C{‘#’}, C{’&’}, C{‘!’}, or C{‘+’}) intact.

me(msg, do_filter=False)

modeChanged(user, irc_channel, *arg, **kw)

name = None

nickname

str(object=’’) -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.

ops = None

privmsg(user, irc_channel, *arg, **kw)

rights

send(msg, do_filter=False)

send_chat(value: str, _)

send_lines(lines: List[str], type: str = None)

signedOn()

Called after successfully signing on to the server.

unaliased_name = None

userKicked(kickee, irc_channel, kicker, message)

Called when I observe someone else being kicked from a channel.

userLeft(user, irc_channel, *arg, **kw)

userQuit(user, message)

Called when I see another user disconnect from the network.

user_types

voices = None

class piqueserver.irc.IRCClientFactory(server, config)

Bases: twisted.internet.protocol.ClientFactory

admin = None

aliases = None

bot = None

buildProtocol(address)

Create an instance of a subclass of Protocol.

The returned instance will handle input on an incoming server connection, and an attribute “factory” pointing to the creating factory.

Alternatively, L{None} may be returned to immediately close the new connection.

Override this method to alter how Protocol instances get created.

@param addr: an object implementing L{IAddress}

clientConnectionFailed(connector, reason)

Called when a connection has failed to connect.

It may be useful to call connector.connect() - this will reconnect.

@type reason: L{twisted.python.failure.Failure}

clientConnectionLost(connector, reason)

Called when an established connection is lost.

It may be useful to call connector.connect() - this will reconnect.

@type reason: L{twisted.python.failure.Failure}

colors = True

failed_reconnect_delay = 60

lost_reconnect_delay = 20

protocol

alias of IRCBot

rights = None

startedConnecting(connector)

Called when a connection has been started.

You can call connector.stopConnecting() to stop the connection attempt.

@param connector: a Connector object.

user_types = None

class piqueserver.irc.IRCRelay(protocol, config)

Bases: object

factory = None

me(*arg, **kw)

send(*arg, **kw)

piqueserver.irc.alias(connection, value=None)

piqueserver.irc.channel(func)

This decorator rewrites the username of incoming messages to strip the ident and rejects it if the source channel is not equal to the channel the bot is in

piqueserver.irc.colors(connection)

piqueserver.irc.format_name(player)

piqueserver.irc.format_name_color(player)

piqueserver.irc.score(connection)

piqueserver.irc.unalias(connection)

piqueserver.irc.who(connection)

piqueserver.map module

class piqueserver.map.Map(rot_info: piqueserver.map.RotationInfo, load_dir: str)

Bases: object

apply_script(protocol, connection, config)

load_information(rot_info: piqueserver.map.RotationInfo, load_dir: str) → None

load_vxl(rot_info)

exception piqueserver.map.MapNotFound(the_map)

Bases: Exception

class piqueserver.map.RotationInfo(name: str = 'pyspades')

Bases: object

get_map_filename(load_dir: str) → str

get_meta_filename(load_dir: str) → str

get_seed() → int

seed = None

piqueserver.map.check_rotation(maps: List[Union[str, RotationInfo]], load_dir: Optional[str] = None) → List[piqueserver.map.RotationInfo]

Checks if provided maps exist in maps dir. and returns an array of RotationInfo objects for those maps. Raises MapNotFound exception if maps are not found.

piqueserver.networkdict module

class piqueserver.networkdict.NetworkDict

Bases: object

get_entry(key)

iteritems()

make_list()

pop(*arg, **kw)

read_list(values)

remove(key)

remove a key from the networkdict and return the removed items

piqueserver.networkdict.get_cidr(network)

piqueserver.player module

class piqueserver.player.FeatureConnection(*args, **kwargs)

Bases: pyspades.player.ServerConnection

ban(reason=None, duration=None)

get_spawn_location() → Tuple[int, int, int]

kick(reason=None, silent=False)

on_animation_update(jump: bool, crouch: bool, sneak: bool, sprint: bool) → Tuple[bool, bool, bool, bool]

on_block_build(x: int, y: int, z: int) → None

on_block_build_attempt(x: int, y: int, z: int) → bool

on_block_destroy(x: int, y: int, z: int, mode: int) → bool

on_block_removed(x: int, y: int, z: int) → None

on_chat(value: str, global_message: bool) → Union[str, bool]

notifies when the server receives a chat message

return False to block sending the message

on_command(command: str, parameters: List[str]) → None

on_connect() → None

on_disconnect() → None

on_fall(damage: int) → Optional[bool]

on_grenade(time_left: float) → None

on_hack_attempt(reason)

on_hit(hit_amount: float, player: piqueserver.player.FeatureConnection, _type: int, grenade: pyspades.world.Grenade) → Optional[bool]

on_join() → None

on_kill(killer: Optional[FeatureConnection], _type: int, grenade: None) → None

on_line_build(points) → None

on_line_build_attempt(points) → bool

on_login(name: str) → None

on_reset() → None

on_team_join(team: pyspades.team.Team) → Optional[bool]

on_user_login(user_type, verbose=True)

send_lines(lines: List[str], key: str = 'unknown') → None

Send a list of lines to the player.

‘key’ is a unique identifier for the lines being sent - for example, a message saying ‘3 medkits are ready!’ could use the key ‘medkits.ready’. The key is used to avoid sending two messages of the same variety at once, to protect the server against a vulnerability which exploits this function.

The key should always be specified when calling this function. The default value of ‘unknown’ exists simply for backwards compatibility.

timed_out()

piqueserver.run module

piqueserver.run.copy_config()

piqueserver.run.copytree(src, dst)

A re-implementation of shutil.copytree that doesn’t fail if dst already exists. Other properties: Doesn’t over-write if src/dst files don’t differ. Creates a backup of dst file before over-writing.

piqueserver.run.get_git_rev()

piqueserver.run.main()

piqueserver.run.update_geoip(target_dir)

piqueserver.scheduler module

class piqueserver.scheduler.Scheduler(protocol)

Bases: object

call_end(*arg, **kw)

call_later(*arg, **kw)

loop_call(delay, func, *arg, **kw)

reset()

piqueserver.server module

pyspades - default/featured server

class piqueserver.server.FeatureProtocol(interface: bytes, config_dict: Dict[str, Any])

Bases: pyspades.server.ServerProtocol

add_ban(ip, reason, duration, name=None)

Ban an ip with an optional reason and duration in seconds. If duration is None, ban is permanent.

advance_call = None

advance_rotation(message: Optional[str] = None) → twisted.internet.defer.Deferred

Advances to the next map in the rotation. If message is provided it will send it to the chat, waits for 10 seconds and then advances.

Returns:Deferred that fires when the map has been loaded

balanced_teams = None

ban_manager = None

ban_publish = None

bans = None

broadcast_chat(value, global_message=True, sender=None, team=None, irc=False)

Send a chat message to many users

building = True

call_end(delay: int, func: Callable, *arg, **kw) → piqueserver.utils._async.EndCall

cancel_vote(connection=None)

connectTCP(*arg, **kw)

connection_class

alias of piqueserver.player.FeatureConnection

data_received(peer: enet.Peer, packet: enet.Packet) → None

default_fog = (128, 232, 255)

everyone_is_admin = False

format(value: str, extra: Optional[Dict[str, str]] = None) → str

format_lines(value: List[str]) → List[str]

game_mode = None

get_advance_time() → float

get_external_ip(ip_getter: str) → Iterator[twisted.internet.defer.Deferred]

get_map_rotation()

get_mode_name() → str

global_chat = True

god_blocks = None

got_master_connection(client)

identifier = None

interface = None

ip = None

irc_relay = None

irc_say(msg: str, me: bool = False) → None

is_indestructable(x: int, y: int, z: int) → bool

killing = True

last_time = None

listenTCP(*arg, **kw) → twisted.internet.tcp.Port

make_map(rot_info: piqueserver.map.RotationInfo) → twisted.internet.defer.Deferred

Creates and returns a Map object from rotation info in a new thread

Returns:Deferred that resolves to a Map object.

map_info = None

master = False

master_disconnected(client=None)

master_reconnect_call = None

on_advance(map_name: str) → None

on_ban(connection, reason, duration)

on_ban_attempt(connection, reason, duration)

on_game_end()

on_map_change(the_map: pyspades.vxl.VXLData) → None

on_map_leave()

planned_map = None

player_memory = None

receive_callback(address: enet.Address, data: bytes) → int

This hook receives the raw UDP data before it is processed by enet

reconnect_master()

remote_console = None

remove_ban(ip)

save_bans()

send_chat(*args, **kwargs)

Deprecated: see broadcast_chat

send_tip()

set_map_name(rot_info: piqueserver.map.RotationInfo) → None

Sets the map by its name.

set_map_rotation(maps: List[str]) → None

Over-writes the current map rotation with provided one. FeatureProtocol.advance_rotation still needs to be called to actually change the map,

set_master_state(value)

set_server_name(name: str) → None

set_time_limit(time_limit: Optional[int] = None, additive: bool = False) → Optional[int]

shutdown()

Notifies players and disconnects them before a shutdown.

spawns = None

team_class

alias of FeatureTeam

time_announce_schedule = None

timestamps = None

undo_last_ban()

update_format() → None

Called when the map (or other variables) have been updated

update_world()

user_blocks = None

vacuum_bans()

remove any bans that might have expired. This takes a while, so it is split up over the event loop

watch_for_releases()

Starts a loop for check_for_releases and updates self.new_release.

class piqueserver.server.FeatureTeam(team_id: int, name: str, color: Tuple[int, int, int], spectator: bool, protocol: pyspades.protocol.BaseProtocol)

Bases: pyspades.team.Team

get_entity_location(entity_id: int) → Tuple[int, int, int]

locked = False

piqueserver.server.ensure_dir_exists(filename: str) → None

piqueserver.server.random_choice_cycle(choices)

piqueserver.server.run() → None

runs the server

piqueserver.server.sleep(secs)

piqueserver.server.validate_team_name(name)

piqueserver.ssh module

class piqueserver.ssh.RemoteConsole(server)

Bases: object

piqueserver.ssh.create_remote_factory(namespace, users)

piqueserver.statistics module

class piqueserver.statistics.StatsClient

Bases: piqueserver.statistics.StatsProtocol

add_death(name)

add_kill(name)

connectionMade()

Called when a connection is made.

This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here.

login_defers = None

login_user(name, password)

object_received(obj)

server = None

class piqueserver.statistics.StatsClientFactory(name, password, callback)

Bases: twisted.internet.protocol.ReconnectingClientFactory

maxDelay = 20

protocol

alias of StatsClient

class piqueserver.statistics.StatsFactory(password)

Bases: twisted.internet.protocol.ServerFactory

protocol

alias of StatsServer

class piqueserver.statistics.StatsProtocol

Bases: twisted.protocols.basic.Int16StringReceiver

object_received(obj)

send_object(obj)

stringReceived(data)

Override this for notification when each complete string is received.

@param string: The complete string which was received with all

framing (length prefix, etc) removed.

@type string: C{bytes}

class piqueserver.statistics.StatsServer

Bases: piqueserver.statistics.StatsProtocol

add_death(name)

add_kill(name)

check_user(name, password)

connectionLost(reason)

Called when the connection is shut down.

Clear any circular references here, and any external references to this Protocol. The connection has been closed.

@type reason: L{twisted.python.failure.Failure}

connectionMade()

Called when a connection is made.

This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here.

connection_accepted()

object_received(obj)

send_login_result(result)

timed_out()

piqueserver.statistics.connect_statistics(host, port, name, password, callback, interface='')

piqueserver.statistics.hash_password(value)

piqueserver.statusserver module

class piqueserver.statusserver.AccessLogger(logger: logging.Logger, log_format: str)

Bases: aiohttp.abc.AbstractAccessLogger

log(request, response, time)

Emit log to logger.

class piqueserver.statusserver.StatusServer(protocol)

Bases: object

create_app()

current_map

index(request)

json(request)

listen()

Starts the status server on configured host/port

overview(request)

update_cached_overview()

Updates cached overview

piqueserver.statusserver.current_state(protocol)

Gathers data on current server/game state from protocol class

piqueserver.statusserver.set_default_headers(request, response)

piqueserver.version module