apyefa 0.0.6__py3-none-any.whl → 1.0.0__py3-none-any.whl

apyefa/commands/__init__.py

@@ -1,15 +1,27 @@
 from .command import Command
+from .command_add_info import CommandAdditionalInfo
+from .command_coord import CommandCoord
 from .command_departures import CommandDepartures
+from .command_geoobject import CommandGeoObject
+from .command_line_list import CommandLineList
+from .command_line_stop import CommandLineStop
 from .command_serving_lines import CommandServingLines
 from .command_stop_finder import CommandStopFinder
+from .command_stop_list import CommandStopList
 from .command_system_info import CommandSystemInfo
 from .command_trip import CommandTrip
 
 __all__ = [
     "Command",
     "CommandDepartures",
+    "CommandAdditionalInfo",
+    "CommandCoord",
+    "CommandGeoObject",
     "CommandStopFinder",
+    "CommandStopList",
     "CommandSystemInfo",
+    "CommandLineStop",
+    "CommandLineList",
     "CommandTrip",
     "CommandServingLines",
 ]

apyefa/commands/command.py

@@ -1,5 +1,6 @@
 import logging
 from abc import abstractmethod
+from datetime import date, datetime
 
 from voluptuous import MultipleInvalid, Schema
 
@@ -7,107 +8,150 @@ from apyefa.commands.parsers.rapid_json_parser import RapidJsonParser
 from apyefa.exceptions import EfaFormatNotSupported, EfaParameterError
 from apyefa.helpers import is_date, is_datetime, is_time
 
-from ..data_classes import CoordFormat
-
 _LOGGER = logging.getLogger(__name__)
 
 
 class Command:
-    def __init__(self, name: str, macro: str, output_format: str = "rapidJSON") -> None:
+    def __init__(self, name: str, format: str) -> None:
         self._name: str = name
-        self._macro: str = macro
         self._parameters: dict[str, str] = {}
-        self._format: str = output_format
+        self._format = format
 
-        self.add_param("outputFormat", output_format)
-        self.add_param("coordOutputFormat", CoordFormat.WGS84.value)
+        self.add_param("outputFormat", format)
 
-    def add_param(self, param: str, value: str):
-        if not param or not value:
-            return
+    def add_param(self, param: str, value: str | bool):
+        """
+        Adds a parameter and its value to the command's parameters.
 
-        if param not in self._get_params_schema().schema.keys():
-            raise EfaParameterError(
-                f"Parameter {param} is now allowed for this command"
-            )
+        Args:
+            param (str): The name of the parameter to add.
+            value (str | bool): The value of the parameter. If the value is a boolean,
+                                it will be converted to "1" for True and "0" for False.
+
+        Raises:
+            EfaParameterError: If the parameter is not allowed for this command.
+        """
+        if not param or value is None:
+            return
 
         _LOGGER.debug(f'Add parameter "{param}" with value "{value}"')
 
+        if isinstance(value, bool):
+            value = "1" if value else "0"
+
         self._parameters.update({param: value})
 
         _LOGGER.debug("Updated parameters:")
         _LOGGER.debug(self._parameters)
 
-    def add_param_datetime(self, date: str):
-        if not date:
-            return
+    def add_param_datetime(self, arg_date: str | datetime | date):
+        """
+        Adds date and/or time parameters to the command based on the provided argument.
 
-        if is_datetime(date):
-            self.add_param("itdDate", date.split(" ")[0])
-            self.add_param("itdTime", date.split(" ")[1].replace(":", ""))
-        elif is_date(date):
-            self.add_param("itdDate", date)
-        elif is_time(date):
-            self.add_param("itdTime", date.replace(":", ""))
-        else:
-            raise ValueError("Date(time) provided in invalid format")
+        Parameters:
+        arg_date (str | datetime | date): The date and/or time to be added. It can be a string, datetime object, or date object.
 
-    def to_str(self) -> str:
-        self._parameters = self.extend_with_defaults()
-        self.validate()
+        Raises:
+        ValueError: If the provided date(time) is in an invalid format.
 
-        return f"{self._name}?commonMacro={self._macro}" + self._get_params_as_str()
+        Notes:
+        - If arg_date is a datetime object, both date and time parameters are added.
+        - If arg_date is a date object, only the date parameter is added.
+        - If arg_date is a string, it will be checked if it is a valid datetime, date, or time string.
+        """
+        if not arg_date:
+            return
 
