openhems 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhems
-Version: 0.2.2
+Version: 0.2.4
 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.4}/pyproject.toml

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

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

@@ -13,7 +13,7 @@ server:
   inDocker: False
   port: 8000
   logformat: "%(levelname)s : %(asctime)s : %(message)s" # for custom configuration see https://docs.python.org/3/library/logging.html#logrecord-attributes
-  logfile: openhems.log # Optional, default is /var/log/openhems.log
+  logfile: "" # set a log file. When "", there is no logfile (only STDOUT)
   loglevel: info # Optional, default is info, availables are debug / info / warn / error / critical / no
   loopDelay: 30 # interval beetween 2 loop
   network: homeassistant # Define the type of network API used to control the home energy.
@@ -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
@@ -77,9 +93,10 @@ default:
         rtetarifbleu:
           price: 0.2516
         generic:
-          hoursRanges: []
+          offpeakhoursranges: []
           defaultPrice: 0.1
           outRangePrice: 1.0
+          sellprice: 0.0
     solarpanel:
       currentPower: None
       maxPower: 500

{openhems-0.2.2 → openhems-0.2.4}/src/openhems/data/openhems_tooltips_en.yaml

@@ -22,6 +22,46 @@ network:
   nodes: "Configure your home nodes"
 # All default values.
 default:
+  strategy:
+    emhass:
+      freq: 30
+      days_to_retrieve: 2
+      method_ts_round: nearest
+      delta_forecast: 1
+      weather_forecast_method: scrapper
+      load_cost_hp: 0.30
+      load_cost_hc: 0.15
+      prod_sell_price: 0.0
+      set_total_pv_sell: False
+      lp_solver: default
+      lp_solver_path: empty
+      set_nocharge_from_grid: False
+      set_nodischarge_to_grid: True
+      set_battery_dynamic: False
+      battery_dynamic_max: 0.9
+      battery_dynamic_min: -0.9
+    offpeak:
+      offpeakhours: None
+    switchoff:
+      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: ""
@@ -30,26 +70,28 @@ default:
       marginPower: ""
       contract:
         rtetempo:
-          color: ""
-          offpeakhoursranges: ": ["22h - 6h"]"
+          color: null
+          nextcolor: null
+          offpeakhoursranges: ["22h - 6h"]
           peakprice:
-            bleu: ""
-            blanc: ""
-            rouge: "
+            bleu: 0.1609
+            blanc: 0.1894
+            rouge: 0.7562
           offpeakprice:
-            bleu: ""
-            blanc: ""
-            rouge: ""
+            bleu: 0.1296
+            blanc: 0.1486
+            rouge: 0.1568
         rteheurescreuses:
-          offpeakhoursranges: "["22h - 6h"]"
-          peakprice: ""
-          offpeakprice: ""
+          offpeakhoursranges: ["22h - 6h"]
+          peakprice: 0.2700
+          offpeakprice: 0.2068
         rtetarifbleu:
-          price: ""
+          price: 0.2516
         generic:
-          offpeakhoursranges: "["22h - 6h"]"
-          peakprice: ""
-          offpeakprice: ""
+          offpeakhoursranges: []
+          defaultPrice: 0.1
+          outRangePrice: 1.0
+          sellprice: 0.0
     solarpanel:
       currentPower: ""
       maxPower: ""

{openhems-0.2.2 → openhems-0.2.4}/src/openhems/data/openhems_tooltips_fr.yaml

@@ -48,8 +48,9 @@ default:
           price: ""
         generic:
           offpeakhoursranges: "['22h - 6h']"
-          peakprice: ""
-          offpeakprice: ""
+          defaultPrice: 0.1
+          outRangePrice: 1.0
+          sellprice: 0.0
     solarpanel:
       currentPower: ""
       maxPower: ""

{openhems-0.2.2 → openhems-0.2.4}/src/openhems/main.py

@@ -13,6 +13,7 @@ from datetime import datetime
 from threading import Thread
 import argparse
 from pathlib import Path
+from requests.exceptions import ConnectTimeout
 openhemsPath = Path(__file__).parents[1]
 sys.path.append(str(openhemsPath))
 # pylint: disable=wrong-import-position
@@ -53,7 +54,11 @@ class OpenHEMSApplication:
 		myHandlers = []
 		fileHandler = None
 		formatter = logging.Formatter(logformat)
