gatelogue_aggregator.types.node.rail.RailLine

class gatelogue_aggregator.types.node.rail.RailLine(*, i: ID = None, source: set[str] = <factory>, code: str, name: Sourced[str] | None = None, colour: Sourced[str] | None = None, mode: Sourced[RailMode] | None = None, company: Sourced[ID] = None, stations: list[Sourced[ID]] = <factory>)

Bases: RailLine, 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 Rail line
colour	Colour of the line (on a map)
company	ID of the RailCompany that operates the line
i	The ID of the node
mode	Type of rail or rail technology used on the line
name	Name of the line
source	All sources that prove the node's existence
stations	List of all RailStation s the line stops at

acceptable_list_node_types()

acceptable_single_node_types()

code: str

Unique code identifying the Rail line

colour: Sourced[str] | None

Colour of the line (on a map)

company: Sourced[ID]

ID of the RailCompany 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: RailSource, other: Self) → bool

export(src: RailSource) → RailLine

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: RailSource, other: Self)

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

merge_key(src: RailSource) → str

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

mode: Sourced[RailMode] | None

Type of rail or rail technology used on the line

name: Sourced[str] | None

Name of the line

classmethod new(src: RailSource, *, code: str, company: RailCompany, name: str | None = None, colour: str | None = None, mode: RailMode | None = None)

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

static process_code(s: T) → T

ref(src: RailSource) → NodeRef[Self]

report(src: RailSource)

sanitise_strings()

source: set[str]

All sources that prove the node’s existence

stations: list[Sourced[ID]]

List of all RailStation s the line stops at

str_src(src: RailSource) → str