feature: add send_config for mara miners.

pyasic/config/__init__.py

@@ -125,6 +125,15 @@ class MinerConfig:
             **self.power_scaling.as_auradine(),
         }
 
+    def as_mara(self, user_suffix: str = None) -> dict:
+        return {
+            **self.fan_mode.as_mara(),
+            **self.temperature.as_mara(),
+            **self.mining_mode.as_mara(),
+            **self.pools.as_mara(user_suffix=user_suffix),
+            **self.power_scaling.as_mara(),
+        }
+
     @classmethod
     def from_dict(cls, dict_conf: dict) -> "MinerConfig":
         return cls(

pyasic/config/fans.py

@@ -61,6 +61,15 @@ class FanModeNormal(MinerConfigValue):
             }
         }
 
+    def as_mara(self) -> dict:
+        return {
+            "general-config": {"environment-profile": "AirCooling"},
+            "advance-config": {
+                "override-fan-control": False,
+                "fan-fixed-percent": 0,
+            },
+        }
+
 
 @dataclass
 class FanModeManual(MinerConfigValue):
@@ -110,6 +119,15 @@ class FanModeManual(MinerConfigValue):
     def as_epic(self) -> dict:
         return {"fans": {"Manual": {"speed": self.speed}}}
 
+    def as_mara(self) -> dict:
+        return {
+            "general-config": {"environment-profile": "AirCooling"},
+            "advance-config": {
+                "override-fan-control": True,
+                "fan-fixed-percent": self.speed,
+            },
+        }
+
 
 @dataclass
 class FanModeImmersion(MinerConfigValue):
@@ -128,6 +146,9 @@ class FanModeImmersion(MinerConfigValue):
     def as_auradine(self) -> dict:
         return {"fan": {"percentage": 0}}
 
+    def as_mara(self) -> dict:
+        return {"general-config": {"environment-profile": "OilImmersionCooling"}}
+
 
 class FanModeConfig(MinerConfigOption):
     normal = FanModeNormal

pyasic/config/mining.py

@@ -56,6 +56,13 @@ class MiningModeNormal(MinerConfigValue):
     def as_goldshell(self) -> dict:
         return {"settings": {"level": 0}}
 
+    def as_mara(self) -> dict:
+        return {
+            "mode": {
+                "work-mode-selector": "Stock",
+            }
+        }
+
 
 @dataclass
 class MiningModeSleep(MinerConfigValue):
@@ -82,6 +89,13 @@ class MiningModeSleep(MinerConfigValue):
     def as_goldshell(self) -> dict:
         return {"settings": {"level": 3}}
 
+    def as_mara(self) -> dict:
+        return {
+            "mode": {
+                "work-mode-selector": "Sleep",
+            }
+        }
+
 
 @dataclass
 class MiningModeLPM(MinerConfigValue):
@@ -219,6 +233,17 @@ class MiningModePowerTune(MinerConfigValue):
     def as_auradine(self) -> dict:
         return {"mode": {"mode": "custom", "tune": "power", "power": self.power}}
 
+    def as_mara(self) -> dict:
+        return {
+            "mode": {
+                "work-mode-selector": "Auto",
+                "concorde": {
+                    "mode-select": "PowerTarget",
+                    "power-target": self.power,
+                },
+            }
+        }
+
 
 @dataclass
 class MiningModeHashrateTune(MinerConfigValue):
@@ -269,6 +294,17 @@ class MiningModeHashrateTune(MinerConfigValue):
     def as_epic(self) -> dict:
         return {"ptune": {"algo": self.algo.as_epic(), "target": self.hashrate}}
 
+    def as_mara(self) -> dict:
+        return {
+            "mode": {
+                "work-mode-selector": "Auto",
+                "concorde": {
+                    "mode-select": "Hashrate",
+                    "hash-target": self.hashrate,
+                },
+            }
+        }
+
 
 @dataclass
 class ManualBoardSettings(MinerConfigValue):
@@ -320,6 +356,17 @@ class MiningModeManual(MinerConfigValue):
         }
         return cls(global_freq=freq, global_volt=voltage, boards=boards)
 
+    def as_mara(self) -> dict:
+        return {
+            "mode": {
+                "work-mode-selector": "Fixed",
+                "fixed": {
+                    "frequency": str(self.global_freq),
+                    "voltage": self.global_volt,
+                },
+            }
+        }
+
 
 class MiningModeConfig(MinerConfigOption):
     normal = MiningModeNormal
@@ -476,7 +523,7 @@ class MiningModeConfig(MinerConfigOption):
             if mode == "Fixed":
                 fixed_conf = web_config["mode"]["fixed"]
                 return cls.manual(
-                    global_freq=fixed_conf["frequency"],
+                    global_freq=int(fixed_conf["frequency"]),
                     global_volt=fixed_conf["voltage"],
                 )
             elif mode == "Stock":

pyasic/config/pools.py

@@ -118,6 +118,15 @@ class Pool(MinerConfigValue):
             }
         return {"pool": self.url, "login": self.user, "password": self.password}
 
+    def as_mara(self, user_suffix: str = None) -> dict:
+        if user_suffix is not None:
+            return {
+                "url": self.url,
+                "user": f"{self.user}{user_suffix}",
+                "pass": self.password,
+            }
+        return {"url": self.url, "user": self.user, "pass": self.password}
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "Pool":
         return cls(
@@ -272,9 +281,12 @@ class PoolGroup(MinerConfigValue):
     def as_auradine(self, user_suffix: str = None) -> list:
         return [p.as_auradine(user_suffix=user_suffix) for p in self.pools]
 
-    def as_epic(self, user_suffix: str = None) -> dict:
+    def as_epic(self, user_suffix: str = None) -> list:
         return [p.as_epic(user_suffix=user_suffix) for p in self.pools]
 
+    def as_mara(self, user_suffix: str = None) -> list:
+        return [p.as_mara(user_suffix=user_suffix) for p in self.pools]
+
     @classmethod
     def from_dict(cls, dict_conf: dict | None) -> "PoolGroup":
         cls_conf = {}
@@ -439,6 +451,11 @@ class PoolConfig(MinerConfigValue):
             }
         }
 
+    def as_mara(self, user_suffix: str = None) -> dict:
+        if len(self.groups) > 0:
+            return {"pools": self.groups[0].as_mara(user_suffix=user_suffix)}
+        return {"pools": []}
+
     @classmethod
     def from_api(cls, api_pools: dict) -> "PoolConfig":
         try:

pyasic/miners/backends/marathon.py

@@ -5,6 +5,7 @@ from pyasic.data import Fan, HashBoard
 from pyasic.errors import APIError
 from pyasic.miners.base import BaseMiner
 from pyasic.miners.data import DataFunction, DataLocations, DataOptions, WebAPICommand
+from pyasic.misc import merge_dicts
 from pyasic.web.marathon import MaraWebAPI
 
 MARA_DATA_LOC = DataLocations(
@@ -79,6 +80,12 @@ class MaraMiner(BaseMiner):
             self.config = MinerConfig.from_mara(data)
         return self.config
 
+    async def send_config(self, config: MinerConfig, user_suffix: str = None) -> None:
+        data = await self.web.get_miner_config()
+        cfg_data = config.as_mara(user_suffix=user_suffix)
+        merged_cfg = merge_dicts(data, cfg_data)
+        await self.web.set_miner_config(**merged_cfg)
+
     async def _get_wattage(self, web_brief: dict = None) -> Optional[int]:
         if web_brief is None:
             try: