pymammotion 0.3.7__tar.gz → 0.4.0a0__tar.gz

{pymammotion-0.3.7 → pymammotion-0.4.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymammotion
-Version: 0.3.7
+Version: 0.4.0a0
 Summary: 
 License: GNU-3.0
 Author: Michael Arthur
@@ -21,6 +21,7 @@ Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
 Requires-Dist: betterproto (>=1.2.5,<2.0.0)
 Requires-Dist: bleak (>=0.21.0)
 Requires-Dist: bleak-retry-connector (>=3.5.0,<4.0.0)
+Requires-Dist: cryptography (>=43.0.1)
 Requires-Dist: jsonic (>=1.0.0,<2.0.0)
 Requires-Dist: mashumaro (>=3.13,<4.0)
 Requires-Dist: numpy (>=1.26.0)

{pymammotion-0.3.7 → pymammotion-0.4.0a0}/pymammotion/__init__.py

@@ -12,7 +12,7 @@ from pymammotion.aliyun.cloud_gateway import CloudIOTGateway
 
 # works outside HA on its own
 from pymammotion.bluetooth.ble import MammotionBLE
-from pymammotion.http.http import MammotionHTTP, connect_http
+from pymammotion.http.http import MammotionHTTP
 
 # TODO make a working device that will work outside HA too.
 from pymammotion.mqtt import MammotionMQTT
@@ -20,7 +20,7 @@ from pymammotion.mqtt import MammotionMQTT
 logger = logging.getLogger(__name__)
 
 
-__all__ = ["MammotionBLE", "MammotionHTTP", "connect_http", "MammotionMQTT", "logger"]
+__all__ = ["MammotionBLE", "MammotionHTTP", "MammotionMQTT", "logger"]
 
 
 # TODO provide interface to pick between mqtt/cloud/bluetooth

pymammotion-0.4.0a0/pymammotion/data/model/device.py

@@ -0,0 +1,115 @@
+"""MowingDevice class to wrap around the betterproto dataclasses."""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+import betterproto
+from mashumaro.mixins.orjson import DataClassORJSONMixin
+
+from pymammotion.data.model import HashList, RapidState
+from pymammotion.data.model.device_info import MowerInfo
+from pymammotion.data.model.location import Location
+from pymammotion.data.model.report_info import ReportData
+from pymammotion.data.mqtt.properties import ThingPropertiesMessage
+from pymammotion.http.model.http import ErrorInfo
+from pymammotion.proto.mctrl_sys import (
+    MowToAppInfoT,
+    ReportInfoData,
+    SystemRapidStateTunnelMsg,
+    SystemUpdateBufMsg,
+)
+from pymammotion.utility.constant import WorkMode
+from pymammotion.utility.conversions import parse_double
+from pymammotion.utility.map import CoordinateConverter
+
+
+@dataclass
+class MowingDevice(DataClassORJSONMixin):
+    """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
+
+    mower_state: MowerInfo = field(default_factory=MowerInfo)
+    mqtt_properties: ThingPropertiesMessage | None = None
+    map: HashList = field(default_factory=HashList)
+    location: Location = field(default_factory=Location)
+    mowing_state: RapidState = field(default_factory=RapidState)
+    report_data: ReportData = field(default_factory=ReportData)
+    err_code_list: list = field(default_factory=list)
+    err_code_list_time: Optional[list] = field(default_factory=list)
+    error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
+
+    def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:
+        """Update the device based on which buffer we are reading from."""
+        match buffer_list.update_buf_data[0]:
+            case 1:
+                # 4 speed
+                self.location.RTK.latitude = parse_double(buffer_list.update_buf_data[5], 8.0)
+                self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
+                self.location.dock.latitude = parse_double(buffer_list.update_buf_data[7], 4.0)
+                self.location.dock.longitude = parse_double(buffer_list.update_buf_data[8], 4.0)
+                self.location.dock.rotation = buffer_list.update_buf_data[3] + 180
+            case 2:
+                self.err_code_list.clear()
+                self.err_code_list_time.clear()
+                self.err_code_list.extend(
+                    [
+                        buffer_list.update_buf_data[3],
+                        buffer_list.update_buf_data[5],
+                        buffer_list.update_buf_data[7],
+                        buffer_list.update_buf_data[9],
+                        buffer_list.update_buf_data[11],
+                        buffer_list.update_buf_data[13],
+                        buffer_list.update_buf_data[15],
+                        buffer_list.update_buf_data[17],
+                        buffer_list.update_buf_data[19],
+                        buffer_list.update_buf_data[21],
+                    ]
+                )
+                self.err_code_list_time.extend(
+                    [
+                        buffer_list.update_buf_data[4],
+                        buffer_list.update_buf_data[6],
+                        buffer_list.update_buf_data[8],
+                        buffer_list.update_buf_data[10],
+                        buffer_list.update_buf_data[12],
+                        buffer_list.update_buf_data[14],
+                        buffer_list.update_buf_data[16],
+                        buffer_list.update_buf_data[18],
+                        buffer_list.update_buf_data[20],
+                        buffer_list.update_buf_data[22],
+                    ]
+                )
+
+    def update_report_data(self, toapp_report_data: ReportInfoData) -> None:
+        coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
+        for index, location in enumerate(toapp_report_data.locations):
+            if index == 0 and location.real_pos_y != 0:
+                self.location.position_type = location.pos_type
+                self.location.orientation = location.real_toward / 10000
+                self.location.device = coordinate_converter.enu_to_lla(
+                    parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
+                )
+                if location.zone_hash:
+                    self.location.work_zone = (
+                        location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
+                    )
+
+        self.report_data.update(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
+
+    def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
+        coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
+        self.mowing_state = RapidState().from_raw(rapid_state.rapid_state_data)
+        self.location.position_type = self.mowing_state.pos_type
+        self.location.orientation = self.mowing_state.toward / 10000
+        self.location.device = coordinate_converter.enu_to_lla(
+            parse_double(self.mowing_state.pos_y, 4.0), parse_double(self.mowing_state.pos_x, 4.0)
+        )
+        if self.mowing_state.zone_hash:
+            self.location.work_zone = (
+                self.mowing_state.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
+            )
+
+    def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
+        pass
+
+    def report_missing_data(self) -> None:
+        """Report missing data so we can refetch it."""

{pymammotion-0.3.7 → pymammotion-0.4.0a0}/pymammotion/data/model/device_config.py

@@ -5,16 +5,6 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 from pymammotion.utility.device_type import DeviceType
 
 
-@dataclass
-class DeviceLimits(DataClassORJSONMixin):
-    blade_height_min: int = 30
-    blade_height_max: int = 100
-    working_speed_min: float = 0.2
-    working_speed_max: float = 1.2
-    working_path_min: int = 15
-    working_path_max: int = 35
-
-
 @dataclass
 class OperationSettings(DataClassORJSONMixin):
     """Operation settings for a device."""

pymammotion-0.4.0a0/pymammotion/data/model/device_limits.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class RangeLimit:
+    min: float
+    max: float
+
+
+@dataclass
+class DeviceLimits:
+    cutter_height: RangeLimit = RangeLimit(min=30, max=100)
+    working_speed: RangeLimit = RangeLimit(min=0.2, max=1.2)
+    working_path: RangeLimit = RangeLimit(min=15, max=35)
+    work_area_num_max: int = 60
+    display_image_type: int = 0
+
+    def to_dict(self) -> dict:
+        """Convert the device limits to a dictionary format."""
+        return {
+            "cutter_height": {"min": self.cutter_height.min, "max": self.cutter_height.max},
+            "working_speed": {"min": self.working_speed.min, "max": self.working_speed.max},
+            "working_path": {"min": self.working_path.min, "max": self.working_path.max},
+            "work_area_num_max": self.work_area_num_max,
+            "display_image_type": self.display_image_type,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DeviceLimits":
+        """Create a DeviceLimits instance from a dictionary."""
+        return cls(
+            cutter_height=RangeLimit(min=data["cutter_height"]["min"], max=data["cutter_height"]["max"]),
+            working_speed=RangeLimit(min=data["working_speed"]["min"], max=data["working_speed"]["max"]),
+            working_path=RangeLimit(min=data["working_path"]["min"], max=data["working_path"]["max"]),
+            work_area_num_max=data["work_area_num_max"],
+            display_image_type=data["display_image_type"],
+        )
+
+    def validate(self) -> bool:
+        """Validate that all ranges are logical (min <= max)."""
+        return all(
+            [
+                self.cutter_height.min <= self.cutter_height.max,
+                self.working_speed.min <= self.working_speed.max,
+                self.working_path.min <= self.working_path.max,
+                self.work_area_num_max > 0,
+                self.display_image_type in (0, 1),
+            ]
+        )

pymammotion-0.3.7/pymammotion/data/model/device.py → pymammotion-0.4.0a0/pymammotion/data/model/raw_data.py

@@ -1,18 +1,8 @@
-"""MowingDevice class to wrap around the betterproto dataclasses."""
-
 from dataclasses import dataclass, field
 from typing import Optional
 
-import betterproto
 from mashumaro.mixins.orjson import DataClassORJSONMixin
 
-from pymammotion.data.model import HashList, RapidState
-from pymammotion.data.model.device_config import DeviceLimits
-from pymammotion.data.model.device_info import MowerInfo
-from pymammotion.data.model.location import Location
-from pymammotion.data.model.report_info import ReportData
-from pymammotion.data.mqtt.properties import ThingPropertiesMessage
-from pymammotion.http.model.http import ErrorInfo
 from pymammotion.proto.dev_net import DevNet
 from pymammotion.proto.luba_msg import LubaMsg
 from pymammotion.proto.luba_mul import SocMul
@@ -20,156 +10,56 @@ from pymammotion.proto.mctrl_driver import MctlDriver
 from pymammotion.proto.mctrl_nav import MctlNav
 from pymammotion.proto.mctrl_ota import MctlOta
 from pymammotion.proto.mctrl_pept import MctlPept
-from pymammotion.proto.mctrl_sys import (
-    MctlSys,
-    MowToAppInfoT,
-    ReportInfoData,
-    SystemRapidStateTunnelMsg,
-    SystemUpdateBufMsg,
-)
-from pymammotion.utility.constant import WorkMode
-from pymammotion.utility.conversions import parse_double
-from pymammotion.utility.map import CoordinateConverter
+from pymammotion.proto.mctrl_sys import MctlSys
 
 
 @dataclass
-class MowingDevice(DataClassORJSONMixin):
-    """Wraps the betterproto dataclasses, so we can bypass the groups for keeping all data."""
-
-    mower_state: MowerInfo = field(default_factory=MowerInfo)
-    mqtt_properties: ThingPropertiesMessage | None = None
-    map: HashList = field(default_factory=HashList)
-    location: Location = field(default_factory=Location)
-    mowing_state: RapidState = field(default_factory=RapidState)
-    report_data: ReportData = field(default_factory=ReportData)
-    err_code_list: list = field(default_factory=list)
-    err_code_list_time: Optional[list] = field(default_factory=list)
-    limits: DeviceLimits = field(default_factory=DeviceLimits)
-    device: Optional[LubaMsg] = field(default_factory=LubaMsg)
-    error_codes: dict[str, ErrorInfo] = field(default_factory=dict)
+class RawMowerData:
+    raw: Optional[LubaMsg] = field(default_factory=LubaMsg)
 
     @classmethod
-    def from_raw(cls, raw: dict) -> "MowingDevice":
+    def from_raw(cls, raw: dict) -> "RawMowerData":
         """Take in raw data to hold in the betterproto dataclass."""
-        mowing_device = MowingDevice()
-        mowing_device.device = LubaMsg(**raw)
-        return mowing_device
+        return RawMowerData(raw=LubaMsg(**raw))
 
     def update_raw(self, raw: dict) -> None:
         """Update the raw LubaMsg data."""
-        self.device = LubaMsg(**raw)
-
-    def buffer(self, buffer_list: SystemUpdateBufMsg) -> None:
-        """Update the device based on which buffer we are reading from."""
-        match buffer_list.update_buf_data[0]:
-            case 1:
-                # 4 speed
-                self.location.RTK.latitude = parse_double(buffer_list.update_buf_data[5], 8.0)
-                self.location.RTK.longitude = parse_double(buffer_list.update_buf_data[6], 8.0)
-                self.location.dock.latitude = parse_double(buffer_list.update_buf_data[7], 4.0)
-                self.location.dock.longitude = parse_double(buffer_list.update_buf_data[8], 4.0)
-                self.location.dock.rotation = buffer_list.update_buf_data[3] + 180
-            case 2:
-                self.err_code_list.clear()
-                self.err_code_list_time.clear()
-                self.err_code_list.extend(
-                    [
-                        buffer_list.update_buf_data[3],
-                        buffer_list.update_buf_data[5],
-                        buffer_list.update_buf_data[7],
-                        buffer_list.update_buf_data[9],
-                        buffer_list.update_buf_data[11],
-                        buffer_list.update_buf_data[13],
-                        buffer_list.update_buf_data[15],
-                        buffer_list.update_buf_data[17],
-                        buffer_list.update_buf_data[19],
-                        buffer_list.update_buf_data[21],
-                    ]
-                )
-                self.err_code_list_time.extend(
-                    [
-                        buffer_list.update_buf_data[4],
-                        buffer_list.update_buf_data[6],
-                        buffer_list.update_buf_data[8],
-                        buffer_list.update_buf_data[10],
-                        buffer_list.update_buf_data[12],
-                        buffer_list.update_buf_data[14],
-                        buffer_list.update_buf_data[16],
-                        buffer_list.update_buf_data[18],
-                        buffer_list.update_buf_data[20],
-                        buffer_list.update_buf_data[22],
-                    ]
-                )
-
-    def update_report_data(self, toapp_report_data: ReportInfoData) -> None:
-        coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
-        for index, location in enumerate(toapp_report_data.locations):
-            if index == 0 and location.real_pos_y != 0:
-                self.location.position_type = location.pos_type
-                self.location.orientation = location.real_toward / 10000
-                self.location.device = coordinate_converter.enu_to_lla(
-                    parse_double(location.real_pos_y, 4.0), parse_double(location.real_pos_x, 4.0)
-                )
-                if location.zone_hash:
-                    self.location.work_zone = (
-                        location.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
-                    )
-
-        self.report_data.update(toapp_report_data.to_dict(casing=betterproto.Casing.SNAKE))
-
-    def run_state_update(self, rapid_state: SystemRapidStateTunnelMsg) -> None:
-        coordinate_converter = CoordinateConverter(self.location.RTK.latitude, self.location.RTK.longitude)
-        self.mowing_state = RapidState().from_raw(rapid_state.rapid_state_data)
-        self.location.position_type = self.mowing_state.pos_type
-        self.location.orientation = self.mowing_state.toward / 10000
-        self.location.device = coordinate_converter.enu_to_lla(
-            parse_double(self.mowing_state.pos_y, 4.0), parse_double(self.mowing_state.pos_x, 4.0)
-        )
-        if self.mowing_state.zone_hash:
-            self.location.work_zone = (
-                self.mowing_state.zone_hash if self.report_data.dev.sys_status == WorkMode.MODE_WORKING else 0
-            )
-
-    def mow_info(self, toapp_mow_info: MowToAppInfoT) -> None:
-        pass
-
-    def report_missing_data(self) -> None:
-        """Report missing data so we can refetch it."""
+        self.raw = LubaMsg(**raw)
 
     @property
     def net(self):
         """Will return a wrapped betterproto of net."""
-        return DevNetData(net=self.device.net)
+        return DevNetData(net=self.raw.net)
 
     @property
     def sys(self):
         """Will return a wrapped betterproto of sys."""
-        return SysData(sys=self.device.sys)
+        return SysData(sys=self.raw.sys)
 
     @property
     def nav(self):
         """Will return a wrapped betterproto of nav."""
-        return NavData(nav=self.device.nav)
+        return NavData(nav=self.raw.nav)
 
     @property
     def driver(self):
         """Will return a wrapped betterproto of driver."""
-        return DriverData(driver=self.device.driver)
+        return DriverData(driver=self.raw.driver)
 
     @property
     def mul(self):
         """Will return a wrapped betterproto of mul."""
-        return MulData(mul=self.device.mul)
+        return MulData(mul=self.raw.mul)
 
     @property
     def ota(self):
         """Will return a wrapped betterproto of ota."""
-        return OtaData(ota=self.device.ota)
+        return OtaData(ota=self.raw.ota)
 
     @property
     def pept(self):
         """Will return a wrapped betterproto of pept."""
-        return PeptData(pept=self.device.pept)
+        return PeptData(pept=self.raw.pept)
 
 
 @dataclass

pymammotion-0.4.0a0/pymammotion/http/encryption.py

@@ -0,0 +1,221 @@
+import base64
+import logging
+import secrets
+import string
+from typing import Optional
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import padding, serialization
+from cryptography.hazmat.primitives.asymmetric import padding as rsa_padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EncryptionUtils:
+    PRIVATE_KEY = """MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAOFizbd1fC5XNKJ89u0XNvPZNR/L
+                         0h547iSWjOCuvvMu76ZSaS3/Tu2C1C+XmlnmBWTyY4ON+xECiNUXm/aWQ3P0g+wf60zjPbNzgL2Q
+                         7njXJG6wka4KkbdQxUdS0TTpL256LnV1LsG855bsbJIJiQPbfUq6HbB5xH7sXdrmFu1DAgMBAAEC
+                         gYEAoT2TGE1ncquWjyxBZup1uMvKkp25C23OSMSfslmxZ75LWjyY3HxK1eYDsKyPkwLZFxfFE6du
+                         VwPuKiyCuk1ToPfnb4niTGzXPyC2PbO4SFrWL8n1YZ80M0bfTGI9dMCZvpmZJ41WYUsBaf2374lt
+                         oEiDEHJp7MeXk/970xiKP1ECQQD65rLHk840q+FZS6kZVexJucPZj/YAII6klU1E20ctioe8Pi5m
+                         WSPqclH27/t4FqdvP7tFqaavyXg+CEQpxmxLAkEA5fddDuzcjWgF9pl9fP7/baFMYjUS9z1Vc3gx
+                         CnvAgCnv71wjDQhvsUc6sAiidsBGFDyud06RyyLcOlQchMb36QJBAIui/Xjpn+fciQxjeXcqRNk7
+                         U+6vml+zvu+GUHyz9Uc5RBXWHYjEr6J5gXiHU1MgeIsH0zgQFT7cR9luTFFbp0UCQFIntfogCocG
+                         E6NOoHMoUi5jQnuPRHBJXB69YJ/DKDlhQhN8EhWU3voxXTkITKop9J9EMnvy+MjecljwNaQFxQkC
+                         QB9lz67iDe9Gj8NxSElVZxUm9EfbL1RPqTZPx/lADR06CPB8pP3Bl5/5/5RGzc+UTZ+wX5GWKvC7
+                         zUJaROxQB+E=""".replace(" ", "")
+
+    PUBLIC_KEY_PROD = """MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApLbeSgOvnwLTWbhaBQWNnnHMtSDAi
+                            Gz0PEDbrtd1tLYoO0hukW5PSa6eHykch0Hc6etiqEx1xziS+vNf+iOXds70I4htaYit6yRToZlQ
+                            Mim3DQxaZX68nIHIZogur0zGv9U8j01v5l/rHRxyDdlVx3+JkBg6Cqx4U1PXEnAJriqcyg0B8Gm
+                            V8Lnmfng+aJLRyq5MkhstYCRv9AsmWu8NpZDJ1ffbkaS02Z9/wpubXTiFP6DG3V2mDw2VvzEcHi
+                            cchw49oXmTi92yui+kBgSYlNygssOAyU6H071AfmRUeH3+TsV5u5rg+bCiKyHemVmcKdd3hhZB+
+                            HjA8o3On6rg5wIDAQAB""".replace(" ", "")
+
+    PUBLIC_KEY_TEST = """MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC1nAzH31arNBmYKvTlvKgkxI1MIr4HpfLbmM
+                            XPIhd8D/cXB0dYY1ppUq4a/ezq41YShN88e0elyZgqdnFrkhiLpnKWa7jXtVRgXi9eS18PLO8ns
+                            eHude9URaj7relK1AZ0xovKsbLKHd01PpmngLXZfnKA06J2ru/zH+cnpXdy8QIDAQAB""".replace(" ", "")
+
+    def __init__(self) -> None:
+        self.AES_PASW = self.get_aes_key()  # Get from previous implementation
+        self.IV = self.get_iv()  # Get from previous implementation
+        self._public_key = self.load_public_key()
+        self._private_key = self.load_private_key()
+
+    @staticmethod
+    def load_private_key():
+        """Load the private key from base64 encoded string"""
+        try:
+            private_key_bytes = base64.b64decode(EncryptionUtils.PRIVATE_KEY)
+            return serialization.load_der_private_key(private_key_bytes, password=None, backend=default_backend())
+        except Exception as e:
+            raise Exception(f"Failed to load private key: {str(e)}")
+
+    @staticmethod
+    def load_public_key(is_production: bool = True):
+        """Load the public key from base64 encoded string
+
+        Args:
+            is_production (bool): If True, uses production key, else uses test key
+
+        """
+        try:
+            key_string = EncryptionUtils.PUBLIC_KEY_PROD if is_production else EncryptionUtils.PUBLIC_KEY_TEST
+            public_key_bytes = base64.b64decode(key_string)
+            return serialization.load_der_public_key(public_key_bytes, backend=default_backend())
+        except Exception as e:
+            raise Exception(f"Failed to load public key: {str(e)}")
+
+    @staticmethod
+    def encrypt(plaintext: str, key: str, iv: str) -> str:
+        """Encrypt text using AES/CBC/PKCS5Padding
+
+        Args:
+            plaintext (str): Text to encrypt
+            key (str): Encryption key
+            iv (str): Initialization vector
+
+        Returns:
+            str: Base64 encoded encrypted string
+
+        Raises:
+            Exception: If encryption fails
+
+        """
+        try:
+            # Convert strings to bytes
+            plaintext_bytes = plaintext.encode("utf-8")
+            key_bytes = key.encode("utf-8")
+            iv_bytes = iv.encode("utf-8")
+
+            # Create padder
+            padder = padding.PKCS7(128).padder()
+            padded_data = padder.update(plaintext_bytes) + padder.finalize()
+
+            # Create cipher
+            cipher = Cipher(algorithms.AES(key_bytes), modes.CBC(iv_bytes), backend=default_backend())
+
+            # Encrypt
+            encryptor = cipher.encryptor()
+            encrypted_bytes = encryptor.update(padded_data) + encryptor.finalize()
+
+            # Encode to base64
+            return base64.b64encode(encrypted_bytes).decode("utf-8")
+
+        except Exception as e:
+            raise Exception(f"Encryption failed: {str(e)}")
+
+    def encryption_by_aes(self, text: str) -> str:
+        """Encrypt text using AES with class-level key and IV
+
+        Args:
+            text (str): Text to encrypt
+
+        Returns:
+            str: Encrypted text or None if encryption fails
+
+        """
+        try:
+            # Perform encryption
+            encrypted = self.encrypt(text, self.AES_PASW, self.IV)
+
+            return encrypted
+
+        except Exception as e:
+            _LOGGER.error(f"Encryption failed: {str(e)}")
+            return None
+
+    def encrypt_by_public_key(self) -> Optional[str]:
+        """Encrypt data using RSA public key.
+
+        Args:
+
+        Returns:
+            Optional[str]: Base64 encoded encrypted data or None if encryption fails
+
+        """
+
+        data = f"{self.AES_PASW},{self.IV}"
+
+        if not self._public_key:
+            _LOGGER.error("Public key not initialized")
+            return None
+
+        try:
+            # Convert input string to bytes
+            data_bytes = data.encode("utf-8")
+
+            # Encrypt the data padding.PKCS7(128).padder()
+            encrypted_bytes = self._public_key.encrypt(data_bytes, rsa_padding.PKCS1v15())
+
+            # Convert to base64 string
+            encrypted_str = base64.b64encode(encrypted_bytes).decode("utf-8")
+            _LOGGER.debug("Data encrypted successfully")
+
+            return encrypted_str
+
+        except Exception as err:
+            _LOGGER.error("Encryption failed: %s", str(err))
+            return None
+
+    @staticmethod
+    def get_random_string(length: int) -> str:
+        """Generate a random string of specified length using alphanumeric characters.
+
+        Args:
+            length (int): The desired length of the random string
+
+        Returns:
+            str: A random alphanumeric string of specified length
+
+        Raises:
+            ValueError: If length is less than 1
+
+        """
+        if length < 1:
+            raise ValueError("Length must be positive")
+
+        charset = string.ascii_letters + string.digits
+        return "".join(secrets.choice(charset) for _ in range(length))
+
+    @staticmethod
+    def get_random_int(length: int) -> str:
+        """Generate a random string of specified length containing only digits.
+
+        Args:
+            length (int): The desired length of the random number string
+
+        Returns:
+            str: A string of random digits of specified length
+
+        Raises:
+            ValueError: If length is less than 1
+
+        """
+        if length < 1:
+            raise ValueError("Length must be positive")
+
+        return "".join(secrets.choice(string.digits) for _ in range(length))
+
+    @staticmethod
+    def get_aes_key() -> str:
+        """Generate a random AES key of 16 characters using alphanumeric characters.
+        Matches Java implementation behavior.
+
+        Returns:
+            str: A 16-character random string for AES key
+
+        """
+        return EncryptionUtils.get_random_string(16)
+
+    @staticmethod
+    def get_iv() -> str:
+        """Generate a random initialization vector of 16 digits.
+        Matches Java implementation behavior.
+
+        Returns:
+            str: A 16-digit random string for initialization vector
+
+        """
+        return EncryptionUtils.get_random_int(16)