We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
[BUG - Develop] Global scripts are not being started, only restarted.
#### Describe the bug
When creating a new game, global scripts are not automatically started.

#### To Reproduce
Steps to reproduce the behavior:
1. Create a new game dir.
2. Create a script with `at_repeat` and add it to your server conf.
3. `evennia migrate` and `evennia start`
4. Check global scripts status.
5. See error

#### Expected behavior
Global scripts are supposed to start automatically.

#### Develop-branch commit
f093c8bcb

#### Additional context
I used the following dict in my settings:
```python
GLOBAL_SCRIPTS = {
                "test_script": {
                        "typeclass": "typeclasses.scripts.TestScript",
                        "persistent": True,
                        "interval": 20,
                        "desc": "Testing script starting and iteration."
                },

        }
```
And the following script class:
```python
class TestScript(Script):

    def at_repeat(self):
        print("hey, listen")
```

The script loaded correctly, and I was able to manually start it. After fully stopping and then starting the server, the script was automatically started again.

However, if I create a new game, start the server, and I _don't_ manually start the script, then fully stopping and then starting the server again does _not_ automatically start the script.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `evennia/utils/containers.py`
Content:
```
1 """
2 Containers
3 
4 Containers are storage classes usually initialized from a setting. They
5 represent Singletons and acts as a convenient place to find resources (
6 available as properties on the singleton)
7 
8 evennia.GLOBAL_SCRIPTS
9 evennia.OPTION_CLASSES
10 
11 """
12 
13 
14 from pickle import dumps
15 from django.conf import settings
16 from evennia.utils.utils import class_from_module, callables_from_module
17 from evennia.utils import logger
18 
19 
20 SCRIPTDB = None
21 
22 
23 class Container:
24     """
25     Base container class. A container is simply a storage object whose
26     properties can be acquired as a property on it. This is generally
27     considered a read-only affair.
28 
29     The container is initialized by a list of modules containing callables.
30 
31     """
32 
33     storage_modules = []
34 
35     def __init__(self):
36         """
37         Read data from module.
38 
39         """
40         self.loaded_data = None
41 
42     def load_data(self):
43         """
44         Delayed import to avoid eventual circular imports from inside
45         the storage modules.
46 
47         """
48         if self.loaded_data is None:
49             self.loaded_data = {}
50             for module in self.storage_modules:
51                 self.loaded_data.update(callables_from_module(module))
52 
53     def __getattr__(self, key):
54         return self.get(key)
55 
56     def get(self, key, default=None):
57         """
58         Retrive data by key (in case of not knowing it beforehand).
59 
60         Args:
61             key (str): The name of the script.
62             default (any, optional): Value to return if key is not found.
63 
64         Returns:
65             any (any): The data loaded on this container.
66 
67         """
68         self.load_data()
69         return self.loaded_data.get(key, default)
70 
71     def all(self):
72         """
73         Get all stored data
74 
75         Returns:
76             scripts (list): All global script objects stored on the container.
77 
78         """
79         self.load_data()
80         return list(self.loaded_data.values())
81 
82 
83 class OptionContainer(Container):
84     """
85     Loads and stores the final list of OPTION CLASSES.
86 
87     Can access these as properties or dictionary-contents.
88     """
89 
90     storage_modules = settings.OPTION_CLASS_MODULES
91 
92 
93 class GlobalScriptContainer(Container):
94     """
95     Simple Handler object loaded by the Evennia API to contain and manage a
96     game's Global Scripts. This will list global Scripts created on their own
97     but will also auto-(re)create scripts defined in `settings.GLOBAL_SCRIPTS`.
98 
99     Example:
100         import evennia
101         evennia.GLOBAL_SCRIPTS.scriptname
102 
103     Note:
104         This does not use much of the BaseContainer since it's not loading
105         callables from settings but a custom dict of tuples.
106 
107     """
108 
109     def __init__(self):
110         """
111         Note: We must delay loading of typeclasses since this module may get
112         initialized before Scripts are actually initialized.
113 
114         """
115         self.typeclass_storage = None
116         self.loaded_data = {
117             key: {} if data is None else data for key, data in settings.GLOBAL_SCRIPTS.items()
118         }
119 
120     def _get_scripts(self, key=None, default=None):
121         global SCRIPTDB
122         if not SCRIPTDB:
123             from evennia.scripts.models import ScriptDB as SCRIPTDB
124         if key:
125             try:
126                 return SCRIPTDB.objects.get(db_key__exact=key, db_obj__isnull=True)
127             except SCRIPTDB.DoesNotExist:
128                 return default
129         else:
130             return SCRIPTDB.objects.filter(db_obj__isnull=True)
131 
132     def _load_script(self, key):
133         self.load_data()
134 
135         typeclass = self.typeclass_storage[key]
136         script = typeclass.objects.filter(
137             db_key=key, db_account__isnull=True, db_obj__isnull=True
138         ).first()
139 
140         kwargs = {**self.loaded_data[key]}
141         kwargs["key"] = key
142         kwargs["persistent"] = kwargs.get("persistent", True)
143 
144         compare_hash = str(dumps(kwargs, protocol=4))
145 
146         if script:
147             script_hash = script.attributes.get("global_script_settings", category="settings_hash")
148             if script_hash is None:
149                 # legacy - store the hash anew and assume no change
150                 script.attributes.add(
151                     "global_script_settings", compare_hash, category="settings_hash"
152                 )
153             elif script_hash != compare_hash:
154                 # wipe the old version and create anew
155                 logger.log_info(f"GLOBAL_SCRIPTS: Settings changed for {key} ({typeclass}).")
156                 script.stop()
157                 script.delete()
158                 script = None
159 
160         if not script:
161             logger.log_info(f"GLOBAL_SCRIPTS: (Re)creating {key} ({typeclass}).")
162 
163             script, errors = typeclass.create(**kwargs)
164             if errors:
165                 logger.log_err("\n".join(errors))
166                 return None
167 
168             # store a hash representation of the setup
169             script.attributes.add("_global_script_settings", compare_hash, category="settings_hash")
170             script.start()
171 
172         return script
173 
174     def start(self):
175         """
176         Called last in evennia.__init__ to initialize the container late
177         (after script typeclasses have finished loading).
178 
179         We include all global scripts in the handler and
180         make sure to auto-load time-based scripts.
181 
182         """
183         # populate self.typeclass_storage
184         self.load_data()
185 
186         # start registered scripts
187         for key in self.loaded_data:
188             self._load_script(key)
189 
190     def load_data(self):
191         """
192         This delayed import avoids trying to load Scripts before they are
193         initialized.
194 
195         """
196         if self.typeclass_storage is None:
197             self.typeclass_storage = {}
198             for key, data in self.loaded_data.items():
199                 try:
200                     typeclass = data.get("typeclass", settings.BASE_SCRIPT_TYPECLASS)
201                     self.typeclass_storage[key] = class_from_module(typeclass)
202                 except Exception:
203                     logger.log_trace(
204                         f"GlobalScriptContainer could not start import global script {key}."
205                     )
206 
207     def get(self, key, default=None):
208         """
209         Retrive data by key (in case of not knowing it beforehand). Any
210         scripts that are in settings.GLOBAL_SCRIPTS that are not found
211         will be recreated on-demand.
212 
213         Args:
214             key (str): The name of the script.
215             default (any, optional): Value to return if key is not found
216                 at all on this container (i.e it cannot be loaded at all).
217 
218         Returns:
219             any (any): The data loaded on this container.
220         """
221         res = self._get_scripts(key)
222         if not res:
223             if key in self.loaded_data:
224                 # recreate if we have the info
225                 return self._load_script(key) or default
226             return default
227         return res
228 
229     def all(self):
230         """
231         Get all global scripts. Note that this will not auto-start
232         scripts defined in settings.
233 
234         Returns:
235             scripts (list): All global script objects stored on the container.
236 
237         """
238         self.typeclass_storage = None
239         self.load_data()
240         for key in self.loaded_data:
241             self._load_script(key)
242         return self._get_scripts(None)
243 
244 
245 # Create all singletons
246 
247 GLOBAL_SCRIPTS = GlobalScriptContainer()
248 OPTION_CLASSES = OptionContainer()
249
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/evennia/utils/containers.py b/evennia/utils/containers.py
--- a/evennia/utils/containers.py
+++ b/evennia/utils/containers.py
@@ -167,7 +167,7 @@
 
             # store a hash representation of the setup
             script.attributes.add("_global_script_settings", compare_hash, category="settings_hash")
-            script.start()
+        script.start()
 
         return script

{"golden_diff": "diff --git a/evennia/utils/containers.py b/evennia/utils/containers.py\n--- a/evennia/utils/containers.py\n+++ b/evennia/utils/containers.py\n@@ -167,7 +167,7 @@\n \n             # store a hash representation of the setup\n             script.attributes.add(\"_global_script_settings\", compare_hash, category=\"settings_hash\")\n-            script.start()\n+        script.start()\n \n         return script\n", "issue": "[BUG - Develop] Global scripts are not being started, only restarted.\n#### Describe the bug\r\nWhen creating a new game, global scripts are not automatically started.\r\n\r\n#### To Reproduce\r\nSteps to reproduce the behavior:\r\n1. Create a new game dir.\r\n2. Create a script with `at_repeat` and add it to your server conf.\r\n3. `evennia migrate` and `evennia start`\r\n4. Check global scripts status.\r\n5. See error\r\n\r\n#### Expected behavior\r\nGlobal scripts are supposed to start automatically.\r\n\r\n#### Develop-branch commit\r\nf093c8bcb\r\n\r\n#### Additional context\r\nI used the following dict in my settings:\r\n```python\r\nGLOBAL_SCRIPTS = {\r\n                \"test_script\": {\r\n                        \"typeclass\": \"typeclasses.scripts.TestScript\",\r\n                        \"persistent\": True,\r\n                        \"interval\": 20,\r\n                        \"desc\": \"Testing script starting and iteration.\"\r\n                },\r\n\r\n        }\r\n```\r\nAnd the following script class:\r\n```python\r\nclass TestScript(Script):\r\n\r\n    def at_repeat(self):\r\n        print(\"hey, listen\")\r\n```\r\n\r\nThe script loaded correctly, and I was able to manually start it. After fully stopping and then starting the server, the script was automatically started again.\r\n\r\nHowever, if I create a new game, start the server, and I _don't_ manually start the script, then fully stopping and then starting the server again does _not_ automatically start the script.\n", "before_files": [{"content": "\"\"\"\nContainers\n\nContainers are storage classes usually initialized from a setting. They\nrepresent Singletons and acts as a convenient place to find resources (\navailable as properties on the singleton)\n\nevennia.GLOBAL_SCRIPTS\nevennia.OPTION_CLASSES\n\n\"\"\"\n\n\nfrom pickle import dumps\nfrom django.conf import settings\nfrom evennia.utils.utils import class_from_module, callables_from_module\nfrom evennia.utils import logger\n\n\nSCRIPTDB = None\n\n\nclass Container:\n    \"\"\"\n    Base container class. A container is simply a storage object whose\n    properties can be acquired as a property on it. This is generally\n    considered a read-only affair.\n\n    The container is initialized by a list of modules containing callables.\n\n    \"\"\"\n\n    storage_modules = []\n\n    def __init__(self):\n        \"\"\"\n        Read data from module.\n\n        \"\"\"\n        self.loaded_data = None\n\n    def load_data(self):\n        \"\"\"\n        Delayed import to avoid eventual circular imports from inside\n        the storage modules.\n\n        \"\"\"\n        if self.loaded_data is None:\n            self.loaded_data = {}\n            for module in self.storage_modules:\n                self.loaded_data.update(callables_from_module(module))\n\n    def __getattr__(self, key):\n        return self.get(key)\n\n    def get(self, key, default=None):\n        \"\"\"\n        Retrive data by key (in case of not knowing it beforehand).\n\n        Args:\n            key (str): The name of the script.\n            default (any, optional): Value to return if key is not found.\n\n        Returns:\n            any (any): The data loaded on this container.\n\n        \"\"\"\n        self.load_data()\n        return self.loaded_data.get(key, default)\n\n    def all(self):\n        \"\"\"\n        Get all stored data\n\n        Returns:\n            scripts (list): All global script objects stored on the container.\n\n        \"\"\"\n        self.load_data()\n        return list(self.loaded_data.values())\n\n\nclass OptionContainer(Container):\n    \"\"\"\n    Loads and stores the final list of OPTION CLASSES.\n\n    Can access these as properties or dictionary-contents.\n    \"\"\"\n\n    storage_modules = settings.OPTION_CLASS_MODULES\n\n\nclass GlobalScriptContainer(Container):\n    \"\"\"\n    Simple Handler object loaded by the Evennia API to contain and manage a\n    game's Global Scripts. This will list global Scripts created on their own\n    but will also auto-(re)create scripts defined in `settings.GLOBAL_SCRIPTS`.\n\n    Example:\n        import evennia\n        evennia.GLOBAL_SCRIPTS.scriptname\n\n    Note:\n        This does not use much of the BaseContainer since it's not loading\n        callables from settings but a custom dict of tuples.\n\n    \"\"\"\n\n    def __init__(self):\n        \"\"\"\n        Note: We must delay loading of typeclasses since this module may get\n        initialized before Scripts are actually initialized.\n\n        \"\"\"\n        self.typeclass_storage = None\n        self.loaded_data = {\n            key: {} if data is None else data for key, data in settings.GLOBAL_SCRIPTS.items()\n        }\n\n    def _get_scripts(self, key=None, default=None):\n        global SCRIPTDB\n        if not SCRIPTDB:\n            from evennia.scripts.models import ScriptDB as SCRIPTDB\n        if key:\n            try:\n                return SCRIPTDB.objects.get(db_key__exact=key, db_obj__isnull=True)\n            except SCRIPTDB.DoesNotExist:\n                return default\n        else:\n            return SCRIPTDB.objects.filter(db_obj__isnull=True)\n\n    def _load_script(self, key):\n        self.load_data()\n\n        typeclass = self.typeclass_storage[key]\n        script = typeclass.objects.filter(\n            db_key=key, db_account__isnull=True, db_obj__isnull=True\n        ).first()\n\n        kwargs = {**self.loaded_data[key]}\n        kwargs[\"key\"] = key\n        kwargs[\"persistent\"] = kwargs.get(\"persistent\", True)\n\n        compare_hash = str(dumps(kwargs, protocol=4))\n\n        if script:\n            script_hash = script.attributes.get(\"global_script_settings\", category=\"settings_hash\")\n            if script_hash is None:\n                # legacy - store the hash anew and assume no change\n                script.attributes.add(\n                    \"global_script_settings\", compare_hash, category=\"settings_hash\"\n                )\n            elif script_hash != compare_hash:\n                # wipe the old version and create anew\n                logger.log_info(f\"GLOBAL_SCRIPTS: Settings changed for {key} ({typeclass}).\")\n                script.stop()\n                script.delete()\n                script = None\n\n        if not script:\n            logger.log_info(f\"GLOBAL_SCRIPTS: (Re)creating {key} ({typeclass}).\")\n\n            script, errors = typeclass.create(**kwargs)\n            if errors:\n                logger.log_err(\"\\n\".join(errors))\n                return None\n\n            # store a hash representation of the setup\n            script.attributes.add(\"_global_script_settings\", compare_hash, category=\"settings_hash\")\n            script.start()\n\n        return script\n\n    def start(self):\n        \"\"\"\n        Called last in evennia.__init__ to initialize the container late\n        (after script typeclasses have finished loading).\n\n        We include all global scripts in the handler and\n        make sure to auto-load time-based scripts.\n\n        \"\"\"\n        # populate self.typeclass_storage\n        self.load_data()\n\n        # start registered scripts\n        for key in self.loaded_data:\n            self._load_script(key)\n\n    def load_data(self):\n        \"\"\"\n        This delayed import avoids trying to load Scripts before they are\n        initialized.\n\n        \"\"\"\n        if self.typeclass_storage is None:\n            self.typeclass_storage = {}\n            for key, data in self.loaded_data.items():\n                try:\n                    typeclass = data.get(\"typeclass\", settings.BASE_SCRIPT_TYPECLASS)\n                    self.typeclass_storage[key] = class_from_module(typeclass)\n                except Exception:\n                    logger.log_trace(\n                        f\"GlobalScriptContainer could not start import global script {key}.\"\n                    )\n\n    def get(self, key, default=None):\n        \"\"\"\n        Retrive data by key (in case of not knowing it beforehand). Any\n        scripts that are in settings.GLOBAL_SCRIPTS that are not found\n        will be recreated on-demand.\n\n        Args:\n            key (str): The name of the script.\n            default (any, optional): Value to return if key is not found\n                at all on this container (i.e it cannot be loaded at all).\n\n        Returns:\n            any (any): The data loaded on this container.\n        \"\"\"\n        res = self._get_scripts(key)\n        if not res:\n            if key in self.loaded_data:\n                # recreate if we have the info\n                return self._load_script(key) or default\n            return default\n        return res\n\n    def all(self):\n        \"\"\"\n        Get all global scripts. Note that this will not auto-start\n        scripts defined in settings.\n\n        Returns:\n            scripts (list): All global script objects stored on the container.\n\n        \"\"\"\n        self.typeclass_storage = None\n        self.load_data()\n        for key in self.loaded_data:\n            self._load_script(key)\n        return self._get_scripts(None)\n\n\n# Create all singletons\n\nGLOBAL_SCRIPTS = GlobalScriptContainer()\nOPTION_CLASSES = OptionContainer()\n", "path": "evennia/utils/containers.py"}], "after_files": [{"content": "\"\"\"\nContainers\n\nContainers are storage classes usually initialized from a setting. They\nrepresent Singletons and acts as a convenient place to find resources (\navailable as properties on the singleton)\n\nevennia.GLOBAL_SCRIPTS\nevennia.OPTION_CLASSES\n\n\"\"\"\n\n\nfrom pickle import dumps\nfrom django.conf import settings\nfrom evennia.utils.utils import class_from_module, callables_from_module\nfrom evennia.utils import logger\n\n\nSCRIPTDB = None\n\n\nclass Container:\n    \"\"\"\n    Base container class. A container is simply a storage object whose\n    properties can be acquired as a property on it. This is generally\n    considered a read-only affair.\n\n    The container is initialized by a list of modules containing callables.\n\n    \"\"\"\n\n    storage_modules = []\n\n    def __init__(self):\n        \"\"\"\n        Read data from module.\n\n        \"\"\"\n        self.loaded_data = None\n\n    def load_data(self):\n        \"\"\"\n        Delayed import to avoid eventual circular imports from inside\n        the storage modules.\n\n        \"\"\"\n        if self.loaded_data is None:\n            self.loaded_data = {}\n            for module in self.storage_modules:\n                self.loaded_data.update(callables_from_module(module))\n\n    def __getattr__(self, key):\n        return self.get(key)\n\n    def get(self, key, default=None):\n        \"\"\"\n        Retrive data by key (in case of not knowing it beforehand).\n\n        Args:\n            key (str): The name of the script.\n            default (any, optional): Value to return if key is not found.\n\n        Returns:\n            any (any): The data loaded on this container.\n\n        \"\"\"\n        self.load_data()\n        return self.loaded_data.get(key, default)\n\n    def all(self):\n        \"\"\"\n        Get all stored data\n\n        Returns:\n            scripts (list): All global script objects stored on the container.\n\n        \"\"\"\n        self.load_data()\n        return list(self.loaded_data.values())\n\n\nclass OptionContainer(Container):\n    \"\"\"\n    Loads and stores the final list of OPTION CLASSES.\n\n    Can access these as properties or dictionary-contents.\n    \"\"\"\n\n    storage_modules = settings.OPTION_CLASS_MODULES\n\n\nclass GlobalScriptContainer(Container):\n    \"\"\"\n    Simple Handler object loaded by the Evennia API to contain and manage a\n    game's Global Scripts. This will list global Scripts created on their own\n    but will also auto-(re)create scripts defined in `settings.GLOBAL_SCRIPTS`.\n\n    Example:\n        import evennia\n        evennia.GLOBAL_SCRIPTS.scriptname\n\n    Note:\n        This does not use much of the BaseContainer since it's not loading\n        callables from settings but a custom dict of tuples.\n\n    \"\"\"\n\n    def __init__(self):\n        \"\"\"\n        Note: We must delay loading of typeclasses since this module may get\n        initialized before Scripts are actually initialized.\n\n        \"\"\"\n        self.typeclass_storage = None\n        self.loaded_data = {\n            key: {} if data is None else data for key, data in settings.GLOBAL_SCRIPTS.items()\n        }\n\n    def _get_scripts(self, key=None, default=None):\n        global SCRIPTDB\n        if not SCRIPTDB:\n            from evennia.scripts.models import ScriptDB as SCRIPTDB\n        if key:\n            try:\n                return SCRIPTDB.objects.get(db_key__exact=key, db_obj__isnull=True)\n            except SCRIPTDB.DoesNotExist:\n                return default\n        else:\n            return SCRIPTDB.objects.filter(db_obj__isnull=True)\n\n    def _load_script(self, key):\n        self.load_data()\n\n        typeclass = self.typeclass_storage[key]\n        script = typeclass.objects.filter(\n            db_key=key, db_account__isnull=True, db_obj__isnull=True\n        ).first()\n\n        kwargs = {**self.loaded_data[key]}\n        kwargs[\"key\"] = key\n        kwargs[\"persistent\"] = kwargs.get(\"persistent\", True)\n\n        compare_hash = str(dumps(kwargs, protocol=4))\n\n        if script:\n            script_hash = script.attributes.get(\"global_script_settings\", category=\"settings_hash\")\n            if script_hash is None:\n                # legacy - store the hash anew and assume no change\n                script.attributes.add(\n                    \"global_script_settings\", compare_hash, category=\"settings_hash\"\n                )\n            elif script_hash != compare_hash:\n                # wipe the old version and create anew\n                logger.log_info(f\"GLOBAL_SCRIPTS: Settings changed for {key} ({typeclass}).\")\n                script.stop()\n                script.delete()\n                script = None\n\n        if not script:\n            logger.log_info(f\"GLOBAL_SCRIPTS: (Re)creating {key} ({typeclass}).\")\n\n            script, errors = typeclass.create(**kwargs)\n            if errors:\n                logger.log_err(\"\\n\".join(errors))\n                return None\n\n            # store a hash representation of the setup\n            script.attributes.add(\"_global_script_settings\", compare_hash, category=\"settings_hash\")\n        script.start()\n\n        return script\n\n    def start(self):\n        \"\"\"\n        Called last in evennia.__init__ to initialize the container late\n        (after script typeclasses have finished loading).\n\n        We include all global scripts in the handler and\n        make sure to auto-load time-based scripts.\n\n        \"\"\"\n        # populate self.typeclass_storage\n        self.load_data()\n\n        # start registered scripts\n        for key in self.loaded_data:\n            self._load_script(key)\n\n    def load_data(self):\n        \"\"\"\n        This delayed import avoids trying to load Scripts before they are\n        initialized.\n\n        \"\"\"\n        if self.typeclass_storage is None:\n            self.typeclass_storage = {}\n            for key, data in self.loaded_data.items():\n                try:\n                    typeclass = data.get(\"typeclass\", settings.BASE_SCRIPT_TYPECLASS)\n                    self.typeclass_storage[key] = class_from_module(typeclass)\n                except Exception:\n                    logger.log_trace(\n                        f\"GlobalScriptContainer could not start import global script {key}.\"\n                    )\n\n    def get(self, key, default=None):\n        \"\"\"\n        Retrive data by key (in case of not knowing it beforehand). Any\n        scripts that are in settings.GLOBAL_SCRIPTS that are not found\n        will be recreated on-demand.\n\n        Args:\n            key (str): The name of the script.\n            default (any, optional): Value to return if key is not found\n                at all on this container (i.e it cannot be loaded at all).\n\n        Returns:\n            any (any): The data loaded on this container.\n        \"\"\"\n        res = self._get_scripts(key)\n        if not res:\n            if key in self.loaded_data:\n                # recreate if we have the info\n                return self._load_script(key) or default\n            return default\n        return res\n\n    def all(self):\n        \"\"\"\n        Get all global scripts. Note that this will not auto-start\n        scripts defined in settings.\n\n        Returns:\n            scripts (list): All global script objects stored on the container.\n\n        \"\"\"\n        self.typeclass_storage = None\n        self.load_data()\n        for key in self.loaded_data:\n            self._load_script(key)\n        return self._get_scripts(None)\n\n\n# Create all singletons\n\nGLOBAL_SCRIPTS = GlobalScriptContainer()\nOPTION_CLASSES = OptionContainer()\n", "path": "evennia/utils/containers.py"}]}