pycityagent 2.0.0a47__cp39-cp39-macosx_11_0_arm64.whl → 2.0.0a49__cp39-cp39-macosx_11_0_arm64.whl

pycityagent/cityagent/blocks/time_block.py

@@ -0,0 +1,116 @@
+import asyncio
+from datetime import datetime
+import json
+from pycityagent.workflow import Block
+from pycityagent.llm.llm import LLM
+from pycityagent.memory import Memory
+from pycityagent.environment import Simulator
+from pycityagent.workflow.prompt import FormatPrompt
+from .utils import clean_json_response
+    
+class WorkReflectionBlock(Block):
+    """
+    反馈工作感受
+    WorkReflectionBlock
+    """
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__("WorkReflectionBlock", llm, memory, simulator)
+        self.description = "Feedback on work experience"
+
+    async def forward(self):
+        prompt = """
+You are a {gender}, your consumption level is {consumption} and your education level is {education}.
+Today's working experience:
+{working_experience}
+
+How is your feeling of work today?
+
+Your answer should be one of the following:
+- excellent
+- good
+- soso
+- bad
+- very bad
+Answer in JSON format:
+{{
+    "evaluation": "good",
+}}
+"""
+        prompt = FormatPrompt(prompt)
+        prompt.format(
+            **{key: await self.memory.get(key) for key in prompt.variables}
+        )
+        evaluation = await self.llm.atext_request(prompt.to_dialog(), timeout=300)
+        evaluation = clean_json_response(evaluation)
+        try:
+            evaluation = json.loads(evaluation)
+        except Exception as e:
+            evaluation = {'evaluation': 'soso'}
+        if evaluation['evaluation'] == 'excellent':
+            safe_improve = 0.2
+        elif evaluation['evaluation'] == 'good':
+            safe_improve = 0.1
+        elif evaluation['evaluation'] == 'soso':
+            safe_improve = 0.0
+        elif evaluation['evaluation'] == 'bad':
+            safe_improve = -0.1
+        elif evaluation['evaluation'] == 'very bad':
+            safe_improve = -0.2
+        else:
+            safe_improve = 0.0
+
+        needs = await self.memory.get("needs")
+        needs['safe'] += safe_improve
+        await self.memory.update("needs", needs)
+        await self.memory.update("working_experience", [])
+        return
+
+
+class TimeBlock(Block):
+    """固定时间trigger的工作流"""
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__(name="time_block", llm=llm, memory=memory, simulator=simulator)
+        self.blocks = []
+        self.work_reflection_block = WorkReflectionBlock(llm, memory, simulator)
+        self.blocks.append((self.work_reflection_block, self.str_to_time('23:59:59'))) # end of day
+        self.last_check_time = None
+        self.trigger_time = 0
+        self.token_consumption = 0
+
+    def str_to_time(self, time_str: str):
+        time_obj = datetime.strptime(time_str, '%H:%M:%S')
+        return time_obj.hour * 3600 + time_obj.minute * 60 + time_obj.second
+
+    async def blocks_to_trigger(self):
+        trigger_blocks = []
+        now_time = await self.simulator.get_time(format_time=True)
+        now_time = self.str_to_time(now_time)
+        if self.last_check_time is None:
+            self.last_check_time = now_time
+        else:
+            whether_cross_day = True if now_time < self.last_check_time else False
+            for block, trigger_time in self.blocks:
+                if whether_cross_day and trigger_time > self.last_check_time:
+                    trigger_blocks.append(block)
+                elif not whether_cross_day and trigger_time > self.last_check_time and trigger_time <= now_time:
+                    trigger_blocks.append(block)
+            self.last_check_time = now_time
+        return trigger_blocks
+
+    async def forward(self):
+        while True:
+            if len(self.blocks) == 0:
+                await asyncio.sleep(30)
+                continue
+            trigger_blocks = await self.blocks_to_trigger()
+            if len(trigger_blocks) == 0:
+                await asyncio.sleep(30)
+                continue
+            self.trigger_time += 1
+            consumption_start = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            tasks = []
+            for block in trigger_blocks:
+                tasks.append(block.forward())
+            await asyncio.gather(*tasks)
+            consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            self.token_consumption += consumption_end - consumption_start

pycityagent/cityagent/blocks/utils.py

@@ -0,0 +1,66 @@
+import re
+import ast
+
+TIME_ESTIMATE_PROMPT = """As an intelligent agent's time estimation system, please estimate the time needed to complete the current action based on the overall plan and current intention.
+
+Overall plan:
+{plan}
+
+Current action: {intention}
+
+Examples:
+- "Learn programming": {{"time": 120}}
+- "Watch a movie": {{"time": 150}} 
+- "Play mobile games": {{"time": 60}}
+- "Read a book": {{"time": 90}}
+- "Exercise": {{"time": 45}}
+
+Please return the result in JSON format (Do not return any other text):
+{{
+    "time": estimated completion time (integer, in minutes)
+}}
+"""
+
+num_labor_hours = 168
+month_days = 0.03
+productivity_per_labor = 1
+max_price_inflation = 0.1
+max_wage_inflation = 0.05
+natural_interest_rate = 0.01
+target_inflation = 0.02
+natural_unemployment_rate = 0.04
+inflation_coeff, unemployment_coeff = 0.5, 0.5
+tao = 1
+period = 3
+UBI = 0
+
+def prettify_document(document: str) -> str:
+    # Remove sequences of whitespace characters (including newlines)
+    cleaned = re.sub(r'\s+', ' ', document).strip()
+    return cleaned
+
+def extract_dict_from_string(input_string):
+    """
+    提取输入字符串中的字典。支持跨行字典和嵌套字典。
+    """
+    # 正则表达式查找所有可能的字典部分，允许多行
+    dict_pattern = r'\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}'  # 匹配字典的正则表达式，支持嵌套
+    matches = re.findall(dict_pattern, input_string, re.DOTALL)  # re.DOTALL允许匹配换行符
+
+    dicts = []
+
+    for match in matches:
+        try:
+            # 使用 ast.literal_eval 将字符串转换为字典
+            parsed_dict = ast.literal_eval(match)
+            if isinstance(parsed_dict, dict):
+                dicts.append(parsed_dict)
+        except (ValueError, SyntaxError) as e:
+            print(f"解析字典失败: {e}")
+
+    return dicts
+
+def clean_json_response(response: str) -> str:
+    """清理LLM响应中的特殊字符"""
+    response = response.replace('```json', '').replace('```', '')
+    return response.strip() 

pycityagent/cityagent/firmagent.py

@@ -0,0 +1,75 @@
+import asyncio
+from typing import Optional
+
+import numpy as np
+from pycityagent import Simulator, InstitutionAgent
+from pycityagent.llm.llm import LLM
+from pycityagent.economy import EconomyClient
+from pycityagent.message import Messager
+from pycityagent.memory import Memory
+import logging
+
+logger = logging.getLogger("pycityagent")
+
+class FirmAgent(InstitutionAgent):    
+    configurable_fields = ["time_diff", "max_price_inflation", "max_wage_inflation"]
+    default_values = {
+        "time_diff": 30 * 24 * 60 * 60,
+        "max_price_inflation": 0.05,
+        "max_wage_inflation": 0.05,
+    }
+
+    def __init__(self, 
+                 name: str,
+                 llm_client: Optional[LLM] = None,
+                 simulator: Optional[Simulator] = None,
+                 memory: Optional[Memory] = None,
+                 economy_client: Optional[EconomyClient] = None,
+                 messager: Optional[Messager] = None,
+                 avro_file: Optional[dict] = None,
+                 ) -> None:
+        super().__init__(name=name, llm_client=llm_client, simulator=simulator, memory=memory, economy_client=economy_client, messager=messager, avro_file=avro_file)
+        self.initailzed = False
+        self.last_time_trigger = None
+        self.forward_times = 0
+        self.time_diff = 30 * 24 * 60 * 60
+        self.max_price_inflation = 0.05
+        self.max_wage_inflation = 0.05
+
+    async def month_trigger(self):
+        now_time = await self.simulator.get_time()
+        if self.last_time_trigger is None:
+            self.last_time_trigger = now_time
+            return False
+        if now_time - self.last_time_trigger >= self.time_diff:
+            self.last_time_trigger = now_time
+            return True
+        return False
+    
+    async def gather_messages(self, agent_ids, content):
+        infos = await super().gather_messages(agent_ids, content)
+        return [info['content'] for info in infos]
+
+    async def forward(self):
+        if await self.month_trigger():
+            employees = await self.memory.get("employees")
+            while True:
+                agents_forward = await self.gather_messages(employees, 'forward')
+                if np.all(np.array(agents_forward) > self.forward_times):
+                    break
+                await asyncio.sleep(1)
+            goods_demand = await self.gather_messages(employees, 'goods_demand')
+            goods_consumption = await self.gather_messages(employees, 'goods_consumption')
+            print(f'goods_demand: {goods_demand}, goods_consumption: {goods_consumption}')
+            total_demand = sum(goods_demand)
+            last_inventory = sum(goods_consumption) + await self.economy_client.get(self._agent_id, "inventory")
+            print(f'total_demand: {total_demand}, last_inventory: {last_inventory}, goods_contumption: {sum(goods_consumption)}')
+            max_change_rate = (total_demand - last_inventory)/(max(total_demand, last_inventory)+1e-8)
+            skills = await self.gather_messages(employees, 'work_skill')
+            for skill, uuid in zip(skills, employees):
+                await self.send_message_to_agent(uuid, f"work_skill@{max(skill*(1 + np.random.uniform(0, max_change_rate*self.max_wage_inflation)), 1)}")
+            price = await self.economy_client.get(self._agent_id, 'price')
+            await self.economy_client.update(self._agent_id, 'price', max(price*(1 + np.random.uniform(0, max_change_rate*self.max_price_inflation)), 1))
+            self.forward_times += 1
+            for uuid in employees:
+                await self.send_message_to_agent(uuid, f"firm_forward@{self.forward_times}")

pycityagent/cityagent/governmentagent.py

@@ -0,0 +1,60 @@
+import asyncio
+from typing import Optional
+
+import numpy as np
+from pycityagent import Simulator, InstitutionAgent
+from pycityagent.llm.llm import LLM
+from pycityagent.economy import EconomyClient
+from pycityagent.message import Messager
+from pycityagent.memory import Memory
+import logging
+
+logger = logging.getLogger("pycityagent")
+
+class GovernmentAgent(InstitutionAgent):    
+    def __init__(self, 
+                 name: str,
+                 llm_client: Optional[LLM] = None,
+                 simulator: Optional[Simulator] = None,
+                 memory: Optional[Memory] = None,
+                 economy_client: Optional[EconomyClient] = None,
+                 messager: Optional[Messager] = None,
+                 avro_file: Optional[dict] = None,
+                 ) -> None:
+        super().__init__(name=name, llm_client=llm_client, simulator=simulator, memory=memory, economy_client=economy_client, messager=messager, avro_file=avro_file)
+        self.initailzed = False
+        self.last_time_trigger = None
+        self.time_diff = 30 * 24 * 60 * 60
+        self.forward_times = 0
+        
+    async def month_trigger(self):
+        now_time = await self.simulator.get_time()
+        if self.last_time_trigger is None:
+            self.last_time_trigger = now_time
+            return False
+        if now_time - self.last_time_trigger >= self.time_diff:
+            self.last_time_trigger = now_time
+            return True
+        return False
+    
+    async def gather_messages(self, agent_ids, content):
+        infos = await super().gather_messages(agent_ids, content)
+        return [info['content'] for info in infos]
+
+    async def forward(self):
+        if await self.month_trigger():
+            citizens = await self.memory.get("citizens")
+            while True:
+                agents_forward = await self.gather_messages(citizens, 'forward')
+                if np.all(np.array(agents_forward) > self.forward_times):
+                    break
+                await asyncio.sleep(1)
+            citizens_agent_id = await self.memory.get("citizens_agent_id")
+            incomes = await self.gather_messages(citizens, 'income_currency') # uuid
+            _, post_tax_incomes = await self.economy_client.calculate_taxes_due(self._agent_id, citizens_agent_id, incomes, enable_redistribution=False)
+            for uuid, income, post_tax_income in zip(citizens, incomes, post_tax_incomes):
+                tax_paid = income - post_tax_income
+                await self.send_message_to_agent(uuid, f"tax_paid@{tax_paid}")
+            self.forward_times += 1
+            for uuid in citizens:
+                await self.send_message_to_agent(uuid, f"government_forward@{self.forward_times}")