-		if not inDocker:
+		# Case wrong logfile path : set to empty : no logging file
+		logfileparents = Path(logfile).parents
+		if len(logfileparents)==0 or not logfileparents[0].is_dir():
+			logfile = "" # No log file
+		if not inDocker and logfile!="":
 			fileHandler = handlers.TimedRotatingFileHandler(filename=logfile,
 	        	when='D',
 	        	interval=1,
@@ -82,7 +87,7 @@ class OpenHEMSApplication:
 		Load YAML configuration, over load it with a secret file if exists.
 		Return a "Configurator"
 		"""
-		print("Load YAML configuration from '",yamlConfFilepath,"'")
+		# print("Load YAML configuration from '",yamlConfFilepath,"'")
 		path = Path(yamlConfFilepath)
 		configurator.addYamlConfig(path)
 		if path.suffix!="":
@@ -90,24 +95,24 @@ class OpenHEMSApplication:
 			secretPath = str(yamlConfFilepath).replace(path.suffix, ".secret"+path.suffix)
 			path = Path(secretPath)
 			if path.is_file():
-				print("Over load YAML configuration with '",str(path),"'")
+				# print("Over load YAML configuration with '",str(path),"'")
 				configurator.addYamlConfig(path)
-			else:
-				print("No '",str(path),"'")
+			# else: print("No '",str(path),"'")
 		configurator.completeWithDefaults()
 		return configurator
 
 	def __init__(self, yamlConfFilepath:str, *, port=0, logfilepath='', inDocker=False):
 		# Temporary logger
 		self.logger = logging.getLogger(__name__)
-		warnings = []
+		# Keep warnings for tests (self.server can be None if it raise Exception).
+		self.warnings = []
 		network = None
 		schedule = []
 		configurator = ConfigurationManager(self.logger)
 		try:
 			configurator = self.loadYamlConfiguration(configurator, yamlConfFilepath)
 		except ConfigurationException as e:
-			warnings.append(str(e))
+			self.warnings.append(str(e))
 		loglevel = configurator.get("server.loglevel")
 		logformat = configurator.get("server.logformat")
 		logfile = logfilepath if logfilepath!='' else configurator.get("server.logfile")
@@ -116,19 +121,19 @@ class OpenHEMSApplication:
 		self.server = None
 		try:
 			network = network_helper.getNetworkFromConfiguration(self.logger, configurator)
-			warnings = warnings + network.getWarningMessages()
+			self.warnings = self.warnings + network.getWarningMessages()
 			self.server = OpenHEMSServer(self.logger, network, configurator)
 			schedule = self.server.getSchedule()
-		except ConfigurationException as e:
+		except (ConfigurationException, ConnectTimeout) as e:
 			self.logger.error(str(e))
-			warnings.append(str(e))
-		for warning in warnings:
+			self.warnings.append(str(e))
+		for warning in self.warnings:
 			self.logger.error(warning)
 		port = port if port>0 else configurator.get("server.port")
 		port = CastUtililty.toTypeInt(port)
 		root = configurator.get("server.htmlRoot")
 		inDocker = inDocker or configurator.get("server.inDocker", "bool")
-		self.webserver = OpenhemsHTTPServer(self.logger, schedule, warnings,
+		self.webserver = OpenhemsHTTPServer(self.logger, schedule, self.warnings,
 			port=port, htmlRoot=root, inDocker=inDocker, configurator=configurator)
 		if network is not None:
 			self.logger.info("OpenHEMS loaded.")

{openhems-0.2.2 → openhems-0.2.4}/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.4}/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'})
@@ -160,7 +160,11 @@ class RTETempoContract(RTEContract):
 		curCall = now.strftime("%Y%m%d%H")
 		if self.lastCall!=curCall:
 			if self.color is not None:
-				self.lastColor = self.color.getValue().lower()
+				color = self.color.getValue()
+				if color is None or not isinstance(color, str):
+					self.logger.warning("RTETempoContract.getCurColor() : color is None, use the API")
+					color = self.callApiRteTempo("today")
+				self.lastColor = color.lower()
 			else:
 				self.lastColor = self.callApiRteTempo("today")
 			self.lastCall = curCall

{openhems-0.2.2 → openhems-0.2.4}/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.4}/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.4}/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