openhems 0.2.2__tar.gz → 0.2.3__tar.gz

{openhems-0.2.2/src/openhems.egg-info → openhems-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhems
-Version: 0.2.2
+Version: 0.2.3
 Summary: A sample Home Energy Managment System based on Home-Assistant
 Home-page: https://github.com/abriotde/openhems-sample.git
 Author: OpenHomeSystem

{openhems-0.2.2 → openhems-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhems"
-version = "0.2.2"
+version = "0.2.3"
 dynamic = [
 	# "version" # , "description"
 ]

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/data/openhems_default.yaml

@@ -51,6 +51,22 @@ default:
       reverse: False
       offhours: []
       offconditions: False
+    annealing:
+      freq: 15
+      max_iteration_number: 1000
+      initial_temp: 1000
+      cooling_factor: 0.95
+      min_temp: 0.1
+      max_no_improve: 100
+    nosell:
+      ratio: -1
+      margin: 300
+    nobuy:
+      ratio: 1
+      margin: 300
+    ratiosellbuy:
+      ratio: 0
+      margin: 200
   node:
     publicpowergrid:
       currentPower: null
@@ -80,6 +96,7 @@ default:
           hoursRanges: []
           defaultPrice: 0.1
           outRangePrice: 1.0
+          sellprice: 0.0
     solarpanel:
       currentPower: None
       maxPower: 500

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/contract/generic_contract.py

@@ -13,16 +13,18 @@ class GenericContract:
 	"""
 	logger = logging.getLogger(__name__)
 
-	def __init__(self, hoursRanges=None, defaultPrice=0.0, outRangePrice=0.15):
+	def __init__(self, hoursRanges=None, defaultPrice=0.0, outRangePrice=0.15, sellPrice=0.0):
 		if hoursRanges is None:
 			self.hoursRanges = HoursRanges([], outRangeCost=defaultPrice)
 		else:
-			self.logger.info("GenericContract(hoursRanges=%s, defaultCost=%s, outRangeCost=%s)",
-				str(hoursRanges), defaultPrice, outRangePrice)
+			self.logger.info(
+				"GenericContract(hoursRanges=%s, defaultCost=%s, outRangeCost=%s, sellPrice=%s)",
+				str(hoursRanges), defaultPrice, outRangePrice, sellPrice)
 			self.hoursRanges = HoursRanges(
 				hoursRanges, defaultCost=defaultPrice , outRangeCost=outRangePrice
 			)
 		self._inOffpeakRange = None
+		self.sellPrice = sellPrice
 		self.rangeEnd = datetime.datetime.now()
 
 	@staticmethod
@@ -30,9 +32,9 @@ class GenericContract:
 		"""
 		Parse a configuration dict to create a GenericContract
 		"""
-		hoursRanges, defaultPrice, outRangePrice = \
+		hoursRanges, defaultPrice, outRangePrice, sellPrice = \
 			GenericContract.extractFromDict(dictConf, configuration)
-		return GenericContract(hoursRanges, defaultPrice, outRangePrice)
+		return GenericContract(hoursRanges, defaultPrice, outRangePrice, sellPrice=sellPrice)
 
 	@staticmethod
 	def extractFromDict(dictConf, configuration):
@@ -43,8 +45,9 @@ class GenericContract:
 		keys = (dictConf, configuration, "generic")
 		defaultPrice = GenericContract.get("defaultPrice", keys, "float")
 		outRangePrice = GenericContract.get("outRangePrice", keys, "float")
+		sellPrice = GenericContract.get("sellPrice", keys, "float")
 		hoursRanges = GenericContract.get("hoursRanges", keys, "list")
-		return (hoursRanges, defaultPrice, outRangePrice)
+		return (hoursRanges, defaultPrice, outRangePrice, sellPrice)
 
 	def getHoursRanges(self, now=None, attime=None):
 		"""
@@ -103,8 +106,19 @@ class GenericContract:
 		_, _, cost = self.getHoursRanges(now, attime).checkRange(self.getTime(now, attime))
 		return cost
 
+	def getSellPrice(self, now=None, attime=None):
+		"""
+		now: datetime witch represent current time, default is datetime.now(). 
+		 now must never go back further at runtime
+		 now is used for cached time, usually it's datetime.now() except for test to simulate situations.
+		attime: datetime witch represent time to check price. Default is now.
+		Return: the Kw sell cost at 'now'.
+		"""
+		del now, attime
+		return self.sellPrice
+
 	def __str__(self):
-		return "GenericContract("+str(self.hoursRanges)+")"
+		return "GenericContract("+str(self.hoursRanges)+", sellPrice={self.sellPrice})"
 
 	def inOffpeakRange(self, now=None, attime=None, useCache=True):
 		"""
@@ -132,16 +146,22 @@ class GenericContract:
 		value = dictConf.get(key)
 		if value is None:
 			baseKey = "default.node.publicpowergrid.contract"
+			completeKey = baseKey+"."+classname+"."+key
 			value = configuration.get(
-				baseKey+"."+classname+"."+key,
+				completeKey,
 				defaultType
 			)
 			if value is None:
-				GenericContract.logger.warning(
-					"No default value for '%s.%s.%s'. Availables are %s",
-					baseKey, classname, key,
-					configuration.get(baseKey, deepSearch=True)
+				value = configuration.get(
+					completeKey.lower(),
+					defaultType
 				)
+				if value is None:
+					GenericContract.logger.warning(
+						"No default value for '%s.%s.%s'. Availables are %s",
+						baseKey, classname, key,
+						configuration.get(baseKey, deepSearch=True)
+					)
 		elif defaultType is not None:
 			value = CastUtililty.toType(defaultType, value)
 		return value

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/contract/rte_contract.py

@@ -62,7 +62,7 @@ class RTETempoContract(RTEContract):
 		url = "https://www.api-couleur-tempo.fr/api/jourTempo/"+day
 		retVal = None
 		for _ in range(3): # Could be usefull for 502 error
-			self.logger.debug("Call API %s : %s.", url)
+			self.logger.debug("Call API %s.", url)
 			# User-Agent is mandatory else 502 error
 			response = requests.get(url, timeout=10, allow_redirects=False,
 						   headers={'User-Agent': 'Mozilla/5.0'})

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/energy_strategy/__init__.py

@@ -9,3 +9,5 @@ from .switchoff_strategy import SwitchoffStrategy
 # from .emhass_strategy import EmhassStrategy
 from .solarbased_strategy import SolarBasedStrategy
 from .hybridinverter_strategy import HybridInverterStrategy
+from .simulated_annealing_strategy import SimulatedAnnealingStrategy
+from .solarnosell_strategy import SolarNoSellStrategy

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/energy_strategy/driver/emhass_adapter.py

@@ -7,7 +7,7 @@ import os
 import logging
 import json
 import sys
-import dataclasses
+import math
 from pathlib import Path
 import importlib
 # from importlib.metadata import version
@@ -38,20 +38,41 @@ import emhass.command_line as em
 import emhass.utils as em_utils
 
 
-@dataclasses.dataclass
 class Deferrable:
 	"""
 	Custom class to simplify emhass module live modifications.
 	"""
 	power: float # Nominal power
-	duration: float # Duration in hours? (In emhass granularity)
-	node:str = None
+	_duration: float # Duration in hours? (In emhass granularity)
+	node = None
 	startTimestep = 0
 	endTimestep = 0
 	constant = False
 	startPenalty: float = 0.0
 	asSemiCont: bool = True
 
+	def __init__(self, power:float, duration:float, node=None):
+		self.power = power
+		self._duration = duration
+		self.node = node
+
+	def getDuration(self):
+		"""
+		return: duration in seconds
+		"""
+		return self._duration
+	def getDurationInHours(self):
+		"""
+		Return duration in Emhass prevision granularity
+		"""
+		# TODO granularity can be less or more than hour...
+		return math.ceil(self._duration / 3600)
+	def setDuration(self, duration):
+		"""
+		param: duration: in seconds
+		"""
+		self._duration = duration
+
 class EmhassAdapter:
 	"""
 	Class to use easily EMHASS on OpenHEMS.
@@ -120,7 +141,7 @@ class EmhassAdapter:
 		optimConf = inputDataDict['opt'].optim_conf
 		optimConf['num_def_loads'] = len(self.deferables)
 		optimConf['P_deferrable_nom'] = [d.power for d in self.deferables]
-		optimConf['def_total_hours'] = [d.duration for d in self.deferables]
+		optimConf['def_total_hours'] = [d.getDurationInHours() for d in self.deferables]
 		optimConf['def_start_timestep'] = [d.startTimestep for d in self.deferables]
 		optimConf['def_end_timestep'] = [d.endTimestep for d in self.deferables]
 		optimConf['set_def_constant'] = [d.constant for d in self.deferables]

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/energy_strategy/emhass_strategy.py

@@ -2,10 +2,11 @@
 This strategy use HEMASS to choose what to do.
 This use Artificial Intelligence to guess the  futur.
 So this require some more Python packages.
+
+TODO : RunOk - InProd
 """
 
-import math
-from datetime import datetime, timedelta
+from datetime import datetime
 import logging
 import pytz
 import numpy as np
@@ -28,21 +29,17 @@ class EmhassStrategy(EnergyStrategy):
 	def __init__(self, mylogger, network: OpenHEMSNetwork,
 			configurationGlobal:ConfigurationManager, configurationEmhass:dict,
 			strategyId:str="emhass"):
-		super().__init__(strategyId, network, mylogger, True)
+		freq = configurationEmhass.get("freq")
+		super().__init__(strategyId, network, mylogger, evalFrequency=freq)
 		self.logger.info("EmhassStrategy(%s)", configurationEmhass)
 		self.adapter = EmhassAdapter.createFromOpenHEMS(
 			configurationEmhass=configurationEmhass, configurationGlobal=configurationGlobal,
 			network=network)
 		self.network = network
-		freq = configurationEmhass.get("freq")
-		self.emhassEvalFrequence = timedelta(minutes=freq)
 		self.timezone = pytz.timezone(configurationGlobal.get("localization.timeZone"))
-		self.data = None
-		self.deferables = {}
-		self.deferablesKeys = []
-		self.nextEvalDate = datetime.now(self.timezone) - self.emhassEvalFrequence
+		self._data = None
 
-	def emhassEval(self):
+	def eval(self):
 		"""
 		Launch EMHASS optimization plan and store result.
 		Also update depending attributes.
@@ -63,61 +60,17 @@ class EmhassStrategy(EnergyStrategy):
 			self.logger.debug("No deferrables so no EMHASS optimization to do.")
 			data = None
 		self.deferablesKeys = self.deferables.keys()
-		self.data = data
-		self.nextEvalDate = datetime.now(self.timezone) + self.emhassEvalFrequence
+		self._data = data
 		return data
 
-	def getDurationInHour(self, durationInSecs):
+	def getDeferrables(self, node, durationInSecs):
 		"""
-		Return duration in Emhass prevision granularity
+		Return a Deferrable representing the node (adding usefull informations for algo).
 		"""
-		# TODO granularity can be less or more than hour...
-		return math.ceil(durationInSecs / 3600)
-
-	def updateDeferables(self):
-		"""
-		Update scheduled devices according to emhass
-		 to scheduled devices according to openhems
-		Return true if schedule has been updated
-		"""
-		# print("EmhassStrategy.updateDeferables()")
-		update = False
-		self.deferables = {}
-		for node in self.network.getAll("out"):
-			nodeId = node.id
-			durationInSecs = node.getSchedule().duration
-			deferable = self.deferables.get(nodeId, None)
-			durationInHour = self.getDurationInHour(durationInSecs)
-			if deferable is None:
-				if durationInSecs>0: # Add a new deferrable
-					update = True
-					power = node.getMaxPower()
-					self.deferables[nodeId] = Deferrable(
-						power=power, duration=durationInHour, node=node
-					)
-			else:
-				if durationInSecs<=0: # Remove a deferrable
-					del self.deferables[nodeId]
-					update = True
-				elif deferable.duration!=durationInHour: # update a deferrable
-					update = True
-					deferable.duration = durationInHour
-		print("EmhassStrategy.updateDeferables() => ", update, )
-		return update
-
-	def check(self, now=None):
-		"""
-		Check and eval if necessary
-		- EMHASS optimization
-		- power margin
-		- conformity to EMHASS plan
-		"""
-		# print("EmhassStrategy.check()")
-		if now is None:
-			now = datetime.now(self.timezone)
-		if self.updateDeferables() or now>self.nextEvalDate:
-			# print("EmhassStrategy.check() : emhassEval")
-			self.emhassEval()
+		power = node.getMaxPower()
+		return Deferrable(
+			power=power, duration=durationInSecs, node=node
+		)
 
 	def evaluatePertinenceSwitchOn(self, switchOnRate, node):
 		"""
@@ -134,7 +87,7 @@ class EmhassStrategy(EnergyStrategy):
 		Return a tuple of datetime and rows for datetime = "now", 
 			with previous (If present) and Next one
 		"""
-		if self.data is None or isinstance(self.data, bool): # Case no deferables or Error
+		if self._data is None or isinstance(self._data, bool): # Case no deferables or Error
 			return ((None, None, None), (None, None, None))
 		if now is None:
 			now = datetime.now(self.timezone)
@@ -146,7 +99,7 @@ class EmhassStrategy(EnergyStrategy):
 		curDT = None
 		nextDT = None
 		stop = False
-		for timestamp, row in self.data.iterrows():
+		for timestamp, row in self._data.iterrows():
 			prevDT = curDT
 			curDT = nextDT
 			nextDT = timestamp.to_pydatetime()
@@ -157,14 +110,14 @@ class EmhassStrategy(EnergyStrategy):
 				return ((prevDT, curDT, nextDT), (prevRow, curRow, nextRow))
 			if nextDT>now:
 				stop = True
-		if not stop: # should be impossible : Relaunch emhassEval()?
+		if not stop: # should be impossible : Relaunch eval()?
 			self.logger.error("No row in data previsions from EMHASS for current datetime.")
 			return ((None, None, None), (None, None, None))
 		return [[prevDT, curDT, nextDT], [prevRow, curRow, nextRow]]
 
-	def emhassApply(self, cycleDuration, now=None):
+	def apply(self, cycleDuration, now=None):
 		"""
-		This should apply emhass result (emhassEval call) : self.data
+		This should apply emhass result (eval call) : self._data
 		"""
 		if now is None:
 			now = datetime.now(self.timezone)
@@ -195,18 +148,3 @@ class EmhassStrategy(EnergyStrategy):
 			doSwitchOn = self.evaluatePertinenceSwitchOn(switchOnRate, deferable.node)
 			self.switchSchedulable(deferable.node, cycleDuration, doSwitchOn)
 		return True
-
-	def updateNetwork(self, cycleDuration, allowSleep:bool, now=None):
-		"""
-		Decide what to do during the cycle:
-		 IF off-peak : switch on all
-		 ELSE : Switch off all AND Sleep until off-peak
-		Now is used to get a fake 
-		"""
-		if now is None:
-			now = datetime.now(self.timezone)
-		elif now.tzinfo is None or now.tzinfo!=self.timezone:
-			now = now.replace(tzinfo=self.timezone)
-		self.check(now)
-		self.emhassApply(cycleDuration, now=now)
-		return cycleDuration

openhems-0.2.3/src/openhems/modules/energy_strategy/energy_strategy.py

@@ -0,0 +1,273 @@
+"""
+Super class for all EnergyStrategy modules
+
+List of todo list to integrate a strategy
+- Implemented : Implement main functions inherit from EnergyStrategy:
+   at least __init__() and updateNetwork() (or eval and apply)
+- Call : Call constructor in server.py
+- Conf : Configure it in openhems_default.py
+- TestAuto : Add unittest in test_xxx_strategy.py.
+- RunOk : Unitest do not test all, if run ok, all seam really ok.
+- InProd : If it's tested in a real house.
+
+#DONE: Implemented - Call - Conf - TestAuto - RunOk - InProd
+"""
+
+import logging
+import datetime
+from openhems.modules.network.network import OpenHEMSNetwork
+
+LOOP_DELAY_VIRTUAL = 0
+
+class StrategyNode:
+	"""
+	Class to manage a node in a strategy: keep track of its state
+	"""
+	def  __init__(self, node, logger):
+		self.logger = logger
+		self.node = node
+		self.isOn = None
+
+	def changed(self, isOn=None):
+		"""
+		Change the state of the node
+		"""
+		wasOn = self.isOn
+		if isOn is None:
+			isOn = self.node.isOn()
+		self.isOn = isOn
+		return wasOn!=self.isOn
+
+	def decreaseTime(self, cycleDuration:int):
+		"""
+		Decrease the time of the schedule
+		"""
+		if self.isOn:
+			if not self.node.isOn(): # Was successfully switched off at previous cycle
+				self.isOn = False
+				return False
+			schedule = self.node.getSchedule()
+			remainingTime = schedule.decreaseTime(cycleDuration)
+			if remainingTime==0:
+				self.logger.info("Switch off '%s' due to elapsed time.", self.node.id)
+				if self.node.switchOn(False):
+					self.logger.warning("Fail switch off '%s'.", self.node.id)
+				else:
+					return False
+			return True
+		return False
+
+class DefaultDeferrable:
+	"""
+	Class to manage a deferrable device
+	"""
+	def __init__(self, node, durationInSecs:int):
+		self.node = node
+		self.durationInSecs = durationInSecs
+
+	def getDuration(self):
+		"""
+		return the duration of the deferrable device
+		"""
+		return self.durationInSecs
+
+	def setDuration(self, durationInSecs:int):
+		"""
+		Set the duration of the deferrable device
+		"""
+		self.durationInSecs = durationInSecs
+
+class EnergyStrategy:
+	"""
+	Super class for all EnergyStrategy modules
+	"""
+	def  __init__(self, strategyId:str, network:OpenHEMSNetwork,
+	              logger=None, evalFrequency:int=60):
+		if logger is None:
+			logger = logging.getLogger(__name__)
+		self.logger = logger
+		self.strategyId = strategyId
+		self.network = network
+		self._nodes = None
+		self.evalFrequence = datetime.timedelta(minutes=evalFrequency)
+		self.nextEvalDate = datetime.datetime.now() - self.evalFrequence
+		self.deferables = {}
+		self.deferablesKeys = []
+
+	def getNodes(self, encapsulated=False):
+		"""
+		Return nodes concerned by a defined strategy
+		"""
+		if encapsulated:
+			if self._nodes is None:
+				self._nodes = [
+					StrategyNode(node, self.logger)
+					for node in self.network.getNodesForStrategy(self.strategyId)
+				]
+			return self._nodes
+		return self.network.getNodesForStrategy(self.strategyId)
+
+	def _switchSchedulableWitchIsOff(self, node, cycleDuration, doSwitchOn):
+		"""
+		Like switchSchedulable() but for node off and switchable
+		"""
+		del cycleDuration
+		if doSwitchOn and node.getSchedule().duration>0:
+			marginPower = node.network.getMarginPowerOn()
+			if node.getMaxPower()>marginPower:
+				self.logger.info(
+					"Not enough power margin (%d) to switch on '%s' witch need %d Kw.",
+					marginPower, node.id, node.getMaxPower())
+				return False
+			if not node.isActivate():
+				self.logger.info(
+					"Can't switch on '%s' due to deactivation for margin power security.",
+					node.id)
+				return False
+			if node.switchOn(True):
+				self.logger.info("Switch on '%s' successfully.", node.id)
+				return True
+			self.logger.warning("Fail switch on '%s'.", node.id)
+		else:
+			self.logger.debug("Node '%s' is off.",
+				node.id)
+		return False
+
+	def switchSchedulable(self, node, cycleDuration, doSwitchOn):
+		"""
+		param node: Node to switch on
+		param doSwitchOn: Set if we want to switch on or off
+		return: True if node is on
+		"""
+		if node.isSwitchable:
+			if node.isOn():
+				remainingTime = node.getSchedule().decreaseTime(cycleDuration)
+				if remainingTime==0 or not doSwitchOn:
+					self.logger.info("Switch off '%s' due to %s.",
+						node.id, "elapsed time" if remainingTime==0 else "strategy")
+					if node.switchOn(False):
+						self.logger.warning("Fail switch off '%s'.", node.id)
+						return True
+				else:
+					self.logger.debug("Node %s isOn for %s more seconds", \
+						node.id, remainingTime)
+					return True
+			else:
+				return self._switchSchedulableWitchIsOff(node, cycleDuration, doSwitchOn)
+		else:
+			self.logger.debug("switchOn() : Node is not switchable : %s.", node.id)
+		return False
+
+	def switchOffAll(self, cycleDuration=1):
+		"""
+		Switch of all connected devices with this strategy.
+		"""
+		self.logger.debug("EnergyStrategy.switchOffAll(%s)", self.strategyId)
+		ok = True
+		for elem in self.getNodes():
+			# self.logger.debug("Switch off '%s'", elem.id)
+			if elem.isSwitchable and self.switchSchedulable(elem, cycleDuration, False):
+				self.logger.warning("Fail to switch off '%s'",elem.id)
+				ok = False
+		return ok
+
+	def getSchedulableNodes(self):
+		"""
+		Return the list of nodes that should be scheduled by the user, using the HTTP UI
+		 to start (or stop) the device
+		"""
+		return self.getNodes()
+
+	def getDeferrable(self, node, durationInSecs:int):
+		"""
+		return: a Deferable device witch can be encapsulated if usefull
+		This function can be overload.
+		"""
+		return DefaultDeferrable(node, durationInSecs)
+
+	def updateDeferables(self):
+		"""
+		Update scheduled devices according to emhass
+		 to scheduled devices according to openhems
+		Return true if schedule has been updated
+		"""
+		# self.logger.debug("EnergyStrategy.updateDeferables()")
+		update = False
+		self.deferables = {}
+		for node in self.getNodes():
+			nodeId = node.id
+			durationInSecs = node.getSchedule().duration
+			deferable = self.deferables.get(nodeId, None)
+			if deferable is None:
+				if durationInSecs>0: # Add a new deferrable
+					update = True
+					self.deferables[nodeId] = self.getDeferrable(node, durationInSecs)
+			else:
+				if durationInSecs<=0: # Remove a deferrable
+					del self.deferables[nodeId]
+					update = True
+				elif deferable.getDuration()!=durationInSecs: # update a deferrable
+					update = True
+					deferable.setDuration(durationInSecs)
+		self.logger.debug("EnergyStrategy.updateDeferables() => %s : %s", update, self.deferables)
+		return update
+
+	def check(self, now=None):
+		"""
+		Check and eval if necessary
+		- EMHASS optimization
+		- power margin
+		- conformity to EMHASS plan
+		"""
+		# self.logger.debug("EnergyStrategy.check()")
+		if now is None:
+			now = datetime.datetime.now()
+		if self.updateDeferables() or now>self.nextEvalDate:
+			# self.logger.debug("EnergyStrategy.check() : eval")
+			self.eval()
+			self.nextEvalDate = datetime.datetime.now() + self.evalFrequence
+
+	def eval(self):
+		"""
+		This function must be overload
+		"""
+		self.logger.debug("EnergyStrategy.eval() must be overload")
+
+	def apply(self, cycleDuration, now):
+		"""
+		This function must be overload
+		"""
+		del cycleDuration, now
+		self.logger.debug("EnergyStrategy.apply() must be overload")
+
+	def updateNetwork(self, cycleDuration, now=None):
+		"""
+		Generic function to updateNetwork base on algorythm
+		In that case, sub-strategy must implement :
+		- eval()
+		- apply(cycleDuration, now)
+		"""
+		if now is None:
+			now = datetime.datetime.now()
+		self.check(now)
+		self.apply(cycleDuration, now=now)
+		return cycleDuration
+
+
+	def switchOnMax(self, cycleDuration):
+		"""
+		Switch on nodes, but 
+		 - If there is no margin to switch on, do nothing.
+		 - Only one (To be sure to not switch on to much devices)
+		"""
+		self.logger.info("%s.switchOnMax()", self.strategyId)
+		marginPower = self.network.getMarginPowerOn()
+		if marginPower<=0:
+			self.logger.info("Can't switch on devices: not enough power margin : %s", marginPower)
+			return True
+		for elem in self.getNodes(True):
+			switchOn = self.switchSchedulable(elem.node, cycleDuration, True)
+			if switchOn and elem.changed(switchOn):
+				self.logger.info("Switch on just one device at each loop to ensure Network constraint.")
+				return True
+		return False

{openhems-0.2.2 → openhems-0.2.3}/src/openhems/modules/energy_strategy/hybridinverter_strategy.py

@@ -6,6 +6,8 @@ Case dual-source managed by controlled "hybrid inverter with security mode" :
 Strategy is to minimize load/unload battery and minimize grid consumption
 Advantages : 
 Disadvantages : 
+
+TODO : Implemented - Call - Conf - TestAuto - RunOk - InProd : 6/6
 """
 
 import logging
@@ -23,14 +25,14 @@ class HybridInverterStrategy(SolarBasedStrategy):
 	Disadvantages : 
 	"""
 
-	def __init__(self, network: OpenHEMSNetwork, geoposition: GeoPosition, offpeakHoursRanges=None):
-		del offpeakHoursRanges
-		super().__init__(network, geoposition)
+	def __init__(self, strategyId:str, network:OpenHEMSNetwork, geoposition:GeoPosition):
+		super().__init__(strategyId, network, geoposition)
 		logging.getLogger("HybridInverterStrategy")\
 			.error("SolarOnlyProductionStrategy() : TODO")
 		# TODO
 
-	def updateNetwork(self, cycleDuration:int, allowSleep:bool, now=None):
+	def updateNetwork(self, cycleDuration:int, now=None):
+		del cycleDuration, now
 		logging.getLogger("HybridInverterStrategy")\
 			.error("SolarOnlyProductionStrategy.updateNetwork() : TODO")
 		# TODO