pyasic-umhost 0.2.3.dev12__tar.gz → 0.2.3.dev14__tar.gz

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyasic-umhost
-Version: 0.2.3.dev12
+Version: 0.2.3.dev14
 Summary: A simplified and standardized interface for Bitcoin ASICs.
 License: Apache 2.0
 License-File: LICENSE.txt
@@ -24,6 +24,7 @@ Requires-Dist: betterproto (==2.0.0b7)
 Requires-Dist: cryptography (>=39.0)
 Requires-Dist: httpx (>=0.26.0)
 Requires-Dist: passlib (>=1.7.4)
+Requires-Dist: playwright (>=1.40)
 Requires-Dist: pyaml (>=23.12.0)
 Requires-Dist: pydantic (>=2.11.0)
 Requires-Dist: semver (>=3.0.4,<4.0.0)

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/config/__init__.py

@@ -405,11 +405,17 @@ class MinerConfig(BaseModel):
 
     @classmethod
     def from_btminer_v3(
-        cls, rpc_pools: dict, rpc_settings: dict, rpc_device_info: dict
+        cls,
+        rpc_pools: dict,
+        rpc_settings: dict,
+        rpc_device_info: dict,
+        rpc_miner_status_summary: dict,
     ) -> "MinerConfig":
         return cls(
             pools=PoolConfig.from_btminer_v3(rpc_pools=rpc_pools["msg"]),
             mining_mode=MiningModeConfig.from_btminer_v3(
-                rpc_device_info=rpc_device_info, rpc_settings=rpc_settings
+                rpc_device_info=rpc_device_info,
+                rpc_settings=rpc_settings,
+                rpc_miner_status_summary=rpc_miner_status_summary,
             ),
         )

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/config/fans.py

@@ -15,7 +15,7 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from pydantic import Field
 
@@ -337,28 +337,45 @@ class FanModeConfig(MinerConfigOption):
 
     @classmethod
     def from_boser(cls, grpc_miner_conf: dict):
-        try:
-            temperature_conf = grpc_miner_conf["temperature"]
-        except LookupError:
+        temperature_conf = grpc_miner_conf.get("temperature")
+        if not isinstance(temperature_conf, dict):
             return cls.default()
 
-        keys = temperature_conf.keys()
-        if "auto" in keys:
-            if "minimumRequiredFans" in keys:
-                return cls.normal(minimum_fans=temperature_conf["minimumRequiredFans"])
+        def _maybe_int(value: Any) -> int | None:
+            if isinstance(value, (int, float, str)) and value != "":
+                try:
+                    return int(value)
+                except (TypeError, ValueError):
+                    return None
+            return None
+
+        min_fans = _maybe_int(temperature_conf.get("minimumRequiredFans"))
+
+        def _build_conf(conf_section: object) -> dict:
+            conf: dict = {}
+            if isinstance(conf_section, dict):
+                speed = _maybe_int(conf_section.get("fanSpeedRatio"))
+                if speed is not None:
+                    conf["speed"] = speed
+            if min_fans is not None:
+                conf["minimum_fans"] = min_fans
+            return conf
+
+        if "auto" in temperature_conf:
+            if min_fans is not None:
+                return cls.normal(minimum_fans=min_fans)
             return cls.normal()
-        if "manual" in keys:
-            conf = {}
-            if "fanSpeedRatio" in temperature_conf["manual"].keys():
-                conf["speed"] = int(temperature_conf["manual"]["fanSpeedRatio"])
-            if "minimumRequiredFans" in keys:
-                conf["minimum_fans"] = int(temperature_conf["minimumRequiredFans"])
-            return cls.manual(**conf)
-        if "disabled" in keys:
-            conf = {}
-            if "fanSpeedRatio" in temperature_conf["disabled"].keys():
-                conf["speed"] = int(temperature_conf["disabled"]["fanSpeedRatio"])
+
+        if "manual" in temperature_conf:
+            conf = _build_conf(temperature_conf.get("manual"))
             return cls.manual(**conf)
+
+        if "disabled" in temperature_conf:
+            conf = _build_conf(temperature_conf.get("disabled"))
+            if conf.get("speed") is not None:
+                return cls.manual(**conf)
+            return cls.immersion()
+
         return cls.default()
 
     @classmethod

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/config/mining/__init__.py