pycityagent/cityagent/initial.py

@@ -0,0 +1,98 @@
+import random
+from pycityagent.cityagent import SocietyAgent, FirmAgent, GovernmentAgent, BankAgent, NBSAgent
+
+async def initialize_social_network(simulation):
+    """
+    初始化智能体之间的社交网络，包括好友关系类型、好友关系和社交关系强度
+    """
+    try:
+        print("Initializing social network...")
+        
+        # 定义可能的关系类型
+        relation_types = ["family", "colleague", "friend"]
+        
+        # 获取所有智能体ID
+        agent_ids = simulation.agent_uuids
+        for agent_id in agent_ids:
+            # 为每个智能体随机选择2-5个好友
+            num_friends = random.randint(2, 5)
+            possible_friends = [aid for aid in agent_ids if aid != agent_id]
+            friends = random.sample(possible_friends, min(num_friends, len(possible_friends)))
+            
+            # 初始化好友关系
+            await simulation.update(agent_id, "friends", friends)
+            
+            # 初始化与每个好友的关系类型和关系强度
+            relationships = {}
+            relation_type_map = {}
+            
+            for friend_id in friends:
+                # 随机选择关系类型
+                relation_type = random.choice(relation_types)
+                # 根据关系类型设置初始关系强度范围
+                if relation_type == "family":
+                    strength = random.randint(60, 90)  # 家人关系强度较高
+                elif relation_type == "colleague":
+                    strength = random.randint(40, 70)  # 同事关系强度中等
+                else:  # friend
+                    strength = random.randint(30, 80)  # 朋友关系强度范围较广
+                
+                relationships[friend_id] = strength
+                relation_type_map[friend_id] = relation_type
+            
+            # 更新关系强度和类型
+            await simulation.update(agent_id, "relationships", relationships)
+            await simulation.update(agent_id, "relation_types", relation_type_map)
+            
+            # 初始化空的聊天历史和互动记录
+            await simulation.update(agent_id, "chat_histories", {friend_id: [] for friend_id in friends})
+            await simulation.update(agent_id, "interactions", {friend_id: [] for friend_id in friends})
+                
+        print("Social network initialization completed!")
+        return True
+        
+    except Exception as e:
+        print(f"Error initializing social network: {str(e)}")
+        return False
+    
+async def bind_agent_info(simulation):
+    """
+    绑定智能体的信息，包括公民、公司、政府、银行和NBS的ID
+    """
+    print("Binding agent info...")
+    infos = await simulation.gather('id')
+    citizen_uuids = await simulation.filter(types=[SocietyAgent])
+    firm_uuids = await simulation.filter(types=[FirmAgent])
+    government_uuids = await simulation.filter(types=[GovernmentAgent])
+    bank_uuids = await simulation.filter(types=[BankAgent])
+    nbs_uuids = await simulation.filter(types=[NBSAgent])
+    citizen_agent_ids = []
+    for info in infos:
+        for k, v in info.items():
+            if k in citizen_uuids:
+                citizen_agent_ids.append(v)
+            elif k in firm_uuids:
+                firm_id = v
+            elif k in government_uuids:
+                government_id = v
+            elif k in bank_uuids:
+                bank_id = v
+            elif k in nbs_uuids:
+                nbs_id = v
+    for citizen_uuid in citizen_uuids:
+        await simulation.update(citizen_uuid, 'firm_id', firm_id)
+        await simulation.update(citizen_uuid, 'government_id', government_id)
+        await simulation.update(citizen_uuid, 'bank_id', bank_id)
+        await simulation.update(citizen_uuid, 'nbs_id', nbs_id)
+    for firm_uuid in firm_uuids:
+        await simulation.update(firm_uuid, 'employees', citizen_uuids)
+        await simulation.update(firm_uuid, 'employees_agent_id', citizen_agent_ids)
+    for government_uuid in government_uuids:
+        await simulation.update(government_uuid, 'citizens', citizen_uuids)
+        await simulation.update(government_uuid, 'citizens_agent_id', citizen_agent_ids)
+    for bank_uuid in bank_uuids:
+        await simulation.update(bank_uuid, 'citizens', citizen_uuids)
+        await simulation.update(bank_uuid, 'citizens_agent_id', citizen_agent_ids)
+    for nbs_uuid in nbs_uuids:
+        await simulation.update(nbs_uuid, 'firm_id', firm_id)
+    print("Agent info binding completed!")

