UIBridge.connect() - Code Metrics - Inspection of "[TESTING] Multigrid" - neovim/python-gui - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#36)

by Björn

created 2018-05-11 09:02 UTC

UIBridge.connect() B

↳ Parent: UIBridge

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
cc	4
c	5
b	0
f	0
dl	0
loc	25
rs	8.5806

"""Bridge for connecting a UI instance to nvim."""
import sys
import os
from threading import Semaphore, Thread
from traceback import format_exc
from inspect import signature


class UIBridge(object):

    """UIBridge class. Connects a Nvim instance to a UI class."""

    def connect(self, nvim, ui, profile=None, notify=False):
        """Connect nvim and the ui.

        This will start loops for handling the UI and nvim events while
        also synchronizing both.
        """
        self._notify = notify
class Foo:
    def __init__(self, x=None):
        self.x = x
        self._error = None
class Foo:
    def __init__(self, x=None):
        self.x = x
        self._nvim = nvim
class Foo:
    def __init__(self, x=None):
        self.x = x
        self._ui = ui
class Foo:
    def __init__(self, x=None):
        self.x = x
        self._profile = profile
class Foo:
    def __init__(self, x=None):
        self.x = x
        self._sem = Semaphore(0)
class Foo:
    def __init__(self, x=None):
        self.x = x
        debug_env = os.environ.get("NVIM_PYTHON_UI_DEBUG", "")
        if debug_env == "2":
            self.debug_events = 2
class Foo:
    def __init__(self, x=None):
        self.x = x
        else:
            self.debug_events = len(debug_env) > 0
class Foo:
    def __init__(self, x=None):
        self.x = x
        t = Thread(target=self._nvim_event_loop)
        t.daemon = True
        t.start()
        self._ui_event_loop()
        if self._error:
            print(self._error)
        if self._profile:
            print(self._profile)

    def exit(self):
        """Disconnect by exiting nvim."""
        self.detach()
        self._call(self._nvim.quit)

    def input(self, input_str):
        """Send input to nvim."""
        self._call(self._nvim.input, input_str)

    def resize(self, grid, columns, rows):
        """Send a resize request to nvim."""
        if 'ext_float' in self._nvim.metadata['ui_options']:
            self._call(self._nvim.api.ui_grid_try_resize, grid, columns, rows)
        else:
            self._call(self._nvim.api.ui_try_resize, columns, rows)

    def attach(self, columns, rows, **options):
        """Attach the UI to nvim."""
        self._call(self._nvim.api.ui_attach, columns, rows, options)

    def detach(self):
        """Detach the UI from nvim."""
        self._call(self._nvim.ui_detach)

    def _call(self, fn, *args):
        self._nvim.async_call(fn, *args)

    def _ui_event_loop(self):
        self._sem.acquire()
        if self._profile:
            import StringIO
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
            import cProfile
            import pstats
            pr = cProfile.Profile()
            pr.enable()
        self._ui.start(self)
        if self._profile:
            pr.disable()
            s = StringIO.StringIO()
            ps = pstats.Stats(pr, stream=s)
            ps.strip_dirs().sort_stats(self._profile).print_stats(30)
            self._profile = s.getvalue()
class Foo:
    def __init__(self, x=None):
        self.x = x

    def _nvim_event_loop(self):
        def on_setup():
            self._sem.release()

        def on_request(method, args):

            raise Exception('Not implemented')

        def on_notification(method, updates):
            def apply_updates():
                if self._notify:
                    sys.stdout.write('attached\n')
                    sys.stdout.flush()
                    self._notify = False
class Foo:
    def __init__(self, x=None):
        self.x = x
                try:
                    for update in updates:
                        # import sys
                        # l = [','.join([str(a) for a in args])
                        #      for args in update[1:]]
                        # print >> sys.stderr, update[0], ' '.join(l)
                        try:
                            handler = getattr(self._ui, '_nvim_' + update[0])
                            nparam = len(signature(handler).parameters)


                        except AttributeError:
                            if self.debug_events:
                                print(self._ui._curgrid, end=' ', file=sys.stderr)
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
                                print(repr(update), file=sys.stderr)
                        else:
                            if self.debug_events == 2 or (self.debug_events and len(update[1]) > nparam):
                                print(repr(update), file=sys.stderr)
                            for args in update[1:]:
                                handler(*args[:nparam])
                    if self.debug_events == 2:
                        print("<flush>")
                except Exception:

                    self._error = format_exc()
class Foo:
    def __init__(self, x=None):
        self.x = x
                    self._call(self._nvim.quit)
            if method == 'redraw':
                self._ui.schedule_screen_update(apply_updates)

        self._nvim.run_loop(on_request, on_notification, on_setup)
        self._ui.quit()


