X-Git-Url: http://www.average.org/gitweb/?a=blobdiff_plain;f=loctrkd%2Fbeesure.py;h=41b25e0bbac0141e8691303bcdd69ca9ffc5eac6;hb=148c0b3bdecfd52371506c348c17e1f2c2fdb137;hp=369abc2db39bdd3be3ebaa15347f94dddee333d2;hpb=b0bfb1a7b499ca18bf707858b0650e04acec9881;p=loctrkd.git diff --git a/loctrkd/beesure.py b/loctrkd/beesure.py index 369abc2..41b25e0 100755 --- a/loctrkd/beesure.py +++ b/loctrkd/beesure.py @@ -22,18 +22,25 @@ from typing import ( ) from types import SimpleNamespace +from .protomodule import ProtoClass +from .common import ( + CoordReport, + HintReport, + StatusReport, + Report, +) + __all__ = ( "Stream", "class_by_prefix", "enframe", + "exposed_protos", "inline_response", "proto_handled", "parse_message", "probe_buffer", - "proto_name", "DecodeError", "Respond", - "LK", ) PROTO_PREFIX = "BS:" @@ -133,6 +140,14 @@ def enframe(buffer: bytes, imei: Optional[str] = None) -> bytes: ### Parser/Constructor ### +class classproperty: + def __init__(self, f: Callable[[Any], str]) -> None: + self.f = f + + def __get__(self, obj: Any, owner: Any) -> str: + return self.f(owner) + + class DecodeError(Exception): def __init__(self, e: Exception, **kwargs: Any) -> None: super().__init__(e) @@ -170,54 +185,19 @@ def l3str(x: Union[str, List[str]]) -> List[str]: return lx -class MetaPkt(type): - """ - For each class corresponding to a message, automatically create - two nested classes `In` and `Out` that also inherit from their - "nest". Class attribute `IN_KWARGS` defined in the "nest" is - copied to the `In` nested class under the name `KWARGS`, and - likewise, `OUT_KWARGS` of the nest class is copied as `KWARGS` - to the nested class `Out`. In addition, method `encode` is - defined in both classes equal to `in_encode()` and `out_encode()` - respectively. - """ - - if TYPE_CHECKING: - - def __getattr__(self, name: str) -> Any: - pass +def pblist(x: Union[str, List[Tuple[str, str]]]) -> List[Tuple[str, str]]: + if isinstance(x, str): - def __setattr__(self, name: str, value: Any) -> None: - pass + def splitpair(s: str) -> Tuple[str, str]: + a, b = s.split(":") + return a, b - def __new__( - cls: Type["MetaPkt"], - name: str, - bases: Tuple[type, ...], - attrs: Dict[str, Any], - ) -> "MetaPkt": - newcls = super().__new__(cls, name, bases, attrs) - newcls.In = super().__new__( - cls, - name + ".In", - (newcls,) + bases, - { - "KWARGS": newcls.IN_KWARGS, - "decode": newcls.in_decode, - "encode": newcls.in_encode, - }, - ) - newcls.Out = super().__new__( - cls, - name + ".Out", - (newcls,) + bases, - { - "KWARGS": newcls.OUT_KWARGS, - "decode": newcls.out_decode, - "encode": newcls.out_encode, - }, - ) - return newcls + lx = [splitpair(el) for el in x.split(",")] + else: + lx = x + if len(lx) > 5: + raise ValueError(str(lx) + " has too many elements (max 5)") + return lx class Respond(Enum): @@ -226,7 +206,8 @@ class Respond(Enum): EXT = 2 # Birirectional, use external responder -class BeeSurePkt(metaclass=MetaPkt): +class BeeSurePkt(ProtoClass): + BINARY = False RESPOND = Respond.NON # Do not send anything back by default IN_KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = () OUT_KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = () @@ -247,11 +228,15 @@ class BeeSurePkt(metaclass=MetaPkt): Construct the object _either_ from (length, payload), _or_ from the values of individual fields """ + self.payload: Union[List[str], bytes] assert not args or (len(args) == 4 and not kwargs) if args: # guaranteed to be two arguments at this point self.vendor, self.imei, self.datalength, self.payload = args try: - self.decode(*self.payload) + if isinstance(self.payload, list): + self.decode(*self.payload) + else: + self.decode(self.payload) except error as e: raise DecodeError(e, obj=self) else: @@ -277,7 +262,7 @@ class BeeSurePkt(metaclass=MetaPkt): ), ) - def decode(self, *args: str) -> None: + def decode(self, *args: Any) -> None: ... def in_decode(self, *args: str) -> None: @@ -301,14 +286,21 @@ class BeeSurePkt(metaclass=MetaPkt): # Overridden in subclasses, otherwise command verb only return "" - @property - def PROTO(self) -> str: + @classproperty + def PROTO(cls: "BeeSurePkt") -> str: + """Name of the class without possible .In / .Out suffix""" + proto: str try: - proto, _ = self.__class__.__name__.split(".") + proto, _ = cls.__name__.split(".") except ValueError: - proto = self.__class__.__name__ + proto = cls.__name__ return proto + @classmethod + def proto_name(cls) -> str: + """Name of the command as used externally""" + return PROTO_PREFIX + cls.PROTO[:16] + @property def packed(self) -> bytes: data = self.encode() @@ -320,37 +312,12 @@ class UNKNOWN(BeeSurePkt): pass -class LK(BeeSurePkt): - RESPOND = Respond.INL - - def in_decode(self, *args: str) -> None: - numargs = len(args) - if numargs > 1: - self.step = args[1] - if numargs > 2: - self.tumbling_number = args[2] - if numargs > 3: - self.battery_percentage = args[3] - - def in_encode(self) -> str: - return "LK" - - -class CONFIG(BeeSurePkt): - pass - - -class ICCID(BeeSurePkt): - pass - - class _LOC_DATA(BeeSurePkt): def in_decode(self, *args: str) -> None: p = SimpleNamespace() _id = lambda x: x for (obj, attr, func), val in zip( ( - (p, "verb", _id), (p, "date", _id), (p, "time", _id), (self, "gps_valid", lambda x: x == "A"), @@ -367,21 +334,21 @@ class _LOC_DATA(BeeSurePkt): (self, "pedometer", int), (self, "tubmling_times", int), (self, "device_status", lambda x: int(x, 16)), - (self, "base_stations_number", int), + (self, "gsm_cells_number", int), (self, "connect_base_station_number", int), (self, "mcc", int), (self, "mnc", int), ), - args[:21], + args[:20], ): setattr(obj, attr, func(val)) # type: ignore - rest_args = args[21:] + rest_args = args[20:] # (area_id, cell_id, strength)* - self.base_stations = [ - tuple(int(el) for el in rest_args[i * 3 : 3 + i * 3]) - for i in range(self.base_stations_number) + self.gsm_cells: List[Tuple[int, int, int]] = [ + tuple(int(el) for el in rest_args[i * 3 : 3 + i * 3]) # type: ignore + for i in range(self.gsm_cells_number) ] - rest_args = rest_args[3 * self.base_stations_number :] + rest_args = rest_args[3 * self.gsm_cells_number :] self.wifi_aps_number = int(rest_args[0]) # (SSID, MAC, strength)* self.wifi_aps = [ @@ -405,37 +372,97 @@ class _LOC_DATA(BeeSurePkt): self.latitude = p.lat * p.nors self.longitude = p.lon * p.eorw + def rectified(self) -> Report: + if self.gps_valid: + return CoordReport( + devtime=str(self.devtime), + battery_percentage=self.battery_percentage, + accuracy=self.positioning_accuracy, + altitude=self.altitude, + speed=self.speed, + direction=self.direction, + latitude=self.latitude, + longitude=self.longitude, + ) + else: + return HintReport( + devtime=str(self.devtime), + battery_percentage=self.battery_percentage, + mcc=self.mcc, + mnc=self.mnc, + gsm_cells=self.gsm_cells, + wifi_aps=self.wifi_aps, + ) + -class UD(_LOC_DATA): +class AL(_LOC_DATA): + RESPOND = Respond.INL + + +class CONFIG(BeeSurePkt): pass -class UD2(_LOC_DATA): +class CR(BeeSurePkt): pass -class TKQ(BeeSurePkt): - RESPOND = Respond.INL +class FLOWER(BeeSurePkt): + OUT_KWARGS = (("number", int, 1),) + def out_encode(self) -> str: + self.number: int + return str(self.number) -class TKQ2(BeeSurePkt): - RESPOND = Respond.INL +class ICCID(BeeSurePkt): + pass -class AL(_LOC_DATA): + +class LK(BeeSurePkt): RESPOND = Respond.INL + def in_decode(self, *args: str) -> None: + numargs = len(args) + if numargs > 0: + self.step = args[0] + if numargs > 1: + self.tumbling_number = args[1] + if numargs > 2: + self.battery_percentage = args[2] -class CR(BeeSurePkt): - pass + def in_encode(self) -> str: + return "LK" -class FLOWER(BeeSurePkt): - OUT_KWARGS = (("number", int, 1),) +class MESSAGE(BeeSurePkt): + OUT_KWARGS = (("message", str, ""),) def out_encode(self) -> str: - self.number: int - return str(self.number) + return str(self.message.encode("utf_16_be").hex()) + + +class _PHB(BeeSurePkt): + OUT_KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = ( + ("entries", pblist, []), + ) + + def out_encode(self) -> str: + self.entries: List[Tuple[str, str]] + return ",".join( + [ + ",".join((num, name.encode("utf_16_be").hex())) + for name, num in self.entries + ] + ) + + +class PHB(_PHB): + pass + + +class PHB2(_PHB): + pass class POWEROFF(BeeSurePkt): @@ -474,6 +501,41 @@ class SOS3(_SET_PHONE): pass +class TK(BeeSurePkt): + BINARY = True + RESPOND = Respond.INL + + def in_decode(self, *args: Any) -> None: + assert len(args) == 1 and isinstance(args[0], bytes) + self.amr_data = ( + args[0] + .replace(b"}*", b"*") + .replace(b"},", b",") + .replace(b"}[", b"[") + .replace(b"}]", b"]") + .replace(b"}}", b"}") + ) + + def out_encode(self) -> str: + return "1" # 0 - receive failure, 1 - receive success + + +class TKQ(BeeSurePkt): + RESPOND = Respond.INL + + +class TKQ2(BeeSurePkt): + RESPOND = Respond.INL + + +class UD(_LOC_DATA): + pass + + +class UD2(_LOC_DATA): + pass + + # Build dicts protocol number -> class and class name -> protocol number CLASSES = {} if True: # just to indent the code, sorry! @@ -507,12 +569,6 @@ def proto_handled(proto: str) -> bool: return proto.startswith(PROTO_PREFIX) -def proto_name(obj: Union[MetaPkt, BeeSurePkt]) -> str: - return PROTO_PREFIX + ( - obj.__class__.__name__ if isinstance(obj, BeeSurePkt) else obj.__name__ - ) - - def proto_of_message(packet: bytes) -> str: return PROTO_PREFIX + packet[20:-1].split(b",")[0].decode() @@ -544,20 +600,30 @@ def probe_buffer(buffer: bytes) -> bool: def parse_message(packet: bytes, is_incoming: bool = True) -> BeeSurePkt: """From a packet (without framing bytes) derive the XXX.In object""" toskip, vendor, imei, datalength = _framestart(packet) - payload = packet[20:-1].decode().split(",") - proto = payload[0] if len(payload) > 0 else "" - if proto not in CLASSES: - cause: Union[DecodeError, ValueError, IndexError] = ValueError( - f"Proto {proto} is unknown" - ) + bsplits = packet[20:-1].split(b",", 1) + try: + proto = bsplits[0].decode("ascii") + except UnicodeDecodeError: + proto = str(bsplits[0]) + if len(bsplits) == 2: + rest = bsplits[1] else: + rest = b"" + if proto in CLASSES: + cls = CLASSES[proto].In if is_incoming else CLASSES[proto].Out + payload = ( + # Some people encode their SSIDs in non-utf8 + rest + if cls.BINARY + else rest.decode("Windows-1252").split(",") + ) try: - if is_incoming: - return CLASSES[proto].In(vendor, imei, datalength, payload) - else: - return CLASSES[proto].Out(vendor, imei, datalength, payload) + return cls(vendor, imei, datalength, payload) except (DecodeError, ValueError, IndexError) as e: - cause = e + cause: Union[DecodeError, ValueError, IndexError] = e + else: + payload = rest + cause = ValueError(f"Proto {proto} is unknown") if is_incoming: retobj = UNKNOWN.In(vendor, imei, datalength, payload) else: @@ -565,3 +631,11 @@ def parse_message(packet: bytes, is_incoming: bool = True) -> BeeSurePkt: retobj.proto = proto # Override class attr with object attr retobj.cause = cause return retobj + + +def exposed_protos() -> List[Tuple[str, bool]]: + return [ + (cls.proto_name(), False) + for cls in CLASSES.values() + if hasattr(cls, "rectified") + ]