-    def __str__(self) -> str:
-        return self.to_str()
+        if isinstance(arg_date, datetime):
+            self.add_param("itdDate", arg_date.strftime("%Y%m%d"))
+            self.add_param("itdTime", arg_date.strftime("%H%M"))
+        elif isinstance(arg_date, date):
+            self.add_param("itdDate", arg_date.strftime("%Y%m%d"))
+        elif is_datetime(arg_date):
+            self.add_param("itdDate", arg_date.split(" ")[0])
+            self.add_param("itdTime", arg_date.split(" ")[1].replace(":", ""))
+        elif is_date(arg_date):
+            self.add_param("itdDate", arg_date)
+        elif is_time(arg_date):
+            self.add_param("itdTime", arg_date.replace(":", ""))
+        else:
+            raise ValueError(f'Date(time) "{arg_date}" provided in invalid format')
 
-    def validate(self):
-        """Validate self._parameters
+    def validate_params(self):
+        """
+        Validates the parameters against the schema.
 
         Raises:
-            EfaParameterError: some of parameters are missing or have invalid values
+            EfaParameterError: If the parameters are invalid
         """
-        params_schema = self._get_params_schema()
 
         try:
-            params = self.extend_with_defaults()
-            params_schema(params)
-        except MultipleInvalid as exc:
-            _LOGGER.error("Parameters validation failed", exc_info=exc)
-            raise EfaParameterError(str(exc)) from exc
+            self._get_params_schema()(self._parameters)
+        except MultipleInvalid as e:
+            raise EfaParameterError(f"Invalid parameter(s) detected: {str(e)}")
 
-    def extend_with_defaults(self) -> dict:
-        """Extend self._parameters with default values
+    def __str__(self) -> str:
+        return f"{self._name}" + self._get_params_as_str()
 
-        Returns:
-            dict: parameters extended with default values
+    def _get_params_as_str(self) -> str:
         """
+        Converts the parameters dictionary to a query string.
 
-        params_schema = self._get_params_schema()
-
-        return params_schema(self._parameters)
-
-    def _get_params_as_str(self) -> str:
-        """Return parameters concatenated with &
+        If the parameters dictionary is empty, returns an empty string.
+        Otherwise, returns a string starting with '?' followed by the
+        parameters in 'key=value' format, joined by '&'.
 
         Returns:
