gatelogue_aggregator.types.node.sea.SeaLine

class gatelogue_aggregator.types.node.sea.SeaLine(*, i: ID = None, source: set[str] = <factory>, code: str, name: Sourced[str] | None = None, colour: Sourced[str] | None = None, mode: Sourced[SeaMode] | None = None, company: Sourced[ID] = None, stops: list[Sourced[ID]] = <factory>)

Bases: SeaLine, Node

__init__()

Methods

__init__()
acceptable_list_node_types()
acceptable_single_node_types()
connect(src, node[, value, source])
connect_one(src, node[, value, source])
disconnect(src, node)
equivalent(src, other)
export(src)
get_all(src, ty[, conn_ty])
get_all_id(src, ty[, conn_ty])
get_edge(src, node[, ty])
get_edges(src, node[, ty])
get_one(src, ty[, conn_ty])
get_one_id(src, ty[, conn_ty])
merge(src, other)
merge_attrs(src, other)
merge_if_equivalent(src, other)
merge_key(src)
merge_lists(src, self, other)
new(src, *, code, company[, name, colour, mode])
print_report(src, level, msg)
process_code(s)
ref(src)
report(src)
sanitise_strings()
str_src(src)

Attributes

code	Unique code identifying the Sea line
colour	Colour of the line (on a map)
company	ID of the SeaCompany that operates the line
i	The ID of the node
mode	Type of boat used on the line
name	Name of the line
source	All sources that prove the node's existence
stops	List of all SeaStop s the line stops at

acceptable_list_node_types()

acceptable_single_node_types()

code: str

Unique code identifying the Sea line

colour: Sourced[str] | None

Colour of the line (on a map)

company: Sourced[ID]

ID of the SeaCompany that operates the line

connect(src: Source, node: Node, value: Any | None = None, source: set[str] | None = None)

connect_one(src: Source, node: Node, value: Any | None = None, source: set[str] | None = None)

disconnect(src: Source, node: Node)

equivalent(src: SeaSource, other: Self) → bool

export(src: SeaSource) → SeaLine

get_all(src: Source, ty: type[T], conn_ty: type | None = None) → Iterator[T]

get_all_id(src: Source, ty: type[Node], conn_ty: type | None = None) → list[Sourced[int]]

get_edge(src: Source, node: Node, ty: type[T] | None = None) → Sourced[T] | None

get_edges(src: Source, node: Node, ty: type[T] | None = None) → Iterator[Sourced[T]]

get_one(src: Source, ty: type[T], conn_ty: type | None = None) → T | None

get_one_id(src: Source, ty: type[Node], conn_ty: type | None = None) → Sourced[int] | None

i: ID

The ID of the node

merge(src: Source, other: Self)

merge_attrs(src: SeaSource, other: Self)

merge_if_equivalent(src: Source, other: Self) → bool

merge_key(src: SeaSource) → str

static merge_lists(src: Source, self: list[T], other: list[T])

mode: Sourced[SeaMode] | None

Type of boat used on the line

name: Sourced[str] | None

Name of the line

classmethod new(src: SeaSource, *, code: str, company: SeaCompany, name: str | None = None, colour: str | None = None, mode: SeaMode | None = None)

print_report(src: Source, level: str, msg: str)

static process_code(s: T) → T

ref(src: SeaSource) → NodeRef[Self]

report(src: SeaSource)

sanitise_strings()

source: set[str]

All sources that prove the node’s existence

stops: list[Sourced[ID]]

List of all SeaStop s the line stops at

str_src(src: SeaSource) → str