bug: try to fix scan timeout with asyncio.wait_for.

docs/generate_miners.py

@@ -47,8 +47,8 @@ def backend_str(backend: MinerTypes) -> str:
             return "Stock Firmware Goldshells"
         case MinerTypes.LUX_OS:
             return "LuxOS Firmware Miners"
-        case MinerTypes.EPIC:
+        case MinerTypes.MARATHON:
-            return "ePIC Firmware Miners"
+            return "Mara Firmware Miners"
 
 
 def create_url_str(mtype: str):

docs/miners/supported_types.md

@@ -608,7 +608,7 @@ details {
     </ul>
 </details>
 <details>
-<summary>None:</summary>
+<summary>Mara Firmware Miners:</summary>
     <ul>
         <details>
             <summary>X19 Series:</summary>

pyasic/miners/factory.py

@@ -541,37 +541,26 @@ class MinerFactory:
         return await concurrent_get_first_result(tasks, lambda x: x is not None)
 
     async def _get_miner_web(self, ip: str) -> MinerTypes | None:
-        tasks = []
+        urls = [f"http://{ip}/", f"https://{ip}/"]
-        try:
+        tasks = [asyncio.create_task(self._web_ping(url)) for url in urls]
-            urls = [f"http://{ip}/", f"https://{ip}/"]
-            async with httpx.AsyncClient(
-                transport=settings.transport(verify=False)
-            ) as session:
-                tasks = [
-                    asyncio.create_task(self._web_ping(session, url)) for url in urls
-                ]
 
-                text, resp = await concurrent_get_first_result(
+        text, resp = await concurrent_get_first_result(
-                    tasks,
+            tasks,
-                    lambda x: x[0] is not None
+            lambda x: x[0] is not None and self._parse_web_type(x[0], x[1]) is not None,
-                    and self._parse_web_type(x[0], x[1]) is not None,
+        )
-                )
+        if text is not None:
-                if text is not None:
+            return self._parse_web_type(text, resp)
-                    return self._parse_web_type(text, resp)
-        except asyncio.CancelledError:
-            for t in tasks:
-                t.cancel()
-                try:
-                    await t
-                except asyncio.CancelledError:
-                    pass
 
     @staticmethod
-    async def _web_ping(
+    async def _web_ping(url: str) -> tuple[str | None, httpx.Response | None]:
-        session: httpx.AsyncClient, url: str
-    ) -> tuple[str | None, httpx.Response | None]:
         try:
-            resp = await session.get(url, follow_redirects=True)
+            async with httpx.AsyncClient(
+                transport=settings.transport(verify=False)
+            ) as c:
+                resp = await asyncio.wait_for(
+                    c.get(url, follow_redirects=True),
+                    settings.get("api_function_timeout", 5),
+                )
             return resp.text, resp
         except (
             httpx.HTTPError,
@@ -612,27 +601,16 @@ class MinerFactory:
             return MinerTypes.AURADINE
 
     async def _get_miner_socket(self, ip: str) -> MinerTypes | None:
-        tasks = []
+        commands = ["version", "devdetails"]
-        try:
+        tasks = [asyncio.create_task(self._socket_ping(ip, cmd)) for cmd in commands]
-            commands = ["version", "devdetails"]
-            tasks = [
-                asyncio.create_task(self._socket_ping(ip, cmd)) for cmd in commands
-            ]
 
-            data = await concurrent_get_first_result(
+        data = await concurrent_get_first_result(
-                tasks,
+            tasks,
-                lambda x: x is not None and self._parse_socket_type(x) is not None,
+            lambda x: x is not None and self._parse_socket_type(x) is not None,
-            )
+        )
-            if data is not None:
+        if data is not None:
-                d = self._parse_socket_type(data)
+            d = self._parse_socket_type(data)
-                return d
+            return d
-        except asyncio.CancelledError:
-            for t in tasks:
-                t.cancel()
-                try:
-                    await t
-                except asyncio.CancelledError:
-                    pass
 
     @staticmethod
     async def _socket_ping(ip: str, cmd: str) -> str | None: