plexus-python-common 1.0.7__py3-none-any.whl

plexus/common/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("plexus-python-common")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"

plexus/common/carto/OSMFile.py

@@ -0,0 +1,259 @@
+from typing import Any, Self
+
+import lxml.etree
+
+from plexus.common.carto.OSMNode import OSMNode
+from plexus.common.carto.OSMTags import OSMTags
+from plexus.common.carto.OSMWay import OSMWay
+from plexus.common.proj import Coord, Proj
+
+
+class OSMFile(object):
+    @classmethod
+    def load_file(cls, path: str, proj: Proj | None) -> Self:
+        """
+        Loads OSM from file given the path
+
+        :param path: path of OSM file
+        :param proj: cartographic projection
+
+        :return: an OSM file instance
+        """
+        root = lxml.etree.parse(path).getroot()
+
+        nodes = {}
+        ways = {}
+        for elem in root:
+            if elem.attrib.get("action") == "delete":
+                continue
+
+            if elem.tag == "node":
+                # Parse an OSM node
+                node_id = int(elem.attrib["id"])
+                tags = {}
+                for child in elem:
+                    if child.tag == "tag":
+                        k = child.attrib["k"]
+                        v = child.attrib["v"]
+                        tags[k] = v
+
+                tags = OSMTags.from_any_tags(tags)
+                coord = Coord.from_latlon(
+                    float(elem.attrib["lat"]),
+                    float(elem.attrib["lon"]),
+                    tags.getfloat("z", 0.0),
+                    proj,
+                )
+
+                nodes[node_id] = OSMNode(node_id, coord, tags)
+
+            elif elem.tag == "way":
+                # Parse an OSM way
+                way_id = int(elem.attrib["id"])
+
+                tags = {}
+                node_ids = []
+                for child in elem:
+                    if child.tag == "tag":
+                        k = child.attrib["k"]
+                        v = child.attrib["v"]
+                        tags[k] = v
+                    elif child.tag == "nd":
+                        node_id = int(child.attrib.get("ref"))
+                        node_ids.append(node_id)
+
+                tags = OSMTags.from_any_tags(tags)
+
+                ways[way_id] = OSMWay(way_id, node_ids, tags)
+
+        return OSMFile(nodes, ways)
+
+    @classmethod
+    def from_coords(cls, coords: list[Coord], way_tags: dict[str, Any] = None) -> Self:
+        """
+        Constructs a single-way OSM file from the given coords
+
+        :param coords: coords on a single way
+        :param way_tags: tags of the corresponding way
+
+        :return: OSM file contains one way
+        """
+        osm = OSMFile()
+        osm.add_way_from_coords(coords, way_tags or {})
+
+        return osm
+
+    @classmethod
+    def from_coords_list(cls, coords_list: list[list[Coord]], way_tags_list: list[dict[str, Any]] = None) -> Self:
+        """
+        Constructs a multi-way OSM file from the given coords
+
+        :param coords_list: coords of each way
+        :param way_tags_list: tags of each corresponding way
+
+        :return: OSM file contains multiple ways
+        """
+        osm = OSMFile()
+
+        if not way_tags_list or len(way_tags_list) != len(coords_list):
+            for coords in coords_list:
+                osm.add_way_from_coords(coords)
+        else:
+            for coords, way_tags in zip(coords_list, way_tags_list):
+                osm.add_way_from_coords(coords, way_tags or {})
+
+        return osm
+
+    def __init__(self, nodes: dict[int, OSMNode] = None, ways: dict[int, OSMWay] = None):
+        """
+        Represents an editable general purpose OSM file
+
+        :param nodes: nodes
+        :param ways: ways
+        """
+        self.nodes: dict[int, OSMNode] = {}
+        self.ways: dict[int, OSMWay] = {}
+
+        self.next_node_id = 1
+        self.next_way_id = 1
+
+        if nodes:
+            self.nodes = nodes
+            self.next_node_id = max(nodes.keys()) + 1
+        if ways:
+            self.ways = ways
+            self.next_way_id = max(ways.keys()) + 1
+
+    def add_node(self, node: OSMNode) -> OSMNode:
+        """
+        Adds the given node
+
+        :param node: the node to be added
+
+        :return: added node
+        """
+        self.nodes[node.node_id] = node
+        if node.node_id >= self.next_node_id:
+            self.next_node_id = node.node_id + 1
+        return node
+
+    def add_node_from_coord(self, coord: Coord, tags: dict[str, Any] = None) -> OSMNode:
+        """
+        Adds node given the coord and tags
+
+        :param coord: coord of the node
+        :param tags: tags of the node
+
+        :return: added node
+        """
+        return self.add_node(OSMNode(self.next_node_id, coord, OSMTags.from_any_tags(tags)))
+
+    def add_way(self, way: OSMWay) -> OSMWay:
+        """
+        Adds the given way
+
+        :param way: the way to be added
+
+        :return: added way
+        """
+        self.ways[way.way_id] = way
+        if way.way_id >= self.next_way_id:
+            self.next_way_id = way.way_id + 1
+        return way
+
+    def add_way_from_coords(self, coords: list[Coord], tags: dict[str, Any] = None) -> OSMWay:
+        """
+        Adds way given the coords of the nodes and tags
+
+        :param coords: coords of the nodes on the way
+        :param tags: tags of the way
+
+        :return: added way
+        """
+        return self.add_way_from_nodes(coords, tags)
+
+    def add_way_from_node_ids(self, node_ids: list[int], tags: dict[str, Any] = None) -> OSMWay:
+        """
+        Adds way given the ids of the nodes and tags
+
+        :param node_ids: ids of the nodes on the way
+        :param tags: tags of the way
+
+        :return: added way
+        """
+        return self.add_way_from_nodes(node_ids, tags)
+
+    def add_way_from_nodes(self, elements: list[OSMNode | Coord | int], tags: dict[str, Any] = None) -> OSMWay:
+        """
+        Adds way given list of the nodes, the coords, or the ids of the nodes and tags
+
+        :param elements: a list of the nodes, the coords, or the ids of the nodes on the way
+        :param tags: tags of the way
+
+        :return: added way
+        """
+        node_ids = []
+        for elem in elements:
+            if isinstance(elem, OSMNode):
+                node_ids.append(self.add_node_from_coord(elem.coord, elem.tags.tags).node_id)
+            elif isinstance(elem, Coord):
+                node_ids.append(self.add_node_from_coord(elem, {}).node_id)
+            else:
+                node_ids.append(elem)
+        return self.add_way(OSMWay(self.next_way_id, node_ids, OSMTags.from_any_tags(tags)))
+
+    def write(self, filename: str):
+        """
+        Writes this OSM file instance to the given file name
+
+        :param filename: file path to write into
+        """
+        root = lxml.etree.Element("osm")
+        root.attrib.update({
+            "version": "0.6",
+            "generator": "Plexus",
+        })
+
+        for _, node in self.nodes.items():
+            node_elem = lxml.etree.Element("node")
+            node_elem.attrib.update(
+                {
+                    "id": str(node.node_id),
+                    "lat": str(node.coord.lat),
+                    "lon": str(node.coord.lon),
+                    "version": "1",
+                }
+            )
+
+            for k, v in node.tags.items():
+                tag_elem = lxml.etree.Element("tag")
+                tag_elem.attrib.update({"k": str(k), "v": str(v)})
+                node_elem.append(tag_elem)
+
+            root.append(node_elem)
+
+        for _, way in self.ways.items():
+            way_elem = lxml.etree.Element("way")
+            way_elem.attrib.update(
+                {
+                    "id": str(way.way_id),
+                    "version": "1",
+                }
+            )
+
+            for k, v in way.tags.items():
+                tag_elem = lxml.etree.Element("tag")
+                tag_elem.attrib.update({"k": str(k), "v": str(v)})
+                way_elem.append(tag_elem)
+
+            for node_id in way.node_ids:
+                nd_elem = lxml.etree.Element("nd")
+                nd_elem.attrib.update({"ref": str(node_id)})
+                way_elem.append(nd_elem)
+
+            root.append(way_elem)
+
+        s = lxml.etree.tostring(root, pretty_print=True, encoding="unicode")
+
+        with open(filename, "w") as fh:
+            fh.write(s)

