co-maps/tools/python/mwm/mwm_interface.py

import enum
import os
from abc import ABC
from abc import abstractmethod
from typing import Dict
from typing import Iterable
from typing import List
from typing import Union

from mwm.feature_types import readable_type

# See coding/string_utf8_multilang.cpp to synchronize languages.
LANGS = (
    "default",
    "en",
    "ja",
    "fr",
    "ko_rm",
    "ar",
    "de",
    "int_name",
    "ru",
    "sv",
    "zh",
    "fi",
    "be",
    "ka",
    "ko",
    "he",
    "nl",
    "ga",
    "ja_rm",
    "el",
    "it",
    "es",
    "zh_pinyin",
    "th",
    "cy",
    "sr",
    "uk",
    "ca",
    "hu",
    "reserved (earlier hsb)",
    "eu",
    "fa",
    "reserved (earlier br)",
    "pl",
    "hy",
    "reserved (earlier kn)",
    "sl",
    "ro",
    "sq",
    "am",
    "no",
    "cs",
    "id",
    "sk",
    "af",
    "ja_kana",
    "reserved (earlier lb)",
    "pt",
    "hr",
    "da",
    "vi",
    "tr",
    "bg",
    "alt_name",
    "lt",
    "old_name",
    "kk",
    "reserved (earlier gsw)",
    "et",
    "ku",
    "mn",
    "mk",
    "lv",
    "hi",
)


class MetadataField(enum.Enum):
    cuisine = 1
    open_hours = 2
    phone_number = 3
    fax_number = 4
    stars = 5
    operator = 6
    url = 7
    website = 8
    internet = 9
    ele = 10
    turn_lanes = 11
    turn_lanes_forward = 12
    turn_lanes_backward = 13
    email = 14
    postcode = 15
    wikipedia = 16
    flats = 18
    height = 19
    min_height = 20
    denomination = 21
    building_levels = 22
    test_id = 23
    sponsored_id = 24
    price_rate = 25
    rating = 26
    banner_url = 27
    level = 28
    airport_iata = 29
    brand = 30
    duration = 31
    building_min_level = 40


class RegionDataField(enum.Enum):
    languages = 0
    driving = 1
    timezone = 2
    address_format = 3
    phone_format = 4
    postcode_format = 5
    public_holidays = 6
    allow_housenames = 7


class MapType(enum.Enum):
    world = 0
    world_coasts = 1
    country = 2


class GeomType(enum.Enum):
    undefined = -1
    point = 0
    line = 1
    area = 2


class SectionInfo:
    __slots__ = "name", "offset", "size"

    def __init__(self, name, offset, size):
        self.name = name
        self.offset = offset
        self.size = size

    def __repr__(self):
        return (
            f"SectionInfo[name: {self.name}, "
            f"offset: {self.offset}, "
            f"size: {self.size}]"
        )

    def to_json(self):
        return {"name": self.name, "offset": self.offset, "size": self.size}


class MwmVersion:
    __slots__ = "format", "seconds_since_epoch", "version"

    def __init__(self, format, seconds_since_epoch, version):
        self.format = format
        self.seconds_since_epoch = seconds_since_epoch
        self.version = version

    def __repr__(self):
        return (
            f"MwmVersion[format: {self.format}, "
            f"seconds since epoch: {self.seconds_since_epoch}, "
            f"version: {self.version}]"
        )

    def to_json(self):
        return {
            "format": self.format,
            "secondsSinceEpoch": self.seconds_since_epoch,
            "version": self.version,
        }


class Point:
    __slots__ = "x", "y"

    def __init__(self, x=0.0, y=0.0):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Point):
            return Point(self.x + other.x, self.y + other.y)
        raise NotImplementedError

    def __iadd__(self, other):
        if isinstance(other, Point):
            self.x += other.x
            self.y += other.y
        raise NotImplementedError

    def __repr__(self):
        return f"({self.x}, {self.y})"

    def to_json(self):
        return {"x": self.x, "y": self.y}


class Rect:
    __slots__ = "left_bottom", "right_top"

    def __init__(self, left_bottom: Point, right_top: Point):
        self.left_bottom = left_bottom
        self.right_top = right_top

    def __repr__(self):
        return f"Rect[{self.left_bottom}, {self.right_top}]"

    def to_json(self):
        return {
            "leftBottom": self.left_bottom.to_json(),
            "rightTop": self.right_top.to_json(),
        }