-            str: parameters as string
+            str: The query string representation of the parameters.
         """
         if not self._parameters:
             return ""
 
-        return "&" + "&".join([f"{k}={str(v)}" for k, v in self._parameters.items()])
+        return "?" + "&".join([f"{k}={str(v)}" for k, v in self._parameters.items()])
 
     @abstractmethod
     def parse(self, data: str):
+        """
+        Parses the given data.
+
+        Args:
+            data (str): The data to be parsed.
+
+        Raises:
+            NotImplementedError: If the method is not implemented by a subclass.
+        """
         raise NotImplementedError("Abstract method not implemented")
 
     @abstractmethod
     def _get_params_schema(self) -> Schema:
+        """
+        Retrieve the schema for the parameters.
+
+        This is an abstract method that should be implemented by subclasses
+        to provide the specific schema for the parameters.
+
+        Returns:
+            Schema: The schema for the parameters.
+
+        Raises:
+            NotImplementedError: If the method is not implemented by a subclass.
+        """
         raise NotImplementedError("Abstract method not implemented")
 
     @abstractmethod
     def _get_parser(self):
+        """
+        Returns the appropriate parser based on the specified format.
+
+        This method uses a match-case statement to determine which parser to return
+        based on the value of the instance variable `self._format`.
+
+        Returns:
+            RapidJsonParser: If the format is "rapidJSON".
+
+        Raises:
+            EfaFormatNotSupported: If the format is not supported.
+        """
         match self._format:
             case "rapidJSON":
                 return RapidJsonParser()

apyefa/commands/command_add_info.py

@@ -0,0 +1,60 @@
+import logging
+
+from voluptuous import Any, Optional, Required, Schema
+
+from apyefa.commands.command import Command
+
+from ..data_classes import CoordFormat
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandAdditionalInfo(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_ADDINFO_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        result = []
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default="WGS84"): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Optional("filterShowLineList", default="0"): Any("0", "1", 0, 1),
+                Optional("filterShowStopList", default="0"): Any("0", "1", 0, 1),
+                Optional("filterShowPlaceList", default="0"): Any("0", "1", 0, 1),
+                Optional("filterPublished", default="0"): Any("0", "1", 0, 1),
+                Optional("filterDateValid"): str,
+                Optional("filterDateValidDay"): str,
+                Optional("filterDateValidMonth"): str,
+                Optional("filterDateValidYear"): str,
+                Optional("filterDateValidComponentsActive"): Any("0", "1", 0, 1),
+                Optional("filterPublicationStatus"): Any("current", "history"),
+                Optional("filterValidIntervalStart"): str,
+                Optional("filterValidIntervalEnd"): str,
+                Optional("filterOMC"): str,
+                Optional("filterValid"): str,
+                Optional("filterOMC_PlaceID"): str,
+                Optional("filterLineNumberIntervalStart"): str,
+                Optional("filterLineNumberIntervalEnd"): str,
+                Optional("filterMOTType"): str,
+                Optional("filterPNLineDir"): str,
+                Optional("filterPNLineSub"): str,
+                Optional("itdLPxx_selLine"): str,
+                Optional("itdLPxx_selOperator"): str,
+                Optional("itdLPxx_selStop"): str,
+                Optional("line"): str,
+                Optional("filterInfoID"): str,
+                Optional("filterInfoType"): str,
+                Optional("filterPriority"): str,
+                Optional("filterProviderCode"): str,
+                Optional("filterSourceSystemName"): str,
+            }
+        )

apyefa/commands/command_coord.py

@@ -0,0 +1,45 @@
+import logging
+
+from voluptuous import Any, Match, Optional, Required, Schema
+
+from apyefa.commands.command import Command
+from apyefa.data_classes import CoordFormat, Location
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandCoord(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_COORD_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        locations = data.get("locations", [])
+
+        _LOGGER.info(f"{len(locations)} location(s) found")
+
+        result = []
+
+        for loc in locations:
+            result.append(Location.from_dict(loc))
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Optional("boundingBox"): Any("0", "1", 0, 1),
+                Optional("boundingBoxLU"): str,
+                Optional("boundingBoxRL"): str,
+                Optional("inclFilter"): Any("0", "1", 0, 1),
+                Optional(Match(r"^type_\d{1,}$")): str,
+                Optional(Match(r"^radius_\d{1,}$")): int,
+                Optional("coord"): str,
+                Optional("max"): int,
+            },
+        )

apyefa/commands/command_departures.py

@@ -9,10 +9,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class CommandDepartures(Command):
-    def __init__(self, stop: str) -> None:
-        super().__init__("XML_DM_REQUEST", "dm")
-
-        self.add_param("name_dm", stop)
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_DM_REQUEST", format)
 
     def parse(self, data: dict):
         data = self._get_parser().parse(data)
@@ -32,9 +30,10 @@ class CommandDepartures(Command):
         return Schema(
             {
                 Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
-                Required("coordOutputFormat", default="WGS84"): Any(
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
                     *[x.value for x in CoordFormat]
                 ),
+                Required("locationServerActive", default="1"): Any("0", "1", 0, 1),
                 Required("name_dm"): str,
                 Required("type_dm", default="stop"): Any("any", "stop"),
                 Required("mode", default="direct"): Any("any", "direct"),

apyefa/commands/command_geoobject.py

@@ -0,0 +1,42 @@
+import logging
+
+from voluptuous import Any, Optional, Required, Schema
+
+from apyefa.commands.command import Command
+from apyefa.data_classes import CoordFormat, Line
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandGeoObject(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_GEOOBJECT_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        locations = data.get("transportations", [])
+
+        _LOGGER.info(f"{len(locations)} location(s) found")
+
+        result = []
+
+        for loc in locations:
+            result.append(Line.from_dict(loc))
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Required("line"): str,
+                Optional("boundingBox"): Any("0", "1", 0, 1),
+                Optional("boundingBoxLU"): str,
+                Optional("boundingBoxRL"): str,
+                Optional("filterDate"): Any("0", "1", 0, 1),
+            },
+        )

apyefa/commands/command_line_list.py

@@ -0,0 +1,46 @@
+import logging
+
+from voluptuous import Any, Optional, Range, Required, Schema
+
+from apyefa.commands.command import Command
+from apyefa.data_classes import CoordFormat, Line, LineRequestType
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandLineList(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_LINELIST_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        lines = data.get("transportations", [])
+
+        _LOGGER.info(f"{len(lines)} line(s) found")
+
+        result = []
+
+        for line in lines:
+            result.append(Line.from_dict(line))
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Optional("lineListBranchCode"): str,
+                Optional("lineListNetBranchCode"): str,
+                Optional("lineListSubnetwork"): str,
+                Optional("lineListOMC"): str,
+                Optional("lineListMixedLines"): Any("0", "1", 0, 1),
+                Optional("mergeDir"): Any("0", "1", 0, 1),
+                Optional("lineReqType"): Range(
+                    min=0, max=sum([x.value for x in LineRequestType])
+                ),
+            }
+        )

apyefa/commands/command_line_stop.py

@@ -0,0 +1,39 @@
+import logging
+
+from voluptuous import Any, Optional, Required, Schema
+
+from apyefa.commands.command import Command
+from apyefa.data_classes import CoordFormat, Location
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandLineStop(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_LINESTOP_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        stops = data.get("locationSequence", [])
+
+        _LOGGER.info(f"{len(stops)} stop(s) found")
+
+        result = []
+
+        for stop in stops:
+            result.append(Location.from_dict(stop))
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Optional("line"): str,
+                Optional("allStopInfo"): Any("0", "1", 0, 1),
+            }
+        )

apyefa/commands/command_serving_lines.py

@@ -9,31 +9,20 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class CommandServingLines(Command):
-    def __init__(self, mode: str, value: str) -> None:
-        super().__init__("XML_SERVINGLINES_REQUEST", "servingLines")
-
-        match mode:
-            case "odv":
-                self.add_param("type_sl", "stopID")
-                self.add_param("name_sl", value)
-            case "line":
-                self.add_param("lineName", value)
-            case _:
-                raise ValueError(f"Mode {mode} not supported for serving lines")
-
-        self.add_param("mode", mode)
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_SERVINGLINES_REQUEST", format)
 
     def parse(self, data: dict) -> list[Line]:
         data = self._get_parser().parse(data)
 
-        transportations = data.get("lines", [])
+        lines = data.get("lines", [])
 
-        _LOGGER.info(f"{len(transportations)} transportation(s) found")
+        _LOGGER.info(f"{len(lines)} line(s) found")
 
         result = []
 
-        for t in transportations:
-            result.append(Line.from_dict(t))
+        for line in lines:
+            result.append(Line.from_dict(line))
 
         return result
 
@@ -41,9 +30,10 @@ class CommandServingLines(Command):
         return Schema(
             {
                 Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
-                Required("coordOutputFormat", default="WGS84"): Any(
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
                     *[x.value for x in CoordFormat]
                 ),
+                Required("locationServerActive", default="1"): Any("0", "1", 0, 1),
                 Required("mode", default="line"): Any("odv", "line"),
                 # mode 'odv'
                 Optional("type_sl"): Any("stopID"),

apyefa/commands/command_stop_finder.py

@@ -9,11 +9,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class CommandStopFinder(Command):
-    def __init__(self, req_type: str, name: str) -> None:
-        super().__init__("XML_STOPFINDER_REQUEST", "stopfinder")
-
-        self.add_param("type_sf", req_type)
-        self.add_param("name_sf", name)
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_STOPFINDER_REQUEST", format)
 
     def parse(self, data: dict) -> list[Location]:
         data = self._get_parser().parse(data)
@@ -33,11 +30,12 @@ class CommandStopFinder(Command):
         return Schema(
             {
                 Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
-                Required("coordOutputFormat", default="WGS84"): Any(
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
                     *[x.value for x in CoordFormat]
                 ),
                 Required("type_sf", default="any"): Any("any", "coord"),
                 Required("name_sf"): str,
+                Required("locationServerActive", default="1"): Any("0", "1", 0, 1),
                 Optional("anyMaxSizeHitList"): int,
                 Optional("anySigWhenPerfectNoOtherMatches"): Any("0", "1", 0, 1),
                 Optional("anyResSort_sf"): str,

apyefa/commands/command_stop_list.py

@@ -0,0 +1,48 @@
+import logging
+
+from voluptuous import Any, Optional, Required, Schema
+
+from apyefa.commands.command import Command
+from apyefa.data_classes import CoordFormat, Location
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CommandStopList(Command):
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_STOPLIST_REQUEST", format)
+
+    def parse(self, data: dict):
+        data = self._get_parser().parse(data)
+
+        locations = data.get("locations", [])
+
+        _LOGGER.info(f"{len(locations)} location(s) found")
+
+        result = []
+
+        for location in locations:
+            result.append(Location.from_dict(location))
+
+        return result
+
+    def _get_params_schema(self) -> Schema:
+        return Schema(
+            {
+                Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
+                Required("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
+                    *[x.value for x in CoordFormat]
+                ),
+                Optional("stopListOMC"): str,
+                Optional("stopListPlaceId"): str,
+                Optional("stopListOMCPlaceId"): str,
+                Optional("rTN"): str,
+                Optional("stopListSubnetwork"): str,
+                Optional("fromstop"): str,
+                Optional("tostop"): str,
+                Optional("servingLines"): Any("0", "1", 0, 1),
+                Optional("servingLinesMOTType"): Any("0", "1", 0, 1),
+                Optional("servingLinesMOTTypes"): Any("0", "1", 0, 1),
+                Optional("tariffZones"): Any("0", "1", 0, 1),
+            }
+        )

apyefa/commands/command_system_info.py

@@ -9,8 +9,8 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class CommandSystemInfo(Command):
-    def __init__(self) -> None:
-        super().__init__("XML_SYSTEMINFO_REQUEST", "system")
+    def __init__(self, format: str) -> None:
+        super().__init__("XML_SYSTEMINFO_REQUEST", format)
 
     def parse(self, data: dict) -> SystemInfo:
         _LOGGER.info("Parsing system info response")
@@ -23,7 +23,7 @@ class CommandSystemInfo(Command):
         return Schema(
             {
                 Required("outputFormat", default="rapidJSON"): Any("rapidJSON"),
-                Optional("coordOutputFormat", default="WGS84"): Any(
+                Optional("coordOutputFormat", default=CoordFormat.WGS84.value): Any(
                     *[x.value for x in CoordFormat]
                 ),
             }