plexus/common/carto/OSMNode.py

@@ -0,0 +1,25 @@
+from iker.common.utils.strutils import repr_data
+
+from plexus.common.carto.OSMTags import OSMTags
+from plexus.common.proj import Coord
+
+
+class OSMNode(object):
+    """
+    Represents node in OSM
+    """
+
+    def __init__(self, node_id: int, coord: Coord, tags: OSMTags):
+        """
+        Creates an instance from the given node id, coord, and tags
+
+        :param node_id: id
+        :param coord: node coordinate
+        :param tags: tags
+        """
+        self.node_id = node_id
+        self.coord = coord
+        self.tags = tags
+
+    def __str__(self):
+        return repr_data(self)

plexus/common/carto/OSMTags.py

@@ -0,0 +1,101 @@
+import datetime
+from typing import Any, Self
+
+from iker.common.utils.strutils import repr_data, str_conv
+
+
+class OSMTags(object):
+    """
+    Represents tag in OSM
+    """
+
+    @classmethod
+    def from_any_tags(cls, any_tags: dict[str, Any] = None) -> Self:
+        """
+        Creates an instance from any-typed tags by automatically inferring data types
+
+        :param any_tags: tags with any-typed values
+
+        :return: OSM tag instance
+        """
+        if any_tags is None:
+            return OSMTags({})
+        return OSMTags({k: str_conv(v) for k, v in any_tags.items()})
+
+    def __init__(self, tags: dict[str, Any]):
+        """
+        Creates an instance from the given tags
+
+        :param tags: given tags
+        """
+        self.tags = tags
+
+    def __str__(self):
+        return repr_data(self)
+
+    def __iter__(self):
+        return self.tags.__iter__()
+
+    def __getitem__(self, k: str):
+        return self.tags.__getitem__(k)
+
+    def items(self):
+        return self.tags.items()
+
+    def set(self, key: str, value: Any) -> Any:
+        old_value = self.tags.get(key)
+        self.tags[key] = str_conv(value)
+        return old_value
+
+    def get(self, key: str, default: Any | None = None) -> Any | None:
+        return self.tags.get(key, default)
+
+    def getint(self, key: str, default: int | None = None) -> int | None:
+        value = self.tags.get(key, default)
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value
+        if default is None:
+            return None
+        if isinstance(default, int) and not isinstance(default, bool):
+            return default
+        raise TypeError("type of either the value or the given default is incompatible, should be 'int'")
+
+    def getfloat(self, key: str, default: float | None = None) -> float | None:
+        value = self.tags.get(key, default)
+        if isinstance(value, float):
+            return value
+        if default is None:
+            return None
+        if isinstance(default, float):
+            return default
+        raise TypeError("type of either the value or the given default is incompatible, should be 'float'")
+
+    def getboolean(self, key: str, default: bool | None = None) -> bool | None:
+        value = self.tags.get(key, default)
+        if isinstance(value, bool):
+            return value
+        if default is None:
+            return None
+        if isinstance(default, bool):
+            return default
+        raise TypeError("type of either the value or the given default is incompatible, should be 'bool'")
+
+    def getdatetime(self, key: str, default: datetime.datetime | None = None) -> datetime.datetime | None:
+        value = self.tags.get(key, default)
+        if isinstance(value, datetime.datetime):
+            return value
+        if default is None:
+            return None
+        if isinstance(default, datetime.datetime):
+            return default
+        raise TypeError("type of either the value or the given default is incompatible, should be 'datetime.datetime'")
+
+    def getstring(self, key: str, default: str | None = None) -> str | None:
+        value = self.tags.get(key, default)
+        if isinstance(value, str):
+            return value
+        if default is None:
+            return None
+        if isinstance(default, str):
+            return default
+        raise TypeError("type of either the value or the given default is incompatible, should be 'str'")

plexus/common/carto/OSMWay.py

@@ -0,0 +1,24 @@
+from iker.common.utils.strutils import repr_data
+
+from plexus.common.carto.OSMTags import OSMTags
+
+
+class OSMWay(object):
+    """
+    Represents way in OSM
+    """
+
+    def __init__(self, way_id: int, node_ids: list[int], tags: OSMTags):
+        """
+        Creates an instance from the given way id, node ids, and tags
+
+        :param way_id: id
+        :param node_ids: nodes ids
+        :param tags: tags
+        """
+        self.way_id = way_id
+        self.node_ids = node_ids
+        self.tags = tags
+
+    def __str__(self):
+        return repr_data(self)

plexus/common/carto/__init__.py

@@ -0,0 +1,11 @@
+__all__ = [
+    "OSMFile",
+    "OSMNode",
+    "OSMTags",
+    "OSMWay",
+]
+
+from plexus.common.carto.OSMFile import OSMFile
+from plexus.common.carto.OSMNode import OSMNode
+from plexus.common.carto.OSMTags import OSMTags
+from plexus.common.carto.OSMWay import OSMWay

plexus/common/config.py

@@ -0,0 +1,84 @@
+import hashlib
+
+from iker.common.utils import logger
+from iker.common.utils.config import Config
+from iker.common.utils.funcutils import singleton
+from iker.common.utils.shutils import expanded_path
+
+
+@singleton
+def config() -> Config:
+    default_items: list[tuple[str, str, str]] = [
+        ("pulse.commons", "logging.level", "INFO"),
+        ("pulse.commons", "logging.format", "%(asctime)s [%(levelname)s] %(name)s: %(message)s"),
+    ]
+
+    config = Config(expanded_path("~/.iker.pulse.cfg"))
+    config.restore()
+    config.update(default_items, overwrite=False)
+
+    return config
+
+
+def validate_pulse_super_token(token: str) -> bool:
+    """
+    Validate the pulse super token.
+    :param token: The token to validate.
+    :return: True if the token is valid, False otherwise.
+    """
+    return hashlib.sha256(token.encode()).hexdigest() == pulse_super_token_sha256()
+
+
+def ask_pulse_super_token():
+    import getpass
+    super_token = getpass.getpass("Pulse super token required: ")
+    if not validate_pulse_super_token(super_token):
+        raise ValueError("wrong Pulse super token")
+
+
+@singleton
+def pulse_super_token_sha256() -> str:
+    return "d7f97abe12bb00a7d19cb5957350509c14b3b085cf84524b80d389c6c2086f1b"
+
+
+def config_print_or_set(config: Config, section: str, key: str, value: str):
+    if value is not None:
+        if section is None or key is None:
+            raise ValueError("cannot specify value without section and key")
+
+        old_value = config.get(section, key)
+        config.set(section, key, value)
+        config.persist()
+
+        print(f"Configuration file '{config.config_path}'", )
+        print(f"Section <{section}>")
+        print(f"  {key} = {old_value} -> {value}")
+
+    else:
+        if section is None and key is None:
+            print(f"Configuration file '{config.config_path}'", )
+            for section in config.config_parser.sections():
+                print(f"Section <{section}>")
+                for key, value in config.config_parser.items(section):
+                    print(f"  {key} = {value}")
+
+        elif section is not None and key is None:
+            if not config.has_section(section):
+                logger.warning("Configuration section <%s> not found", section)
+                return
+            print(f"Configuration file '{config.config_path}'", )
+            print(f"Section <{section}>")
+            for key, value in config.config_parser.items(section):
+                print(f"  {key} = {value}")
+
+        elif section is not None and key is not None:
+            value = config.get(section, key)
+            if value is None:
+                logger.warning("Configuration section <%s> key <%s> not found", section, key)
+                return
+            print(f"Configuration file '{config.config_path}'", )
+            print(f"Section <{section}>")
+            print(f"  {key} = {value}")
+
+        else:
+            raise ValueError("cannot specify key without section")

