Fix examine using wrong cmdset target for accounts. Resolve #1886

evennia/commands/cmdsethandler.py

@@ -180,7 +180,7 @@ def import_cmdset(path, cmdsetobj, emit_to_obj=None, no_logging=False):
                 except ImportError as exc:
                     if len(trace()) > 2:
                         # error in module, make sure to not hide it.
-                        _, _, tb = sys.exc_info()
+                        dum, dum, tb = sys.exc_info()
                         raise exc.with_traceback(tb)
                     else:
                         # try next suggested path
@@ -191,7 +191,7 @@ def import_cmdset(path, cmdsetobj, emit_to_obj=None, no_logging=False):
                 except AttributeError as exc:
                     if len(trace()) > 2:
                         # Attribute error within module, don't hide it
-                        _, _, tb = sys.exc_info()
+                        dum, dum, tb = sys.exc_info()
                         raise exc.with_traceback(tb)
                     else:
                         errstring += _("\n(Unsuccessfully tried '%s')." % python_path)

evennia/commands/default/building.py

@@ -1596,7 +1596,7 @@ class CmdSetAttribute(ObjManipCommand):
     or |c{ |n.
 
     Once you have stored a Python primitive as noted above, you can include
-    |c[<key>]|n in <attr> to reference nested values in e.g. a list or dict. 
+    |c[<key>]|n in <attr> to reference nested values in e.g. a list or dict.
 
     Remember that if you use Python primitives like this, you must
     write proper Python syntax too - notably you must include quotes
@@ -2352,7 +2352,6 @@ class CmdExamine(ObjManipCommand):
 
         returns a string.
         """
-
         string = "\n|wName/key|n: |c%s|n (%s)" % (obj.name, obj.dbref)
         if hasattr(obj, "aliases") and obj.aliases.all():
             string += "\n|wAliases|n: %s" % (", ".join(utils.make_iter(str(obj.aliases))))
@@ -2534,9 +2533,11 @@ class CmdExamine(ObjManipCommand):
                     # If we don't have special info access, just look at the object instead.
                     self.msg(caller.at_look(obj))
                     return
+                obj_session = obj.sessions.get()[0] if obj.sessions.count() else None
+
                 # using callback for printing result whenever function returns.
                 get_and_merge_cmdsets(
-                    obj, self.session, self.account, obj, "object", self.raw_string
+                    obj, obj_session, self.account, obj, "object", self.raw_string
                 ).addCallback(get_cmdset_callback)
             else:
                 self.msg("You need to supply a target to examine.")
@@ -2578,15 +2579,25 @@ class CmdExamine(ObjManipCommand):
                     # we are only interested in specific attributes
                     caller.msg(self.format_attributes(obj, attrname, crop=False))
             else:
+                session = obj.sessions.get()[0]
                 if obj.sessions.count():
                     mergemode = "session"
                 elif self.account_mode:
                     mergemode = "account"
                 else:
                     mergemode = "object"
+
+                account = None
+                objct = None
+                if self.account_mode:
+                    account = obj
+                else:
+                    account = obj.account
+                    objct = obj
+
                 # using callback to print results whenever function returns.
                 get_and_merge_cmdsets(
-                    obj, self.session, self.account, obj, mergemode, self.raw_string
+                    obj, session, account, objct, mergemode, self.raw_string
                 ).addCallback(get_cmdset_callback)
 
 

evennia/contrib/evscaperoom/states/README.md

@@ -15,7 +15,7 @@ system but they don't necessarily need to follow each other in the exact
 sequence.
 
 Each state module must make a class `State` available in the global scope. This
-should be a child of `evennia.contribs.evscaperoom.state.BaseState`. The
+should be a child of `evennia.contrib.evscaperoom.state.BaseState`. The
 methods on this class will be called to initialize the state and clean up etc.
 There are no other restrictions on the module.
 

evennia/settings_default.py

@@ -417,7 +417,7 @@ CMDSET_CHARACTER = "commands.default_cmdsets.CharacterCmdSet"
 # Command set for accounts without a character (ooc)
 CMDSET_ACCOUNT = "commands.default_cmdsets.AccountCmdSet"
 # Location to search for cmdsets if full path not given
-CMDSET_PATHS = ["commands", "evennia", "contribs"]
+CMDSET_PATHS = ["commands", "evennia", "evennia.contrib"]
 # Fallbacks for cmdset paths that fail to load. Note that if you change the path for your
 # default cmdsets, you will also need to copy CMDSET_FALLBACKS after your change in your
 # settings file for it to detect the change.

evennia/utils/batchprocessors.py

@@ -233,7 +233,7 @@ def read_batchfile(pythonpath, file_ending=".py"):
                 continue
             break
     if not text and decoderr:
-        raise UnicodeDecodeError("\n".join(decoderr), bytearray(), 0, 0, '')
+        raise UnicodeDecodeError("\n".join(decoderr), bytearray(), 0, 0, "")
 
     return text
 

evennia/utils/tests/test_batchprocessors.py

@@ -8,26 +8,24 @@ import textwrap
 
 
 class TestBatchprocessorErrors(TestCase):
-
+    @mock.patch.object(utils, "pypath_to_realpath", return_value=[])
-    @mock.patch.object(utils, 'pypath_to_realpath', return_value=[])
     def test_read_batchfile_raises_IOError(self, _):
         with self.assertRaises(IOError):
-            batchprocessors.read_batchfile('foopath')
+            batchprocessors.read_batchfile("foopath")
 
-    @mock.patch.object(utils, 'pypath_to_realpath', return_value=['pathfoo'])
+    @mock.patch.object(utils, "pypath_to_realpath", return_value=["pathfoo"])
-    @mock.patch.object(codecs, 'open', side_effect=ValueError('decodeerr'))
+    @mock.patch.object(codecs, "open", side_effect=ValueError("decodeerr"))
-    @mock.patch.object(batchprocessors, '_ENCODINGS', ['fooencoding'])
+    @mock.patch.object(batchprocessors, "_ENCODINGS", ["fooencoding"])
     def test_read_batchfile_raises_UnicodeDecodeError(self, *_):
-        with self.assertRaises(UnicodeDecodeError, msg='decodeerr'):
+        with self.assertRaises(UnicodeDecodeError, msg="decodeerr"):
-            batchprocessors.read_batchfile('foopath')
+            batchprocessors.read_batchfile("foopath")
 
 
 class TestBatchCommandProcessor(TestCase):
-
+    @mock.patch.object(batchprocessors, "read_batchfile")
-    @mock.patch.object(batchprocessors, 'read_batchfile')
     def test_parses_2_commands(self, mocked_read):
         mocked_read.return_value = textwrap.dedent(
-        r"""
+            r"""
         @create rock
         #
 
@@ -35,93 +33,102 @@ class TestBatchCommandProcessor(TestCase):
         A big rock. You can tell is ancient.
         #
 
-        """)
+        """
-        commands = batchprocessors.BATCHCMD.parse_file('foopath')
+        )
-        self.assertEqual([
+        commands = batchprocessors.BATCHCMD.parse_file("foopath")
-            '@create rock', '@set rock/desc =\nA big rock. You can tell is ancient.'],
+        self.assertEqual(
-            commands)
+            ["@create rock", "@set rock/desc =\nA big rock. You can tell is ancient."], commands
+        )
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_INSERT(self, mocked_read):
         mocked_read.side_effect = [
-        textwrap.dedent(r"""
+            textwrap.dedent(
+                r"""
             @create sky
             #
             #INSERT another.ev
             #
             @create sun
             #
-            """),
+            """
-        textwrap.dedent(r"""
+            ),
+            textwrap.dedent(
+                r"""
             @create bird
             #
             @create cloud
             #
-            """)
+            """
+            ),
         ]
-        commands = batchprocessors.BATCHCMD.parse_file('foopath')
+        commands = batchprocessors.BATCHCMD.parse_file("foopath")
+        self.assertEqual(commands, ["@create sky", "@create bird", "@create cloud", "@create sun"])
         self.assertEqual(
-            commands,
+            mocked_read.mock_calls,
-            ['@create sky', '@create bird', '@create cloud', '@create sun'])
+            [mock.call("foopath", file_ending=".ev"), mock.call("another.ev", file_ending=".ev")],
-        self.assertEqual(mocked_read.mock_calls, [
+        )
-            mock.call('foopath', file_ending='.ev'),
-            mock.call('another.ev', file_ending='.ev')])
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_INSERT_raises_IOError(self, mocked_read):
         mocked_read.side_effect = [
-        textwrap.dedent(r"""
+            textwrap.dedent(
+                r"""
             @create sky
             #
             #INSERT x
             #
             @create sun
             #
-            """),
+            """
-            IOError
+            ),
+            IOError,
         ]
-        with self.assertRaises(IOError, msg='#INSERT x failed.'):
+        with self.assertRaises(IOError, msg="#INSERT x failed."):
-            batchprocessors.BATCHCMD.parse_file('foopath')
+            batchprocessors.BATCHCMD.parse_file("foopath")
-        self.assertEqual(mocked_read.mock_calls, [
+        self.assertEqual(
-            mock.call('foopath', file_ending='.ev'),
+            mocked_read.mock_calls,
-            mock.call('x', file_ending='.ev')])
+            [mock.call("foopath", file_ending=".ev"), mock.call("x", file_ending=".ev")],
+        )
 
 
 class TestBatchCodeProcessor(TestCase):
-
+    @mock.patch.object(batchprocessors, "read_batchfile")
-    @mock.patch.object(batchprocessors, 'read_batchfile')
     def test_parses_one_codeblock(self, mocked_read):
         mocked_read.return_value = textwrap.dedent(
-        r"""
+            r"""
         print("Hello")
-        """)
+        """
-        commands = batchprocessors.BATCHCODE.parse_file('foopath')
+        )
-        self.assertEqual([
+        commands = batchprocessors.BATCHCODE.parse_file("foopath")
-            '# batchcode code:\n\nprint("Hello")\n'],
+        self.assertEqual(['# batchcode code:\n\nprint("Hello")\n'], commands)
-            commands)
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_codeblocks(self, mocked_read):
         mocked_read.return_value = textwrap.dedent(
-        r"""
+            r"""
         #CODE
         print("Hello")
         #CODE
         a = 1
         b = [1,
         2, 3]
-        """)
+        """
-        commands = batchprocessors.BATCHCODE.parse_file('foopath')
+        )
-        self.assertEqual([
+        commands = batchprocessors.BATCHCODE.parse_file("foopath")
-            '# batchcode code:\n\n',
+        self.assertEqual(
-            '# batchcode code:\n\nprint("Hello")\n',
+            [
-            '# batchcode code:\n\na = 1\nb = [1,\n2, 3]\n'],
+                "# batchcode code:\n\n",
-            commands)
+                '# batchcode code:\n\nprint("Hello")\n',
+                "# batchcode code:\n\na = 1\nb = [1,\n2, 3]\n",
+            ],
+            commands,
+        )
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_header_and_two_codeblock(self, mocked_read):
         mocked_read.return_value = textwrap.dedent(
-        r"""
+            r"""
         #HEADER
         a = 100
         #CODE
@@ -129,71 +136,86 @@ class TestBatchCodeProcessor(TestCase):
         #CODE
         a += 100
         a == 100
-        """)
+        """
-        commands = batchprocessors.BATCHCODE.parse_file('foopath')
+        )
-        self.assertEqual([
+        commands = batchprocessors.BATCHCODE.parse_file("foopath")
-            '# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\n',
+        self.assertEqual(
-            '# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\na += 100\n',
+            [
-            '# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\na += 100\na == 100\n'],
+                "# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\n",
-            commands)
+                "# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\na += 100\n",
+                "# batchcode header:\n\na = 100\n\n\n# batchcode code:\n\na += 100\na == 100\n",
+            ],
+            commands,
+        )
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_INSERT(self, mocked_read):
         mocked_read.side_effect = [
-        textwrap.dedent(r"""
+            textwrap.dedent(
+                r"""
             a = 1
             #INSERT another.py
-            """),
+            """
-        textwrap.dedent(r"""
+            ),
+            textwrap.dedent(
+                r"""
             print("Hello")
-            """)
+            """
+            ),
         ]
-        commands = batchprocessors.BATCHCODE.parse_file('foopath')
+        commands = batchprocessors.BATCHCODE.parse_file("foopath")
         self.assertEqual(
-            commands, [
+            commands,
-            '# batchcode code:\n'
+            [
-            '\n'
+                "# batchcode code:\n"
-            'a = 1\n'
+                "\n"
-            '# batchcode insert (another.py):# batchcode code:\n'
+                "a = 1\n"
-            '\n'
+                "# batchcode insert (another.py):# batchcode code:\n"
-            'print("Hello")\n'
+                "\n"
-            '\n'])
+                'print("Hello")\n'
-        self.assertEqual(mocked_read.mock_calls, [
+                "\n"
-            mock.call('foopath', file_ending='.py'),
+            ],
-            mock.call('another.py', file_ending='.py')])
+        )
+        self.assertEqual(
+            mocked_read.mock_calls,
+            [mock.call("foopath", file_ending=".py"), mock.call("another.py", file_ending=".py")],
+        )
 
-    @mock.patch.object(batchprocessors, 'read_batchfile')
+    @mock.patch.object(batchprocessors, "read_batchfile")
     def test_parses_INSERT_raises_IOError(self, mocked_read):
         mocked_read.side_effect = [
-        textwrap.dedent(r"""
+            textwrap.dedent(
+                r"""
             #INSERT x
-            """),
+            """
-            IOError
+            ),
+            IOError,
         ]
-        with self.assertRaises(IOError, msg='#INSERT x failed.'):
+        with self.assertRaises(IOError, msg="#INSERT x failed."):
-            batchprocessors.BATCHCODE.parse_file('foopath')
+            batchprocessors.BATCHCODE.parse_file("foopath")
-        self.assertEqual(mocked_read.mock_calls, [
+        self.assertEqual(
-            mock.call('foopath', file_ending='.py'),
+            mocked_read.mock_calls,
-            mock.call('x', file_ending='.py')])
+            [mock.call("foopath", file_ending=".py"), mock.call("x", file_ending=".py")],
+        )
 
-    @mock.patch('builtins.exec')
+    @mock.patch("builtins.exec")
     def test_execs_codeblock(self, mocked_exec):
         err = batchprocessors.BATCHCODE.code_exec(
-            '# batchcode code:\n\nprint("Hello")\n',
+            '# batchcode code:\n\nprint("Hello")\n', extra_environ={}
-            extra_environ={})
+        )
         self.assertIsNone(err)
 
-    @mock.patch('builtins.exec')
+    @mock.patch("builtins.exec")
     def test_execs_codeblock_with_extra_environ(self, mocked_exec):
         err = batchprocessors.BATCHCODE.code_exec(
-            '# batchcode code:\n\nprint("Hello")\n',
+            '# batchcode code:\n\nprint("Hello")\n', extra_environ={"foo": "bar", "baz": True}
-            extra_environ={'foo': 'bar', 'baz': True})
+        )
         self.assertIsNone(err)
 
-    @mock.patch('builtins.exec')
+    @mock.patch("builtins.exec")
     def test_execs_codeblock_raises(self, mocked_exec):
         mocked_exec.side_effect = Exception
         err = batchprocessors.BATCHCODE.code_exec(
-            '# batchcode code:\n\nprint("Hello")\nprint("Evennia")',
+            '# batchcode code:\n\nprint("Hello")\nprint("Evennia")', extra_environ={}
-            extra_environ={})
+        )
         self.assertIsNotNone(err)