1			"""Bridge for connecting a UI instance to nvim."""
2			import sys
3			import os
4			from threading import Semaphore, Thread
5			from traceback import format_exc
6			from inspect import signature
7
8
9			class UIBridge(object):
10
11			"""UIBridge class. Connects a Nvim instance to a UI class."""
12
13			def connect(self, nvim, ui, profile=None, notify=False):
14			"""Connect nvim and the ui.
15
16			This will start loops for handling the UI and nvim events while
17			also synchronizing both.
18			"""
19			self._notify = notify
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_notify` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
20			self._error = None
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_error` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
21			self._nvim = nvim
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_nvim` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
22			self._ui = ui
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_ui` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
23			self._profile = profile
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_profile` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
24			self._sem = Semaphore(0)
			0 ignored issues – show Coding Style introduced 2017-11-03 09:02 UTC by Report Bug Copy Issue Report The attribute `_sem` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
25			debug_env = os.environ.get("NVIM_PYTHON_UI_DEBUG", "")
26			if debug_env == "2":
27			self.debug_events = 2
			0 ignored issues – show Coding Style introduced 2018-05-11 09:03 UTC by Report Bug Copy Issue Report The attribute `debug_events` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
28			else:
29			self.debug_events = len(debug_env) > 0
			0 ignored issues – show Coding Style introduced 2018-05-11 09:03 UTC by Report Bug Copy Issue Report The attribute `debug_events` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
30			t = Thread(target=self._nvim_event_loop)
31			t.daemon = True
32			t.start()
33			self._ui_event_loop()
34			if self._error:
35			print(self._error)
36			if self._profile:
37			print(self._profile)
38
39			def exit(self):
40			"""Disconnect by exiting nvim."""
41			self.detach()
42			self._call(self._nvim.quit)
43
44			def input(self, input_str):
45			"""Send input to nvim."""
46			self._call(self._nvim.input, input_str)
47
48			def resize(self, grid, columns, rows):
49			"""Send a resize request to nvim."""
50			if 'ext_float' in self._nvim.metadata['ui_options']:
51			self._call(self._nvim.api.ui_grid_try_resize, grid, columns, rows)
52			else:
53			self._call(self._nvim.api.ui_try_resize, columns, rows)
54
55			def attach(self, columns, rows, **options):
56			"""Attach the UI to nvim."""
57			self._call(self._nvim.api.ui_attach, columns, rows, options)
58
59			def detach(self):
60			"""Detach the UI from nvim."""
61			self._call(self._nvim.ui_detach)
62
63			def _call(self, fn, *args):
64			self._nvim.async_call(fn, *args)
65
66			def _ui_event_loop(self):
67			self._sem.acquire()
68			if self._profile:
69			import StringIO
			0 ignored issues – show Configuration introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The import `StringIO` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
70			import cProfile
71			import pstats
72			pr = cProfile.Profile()
73			pr.enable()
74			self._ui.start(self)
75			if self._profile:
76			pr.disable()
77			s = StringIO.StringIO()
78			ps = pstats.Stats(pr, stream=s)
79			ps.strip_dirs().sort_stats(self._profile).print_stats(30)
80			self._profile = s.getvalue()
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_profile` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
81
82			def _nvim_event_loop(self):
83			def on_setup():
84			self._sem.release()
85
86			def on_request(method, args):
			0 ignored issues – show Unused Code introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The argument `method` seems to be unused. Loading history... Unused Code introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The argument `args` seems to be unused. Loading history...
87			raise Exception('Not implemented')
88
89			def on_notification(method, updates):
90			def apply_updates():
91			if self._notify:
92			sys.stdout.write('attached\n')
93			sys.stdout.flush()
94			self._notify = False
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_notify` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
95			try:
96			for update in updates:
97			# import sys
98			# l = [','.join([str(a) for a in args])
99			# for args in update[1:]]
100			# print >> sys.stderr, update[0], ' '.join(l)
101			try:
102			handler = getattr(self._ui, '_nvim_' + update[0])
103			nparam = len(signature(handler).parameters)
104
105
106			except AttributeError:
107			if self.debug_events:
108			print(self._ui._curgrid, end=' ', file=sys.stderr)
			0 ignored issues – show Coding Style Best Practice introduced 2018-01-07 22:02 UTC by Report Bug Copy Issue Report It seems like `_curgrid` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
109			print(repr(update), file=sys.stderr)
110			else:
111			if self.debug_events == 2 or (self.debug_events and len(update[1]) > nparam):
112			print(repr(update), file=sys.stderr)
113			for args in update[1:]:
114			handler(*args[:nparam])
115			if self.debug_events == 2:
116			print("<flush>")
117			except Exception:
			0 ignored issues – show Best Practice introduced 2018-05-11 09:03 UTC by Report Bug Copy Issue Report Catching very general exceptions such as `Exception` is usually not recommended. Generally, you would want to handle very specific errors in the exception handler. This ensure that you do not hide other types of errors which should be fixed. So, unless you specifically plan to handle any error, consider adding a more specific exception. Loading history...
118			self._error = format_exc()
			0 ignored issues – show Coding Style introduced 2016-02-28 11:36 UTC by Report Bug Copy Issue Report The attribute `_error` was defined outside `__init__`. It is generally a good practice to initialize all attributes to default values in the `__init__` method: class Foo: def __init__(self, x=None): self.x = x Loading history...
119			self._call(self._nvim.quit)
120			if method == 'redraw':
121			self._ui.schedule_screen_update(apply_updates)
122
123			self._nvim.run_loop(on_request, on_notification, on_setup)
124			self._ui.quit()
125

neovim / python-gui

Pull Request — master (#36)

UIBridge.connect() B

Complexity

Size

Duplication

Importance

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

2. Missing init.py files