unienv_interface.space.spaces.text

Implementation of a space that represents the cartesian product of Discrete spaces.

alphanumeric module-attribute

alphanumeric: FrozenSet[str] = frozenset('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')

TextSpace

TextSpace(backend: ComputeBackend[Any, BDeviceType, BDtypeType, BRNGType], max_length: int, *, min_length: int = 0, charset: Optional[FrozenSet[str] | str] = None, device: Optional[BDeviceType] = None)

Bases: Space[str, BDeviceType, BDtypeType, BRNGType]

min_length instance-attribute

min_length: int = min_length

max_length instance-attribute

max_length: int = max_length

charset property

charset: Optional[FrozenSet[str]]

charset_index property

charset_index: Optional[Mapping[str, int]]

charset_list property

charset_list: Optional[Tuple[str, ...]]

backend instance-attribute

backend = backend

dtype instance-attribute

dtype = dtype

device property

device: Optional[_SpaceBDeviceT]

shape property

shape: tuple[int, ...] | None

Return the shape of the space as an immutable property.

to

to(backend=None, device=None)

character_index

character_index(char: str) -> Optional[int]

sample

sample(rng: BRNGType) -> Tuple[BRNGType, str]

create_empty

create_empty() -> str

is_bounded

is_bounded(manner='both')

contains

contains(x: Any) -> bool

get_repr

get_repr(abbreviate=False, include_backend=True, include_device=True, include_dtype=True)

is_subspaceeq

is_subspaceeq(other: Any) -> bool

Return whether this text space is a non-strict subspace of other (⊆).

True iff other is a TextSpace on the same backend, self's charset is a subset of other's charset (a None charset on self is a subset of any charset; a None charset on other only contains a None charset on self), self.min_length >= other.min_length and self.max_length <= other.max_length. device is ignored.

data_to

data_to(data, backend=None, device=None)

is_subspace

is_subspace(other: Space) -> bool

Return whether this space is a STRICT subspace of other (self ⊂ other).

Defined uniformly for all spaces as::

self.is_subspace(other)  ⟺  self.is_subspaceeq(other) and not other.is_subspaceeq(self)

I.e. self ⊆ other holds but other ⊆ self does not, so self is a PROPER (strict) subspace of other. This is the ⊂ relation versus the non-strict ⊆ provided by :meth:is_subspaceeq.

This definition is used instead of relying on __eq__ because some space classes only have identity __eq__; defining strict containment via the symmetric non-strict check works uniformly for all classes regardless of their __eq__ implementation.

For structurally-distinct-but-mutually-containing spaces (which should not occur under the strict dtype/shape policies enforced by the per-class is_subspaceeq implementations) this degrades gracefully to False: if both self.is_subspaceeq(other) and other.is_subspaceeq(self) hold, the two spaces are considered equivalent and neither is a STRICT subspace of the other.

If either side's is_subspaceeq is not implemented (the base :meth:is_subspaceeq raises NotImplementedError), the exception propagates to the caller — it is NOT swallowed into False so that callers can tell that the comparison is unsupported.

Note: controller-required-space checks should typically use :meth:is_subspaceeq (a controller's required space may exactly equal the env space, in which case the strict is_subspace would return False).

abbr_device staticmethod

abbr_device(spaces: Iterable[Space[Any, _SpaceBDeviceT, _SpaceBDTypeT, _SpaceBDRNGT]]) -> Optional[_SpaceBDeviceT]

Return the shared device across spaces, or None if mixed/empty.