TYPE_CHECKING,
Union,
)
+from types import SimpleNamespace
__all__ = (
"Stream",
return x
+def l3str(x: Union[str, List[str]]) -> List[str]:
+ if isinstance(x, str):
+ lx = x.split(",")
+ else:
+ lx = x
+ if len(lx) != 3 or not all(isinstance(el, str) for el in x):
+ raise ValueError(str(lx) + " is not a list of three strings")
+ return lx
+
+
class MetaPkt(type):
"""
For each class corresponding to a message, automatically create
class BeeSurePkt(metaclass=MetaPkt):
RESPOND = Respond.NON # Do not send anything back by default
- PROTO: str
IN_KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = ()
OUT_KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = ()
KWARGS: Tuple[Tuple[str, Callable[[Any], Any], Any], ...] = ()
def out_encode(self) -> str:
# Overridden in subclasses, otherwise command verb only
- return self.PROTO
+ return ""
+
+ @property
+ def PROTO(self) -> str:
+ try:
+ proto, _ = self.__class__.__name__.split(".")
+ except ValueError:
+ proto = self.__class__.__name__
+ return proto
@property
def packed(self) -> bytes:
- buffer = self.encode().encode()
- return f"[LT*0000000000*{len(buffer):04X}*".encode() + buffer + b"]"
+ data = self.encode()
+ payload = self.PROTO + "," + data if data else self.PROTO
+ return f"[LT*0000000000*{len(payload):04X}*{payload}]".encode()
class UNKNOWN(BeeSurePkt):
- PROTO = "UNKNOWN"
+ pass
class LK(BeeSurePkt):
- PROTO = "LK"
RESPOND = Respond.INL
def in_decode(self, *args: str) -> None:
class CONFIG(BeeSurePkt):
- PROTO = "CONFIG"
+ pass
class ICCID(BeeSurePkt):
- PROTO = "ICCID"
-
+ pass
-class UD(BeeSurePkt):
- PROTO = "UD"
+class _LOC_DATA(BeeSurePkt):
def in_decode(self, *args: str) -> None:
- (
- _,
- self.date,
- self.time,
- self.gps_valid,
- self.lat,
- self.nors,
- self.lon,
- self.eorw,
- self.speed,
- self.direction,
- self.altitude,
- self.num_of_sats,
- self.gsm_strength_percentage,
- self.battery_percentage,
- self.pedometer,
- self.tubmling_times,
- self.device_status,
- ) = args[:17]
- rest_args = args[17:]
- self.base_stations_number = int(rest_args[0])
- # ???, mcc, net, (area, cell, strength)*
- self.base_stations = rest_args[1 : 4 + 3 * self.base_stations_number]
- rest_args = rest_args[3 + 3 * self.base_stations_number + 1 :]
- self.wifi_ap_number = int(rest_args[0])
+ 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"),
+ (p, "lat", float),
+ (p, "nors", lambda x: 1 if x == "N" else -1),
+ (p, "lon", float),
+ (p, "eorw", lambda x: 1 if x == "E" else -1),
+ (self, "speed", float),
+ (self, "direction", float),
+ (self, "altitude", float),
+ (self, "num_of_sats", int),
+ (self, "gsm_strength_percentage", int),
+ (self, "battery_percentage", int),
+ (self, "pedometer", int),
+ (self, "tubmling_times", int),
+ (self, "device_status", lambda x: int(x, 16)),
+ (self, "base_stations_number", int),
+ (self, "connect_base_station_number", int),
+ (self, "mcc", int),
+ (self, "mnc", int),
+ ),
+ args[:21],
+ ):
+ setattr(obj, attr, func(val)) # type: ignore
+ rest_args = args[21:]
+ # (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)
+ ]
+ rest_args = rest_args[3 * self.base_stations_number :]
+ self.wifi_aps_number = int(rest_args[0])
# (SSID, MAC, strength)*
- self.wifi_ap = rest_args[1 : 1 + 3 * self.wifi_ap_number]
- self.positioning_accuracy = rest_args[-1]
+ self.wifi_aps = [
+ (
+ rest_args[1 + i * 3],
+ rest_args[2 + i * 3],
+ int(rest_args[3 + i * 3]),
+ )
+ for i in range(self.wifi_aps_number)
+ ]
+ rest_args = rest_args[1 + 3 * self.wifi_aps_number :]
+ self.positioning_accuracy = float(rest_args[0])
+ self.devtime = (
+ datetime.strptime(
+ p.date + p.time,
+ "%d%m%y%H%M%S",
+ )
+ # .replace(tzinfo=timezone.utc)
+ # .astimezone(tz=timezone.utc)
+ )
+ self.latitude = p.lat * p.nors
+ self.longitude = p.lon * p.eorw
+
+
+class UD(_LOC_DATA):
+ pass
-class UD2(BeeSurePkt):
- PROTO = "UD2"
+class UD2(_LOC_DATA):
+ pass
class TKQ(BeeSurePkt):
- PROTO = "TKQ"
RESPOND = Respond.INL
class TKQ2(BeeSurePkt):
- PROTO = "TKQ2"
RESPOND = Respond.INL
-class AL(BeeSurePkt):
- PROTO = "AL"
+class AL(_LOC_DATA):
RESPOND = Respond.INL
+class CR(BeeSurePkt):
+ pass
+
+
+class FLOWER(BeeSurePkt):
+ OUT_KWARGS = (("number", int, 1),)
+
+ def out_encode(self) -> str:
+ self.number: int
+ return str(self.number)
+
+
+class POWEROFF(BeeSurePkt):
+ pass
+
+
+class RESET(BeeSurePkt):
+ pass
+
+
+class SOS(BeeSurePkt):
+ OUT_KWARGS = (("phonenumbers", l3str, ["", "", ""]),)
+
+ def out_encode(self) -> str:
+ self.phonenumbers: List[str]
+ return ",".join(self.phonenumbers)
+
+
+class _SET_PHONE(BeeSurePkt):
+ OUT_KWARGS = (("phonenumber", str, ""),)
+
+ def out_encode(self) -> str:
+ self.phonenumber: str
+ return self.phonenumber
+
+
+class SOS1(_SET_PHONE):
+ pass
+
+
+class SOS2(_SET_PHONE):
+ pass
+
+
+class SOS3(_SET_PHONE):
+ pass
+
+
# Build dicts protocol number -> class and class name -> protocol number
CLASSES = {}
-PROTOS = {}
if True: # just to indent the code, sorry!
for cls in [
cls
and issubclass(cls, BeeSurePkt)
and not name.startswith("_")
]:
- if hasattr(cls, "PROTO"):
- CLASSES[cls.PROTO] = cls
- PROTOS[cls.__name__] = cls.PROTO
+ CLASSES[cls.__name__] = cls
def class_by_prefix(
prefix: str,
-) -> Union[Type[BeeSurePkt], List[Tuple[str, str]]]:
- lst = [
- (name, proto)
- for name, proto in PROTOS.items()
- if name.upper().startswith(prefix.upper())
- ]
- if len(lst) != 1:
- return lst
- _, proto = lst[0]
- return CLASSES[proto]
+) -> Union[Type[BeeSurePkt], List[str]]:
+ if prefix.startswith(PROTO_PREFIX):
+ pname = prefix[len(PROTO_PREFIX) :].upper()
+ else:
+ raise KeyError(pname)
+ lst = [name for name in CLASSES.keys() if name.upper().startswith(pname)]
+ for proto in lst:
+ if len(lst) == 1: # unique prefix match
+ return CLASSES[proto]
+ if proto == pname: # exact match
+ return CLASSES[proto]
+ return lst
def proto_handled(proto: str) -> bool:
retobj = UNKNOWN.In(vendor, imei, datalength, payload)
else:
retobj = UNKNOWN.Out(vendor, imei, datalength, payload)
- retobj.PROTO = proto # Override class attr with object attr
+ retobj.proto = proto # Override class attr with object attr
retobj.cause = cause
return retobj