World

exception textworld.generator.world.NoFreeExitError

Bases: Exception

class textworld.generator.world.World(kb=None)

Bases: object

add_fact(fact)

Return type:

None

add_facts(facts)

Return type:

None

classmethod deserialize(serialized_facts, kb=None)

Return type:

World

find_object_by_id(id)

Return type:

Optional[WorldObject]

find_room_by_id(id)

Return type:

Optional[WorldRoom]

classmethod from_facts(facts, kb=None)

Return type:

World

classmethod from_map(map, kb=None)

Parameters:

map (Graph) – Graph defining the structure of the world.

Return type:

World

get_all_objects_in(obj)

Return type:

List[WorldObject]

get_entities_per_type(type)

Get all entities of a certain type.

Return type:

List[WorldEntity]

get_facts_in_scope()

Return type:

List[Proposition]

get_objects_in_inventory()

Return type:

List[WorldObject]

get_visible_objects_in(obj)

Return type:

List[WorldObject]

populate(nb_objects, rng=None, object_types_probs=None)

Return type:

List[Proposition]

populate_room(nb_objects, room, rng=None, object_types_probs=None)

Return type:

List[Proposition]

populate_room_with(objects, room, rng=None)

Return type:

List[Proposition]

populate_with(objects, rng=None)

Return type:

List[Proposition]

serialize()

Return type:

List

set_player_room(start_room=None)

Return type:

Proposition

property entities: ValuesView[WorldEntity]

Return type:

ValuesView[WorldEntity]

property facts: List[Proposition]

Return type:

List[Proposition]

property objects: List[WorldObject]

Return type:

List[WorldObject]

property player_room: WorldRoom

Return type:

WorldRoom

property rooms: List[WorldRoom]

Return type:

List[WorldRoom]

property state: State

Return type:

State

class textworld.generator.world.WorldEntity(*args, **kwargs)

Bases: Variable

A WorldEntity is an abstract concept representing anything with a name and a type.

Create a Variable.

Parameters:

• name – The (unique) name of the variable.

• type (optional) – The type of the variable. Defaults to the same as the name.

add_related_fact(fact)

Return type:

None

classmethod create(var)

Return type:

Union[WorldRoom, WorldObject]

get_attributes()

Return type:

List[Proposition]

property id: str

Return type:

str

name

type

class textworld.generator.world.WorldObject(*args, **kwargs)

Bases: WorldEntity

A WorldObject is anything we can directly interact with.

Create a Variable.

Parameters:

• name – The (unique) name of the variable.

• type (optional) – The type of the variable. Defaults to the same as the name.

name

type

class textworld.generator.world.WorldRoom(*args, **kwargs)

Bases: WorldEntity

WorldRooms can be linked with each other through exits.

Create a Variable.

Parameters:

• name – The (unique) name of the variable.

• type (optional) – The type of the variable. Defaults to the same as the name.

name

type

textworld.generator.world.connect(room1, direction, room2, door=None)

Generate predicates that connect two rooms.

Parameters:

• room1 (Variable) – A room variable.

• direction (str) – Direction that we need to travel to go from room1 to room2.

• room2 (Variable) – A room variable.

• door (Optional[Variable]) – The door separating the two rooms. If None, there is no door between the rooms.

Return type:

List[Proposition]

textworld.generator.world.graph2state(G, rooms)

Convert Graph object to a list of Proposition.

Parameters:

• G (Graph) – Graph defining the structure of the world.

• rooms (Dict[str, Variable]) – information about the rooms in the world.

Return type:

List[Proposition]

textworld.generator.graph_networks.create_map(rng, n_nodes, h, w, possible_door_states=['open', 'closed', 'locked'])

textworld.generator.graph_networks.create_small_map(rng, n_rooms, possible_door_states=['open', 'closed', 'locked'])

textworld.generator.graph_networks.direction(x, y)

textworld.generator.graph_networks.extremes(G)

Find left most and bottom nodes in the cartesian sense.

textworld.generator.graph_networks.gen_layout(rng, n_nodes=5, h=10, w=10)

Generate a map with n_nodes rooms by picking a subgraph from a h,w grid.

textworld.generator.graph_networks.get_path(G, room1, room2)

textworld.generator.graph_networks.mark_doors(G, rng, possible_door_states=['open', 'closed', 'locked'])

Put doors between neighbouring articulation points.

textworld.generator.graph_networks.plot_graph(G, show=True)

Plot TextWorld’s graph representation of a world.

Return type:

None

textworld.generator.graph_networks.relabel(G)

Relabel G so that its origin is (0, 0)

textworld.generator.graph_networks.reverse_direction(direction)

textworld.generator.graph_networks.shortest_path(G, source, target)

Return shortest path in terms of directions.

textworld.generator.graph_networks.xy_diff(x, y)