@@ -835,13 +835,13 @@ class MiningModeConfig(MinerConfigOption):
 
     @classmethod
     def from_btminer_v3(
-        cls, rpc_device_info: dict, rpc_settings: dict
+        cls, rpc_device_info: dict, rpc_settings: dict, rpc_miner_status_summary: dict
     ) -> MiningModeConfig:
         try:
             is_mining = rpc_device_info["msg"]["miner"]["working"] == "true"
             if not is_mining:
                 return cls.sleep()
-            power_limit = rpc_settings["msg"]["power-limit"]
+            power_limit = rpc_miner_status_summary["msg"]["power-limit"]
             if not power_limit == 0:
                 return cls.power_tuning(power=power_limit)
             power_mode = rpc_settings["msg"]["power-mode"]

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/config/pools.py

@@ -643,7 +643,7 @@ class PoolConfig(MinerConfigValue):
     def from_btminer_v3(cls, rpc_pools: dict) -> PoolConfig:
         try:
             pool_data = rpc_pools["pools"]
-        except KeyError:
+        except (KeyError, TypeError):
             return PoolConfig.default()
         pool_data = sorted(pool_data, key=lambda x: int(x["id"]))
 

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/config/temperature.py

@@ -114,32 +114,44 @@ class TemperatureConfig(MinerConfigValue):
 
     @classmethod
     def from_boser(cls, grpc_miner_conf: dict) -> TemperatureConfig:
-        try:
-            temperature_conf = grpc_miner_conf["temperature"]
-        except KeyError:
+        temperature_conf = grpc_miner_conf.get("temperature")
+        if not isinstance(temperature_conf, dict):
             return cls.default()
 
         root_key = None
         for key in ["auto", "manual", "disabled"]:
-            if key in temperature_conf.keys():
+            if key in temperature_conf:
                 root_key = key
                 break
         if root_key is None:
             return cls.default()
 
-        conf = {}
-        keys = temperature_conf[root_key].keys()
-        if "targetTemperature" in keys:
-            conf["target"] = int(
-                temperature_conf[root_key]["targetTemperature"]["degreeC"]
-            )
-        if "hotTemperature" in keys:
-            conf["hot"] = int(temperature_conf[root_key]["hotTemperature"]["degreeC"])
-        if "dangerousTemperature" in keys:
-            conf["danger"] = int(
-                temperature_conf[root_key]["dangerousTemperature"]["degreeC"]
-            )
+        raw_conf = temperature_conf.get(root_key) or {}
+        if not isinstance(raw_conf, dict):
+            return cls.default()
 
+        def _read_temp(temp_block: object) -> int | None:
+            if isinstance(temp_block, dict):
+                temp_value = temp_block.get("degreeC")
+            else:
+                temp_value = temp_block
+            try:
+                return int(temp_value) if temp_value is not None else None
+            except (TypeError, ValueError):
+                return None
+
+        conf: dict = {}
+        target_temp = _read_temp(raw_conf.get("targetTemperature"))
+        if target_temp is not None:
+            conf["target"] = target_temp
+        hot_temp = _read_temp(raw_conf.get("hotTemperature"))
+        if hot_temp is not None:
+            conf["hot"] = hot_temp
+        danger_temp = _read_temp(raw_conf.get("dangerousTemperature"))
+        if danger_temp is not None:
+            conf["danger"] = danger_temp
+
+        if conf:
             return cls(**conf)
         return cls.default()
 

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/data/__init__.py

@@ -25,6 +25,7 @@ from pyasic.config import MinerConfig
 from pyasic.config.mining import MiningModePowerTune
 from pyasic.data.pools import PoolMetrics, Scheme
 from pyasic.device.algorithm.hashrate import AlgoHashRateType
+from pyasic.device.algorithm.hashrate.base import GenericHashrate
 
 from .boards import HashBoard
 from .device import DeviceInfo
@@ -41,13 +42,14 @@ class MinerData(BaseModel):
 
     # general
     ip: str