plexus/common/pose.py

@@ -0,0 +1,107 @@
+from typing import Self
+
+import numpy as np
+import pyquaternion as pyquat
+from iker.common.utils.strutils import repr_data
+
+
+class Pose(object):
+    @classmethod
+    def from_numbers(
+        cls,
+        px: float,
+        py: float,
+        pz: float,
+        qx: float,
+        qy: float,
+        qz: float,
+        qw: float,
+        ts: float = 0,
+    ) -> Self:
+        """
+        Constructs a pose from numbers representing position and orientation
+        """
+        return Pose(ts, np.array([px, py, pz], dtype=np.float64), np.array([qw, qx, qy, qz], dtype=np.float64))
+
+    @classmethod
+    def add(cls, x: Self, d: Self) -> Self:
+        """
+        Performs pose SE3 addition, as x + d = y
+        """
+        xq = pyquat.Quaternion(x.q)
+        dq = pyquat.Quaternion(d.q)
+
+        yp = x.p + xq.rotate(d.p)
+        yq = xq * dq
+
+        return Pose(0, yp, yq.normalised.elements)
+
+    @classmethod
+    def sub(cls, y: Self, x: Self) -> Self:
+        """
+        Performs pose SE3 subtraction, as x + d = y => d = y - x
+        """
+        xq = pyquat.Quaternion(x.q)
+        yq = pyquat.Quaternion(y.q)
+
+        dp = xq.inverse.rotate(y.p - x.p)
+        dq = xq.inverse * yq
+
+        return Pose(0, dp, dq.normalised.elements)
+
+    @classmethod
+    def interpolate(cls, a: Self, b: Self, t: float) -> Self:
+        """
+        Interpolates between two given poses, as a * t + b * (1 - t)
+
+        :return: interpolated pose
+        """
+        ts = a.ts + (b.ts - a.ts) * t
+        p = a.p + (b.p - a.p) * t
+        q = pyquat.Quaternion.slerp(pyquat.Quaternion(a.q), pyquat.Quaternion(b.q), t)
+        return Pose(ts, p, q.normalised.elements)
+
+    def __init__(self, ts: float, p: np.ndarray, q: np.ndarray):
+        """
+        Represents a pose
+
+        :param ts: timestamp
+        :param p: position vector
+        :param q: orientation quaternion
+        """
+        self.ts = ts
+        self.p = p
+        self.q = q
+
+    def matrix(self) -> np.ndarray:
+        """
+        Returns the transformation matrix of this pose
+
+        :return: transformation matrix
+        """
+        r = pyquat.Quaternion(self.q).rotation_matrix
+        t = self.p[:, None]
+        return np.block([[r, t], [np.zeros((1, 3), dtype=np.float64), np.ones((1, 1), dtype=np.float64)]])
+
+    def translate(self, v: np.ndarray) -> np.ndarray:
+        """
+        Translate the given vector with the pose position
+
+        :param v: the vector to be translated
+
+        :return: translated vector
+        """
+        return self.p + v
+
+    def rotate(self, v: np.ndarray) -> np.ndarray:
+        """
+        Rotates the given vector with the pose orientation
+
+        :param v: the vector to be rotated
+
+        :return: rotated vector
+        """
+        return pyquat.Quaternion(self.q).rotate(v)
+
+    def __str__(self):
+        return repr_data(self)