Initial commit, Json formatting, engine, user, producer und meter erstellt.

client/main.py

@@ -0,0 +1,164 @@
+import json
+import sys
+import random
+import JsonHandling as JsonHandling
+from collections import defaultdict
+import energyuser as energyuser
+import random
+
+class EnergyUser:
+    def __init__(self, config):
+        self.ID = config.get("ID")
+        self.user_prio = config.get("user_prio", 0)
+        self.lock_prio = config.get("lock_prio", 0)
+        self.idle = True
+        self.used_energy = 0
+        self.current_power = 0
+        self.current_delta_power = 0
+
+    def use_energy(self, amount):
+        raise NotImplementedError("Subclasses must implement use_energy method")
+        
+    modular = False
+    powersteps = []
+    
+    def get_requested_power(self):
+
+                    max_power = max(self.powersteps)
+                    return max_power if random.choice([True, False]) else max_power
+                    return 0
+
+class User1(EnergyUser):
+    modular = True
+    powersteps = [100, 600]
+    
+    def __init__(self, config):
+        self.ID = config.get("ID")
+        self.user_prio = config.get("user_prio", 0)
+        self.lock_prio = config.get("lock_prio", 0)
+        self.idle = True
+        self.used_energy = 6
+        self.current_power = 0
+        self.current_delta_power = 0   
+        
+    def use_energy(self, amount):
+        print(f"Using energy as {self.ID} with amount {amount}")
+        # Hier kannst du die spezifische Logik für User 1 implementieren
+   
+
+
+class User2(EnergyUser):
+    modular = False
+    powersteps = [200, 400]
+    
+    def __init__(self, config):
+        self.ID = config.get("ID")
+        self.user_prio = config.get("user_prio", 0)
+        self.lock_prio = config.get("lock_prio", 0)
+        self.idle = True
+        self.used_energy = 4
+        self.current_power = 0
+        self.current_delta_power = 0
+        
+        
+    def use_energy(self, amount):
+        print(f"Using energy as {self.ID} with amount {amount}")
+        # Hier kannst du die spezifische Logik für User 2 implementieren
+        
+
+
+class EnergyUserFactory:
+    @staticmethod
+    def create_from_json(json_data):
+        subclasses = [cls for cls in sys.modules[__name__].__dict__.values() if isinstance(cls, type) and issubclass(cls, EnergyUser) and cls != EnergyUser]
+    
+        energy_users = []
+        data = json.loads(json_data)
+    
+        for user_data in data["users"]:
+            user_type = user_data["type"]
+            user_config = user_data["config"]
+            for subclass in subclasses:
+                if user_type in subclass.__name__:
+                    energy_users.append(subclass(user_config))
+    
+        return energy_users
+    
+        
+        
+        
+    @staticmethod
+    def get_current_available_power():
+        a =  random.randint(0,3000)
+        print(a)
+        return a
+    
+    @staticmethod
+    def distribute_energy(energy_users, current_power):
+        remaining_power = current_power - sum(user.current_delta_power for user in energy_users)
+        print(remaining_power)
+        # Filtere Benutzer mit idle = True
+        idle_energy_users = [user for user in energy_users if user.idle]
+    
+        # Erweitere die Schritte für modulare Benutzer
+        for user in idle_energy_users:
+            if user.modular:
+                user.powersteps = list(range(min(user.powersteps), max(user.powersteps) + 1))
+    
+        # Sortiere die Benutzer nach ihrer Priorität und dann nach ihrer ID
+        idle_energy_users.sort(key=lambda x: (x.user_prio, x.used_energy))
+    
+        # Schleife durch alle Prioritäten
+        priorities = set(user.user_prio for user in idle_energy_users)
+        for priority in priorities:
+            # Benutzer mit gleicher Priorität sammeln
+            same_priority_users = [u for u in idle_energy_users if u.user_prio == priority]
+            if not same_priority_users:
+                continue
+    
+            # Sammle alle Schritte der Benutzer in einem Array
+            all_steps = []
+            for user in same_priority_users:
+                all_steps.extend([(user, step) for step in user.powersteps])
+    
+            # Sortiere die Schritte nach Größe
+            all_steps.sort(key=lambda x: x[1])
+    
+            # Variable zur Verfolgung der bereitgestellten Energie für jeden Benutzer
+            user_energy_prov = {user: 0 for user in same_priority_users}
+    
+            # Iteriere durch alle Schritte
+            for user, powerstep in all_steps:
+                # Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist
+                if remaining_power >= powerstep - user_energy_prov[user]:
+                    # Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer
+                    remaining_power -= (powerstep - user_energy_prov[user])
+                    user_energy_prov[user] = powerstep
+    
+            # Verteile die bereitgestellte Energie auf die Benutzer
+            for user in same_priority_users:
+                user.use_energy(user_energy_prov[user])
+    
+        print("Final state after distributing power:")
+        for user in energy_users:
+            print(f"{user.ID}: {user.used_energy}")
+
+# Beispielverwendung
+json_data = '''
+{
+  "metadata":{"config_has_changed" : "0"},
+  "users": [
+    {"type": "User1", "config": {"ID":"Umod1","user_prio":1,"lock_prio":2}},
+    {"type": "User1", "config": {"ID":"Umod3","user_prio":3,"lock_prio":4}},
+    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
+    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
+    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
+    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
+    {"type": "User2", "config": {"ID":"Usta2","user_prio":2,"lock_prio":6}},
+    {"type": "User2", "config": {"ID":"Usta2","user_prio":2,"lock_prio":6}}
+  ]
+}
+
+'''
+
+#