EventGhost/EventGhost

View on GitHub
plugins/SchedulGhost/__init__.py

Summary

Maintainability
F
3 mos
Test Coverage

File __init__.py has 3199 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- coding: utf-8 -*-

version="0.1.19"

# plugins/SchedulGhost/__init__.py
Severity: Major
Found in plugins/SchedulGhost/__init__.py - About 1 wk to fix

    Function NextRun has a Cognitive Complexity of 439 (exceeds 5 allowed). Consider refactoring.
    Open

        def NextRun(self, type, data):
    
            def FindRunDateTime(runList, cond, cond2):
                runList.sort()
                runDateTime = ""
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py - About 1 wk to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function __init__ has a Cognitive Complexity of 351 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(self, text, plugin):
            wx.Dialog.__init__(
                self,
                None,
                -1,
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py - About 1 wk to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Cyclomatic complexity is too high in method NextRun. (129)
    Open

    
        def NextRun(self, type, data):
    
            def FindRunDateTime(runList, cond, cond2):
                runList.sort()
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function Configure has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
    Open

        def Configure(self, args = [
            "00:03:00",
            "SchedulGhost",
            None,
            "",
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py - About 4 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function xmlToData has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

        def xmlToData(self):
            data = []
            xmlfile = self.xmlpath
            xmldoc = miniDom.parse(xmlfile)
            document = xmldoc.getElementsByTagName('Document')[0]
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py - About 4 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function Configure has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
    Open

        def Configure(
            self,
            xmlpath = "",
            logfile = "",
            prefix = "SchedulGhost",
    Severity: Minor
    Found in plugins/SchedulGhost/__init__.py - About 4 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function __init__ has 101 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        def __init__(self, text, plugin):
            wx.Dialog.__init__(
                self,
                None,
                -1,
    Severity: Major
    Found in plugins/SchedulGhost/__init__.py - About 4 hrs to fix

      Function Configure has 97 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          def Configure(self, args = [
              "00:03:00",
              "SchedulGhost",
              None,
              "",
      Severity: Major
      Found in plugins/SchedulGhost/__init__.py - About 3 hrs to fix

        Function __init__ has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
        Open

            def __init__(self, text, plugin):
                self.plugin = plugin
                wx.Frame.__init__(
                    self,
                    None,
        Severity: Minor
        Found in plugins/SchedulGhost/__init__.py - About 3 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function UpdateEGscheduler has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
        Open

            def UpdateEGscheduler(self):
                data = self.data
                tmpList = []
                sched_list = eg.scheduler.__dict__['heap']
                for sched in sched_list:
        Severity: Minor
        Found in plugins/SchedulGhost/__init__.py - About 3 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function ShowHolidaysFrame has 68 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            def ShowHolidaysFrame(self):
                text = self.plugin.text
                self.SetTitle(self.plugin.text.holidButton_1+" "+self.plugin.text.holidButton_2)
                self.fixWin = CalendarPopup(self, False, self.plugin.first_day)
                self.varWin = CalendarPopup(self, True, self.plugin.first_day)
        Severity: Major
        Found in plugins/SchedulGhost/__init__.py - About 2 hrs to fix

          Function Configure has 57 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              def Configure(
                  self,
                  xmlpath = "",
                  logfile = "",
                  prefix = "SchedulGhost",
          Severity: Major
          Found in plugins/SchedulGhost/__init__.py - About 2 hrs to fix

            Function __init__ has 43 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                def __init__(self, text, plugin, args):
                    self.plugin = plugin
                    wx.Frame.__init__(
                        self,
                        None,
            Severity: Minor
            Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

              Function OnChangeMonth has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
              Open

                  def OnChangeMonth(self, evt = None):
                      date = self.cal.GetDate()
                      cur_month = date.GetMonth() + 1   # convert wx.DateTime 0-11 => 1-12
                      if self.yearChange:
                          cur_year = date.GetYear()
              Severity: Minor
              Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function __init__ has 35 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  def __init__(self, text, plugin):
                      self.plugin = plugin
                      wx.Frame.__init__(
                          self,
                          None,
              Severity: Minor
              Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Function dataToXml has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                Open

                    def dataToXml(self):
                        data = self.data
                        impl = miniDom.getDOMImplementation()
                        dom = impl.createDocument(None, u'Document', None)
                        root = dom.documentElement
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function Execute has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                Open

                    def Execute(self, params, stopEvent, ticks, immed = False):
                        if not stopEvent:
                            span = params[3][1]
                            if span != "00:00:00":
                                stopTicks = ticks + int(span[6:]) + 60 * int(span[3:5]) + 3600 * int(span[:2])
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function __call__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                Open

                    def __call__(self, expr = ""):
                        schedule = eg.ParseString(expr)
                        schedule = eval(schedule)
                        if len(schedule) == 9 and isinstance(schedule[1], unicode):
                            data = self.plugin.data
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function __call__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                Open

                    def __call__(self, schedule="", update=False):
                        schedule = eg.ParseString(schedule)
                        data = self.plugin.data
                        tmpLst = [item[1] for item in data]
                        if schedule in tmpLst:
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function AbortEggTimers has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                Open

                    def AbortEggTimers(self, eggName = None):
                        egg_list = eg.scheduler.__dict__['heap']
                        tmpLst = []
                        for egg in egg_list:
                            if egg[1] == self.SchedulGhost_EggFunction:
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 1 hr to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function __stop__ has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                Open

                    def __stop__(self):
                        sched_list = eg.scheduler.__dict__['heap']
                        tmpLst = []
                        self.updateLogFile(self.text.stop, True)
                        for sched in sched_list:
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 55 mins to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function Reset has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                Open

                    def Reset(self, list):
                        tmpList = []
                        for item in list:
                            day = item[-1]
                            day = "  %i" % day if day < 10 else "%i" % day
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 55 mins to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Function SchedulGhostScheduleRun has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                Open

                    def SchedulGhostScheduleRun(self, schedule, stopEvent, ticks = 0):
                        data = self.data
                        ix = [item[1] for item in data].index(schedule)
                        next = self.Execute(data[ix], stopEvent, ticks)
                        if stopEvent:
                Severity: Minor
                Found in plugins/SchedulGhost/__init__.py - About 55 mins to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Avoid deeply nested control flow statements.
                Open

                                        if data[6]:
                                            found2=False
                                            delta += 1
                                            tmpRunDT2 = runDateTime + td(days = delta)
                                            if (tmpRunDT2.month, tmpRunDT2.day) in self.holidays[0]:
                Severity: Major
                Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                          if (tmpRunDT2.month, tmpRunDT2.day) in self.holidays[0]:
                                              break
                                          elif (tmpRunDT2.year, tmpRunDT2.month, tmpRunDT2.day) in self.holidays[1]:
                                              break
                                      delta+=1
                  Severity: Major
                  Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                            if (tmpRunDT.month, tmpRunDT.day) in self.holidays[0]:
                                                break
                                            elif (tmpRunDT.year, tmpRunDT.month, tmpRunDT.day) in self.holidays[1]:
                                                break
                                        if data[5]:
                    Severity: Major
                    Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                              if data[6]:
                                                  found2=False
                                                  delta += 1
                                                  tmpRunDT2 = runDateTime + td(days = delta)
                                                  if (tmpRunDT2.month, tmpRunDT2.day) in self.holidays[0]:
                      Severity: Major
                      Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                                if 2 ** ix & data[2]:
                                                    for weekday in range(7):
                                                        if 2 ** weekday & data[3]:
                                                            day=FindMonthDay(year, month, weekday, ix)
                                                            if day:
                        Severity: Major
                        Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                                  if found1 and found2:
                                                      found = True
                                                      break
                                              if found:
                          Severity: Major
                          Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                            Avoid deeply nested control flow statements.
                            Open

                                                    for day in days:
                                                        if day > monthrange(nextYear, month)[1]:
                                                            break
                                                        runDateTime = dt.combine(dt(nextYear, month, day).date(), runTime)
                                                        runList.append(runDateTime)
                            Severity: Major
                            Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                              Avoid deeply nested control flow statements.
                              Open

                                                      if data[4]:
                                                          found1=False
                                                          if (tmpRunDT.month, tmpRunDT.day) in self.holidays[0]:
                                                              continue
                                                          elif (tmpRunDT.year, tmpRunDT.month, tmpRunDT.day) in self.holidays[1]:
                              Severity: Major
                              Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                                        for day in days:
                                                            if day > monthrange(nextYear, month)[1]:
                                                                break
                                                            runDateTime = dt.combine(dt(nextYear, month, day).date(), runTime)
                                                            runList.append(runDateTime)
                                Severity: Major
                                Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                          if 2 ** ix & data[2]:
                                                              for weekday in range(7):
                                                                  if 2 ** weekday & data[3]:
                                                                      day = FindMonthDay(year, month, weekday, ix)
                                                                      if day:
                                  Severity: Major
                                  Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                    Avoid deeply nested control flow statements.
                                    Open

                                                            if data[4]:
                                                                found1=False
                                                                if (tmpRunDT.month, tmpRunDT.day) in self.holidays[0]:
                                                                    continue
                                                                elif (tmpRunDT.year, tmpRunDT.month, tmpRunDT.day) in self.holidays[1]:
                                    Severity: Major
                                    Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                              if found1 and found2:
                                                                  found = True
                                                                  break
                                                          if found:
                                      Severity: Major
                                      Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                        Avoid deeply nested control flow statements.
                                        Open

                                                                for weekday in range(7):
                                                                    if 2 ** weekday & data[3]:
                                                                        day = FindMonthDay(currYear, currMonth, weekday, ix)
                                                                        if day:
                                                                            runDateTime = dt.combine(dt(currYear, currMonth, day).date(), runTime)
                                        Severity: Major
                                        Found in plugins/SchedulGhost/__init__.py - About 45 mins to fix

                                          Function __start__ has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                          Open

                                              def __start__(
                                          Severity: Minor
                                          Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                            Function __init__ has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                            Open

                                                def __init__(
                                            Severity: Minor
                                            Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                              Function Configure has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                              Open

                                                  def Configure(
                                              Severity: Minor
                                              Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                                Function EnableAll has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                    def EnableAll(self, flag):
                                                        for ix in range(len(self.tmpData)):
                                                            self.tmpData[ix][0] = flag
                                                            if self.grid.GetItem(ix, 1).GetText() == self.tmpData[ix][1]:
                                                                if flag:
                                                Severity: Minor
                                                Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Function AddSchedule has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                    def AddSchedule(self, schedule):
                                                        tmpList = [item[1] for item in self.tmpData]
                                                        if schedule[1] in tmpList:
                                                            ix = tmpList.index(schedule[1])
                                                            self.tmpData[ix] = schedule
                                                Severity: Minor
                                                Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Function EnableSchedule has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                    def EnableSchedule(self, schedule, flag):
                                                        tmpList = [item[1] for item in self.tmpData]
                                                        if schedule in tmpList:
                                                            ix = tmpList.index(schedule)
                                                            self.tmpData[ix][0] = flag
                                                Severity: Minor
                                                Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Function __call__ has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                    def __call__(self, schedule=""):
                                                        schedule = eg.ParseString(schedule)
                                                        data = self.plugin.data
                                                        tmpLst = [item[1] for item in data]
                                                        if schedule in tmpLst:
                                                Severity: Minor
                                                Found in plugins/SchedulGhost/__init__.py - About 35 mins to fix

                                                Cognitive Complexity

                                                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                A method's cognitive complexity is based on a few simple rules:

                                                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                • Code is considered more complex for each "break in the linear flow of the code"
                                                • Code is considered more complex when "flow breaking structures are nested"

                                                Further reading

                                                Avoid too many return statements within this function.
                                                Open

                                                                    return str(runDateTime + td(days = delta))
                                                Severity: Major
                                                Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                  Avoid too many return statements within this function.
                                                  Open

                                                              return str(tmpRunDT)
                                                  Severity: Major
                                                  Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                    Avoid too many return statements within this function.
                                                    Open

                                                                    return ""
                                                    Severity: Major
                                                    Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                      Avoid too many return statements within this function.
                                                      Open

                                                                  return str(tmpRunDT)
                                                      Severity: Major
                                                      Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                        Avoid too many return statements within this function.
                                                        Open

                                                                        return str(runDateTime + td(days = delta))
                                                        Severity: Major
                                                        Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                          Avoid too many return statements within this function.
                                                          Open

                                                                          return ""
                                                          Severity: Major
                                                          Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                            Avoid too many return statements within this function.
                                                            Open

                                                                                return str(tmpRunDT)
                                                            Severity: Major
                                                            Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                              Avoid too many return statements within this function.
                                                              Open

                                                                              return ""
                                                              Severity: Major
                                                              Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                Avoid too many return statements within this function.
                                                                Open

                                                                                return ""
                                                                Severity: Major
                                                                Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                  Avoid too many return statements within this function.
                                                                  Open

                                                                                  return str(min(runList))
                                                                  Severity: Major
                                                                  Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                    Avoid too many return statements within this function.
                                                                    Open

                                                                                return str(runDateTime)
                                                                    Severity: Major
                                                                    Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                      Avoid too many return statements within this function.
                                                                      Open

                                                                                      return str(runDateTime + delta)
                                                                      Severity: Major
                                                                      Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                        Avoid too many return statements within this function.
                                                                        Open

                                                                                        return str(runDateTime)
                                                                        Severity: Major
                                                                        Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                          Avoid too many return statements within this function.
                                                                          Open

                                                                                          return str(runDateTime)
                                                                          Severity: Major
                                                                          Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                            Avoid too many return statements within this function.
                                                                            Open

                                                                                                    return str(dt.combine(now.date(), runTime))
                                                                            Severity: Major
                                                                            Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                              Avoid too many return statements within this function.
                                                                              Open

                                                                                              return str(runDateTime)
                                                                              Severity: Major
                                                                              Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                                Avoid too many return statements within this function.
                                                                                Open

                                                                                                return str(runDateTime + delta)
                                                                                Severity: Major
                                                                                Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                                  Avoid too many return statements within this function.
                                                                                  Open

                                                                                              return ""
                                                                                  Severity: Major
                                                                                  Found in plugins/SchedulGhost/__init__.py - About 30 mins to fix

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            elif type == 4: #monthly/day
                                                                                                if (data[2] + data[3] + data[4] + data[5]) == 0 or (data[6] + data[7]) == 0:
                                                                                                    return ""
                                                                                                runList = []
                                                                                                currMonth = now.month
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 6 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4263..4314

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 653.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    class CalendarPopup(wx.PopupWindow):
                                                                                        yearChange = True
                                                                                    
                                                                                        def __init__(self, parent, yearChange, first_day):
                                                                                            self.yearChange = yearChange
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 6 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 864..943

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 634.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                                if item[2] == 4:
                                                                                                    q_1_Node = dom.createElement(u'Q_1')
                                                                                                    q_1_Text = dom.createTextNode(unicode(item[3][2]))
                                                                                                    q_1_Node.appendChild(q_1_Text)
                                                                                                    dateTimeNode.appendChild(q_1_Node)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 3 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4549..4573
                                                                                    plugins/SchedulGhost/__init__.py on lines 2479..2503

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 352.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                                if item[2] == 3:
                                                                                                    orderNode = dom.createElement(u'Order')
                                                                                                    orderText = dom.createTextNode(unicode(item[3][2]))
                                                                                                    orderNode.appendChild(orderText)
                                                                                                    dateTimeNode.appendChild(orderNode)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 3 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4549..4573
                                                                                    plugins/SchedulGhost/__init__.py on lines 2504..2528

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 352.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if type == 0:
                                                                                                    if flag:
                                                                                                        self.ctrls.append(wx.NewId())
                                                                                                        dp = wx.DatePickerCtrl(self, self.ctrls[2], size = (86, -1),
                                                                                                                style = wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 3 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 1904..1928

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 350.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if item[2] == 2:
                                                                                                    weekdayNode = dom.createElement(u'Weekday')
                                                                                                    weekdayText = dom.createTextNode(unicode(item[3][2]))
                                                                                                    weekdayNode.appendChild(weekdayText)
                                                                                                    dateTimeNode.appendChild(weekdayNode)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4528..4548

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 296.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def AddSchedule(self, schedule):
                                                                                            tmpList = [item[1] for item in self.tmpData]
                                                                                            if schedule[1] in tmpList:
                                                                                                ix = tmpList.index(schedule[1])
                                                                                                self.tmpData[ix] = schedule
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2993..3013

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 287.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    class HolidaysBox(wx.ListBox):
                                                                                    
                                                                                        def __init__ (self, parent, id, size, style):
                                                                                            wx.ListBox.__init__(
                                                                                                self,
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 828..861

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 282.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                elif type == 5:
                                                                                                    if flag:
                                                                                                        self.ctrls.append(wx.NewId())
                                                                                                        dp = wx.DatePickerCtrl(self, self.ctrls[2], size = (86, -1),
                                                                                                                style = wx.DP_DROPDOWN | wx.DP_SHOWCENTURY)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 days to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2161..2180

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 254.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                        for day in weekdaysLarger:
                                                                                                            delta = day + shift - nowDay
                                                                                                            tmpRunDT = runDateTime + td(days = delta)
                                                                                                            found1=True
                                                                                                            if data[4]:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 2061..2086

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 243.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if flag:
                                                                                                        bottomSizer = wx.StaticBoxSizer(
                                                                                                            wx.StaticBox(self, -1, self.text.choosePeriod),
                                                                                                            wx.HORIZONTAL
                                                                                                        )
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2249..2278

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 243.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                        for day in weekdaysLower:
                                                                                                            delta = day + shift - nowDay
                                                                                                            tmpRunDT = runDateTime + td(days = delta)
                                                                                                            found1=True
                                                                                                            if data[4]:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 2032..2057

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 243.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if type == 4:
                                                                                                    q_1 = int(dateTime.getElementsByTagName('Q_1')[0].firstChild.data)
                                                                                                    params.append(q_1)
                                                                                                    q_2 = int(dateTime.getElementsByTagName('Q_2')[0].firstChild.data)
                                                                                                    params.append(q_2)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4641..4653

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 214.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                elif data[4] == 3 or data[4] == 4: #unit = day or week
                                                                                                    period = data[3] if data[4] == 3 else 7 * data[3]
                                                                                                    delta = (now - runDateTime).days
                                                                                                    share = delta / period
                                                                                                    if not delta % period:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4334..4364

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 199.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            def FindNewTitle(title):
                                                                                                tmpLst = []
                                                                                                for item in self.tmpData:
                                                                                                    if item[1].startswith(title + " ("):
                                                                                                        tmpLst.append(item[1][2 + len(title):])
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2415..2432

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 193.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                        if int(val) == 1:
                                                                                                            self.tmpData[self.lastRow][3][4] = 0
                                                                                                            holidCheck_2.SetValue(0)
                                                                                                            holidCheck_2.Enable(False)
                                                                                                            self.tmpData[self.lastRow][3][6] = 0
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 1238..1247

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 188.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                        if int(val) == 1:
                                                                                                            self.tmpData[self.lastRow][3][3] = 0
                                                                                                            holidCheck_1.SetValue(0)
                                                                                                            holidCheck_1.Enable(False)
                                                                                                            self.tmpData[self.lastRow][3][5] = 0
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 1224..1233

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 188.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                                if item[2] == 5:
                                                                                                    dateNode = dom.createElement(u'Date')
                                                                                                    dateText = dom.createTextNode(unicode(item[3][2]))
                                                                                                    dateNode.appendChild(dateText)
                                                                                                    dateTimeNode.appendChild(dateNode)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4515..4527
                                                                                    plugins/RadioSure/__init__.py on lines 4574..4586

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 184.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def SelRow(self, row):
                                                                                            if row != self.selRow:
                                                                                                if self.selRow in range(self.GetItemCount()):
                                                                                                    item = self.GetItem(self.selRow)
                                                                                                    item.SetTextColour(self.fore)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 1004..1017

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 163.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            def onPeriodNumber(evt):
                                                                                                if len(self.ctrls) == 5 and evt.GetId() == self.ctrls[3]:
                                                                                                    self.tmpData[self.lastRow][3][3] = int(evt.GetString())
                                                                                                    next = self.plugin.NextRun(
                                                                                                        self.tmpData[self.lastRow][2],
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2656..2666

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 152.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    for month in lower:
                                                                                                        runList = []
                                                                                                        for ix in range(6):
                                                                                                            if 2 ** ix & data[2]:
                                                                                                                for weekday in range(7):
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 2149..2160

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 150.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                for row in range(rows):
                                                                                                    grid.InsertStringItem(row, "")
                                                                                                    if self.tmpData[row][0]:
                                                                                                        grid.CheckItem(row)
                                                                                                    grid.SetStringItem(row, 1, self.tmpData[row][1])
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2717..2724

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 150.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    for month in larger:
                                                                                                        runList = []
                                                                                                        for ix in range(6):
                                                                                                            if 2 ** ix & data[2]:
                                                                                                                for weekday in range(7):
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 day to fix
                                                                                    plugins/SchedulGhost/__init__.py on lines 2165..2176

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 150.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            def onPeriodUnit(evt):
                                                                                                if len(self.ctrls) == 5 and evt.GetId() == self.ctrls[4]:
                                                                                                    self.tmpData[self.lastRow][3][4] = evt.GetSelection()
                                                                                                    next = self.plugin.NextRun(
                                                                                                        self.tmpData[self.lastRow][2],
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2347..2357

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 148.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def EnableSchedule(self, schedule, flag):
                                                                                            tmpList = [item[1] for item in self.tmpData]
                                                                                            if schedule in tmpList:
                                                                                                ix = tmpList.index(schedule)
                                                                                                self.tmpData[ix][0] = flag
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2971..2980

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 145.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def Configure(self, expr = ""):
                                                                                            panel = eg.ConfigPanel(resizable = True)
                                                                                            textControl = wx.TextCtrl(panel, -1, expr, size = (300,-1), style = wx.TE_MULTILINE )
                                                                                            panel.sizer.Add(wx.StaticText(panel,-1,self.text.python_expr), 0,wx.LEFT | wx.TOP, 10)
                                                                                            panel.sizer.Add(textControl, 1, wx.LEFT | wx.RIGHT | wx.BOTTOM | wx.EXPAND, 10)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 5760..5766

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 144.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                        def Configure(self, schedule = ""):
                                                                                            panel = eg.ConfigPanel()
                                                                                            data = self.plugin.data
                                                                                            choices = [item[1] for item in data]
                                                                                            textControl = wx.ComboBox(panel, -1, schedule, size = (300, -1), choices = choices)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 5718..5727
                                                                                    plugins/SchedulGhost/__init__.py on lines 2787..2795

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 142.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                        def Configure(self, schedule = ""):
                                                                                            panel = eg.ConfigPanel()
                                                                                            data = self.plugin.data
                                                                                            choices = [item[1] for item in data]
                                                                                            textControl = wx.ComboBox(panel, -1, schedule, size = (300, -1), choices = choices)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 5718..5727
                                                                                    plugins/SchedulGhost/__init__.py on lines 2734..2751

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 142.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def onClose(self, evt):
                                                                                            hwnd = self.GetHandle()
                                                                                            wp = GetWindowPlacement(hwnd)[4]
                                                                                            cdr = wx.GetClientDisplayRect()
                                                                                            pos = (wp[0] + cdr[0], wp[1] + cdr[1])
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 7 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 3022..3035

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 142.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if item[2] == 0:
                                                                                                    dateNode = dom.createElement(u'Date')
                                                                                                    dateText = dom.createTextNode(unicode(item[3][2]))
                                                                                                    dateNode.appendChild(dateText)
                                                                                                    dateTimeNode.appendChild(dateNode)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 6 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4506..4514

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 128.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            if type == 0: # once or yearly
                                                                                                runDate = dt.strptime(data[2], '%Y-%m-%d')
                                                                                                runDateTime = dt.combine(runDate, runTime)
                                                                                                if now < runDateTime:
                                                                                                    return str(runDateTime)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 6 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4106..4117

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 128.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            def onDatePicker(evt):
                                                                                                val = str(dt.fromtimestamp(evt.GetDate().GetTicks()))[:10]
                                                                                                self.tmpData[self.lastRow][3][2] = val
                                                                                                next = self.plugin.NextRun(
                                                                                                    self.tmpData[self.lastRow][2],
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 6 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2360..2368

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 126.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    def FindMonthDay(year, month, weekday, index):
                                                                                        """weekday = what day of the week looking for (numbered 0-6, 0 = monday)
                                                                                        index = how many occurrence of looking for (numbered 0-4 and 5 for the last day)
                                                                                        Returns the day of the month (date) or 0 (if no such date exists)"""
                                                                                        first_wd, length = monthrange(year, month)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 5 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 3138..3151

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 123.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    for ix in range(6):
                                                                                                        if 2 ** ix & data[2]:
                                                                                                            for weekday in range(7):
                                                                                                                if 2 ** weekday & data[3]:
                                                                                                                    day = FindMonthDay(currYear, currMonth, weekday, ix)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 5 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4209..4217

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 121.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def DeleteSchedule(self, schedule):
                                                                                            tmpList = [item[1] for item in self.tmpData]
                                                                                            if schedule in tmpList:
                                                                                                ix = tmpList.index(schedule)
                                                                                                if self.grid.GetItem(ix, 1).GetText() == self.tmpData[ix][1]:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 5 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2983..2990

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 117.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if flag:
                                                                                                        dateSizer = wx.BoxSizer(wx.HORIZONTAL)
                                                                                                        topSizer.Add(dateSizer, 0, wx.EXPAND)
                                                                                                        dynamicSizer.Add(topSizer, 0, wx.EXPAND | wx.TOP, 2)
                                                                                                        self.ctrls.append(wx.NewId())
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 5 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2082..2142
                                                                                    plugins/SchedulGhost/__init__.py on lines 835..910

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 115.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if flag:
                                                                                                        dateSizer = wx.BoxSizer(wx.HORIZONTAL)
                                                                                                        dateSizer.Add(
                                                                                                            wx.StaticText(
                                                                                                                self,
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 2 other locations - About 5 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2082..2142
                                                                                    plugins/SchedulGhost/__init__.py on lines 936..990

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 115.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def EnableAll(self, flag):
                                                                                            for ix in range(len(self.tmpData)):
                                                                                                self.tmpData[ix][0] = flag
                                                                                                if self.grid.GetItem(ix, 1).GetText() == self.tmpData[ix][1]:
                                                                                                    if flag:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 4 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2957..2963

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 111.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if type == 5:
                                                                                                    date = dateTime.getElementsByTagName('Date')[0].firstChild.data
                                                                                                    params.append(date)
                                                                                                    number = int(dateTime.getElementsByTagName('Number')[0].firstChild.data)
                                                                                                    params.append(number)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 4 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4654..4660

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 108.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if flag:
                                                                                                        if self.plugin.first_day:
                                                                                                            choices = list(day_name)[:-1]
                                                                                                            choices.insert(0, list(day_name)[-1])
                                                                                                        else:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 3 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 1989..2060

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 96.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if not data[4] and not data[3] and not data[6] and not data[5]: # without holiday check
                                                                                                    if len(weekdaysLarger) > 0:
                                                                                                        delta = weekdaysLarger[0] - nowDay
                                                                                                        return str(runDateTime + td(days = delta))
                                                                                                    delta = 7 + weekdaysLower[0] - nowDay
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 3 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4136..4141

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 93.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def updateLogFile(self, line, blank = False):
                                                                                            if not self.logfile:
                                                                                                return
                                                                                            f = openFile(self.logfile, encoding = 'utf-8', mode = 'a')
                                                                                            if blank:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 3 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4367..4374

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 91.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if box.IsChecked(sel):
                                                                                                    self.tmpData[self.lastRow][3][ix] |= 2 ** exp
                                                                                                else:
                                                                                                    self.tmpData[self.lastRow][3][ix] &= 255 - 2 ** exp
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2308..2311

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 87.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def OnMouseMove(self, evt):
                                                                                            if evt.Dragging() and evt.LeftIsDown():
                                                                                                x, y = self.ClientToScreen(evt.GetPosition())
                                                                                                fp = (x - self.delta[0], y - self.delta[1])
                                                                                                self.Move(fp)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/System/__init__.py on lines 993..997

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 87.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                for weekday in range(7):
                                                                                                    if 2**weekday & data[2]:
                                                                                                        if weekday < nowDay or (weekday == nowDay and now.time() > runTime):
                                                                                                            weekdaysLower.append(weekday)
                                                                                                        else:
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4130..4135

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 87.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if len(self.tmpData) > 0:
                                                                                                        if self.lastRow == len(self.tmpData):
                                                                                                            self.lastRow -= 1
                                                                                                        OpenSchedule()
                                                                                                        grid.SelRow(self.lastRow)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2499..2508

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 86.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                    if period < 86400 and not 86400 % period:
                                                                                                        if now.time() > runTime:
                                                                                                            date = now.date()
                                                                                                        else:
                                                                                                            date = now.date() - td(days = 1)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4322..4327

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 82.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if self.dialog:
                                                                                                    tmpList = [item[1] for item in self.tmpData]
                                                                                                    if schedule in tmpList:
                                                                                                        ixTmp = tmpList.index(schedule)
                                                                                                        self.tmpData[ixTmp][4] = last
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 2 hrs to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4423..4428

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 80.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def OnLeftDown(self, evt):
                                                                                            self.CaptureMouse()
                                                                                            x, y = self.ClientToScreen(evt.GetPosition())
                                                                                            originx, originy = self.GetPosition()
                                                                                            dx = x - originx
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 hr to fix
                                                                                    plugins/System/__init__.py on lines 981..987

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 76.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            def onCheckListCtrl(evt):
                                                                                                index, flag = evt.GetValue()
                                                                                                if self.tmpData[index][0] != int(flag):
                                                                                                    self.tmpData[index][0] = int(flag)
                                                                                                    Diff()
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 hr to fix
                                                                                    plugins/RadioSure/__init__.py on lines 2642..2646

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 74.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if type == 0:
                                                                                                    date = dateTime.getElementsByTagName('Date')[0].firstChild.data
                                                                                                    params.append(date)
                                                                                                    date = int(dateTime.getElementsByTagName('Yearly')[0].firstChild.data)
                                                                                                    params.append(date)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 hr to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4618..4622

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 74.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def RefreshGrid(self, ix, last, next):
                                                                                            if self.grid.GetItem(ix, 1).GetText() == self.tmpData[ix][1]:
                                                                                                self.grid.SetStringItem(ix, 2, last)
                                                                                                self.grid.SetStringItem(ix, 3, next)
                                                                                    Severity: Major
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 1 hr to fix
                                                                                    plugins/RadioSure/__init__.py on lines 3016..3019

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 72.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        def OnChangeDay(self, evt):
                                                                                            if evt.GetId() == self.fixWin.GetCalId():
                                                                                                self.fixListBox.Reset(self.fixHolidays)
                                                                                            else:
                                                                                                self.varListBox.Reset(self.varHolidays)
                                                                                    Severity: Minor
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 35 mins to fix
                                                                                    plugins/RadioSure/__init__.py on lines 820..825

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 61.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                if data[2] == 0 or data[3] == 0 or (data[4] + data[5]) == 0:
                                                                                                    return ""
                                                                                    Severity: Minor
                                                                                    Found in plugins/SchedulGhost/__init__.py and 1 other location - About 35 mins to fix
                                                                                    plugins/RadioSure/__init__.py on lines 4198..4199

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 61.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    There are no issues that match your filters.

                                                                                    Category
                                                                                    Status