pycityagent/cityagent/memory_config.py

@@ -0,0 +1,202 @@
+import random
+from mosstool.map._map_util.const import AOI_START_ID
+import numpy as np
+import pycityproto.city.economy.v2.economy_pb2 as economyv2
+from collections import deque
+
+pareto_param = 8
+payment_max_skill_multiplier = 950
+payment_max_skill_multiplier = float(payment_max_skill_multiplier)
+pmsm = payment_max_skill_multiplier
+pareto_samples = np.random.pareto(pareto_param, size=(1000, 10))
+clipped_skills = np.minimum(pmsm, (pmsm - 1) * pareto_samples + 1)
+sorted_clipped_skills = np.sort(clipped_skills, axis=1)
+agent_skills = list(sorted_clipped_skills.mean(axis=0))
+
+def memory_config_societyagent():
+    EXTRA_ATTRIBUTES = {
+        "city": 'New York',
+
+        # 需求信息
+        "type": (str, 'citizen'), 
+        "needs": (dict, {
+            'hungry': random.random(),  # 饥饿感
+            'tired': random.random(),   # 疲劳感
+            'safe': random.random(),    # 安全需
+            'social': random.random(),  # 社会需求
+        }, True),
+        "current_need": (str, "none", True),
+        "current_plan": (list, [], True),
+        "current_step": (dict, {"intention": "", "type": ""}, True),
+        "execution_context" : (dict, {}, True),
+        "plan_history": (list, [], True),
+
+        # cognition
+        "emotion": (dict, {"sadness": 5, "joy": 5, "fear": 5, "disgust": 5, "anger": 5, "surprise": 5}, True),
+        "attitude": (dict, {}, True),
+        "thought": (str, "Currently nothing good or bad is happening", True),
+        "emotion_types": (str, "Relief", True),
+        "incident": (list, [], True),
+        
+        "city": (str, 'Texas', True),
+        "work_skill": (float, random.choice(agent_skills), True), # 工作技能, 即每小时的工资
+        "tax_paid": (float, 0.0, True), # 纳税
+        "consumption_currency": (float, 0.0, True), # 月消费
+        "goods_demand": (int, 0, True), 
+        "goods_consumption": (int, 0, True),
+        "work_propensity": (float, 0.0, True), 
+        "consumption_propensity": (float, 0.0, True),
+        "income_currency": (float, 0.0, True), # 月收入
+        "to_income": (float, 0.0, True),
+        "to_consumption_currency": (float, 0.0, True),
+        "firm_id": (int, 0, True),
+        "government_id": (int, 0, True),
+        "bank_id": (int, 0, True),
+        'nbs_id': (int, 0, True),
+        "dialog_queue": (deque(maxlen=3), [], True),
+        "firm_forward": (int, 0, True),
+        "bank_forward": (int, 0, True),
+        "nbs_forward": (int, 0, True),
+        "government_forward": (int, 0, True),
+        "forward": (int, 0, True),
+        "depression": (float, 0.0, True),
+        "ubi_opinion": (list, [], True),
+
+        #social
+        "friends": (list, [], True),  # 好友列表
+        "relationships": (dict, {}, True),  # 与每个好友的关系强度
+        "relation_types": (dict, {}, True),
+        "chat_histories": (dict, {}, True),  # 所有聊天历史记录
+        "interactions": (dict, {}, True),  # 所有互动记录
+        "to_discuss":(dict, {}, True),
+
+        # economy
+        "working_experience": (list, [], True),
+        "work_hour_month": (float, 160, True),
+        "work_hour_finish": (float, 0, True),
+
+        # mobility
+        "environment": (str, "The environment outside is good", True),
+    }
+
+    PROFILE = {
+        "name": random.choice(["Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace", "Helen", "Ivy", "Jack", "Kelly", "Lily", "Mike", "Nancy", "Oscar", "Peter", "Queen", "Rose", "Sam", "Tom", "Ulysses", "Vicky", "Will", "Xavier", "Yvonne", "Zack"]),
+        "gender": random.choice(["male", "female"]),
+        "age": random.randint(18, 65),
+        "education": random.choice(["Doctor", "Master", "Bachelor", "College", "High School"]),
+        "skill": random.choice(["Good at problem-solving", "Good at communication", "Good at creativity", "Good at teamwork", "Other"]),
+        "occupation": random.choice(["Student", "Teacher", "Doctor", "Engineer", "Manager", "Businessman", "Artist", "Athlete", "Other"]),
+        "family_consumption": random.choice(["low", "medium", "high"]),
+        "consumption": random.choice(["sightly low", "low", "medium", "high"]),
+        "personality": random.choice(["outgoint", "introvert", "ambivert", "extrovert"]),
+        "income": '0',
+        "currency": random.randint(1000, 100000),
+        "residence": random.choice(["city", "suburb", "rural"]),
+        "race": random.choice(["Chinese", "American", "British", "French", "German", "Japanese", "Korean", "Russian", "Other"]),
+        "religion": random.choice(["none", "Christian", "Muslim", "Buddhist", "Hindu", "Other"]),
+        "marital_status": random.choice(["not married", "married", "divorced", "widowed"]),
+    }
+
+    BASE = {
+        "home": {"aoi_position": {"aoi_id": AOI_START_ID + random.randint(1000, 10000)}},
+        "work": {"aoi_position": {"aoi_id": AOI_START_ID + random.randint(1000, 10000)}},
+    }
+
+    return EXTRA_ATTRIBUTES, PROFILE, BASE
+
+def memory_config_firm():
+    EXTRA_ATTRIBUTES = {'type': (int, economyv2.ORG_TYPE_FIRM),
+                        'price': (float, float(np.mean(agent_skills))),
+                        'inventory': (int, 0),
+                        'employees': (list, []),
+                        'employees_agent_id': (list, []),
+                        'nominal_gdp': (list, []), # useless
+                        'real_gdp': (list, []),
+                        'unemployment': (list, []),
+                        'wages': (list, []),
+                        'prices': (list, [float(np.mean(agent_skills))]),
+                        "working_hours": (list, []),
+                        "depression": (list, []),
+                        "consumption_currency": (list, []),
+                        "income_currency": (list, []),
+                        "locus_control": (list, []),
+                        'bracket_cutoffs': (list, list(np.array([0, 9875, 40125, 85525, 163300, 207350, 518400])/12)),
+                        "bracket_rates": (list, [0.1, 0.12, 0.22, 0.24, 0.32, 0.35, 0.37]),
+                        'interest_rate': (float, 0.03),
+                        'citizens': (list, []),
+                        'citizens_agent_id': (list, []),
+                        'firm_id': (int, 0),}
+    return EXTRA_ATTRIBUTES, {'currency': 1e12}, {}
+
+def memory_config_government():
+    EXTRA_ATTRIBUTES = {'type': (int, economyv2.ORG_TYPE_GOVERNMENT),
+                        # 'bracket_cutoffs': (list, list(np.array([0, 97, 394.75, 842, 1607.25, 2041, 5103])*100/12)),
+                        'bracket_cutoffs': (list, list(np.array([0, 9875, 40125, 85525, 163300, 207350, 518400])/12)),
+                        "bracket_rates": (list, [0.1, 0.12, 0.22, 0.24, 0.32, 0.35, 0.37]),
+                        'citizens': (list, []),
+                        'citizens_agent_id': (list, []),
+                        'nominal_gdp': (list, []), # useless
+                        'real_gdp': (list, []),
+                        'unemployment': (list, []),
+                        'wages': (list, []),
+                        'prices': (list, [float(np.mean(agent_skills))]),
+                        "working_hours": (list, []),
+                        "depression": (list, []),
+                        "consumption_currency": (list, []),
+                        "income_currency": (list, []),
+                        "locus_control": (list, []),
+                        'inventory': (int, 0),
+                        'interest_rate': (float, 0.03),
+                        'price': (float, float(np.mean(agent_skills))),
+                        'employees': (list, []),
+                        'employees_agent_id': (list, []),
+                        'firm_id': (int, 0),}
+    return EXTRA_ATTRIBUTES, {'currency': 1e12}, {}
+
+def memory_config_bank():
+    EXTRA_ATTRIBUTES = {'type': (int, economyv2.ORG_TYPE_BANK),
+                        'interest_rate': (float, 0.03),
+                        'citizens': (list, []),
+                        'citizens_agent_id': (list, []),
+                        'bracket_cutoffs': (list, list(np.array([0, 9875, 40125, 85525, 163300, 207350, 518400])/12)), #useless
+                        "bracket_rates": (list, [0.1, 0.12, 0.22, 0.24, 0.32, 0.35, 0.37]),
+                        'inventory': (int, 0),
+                        'nominal_gdp': (list, []), # useless
+                        'real_gdp': (list, []),
+                        'unemployment': (list, []),
+                        'wages': (list, []),
+                        'prices': (list, [float(np.mean(agent_skills))]),
+                        "working_hours": (list, []),
+                        "depression": (list, []),
+                        "consumption_currency": (list, []),
+                        "income_currency": (list, []),
+                        "locus_control": (list, []),
+                        'price': (float, float(np.mean(agent_skills))),
+                        'employees': (list, []),
+                        'employees_agent_id': (list, []),
+                        'firm_id': (int, 0),}
+    return EXTRA_ATTRIBUTES, {'currency': 1e12}, {}
+
+def memory_config_nbs():
+    EXTRA_ATTRIBUTES = {'type': (int, economyv2.ORG_TYPE_NBS),
+                        'nominal_gdp': (list, []),
+                        'real_gdp': (list, []),
+                        'unemployment': (list, []),
+                        'wages': (list, []),
+                        'prices': (list, [float(np.mean(agent_skills))]),
+                        "working_hours": (list, []),
+                        "depression": (list, []),
+                        "consumption_currency": (list, []),
+                        "income_currency": (list, []),
+                        "locus_control": (list, []),
+                        'citizens': (list, []),
+                        'citizens_agent_id': (list, []),
+                        'firm_id': (int, 0),
+                        'bracket_cutoffs': (list, list(np.array([0, 9875, 40125, 85525, 163300, 207350, 518400])/12)), #useless
+                        "bracket_rates": (list, [0.1, 0.12, 0.22, 0.24, 0.32, 0.35, 0.37]),
+                        'inventory': (int, 0),
+                        'interest_rate': (float, 0.03),
+                        'price': (float, float(np.mean(agent_skills))),
+                        'employees': (list, []),
+                        'employees_agent_id': (list, []),}
+    return EXTRA_ATTRIBUTES, {}, {}