class Triangle:
    __slots__ = "x", "y", "z"

    def __init__(self, x: Point, y: Point, z: Point):
        self.x = x
        self.y = y
        self.z = z

    def __repr__(self):
        return f"Triangle[{self.x}, {self.y}, {self.z}]"

    def to_json(self):
        return {"x": self.x.to_json(), "y": self.y.to_json(), "z": self.z.to_json()}


class Mwm(ABC):
    def __init__(self, filename: str):
        self.filename = filename

    def name(self) -> str:
        return os.path.basename(self.filename)

    def path(self) -> str:
        return self.filename

    @abstractmethod
    def version(self) -> MwmVersion:
        pass

    @abstractmethod
    def type(self) -> MapType:
        pass

    @abstractmethod
    def bounds(self) -> Rect:
        pass

    @abstractmethod
    def sections_info(self) -> Dict[str, SectionInfo]:
        pass

    @abstractmethod
    def __len__(self) -> int:
        pass

    @abstractmethod
    def __iter__(self) -> Iterable:
        pass

    def __repr__(self):
        si = "\n".join(
            [
                f"    {s}"
                for s in sorted(self.sections_info().values(), key=lambda x: x.offset)
            ]
        )
        return (
            f"Mwm[\n"
            f"  name: {self.name()}\n"
            f"  type: {self.type()}\n"
            f"  version: {self.version()}\n"
            f"  number of features: {len(self)}\n"
            f"  bounds: {self.bounds()}\n"
            f"  sections info: [\n{si} \n  ]\n"
            f"]"
        )

    def to_json(self, with_features=False):
        m = {
            "name": self.name(),
            "version": self.version().to_json(),
            "type": self.type(),
            "bounds": self.bounds().to_json(),
            "sections_info": {k: v.to_json() for k, v in self.sections_info().items()},
            "size": len(self),
        }

        if with_features:
            m["features"] = [f.to_json() for f in self]

        return m


class Feature(ABC):
    @abstractmethod
    def index(self) -> int:
        pass

    @abstractmethod
    def types(self) -> List[int]:
        pass

    def readable_types(self) -> List[str]:
        return [readable_type(i) for i in self.types()]

    @abstractmethod
    def metadata(self) -> Dict[MetadataField, str]:
        pass

    @abstractmethod
    def names(self) -> Dict[str, str]:
        pass

    @abstractmethod
    def readable_name(self) -> str:
        pass

    @abstractmethod
    def rank(self) -> int:
        pass

    @abstractmethod
    def population(self) -> int:
        pass

    @abstractmethod
    def road_number(self) -> str:
        pass

    @abstractmethod
    def house_number(self) -> str:
        pass

    @abstractmethod
    def layer(self) -> int:
        pass

    @abstractmethod
    def geom_type(self) -> GeomType:
        pass

    @abstractmethod
    def center(self) -> Point:
        pass

    @abstractmethod
    def geometry(self) -> Union[List[Point], List[Triangle]]:
        pass

    @abstractmethod
    def limit_rect(self) -> Rect:
        pass

    @abstractmethod
    def parse(self):
        pass

    def __repr__(self):
        return (
            f"Feature[\n"
            f"  index: {self.index()}\n"
            f"  readable name: {self.readable_name()}\n"
            f"  types: {self.readable_types()}\n"
            f"  names: {self.names()}\n"
            f"  metadata: {self.metadata()}\n"
            f"  geom_type: {self.geom_type()}\n"
            f"  center: {self.center()}\n"
            f"  limit_rect: {self.limit_rect()}\n"
            f"]"
        )

    def to_json(self):
        center = None
        center_ = self.center()
        if center_:
            center = self.center().to_json()

        limit_rect = None
        limit_rect_ = self.limit_rect()
        if limit_rect_:
            limit_rect = limit_rect_.to_json()

        return {
            "index": self.index(),
            "types": {t: readable_type(t) for t in self.types()},
            "metadata": {k.name: v for k, v in self.metadata().items()},
            "names": self.names(),
            "readable_name": self.readable_name(),
            "rank": self.rank(),
            "population": self.population(),
            "road_number": self.road_number(),
            "house_number": self.house_number(),
            "layer": self.layer(),
            "geom_type": self.geom_type(),
            "center": center,
            "limit_rect": limit_rect,
        }