-    raw_datetime: datetime = Field(
+    raw_datetime: Any = Field(
         exclude=True, default_factory=datetime.now(timezone.utc).astimezone, repr=False
     )
 
     # about
     device_info: DeviceInfo | None = None
     serial_number: str | None = None
+    psu_serial_number: str | None = None
     mac: str | None = None
     api_ver: str | None = None
     fw_ver: str | None = None
@@ -60,6 +62,8 @@ class MinerData(BaseModel):
 
     # sticker / expected (в H/s, без единиц)
     sticker_hashrate: AlgoHashRateType | None = None
+
+    # expected
     expected_hashrate: AlgoHashRateType | None = None
     expected_hashboards: int | None = None
     expected_chips: int | None = None
@@ -101,7 +105,7 @@ class MinerData(BaseModel):
         all_fields.update(set(cls.model_computed_fields.keys()))
         return all_fields
 
-    def get(self, __key: str, default: Any = None):
+    def get(self, __key: str, default: Any | None = None):
         try:
             val = self.__getitem__(__key)
             if val is None:

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/device/models.py

@@ -68,6 +68,7 @@ class AntminerModels(MinerModelType):
     S21Hydro = "S21 Hydro"
     T21 = "T21"
     S19XPHydro = "S19 XP Hydro"
+    S19XPPlus = "S19 XP+"
     S21XPHydro = "S21 XP Hydro"
 
     def __str__(self):
@@ -463,6 +464,7 @@ class AvalonminerModels(MinerModelType):
     Avalon1566 = "Avalon 1566"
     AvalonNano3 = "Avalon Nano 3"
     AvalonNano3s = "Avalon Nano 3s"
+    AvalonMini3 = "Avalon Mini 3"
     AvalonQHome = "Avalon Q Home"
 
     def __str__(self):

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/antminer/bmminer/X21/S21.py

@@ -15,7 +15,15 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import AntminerModern
-from pyasic.miners.device.models import S21, S21Hydro, S21Plus, S21PlusHydro, S21Pro, S21XPHydro
+from pyasic.miners.device.models import (
+    S21,
+    S21XP,
+    S21Hydro,
+    S21Plus,
+    S21PlusHydro,
+    S21Pro,
+    S21XPHydro,
+)
 
 
 class BMMinerS21(AntminerModern, S21):
@@ -39,3 +47,6 @@ class BMMinerS21Hydro(AntminerModern, S21Hydro):
 
 class BMMinerS21XPHydro(AntminerModern, S21XPHydro):
     pass
+
+class BMMinerS21XP(AntminerModern, S21XP):
+    pass

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/antminer/luxos/X21/S21.py

@@ -15,8 +15,12 @@
 # ------------------------------------------------------------------------------
 
 from pyasic.miners.backends import LUXMiner
-from pyasic.miners.device.models import S21
+from pyasic.miners.device.models import S21, S21Pro
 
 
 class LUXMinerS21(LUXMiner, S21):
     pass
+
+
+class LUXMinerS21Pro(LUXMiner, S21Pro):
+    pass

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/antminer/luxos/X21/__init__.py

@@ -14,5 +14,5 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
 
-from .S21 import LUXMinerS21
+from .S21 import LUXMinerS21, LUXMinerS21Pro
 from .T21 import LUXMinerT21

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/antminer/vnish/X19/S19.py

@@ -24,12 +24,15 @@ from pyasic.miners.device.models import (
     S19i,
     S19j,
     S19jPro,
+    S19jProPlus,
+    S19jXP,
     S19kPro,
     S19NoPIC,
     S19Pro,
     S19ProA,
     S19ProHydro,
     S19XPHydro,
+    S19XPPlus,
     S19XPPlusHyd,
 )
 
@@ -96,3 +99,15 @@ class VNishS19kPro(VNish, S19kPro):
 
 class VNishS19ProA(VNish, S19ProA):
     pass
+
+
+class VNishS19XPPlus(VNish, S19XPPlus):
+    pass
+
+
+class VNishS19jProPlus(VNish, S19jProPlus):
+    pass
+
+
+class VNishS19jXP(VNish, S19jXP):
+    pass

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/antminer/vnish/X19/__init__.py

@@ -22,6 +22,8 @@ from .S19 import (
     VNishS19i,
     VNishS19j,
     VNishS19jPro,
+    VNishS19jProPlus,
+    VNishS19jXP,
     VNishS19kPro,
     VNishS19NoPIC,
     VNishS19Pro,
@@ -29,6 +31,7 @@ from .S19 import (
     VNishS19ProHydro,
     VNishS19XP,
     VNishS19XPHydro,
+    VNishS19XPPlus,
     VNishS19XPPlusHyd,
 )
 from .T19 import VNishT19

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/avalonminer/cgminer/__init__.py

@@ -22,5 +22,6 @@ from .A11X import *
 from .A12X import *
 from .A13X import *
 from .A15X import *
+from .mini import *
 from .nano import *
 from .Q import *

pyasic_umhost-0.2.3.dev14/pyasic/miners/avalonminer/cgminer/mini/__init__.py

@@ -0,0 +1,17 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+
+from .mini3 import CGMinerAvalonMini3

pyasic_umhost-0.2.3.dev14/pyasic/miners/avalonminer/cgminer/mini/mini3.py

@@ -0,0 +1,113 @@
+# ------------------------------------------------------------------------------
+#  Copyright 2022 Upstream Data Inc                                            -
+#                                                                              -
+#  Licensed under the Apache License, Version 2.0 (the "License");             -
+#  you may not use this file except in compliance with the License.            -
+#  You may obtain a copy of the License at                                     -
+#                                                                              -
+#      http://www.apache.org/licenses/LICENSE-2.0                              -
+#                                                                              -
+#  Unless required by applicable law or agreed to in writing, software         -
+#  distributed under the License is distributed on an "AS IS" BASIS,           -
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    -
+#  See the License for the specific language governing permissions and         -
+#  limitations under the License.                                              -
+# ------------------------------------------------------------------------------
+from typing import Any
+
+from pyasic import APIError
+from pyasic.miners.backends import AvalonMiner
+from pyasic.miners.data import (
+    DataFunction,
+    DataLocations,
+    DataOptions,
+    RPCAPICommand,
+    WebAPICommand,
+)
+from pyasic.miners.device.models import AvalonMini3
+from pyasic.web.avalonminer import AvalonMinerWebAPI
+
+AVALON_MINI_DATA_LOC = DataLocations(
+    **{
+        str(DataOptions.MAC): DataFunction(
+            "_get_mac",
+            [WebAPICommand("web_minerinfo", "minerinfo")],
+        ),
+        str(DataOptions.API_VERSION): DataFunction(
+            "_get_api_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.FW_VERSION): DataFunction(
+            "_get_fw_ver",
+            [RPCAPICommand("rpc_version", "version")],
+        ),
+        str(DataOptions.HASHRATE): DataFunction(
+            "_get_hashrate",
+            [RPCAPICommand("rpc_devs", "devs")],
+        ),
+        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
+            "_get_expected_hashrate",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.HASHBOARDS): DataFunction(
+            "_get_hashboards",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
+            "_get_env_temp",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.WATTAGE_LIMIT): DataFunction(
+            "_get_wattage_limit",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.WATTAGE): DataFunction(
+            "_get_wattage",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.FANS): DataFunction(
+            "_get_fans",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.FAULT_LIGHT): DataFunction(
+            "_get_fault_light",
+            [RPCAPICommand("rpc_estats", "estats")],
+        ),
+        str(DataOptions.UPTIME): DataFunction(
+            "_get_uptime",
+            [RPCAPICommand("rpc_stats", "stats")],
+        ),
+        str(DataOptions.POOLS): DataFunction(
+            "_get_pools",
+            [RPCAPICommand("rpc_pools", "pools")],
+        ),
+    }
+)
+
+
+class CGMinerAvalonMini3(AvalonMiner, AvalonMini3):
+    _web_cls = AvalonMinerWebAPI
+    web: AvalonMinerWebAPI
+
+    data_locations = AVALON_MINI_DATA_LOC
+
+    async def _get_mac(self, web_minerinfo: dict[Any, Any] | None = None) -> str | None:
+        if web_minerinfo is None:
+            try:
+                # Try get_miner_info first (with underscore)
+                web_minerinfo = await self.web.miner_info()
+            except APIError:
+                try:
+                    # Fallback to get_minerinfo
+                    web_minerinfo = await self.web.minerinfo()
+                except APIError:
+                    return None
+
+        if web_minerinfo is not None:
+            try:
+                mac = web_minerinfo.get("mac")
+                if mac is not None:
+                    return mac.upper()
+            except (KeyError, ValueError):
+                pass
+        return None

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/avalonminer/cgminer/nano/nano3.py

@@ -33,7 +33,7 @@ AVALON_NANO_DATA_LOC = DataLocations(
     **{
         str(DataOptions.MAC): DataFunction(
             "_get_mac",
-            [WebAPICommand("web_minerinfo", "get_minerinfo")],
+            [WebAPICommand("web_minerinfo", "minerinfo")],
         ),
         str(DataOptions.API_VERSION): DataFunction(
             "_get_api_ver",
@@ -153,9 +153,14 @@ class CGMinerAvalonNano3(AvalonMiner, AvalonNano3):
     async def _get_mac(self, web_minerinfo: dict[Any, Any] | None = None) -> str | None:
         if web_minerinfo is None:
             try:
-                web_minerinfo = await self.web.minerinfo()
+                # Try get_miner_info first (with underscore)
+                web_minerinfo = await self.web.miner_info()
             except APIError:
-                return None
+                try:
+                    # Fallback to get_minerinfo
+                    web_minerinfo = await self.web.minerinfo()
+                except APIError:
+                    return None
 
         if web_minerinfo is not None:
             try:

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/backends/antminer.py

@@ -17,7 +17,7 @@
 import logging
 from pathlib import Path
 
-from pyasic.config import MinerConfig, MiningModeConfig
+from pyasic.config import MinerConfig, MiningModeConfig, PoolConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.data.error_codes import X19Error
 from pyasic.data.pools import PoolMetrics, PoolUrl
@@ -532,7 +532,12 @@ class AntminerModern(BMMiner):
             except LookupError:
                 pass
         return pools_data
-		
+
+    async def set_pools(self, pools: PoolConfig):
+        cfg = await self.get_config()
+        cfg.pools = pools
+        await self.send_config(cfg)
+        return True
 		
     async def _is_sleep(self, web_get_conf: dict = None) -> bool | None:
         if web_get_conf is None:
@@ -551,6 +556,9 @@ class AntminerModern(BMMiner):
             except LookupError:
                 pass
 
+    async def _get_kernel_log(self) -> str | None:
+        return await self.web.get_kernel_log()
+
 
 ANTMINER_OLD_DATA_LOC = DataLocations(
     **{

{pyasic_umhost-0.2.3.dev12 → pyasic_umhost-0.2.3.dev14}/pyasic/miners/backends/avalonminer.py

@@ -17,6 +17,9 @@ import copy
 import re
 import time
 
+import requests
+
+from pyasic.config import PoolConfig
 from pyasic.data import Fan, HashBoard
 from pyasic.device.algorithm import AlgoHashRateType
 from pyasic.errors import APIError
@@ -547,3 +550,62 @@ class AvalonMiner(CGMiner):
 
         except (IndexError, KeyError, ValueError, TypeError, AttributeError):
             return False
+
+    async def _get_kernel_log(self) -> str | None:
+        """Возвращает строку логов устройства"""
+        try:
+            return f"{await self.rpc.summary()}\n{await self.rpc.estats()}"
+        except (IndexError, KeyError, ValueError, TypeError):
+            return None
+
+    async def set_pools(self, pools: PoolConfig) -> bool:
+        """Настройка пулов на Avalon 1346 через cgconf.cgi (синхронная версия)"""
+        try:
+            # Получаем список пулов
+            all_pools = []
+            for group in pools.groups:
+                all_pools.extend(group.pools)
+
+            # Берем первые 3 пула
+            active_pools = all_pools[:3]
+
+            # Формируем данные
+            form_data = {}
+
+            for i in range(3):
+                idx = i + 1
+                if i < len(active_pools):
+                    pool = active_pools[i]
+                    form_data[f"pool{idx}"] = pool.url
+                    form_data[f"worker{idx}"] = pool.user
+                    form_data[f"passwd{idx}"] = pool.password
+                else:
+                    form_data[f"pool{idx}"] = ""
+                    form_data[f"worker{idx}"] = ""
+                    form_data[f"passwd{idx}"] = ""
+
+            form_data["mode"] = "1"
+            form_data["power_level"] = "0"
+
+            # Отправляем POST запрос
+            url = f"http://{self.ip}/cgconf.cgi"
+
+            headers = {
+                "Content-Type": "application/x-www-form-urlencoded",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "Origin": f"http://{self.ip}",
+                "Referer": f"http://{self.ip}/"
+            }
+
+            try:
+                response = requests.post(url, data=form_data, headers=headers, timeout=10)
+
+                if response.status_code == 200:
+                    return True
+                else:
+                    return False
+            except Exception:
+                return False
+
+        except Exception:
+            return False