Sign upLogin

Konano/arknights-mower

View on GitHub
Star
arknights_mower/solvers/base_schedule.py

Summary

Maintainability
F
3 wks
Test Coverage

File base_schedule.py has 1439 lines of code (exceeds 250 allowed). Consider refactoring.
Open

from __future__ import annotations
import copy
import time
from enum import Enum
from datetime import datetime, timedelta
Severity: Major
Found in arknights_mower/solvers/base_schedule.py - About 3 days to fix

    Function plan_solver has a Cognitive Complexity of 169 (exceeds 5 allowed). Consider refactoring.
    Open

        def plan_solver(self):
        plan = self.currentPlan
        # 如果下个 普通任务 <10 分钟则跳过 plan
        if (
        next((e for e in self.tasks if 'type' not in e.keys() and e['time'] < datetime.now() + timedelta(seconds=600)),
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 3 days 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 agent_get_mood has a Cognitive Complexity of 111 (exceeds 5 allowed). Consider refactoring.
    Open

        def agent_get_mood(self,skip_dorm = False):
        # 如果5分钟之内有任务则跳过心情读取
        if next((k for k in self.tasks if k['time'] <datetime.now()+ timedelta(seconds=300)),None) is not None:
            logger.info('有未完成的任务，跳过纠错')
            return
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 2 days 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 agent_arrange has a Cognitive Complexity of 111 (exceeds 5 allowed). Consider refactoring.
    Open

        def agent_arrange(self, plan: tp.BasePlan, read_time_room=[]):
        logger.info('基建：排班')
        in_and_out = []
        fia_room = ""
        rooms = list(plan.keys())
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 2 days 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 choose_agent has a Cognitive Complexity of 69 (exceeds 5 allowed). Consider refactoring.
    Open

        def choose_agent(self, agents: list[str], room: str) -> None:
        """
        :param order: ArrangeOrder, 选择干员时右上角的排序功能
        """
        first_name = ''
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 1 day 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 get_swap_plan has a Cognitive Complexity of 53 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_swap_plan(self, resting_dorm, operators, skip_read_time):
        result = {}
        agents = copy.deepcopy(operators)
        # 替换计划
        for a in operators:
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 1 day 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 plan_metadata has a Cognitive Complexity of 51 (exceeds 5 allowed). Consider refactoring.
    Open

        def plan_metadata(self, time_result):
        group_info = self.task['metadata']['plan']
        read_time_rooms = self.task['metadata']['room']
        if time_result is None:
            time_result = {}
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 7 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 get_agent has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_agent(self):
        plan = self.currentPlan
        high_production = []
        replacements = []
        for room in plan.keys():
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 6 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

    BaseSchedulerSolver has 44 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class BaseSchedulerSolver(BaseSolver):
    """
    收集基建的产物：物资、赤金、信赖
    """
    Severity: Minor
    Found in arknights_mower/solvers/base_schedule.py - About 6 hrs to fix

      Function get_agent_from_room has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
      Open

          def get_agent_from_room(self, room, read_time_index=[]):
        error_count = 0
        if room == 'meeting':
            time.sleep(3)
        while self.find('room_detail') is None:
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.py - About 5 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 maa_plan_solver has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
      Open

          def maa_plan_solver(self):
        try:
            if self.maa_config['last_execution'] is not None and datetime.now() - timedelta(seconds=self.maa_config['maa_execution_gap']*3600)< self.maa_config['last_execution']:
                logger.info("间隔未超过设定时间，不启动maa")
            else:
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 infra_main has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
      Open

          def infra_main(self):
        """ 位于基建首页 """
        if self.find('control_central') is None:
            self.back()
            return
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 recog_view_mask_right has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
      Open

          def recog_view_mask_right(self) -> int:
        """ 识别线索视图中右边黑色 mask 边缘的位置 """
        x3 = x2
        while True:
            max_abs = 0
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 overtake_room has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

          def overtake_room(self):
        name = self.task['type']
        candidate = []
        if self.operators[name]['group'] != '':
            candidate.extend([v['name'] for k, v in self.operators.items() if
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 clue has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
      Open

          def clue(self) -> None:
        # 一些识别时会用到的参数
        global x1, x2, x3, x4, y0, y1, y2
        x1, x2, x3, x4 = 0, 0, 0, 0
        y0, y1, y2 = 0, 0, 0
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.py - About 2 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 read_screen has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
      Open

          def read_screen(self,img, type="mood",limit=24, cord=None, change_color=False):
        if cord is not None:
            img = img[cord[1]:cord[3], cord[0]:cord[2]]
        if 'mood' in type or type == "time":
            # 心情图片太小，复制8次提高准确率
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.py - About 2 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 drone has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
      Open

          def drone(self, room: str, one_time=False, not_return=False):
        logger.info('基建：无人机加速')

        # 点击进入该房间
        self.enter_room(room)
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.py - About 2 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 scan_agant has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          def scan_agant(self, agent: list[str], error_count=0, max_agent_count=-1):
        try:
            # 识别干员
            self.recog.update()
            ret = character_recognize.agent(self.recog.img)  # 返回的顺序是从左往右从上往下
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 ori_clue has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          def ori_clue(self):
        """ 获取界面内有多少线索 """
        clues = []
        y3 = y1
        status = -2
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 transition has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

          def transition(self) -> None:
        self.recog.update()
        if self.scene() == Scene.INDEX:
            self.tap_element('index_infrastructure')
        elif self.scene() == Scene.INFRA_MAIN:
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 clear_clue_mask has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
      Open

          def clear_clue_mask(self) -> None:
        """ 清空界面内被选中的线索 """
        try:
            while True:
                mask = False
      Severity: Minor
      Found in arknights_mower/solvers/base_schedule.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 _room not in result.keys():
                            result[_room] = ['Current'] * len(self.currentPlan[_room])
                        result[_room][self.operators[_item_name]['index']] = _item_name
      Severity: Major
      Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

        Function read_time has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

            def read_time(self, cord, upperlimit, error_count=0):
        # 刷新图片
        self.recog.update()
        time_str = segment.read_screen(self.recog.img, type='time', cord=cord)
        logger.debug(str(time_str))
        Severity: Minor
        Found in arknights_mower/solvers/base_schedule.py - About 45 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

                                    for current_idx, _name in enumerate(plan[room]):
                                if _name == 'Current':
                                    current_name = self.current_base[room][current_idx]["agent"]
                                    if current_name in agent_list:
                                        plan[room][current_idx] = current_name
        Severity: Major
        Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                                      if min_mood == -99:
                                min_mood = agent['mood']
                            break
          Severity: Major
          Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

            Avoid deeply nested control flow statements.
            Open

                                        for x in group_resting:
                                if self.operators[x['agent']]['resting_priority'] == 'low':
                                    continue
                                else:
                                    group_restingCount += 1
            Severity: Major
            Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                      if a == "Current":
                            continue
                        elif 'exhaust_require' in self.operators[a].keys() and self.operators[a]['exhaust_require']:
                            ignore.append(a)
        resting_dorm.extend([self.operators[a]['current_room'] for a in ignore])
              Severity: Major
              Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

                Avoid deeply nested control flow statements.
                Open

                                        if dorm not in read_time_rooms:
                            continue
                        if dorm in time_result.keys() and min_time > time_result[dorm]:
                Severity: Major
                Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                              if group_restingCount + actuall_resting <= self.dorm_count:
                                need_to_rest.extend(group_resting)
                                actuall_resting += group_restingCount
                            else:
                                # 因为人数不够而跳过记录心情
                  Severity: Major
                  Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                            if dorm in time_result.keys() and min_time > time_result[dorm]:
                            min_time = time_result[dorm]
                    _plan["time"] = min_time
                    Severity: Major
                    Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                              if k not in existing_plan['plan']:
                            existing_plan['plan'][k] = _plan['plan'][k]
                        else:
                            for idx, _a in enumerate(_plan['plan'][k]):
                                if _plan['plan'][k][idx] != 'Current':
                      Severity: Major
                      Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                                    if next((e for e in self.tasks if 'type' in e.keys() and e['type'] == agent['agent']),
                                    None) is None:
                                __agent = self.operators[agent['agent']]
                                self.enter_room(__agent['current_room'])
                                result = self.get_agent_from_room(__agent['current_room'], [__agent['current_index']])
                        Severity: Major
                        Found in arknights_mower/solvers/base_schedule.py - About 45 mins to fix

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

                              def read_screen(self,img, type="mood",limit=24, cord=None, change_color=False):
                          Severity: Minor
                          Found in arknights_mower/solvers/base_schedule.py - About 35 mins to fix

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

                                def get_clue_mask(self) -> None:
        """ 界面内是否有被选中的线索 """
        try:
            mask = []
            for y in range(y1, y2):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.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 handle_error has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def handle_error(self,force = False):
        # 如果有任何报错，则生成一个空
        if self.scene() == Scene.UNKNOWN:
            self.device.exit('com.hypergryph.arknights')
        if self.error or force:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.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 check_in_and_out has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def check_in_and_out(self):
        res = {}
        for x, y in self.currentPlan.items():
            if not x.startswith('room'): continue
            if any(('但书' in obj['replacement'] or '龙舌兰' in obj['replacement']) for obj in y):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py - About 25 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

                            Refactor this function to reduce its Cognitive Complexity from 53 to the 15 allowed.
                            Open

                                def plan_metadata(self, time_result):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 20 to the 15 allowed.
                            Open

                                def clue(self) -> None:
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 70 to the 15 allowed.
                            Open

                                def choose_agent(self, agents: list[str], room: str) -> None:
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 37 to the 15 allowed.
                            Open

                                def get_agent_from_room(self, room, read_time_index=[]):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 33 to the 15 allowed.
                            Open

                                def maa_plan_solver(self):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 112 to the 15 allowed.
                            Open

                                def agent_get_mood(self,skip_dorm = False):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 50 to the 15 allowed.
                            Open

                                def get_agent(self):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 20 to the 15 allowed.
                            Open

                                def drone(self, room: str, one_time=False, not_return=False):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 56 to the 15 allowed.
                            Open

                                def get_swap_plan(self, resting_dorm, operators, skip_read_time):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 20 to the 15 allowed.
                            Open

                                def read_screen(self,img, type="mood",limit=24, cord=None, change_color=False):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 113 to the 15 allowed.
                            Open

                                def agent_arrange(self, plan: tp.BasePlan, read_time_room=[]):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 27 to the 15 allowed.
                            Open

                                def overtake_room(self):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 177 to the 15 allowed.
                            Open

                                def plan_solver(self):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 28 to the 15 allowed.
                            Open

                                def infra_main(self):
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Refactor this function to reduce its Cognitive Complexity from 26 to the 15 allowed.
                            Open

                                def recog_view_mask_right(self) -> int:
                            Severity: Critical
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                            See

                            Merge this if statement with the enclosing one.
                            Open

                                                    if len(select_name) >= max_agent_count:
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Merging collapsible if statements increases the code's readability.

                            Noncompliant Code Example

                            if condition1:
    if condition2:
        # ...

                            Compliant Solution

                            if condition1 and condition2:
    # ...

                            Remove those useless parentheses.
                            Open

                                    time_p = [((1650, 270, 1780, 305)), ((1650, 480, 1780, 515)), ((1650, 690, 1780, 725)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                    time_p = [((1650, 270, 1780, 305)), ((1650, 480, 1780, 515)), ((1650, 690, 1780, 725)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                    mood_p = [((1685, 213, 1780, 256)), ((1685, 422, 1780, 465)), ((1685, 632, 1780, 675)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                    mood_p = [((1685, 213, 1780, 256)), ((1685, 422, 1780, 465)), ((1685, 632, 1780, 675)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                    mood_p = [((1685, 213, 1780, 256)), ((1685, 422, 1780, 465)), ((1685, 632, 1780, 675)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                              ((1685, 612, 1780, 655)), ((1685, 822, 1780, 865))]
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Merge this if statement with the enclosing one.
                            Open

                                        if 'replacement' in self.operators['菲亚梅塔'].keys():
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Merging collapsible if statements increases the code's readability.

                            Noncompliant Code Example

                            if condition1:
    if condition2:
        # ...

                            Compliant Solution

                            if condition1 and condition2:
    # ...

                            Remove those useless parentheses.
                            Open

                                    time_p = [((1650, 270, 1780, 305)), ((1650, 480, 1780, 515)), ((1650, 690, 1780, 725)),
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                              ((1650, 665, 1780, 700)), ((1650, 875, 1780, 910))]
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Remove those useless parentheses.
                            Open

                                              ((1685, 612, 1780, 655)), ((1685, 822, 1780, 865))]
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Merge this if statement with the enclosing one.
                            Open

                                                if next((k for k, v in self.operators.items() if
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Merging collapsible if statements increases the code's readability.

                            Noncompliant Code Example

                            if condition1:
    if condition2:
        # ...

                            Compliant Solution

                            if condition1 and condition2:
    # ...

                            Remove those useless parentheses.
                            Open

                                              ((1650, 665, 1780, 700)), ((1650, 875, 1780, 910))]
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. But redundant pairs of parentheses could be misleading, and should be removed.

                            Noncompliant Code Example

                            return ((3))        # Noncompliant
return ((x + 1))    # Noncompliant
x = ((y / 2)) + 1   # Noncompliant

                            Compliant Solution

                            return 3
return (3)
return x + 1
return (x + 1)
x = y / 2 + 1
x = (y / 2) + 1

                            Merge this if statement with the enclosing one.
                            Open

                                                if ("LowerLimit" in self.agent_base_config[current_base[key][idx]["agent"]]):
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Merging collapsible if statements increases the code's readability.

                            Noncompliant Code Example

                            if condition1:
    if condition2:
        # ...

                            Compliant Solution

                            if condition1 and condition2:
    # ...

                            Merge this if statement with the enclosing one.
                            Open

                                            if '.' in __str:
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Merging collapsible if statements increases the code's readability.

                            Noncompliant Code Example

                            if condition1:
    if condition2:
        # ...

                            Compliant Solution

                            if condition1 and condition2:
    # ...

                            Remove the code after this "return".
                            Open

                                    return
                            Severity: Major
                            Found in arknights_mower/solvers/base_schedule.py by sonar-python

                            Jump statements (return, break, continue, and raise) move control flow out of the current code block. Typically, any statements in a block that come after a jump are simply wasted keystrokes lying in wait to confuse the unwary.

                            Noncompliant Code Example

                            def fun(a):
  i = 10
  return i + a       # Noncompliant
  i += 1             # this is never executed

                            Compliant Solution

                            def fun(a):
  i = 10
  return i + a

                            See

                            • MISRA C:2004, 14.1 - There shall be no unreachable code
                            • MISRA C++:2008, 0-1-1 - A project shall not contain unreachable code
                            • MISRA C++:2008, 0-1-9 - There shall be no dead code
                            • MISRA C:2012, 2.1 - A project shall not contain unreachable code
                            • MISRA C:2012, 2.2 - There shall be no dead code
                            • MITRE, CWE-561 - Dead Code
                            • CERT, MSC56-J. - Detect and remove superfluous code and values
                            • CERT, MSC12-C. - Detect and remove code that has no effect or is never executed
                            • CERT, MSC07-CPP. - Detect and remove dead code

                            Multiple statements on one line (colon)
                            Open

                                        if (key == 'train'): continue
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Continuation line with same indent as next logical line
                            Open

                                                __high['name']].keys() and self.agent_base_config[__high['name']]['RestingPriority'] == 'low':
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Continuation line with same indent as next logical line
                            Open

                                                __high['name']].keys() and self.agent_base_config[__high['name']]['RestInFull'] == True:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Blank line contains whitespace
                            Open
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Trailing whitespace is superfluous.

                            The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                            Multiple statements on one line (colon)
                            Open

                                        if retry_count > 3: raise Exception(f"到达最大尝试次数 3次")
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace around operator
                            Open

                                                if data['agent']in ['菲亚梅塔','刻俄柏']:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace around operator
                            Open

                                                if drone_count < 100 or drone_count ==200:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Multiple statements on one line (colon)
                            Open

                                                if len(agent) == 0: break
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace around operator
                            Open

                                            error_count+=1
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace around operator
                            Open

                                        if res>upperlimit:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Multiple statements on one line (colon)
                            Open

                                    if length > 3: self.swipe((self.recog.w * 0.8, self.recog.h * 0.8), (0, self.recog.h * 0.4), interval=1,
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Whitespace before ':'
                            Open

                                            'current_room'] == room and _operator not in [res['agent'] for res in result] :
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Avoid extraneous whitespace.

                            Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                            Too many leading '#' for block comment
                            Open

                            ## Maa
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Separate inline comments by at least two spaces.

                            An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                            Unexpected spaces around keyword / parameter equals
                            Open

                                def agent_get_mood(self,skip_dorm = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Don't use spaces around the '=' sign in function arguments.

                            Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                            Continuation line missing indentation or outdented
                            Open

                                    next((e for e in self.tasks if 'type' not in e.keys() and e['time'] < datetime.now() + timedelta(seconds=600)),
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Continuation line under-indented for visual indent
                            Open

                                                    'room' in self.operators[agent[0]].keys() and self.operators[agent[0]]['room'].startswith(
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Continuation line over-indented for visual indent
                            Open

                                                         None)) is None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Comparison to true should be 'if cond is true:' or 'if cond:'
                            Open

                                                __high['name']].keys() and self.agent_base_config[__high['name']]['RestInFull'] == True:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Comparison to singletons should use "is" or "is not".

                            Comparisons to singletons like None should always be done
with "is" or "is not", never the equality operators.

Okay: if arg is not None:
E711: if arg != None:
E711: if None == arg:
E712: if arg == True:
E712: if False == arg:

Also, beware of writing if x when you really mean if x is not None
-- e.g. when testing whether a variable or argument that defaults to
None was set to some other value.  The other value might have a type
(such as a container) that could be false in a boolean context!

                            Missing whitespace after ','
                            Open

                                def read_screen(self,img, type="mood",limit=24, cord=None, change_color=False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace after ','
                            Open

                                def agent_get_mood(self,skip_dorm = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Unexpected spaces around keyword / parameter equals
                            Open

                                def agent_get_mood(self,skip_dorm = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Don't use spaces around the '=' sign in function arguments.

                            Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                            Multiple statements on one line (colon)
                            Open

                                    if change_color: img[img == 137] = 255
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Whitespace before ':'
                            Open

                                    except Exception as e :
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Avoid extraneous whitespace.

                            Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                            Multiple statements on one line (colon)
                            Open

                                        else :return res
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Do not use bare 'except'
                            Open

                                    except:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            When catching exceptions, mention specific exceptions when possible.

                            Okay: except Exception:
Okay: except BaseException:
E722: except:

                            Multiple statements on one line (colon)
                            Open

                                            if any(room in obj["plan"].keys() and 'type' not in obj.keys() for obj in self.tasks): continue;
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Continuation line missing indentation or outdented
                            Open

                                                    self.operators[agent['agent']]['current_room'].startswith('dormitory'):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Continuation line with same indent as next logical line
                            Open

                                                __high['name']].keys():
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Multiple spaces after operator
                            Open

                                        res =  int(h) * 3600 + int(m) * 60 + int(s)
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Avoid extraneous whitespace around an operator.

                            Okay: a = 12 + 3
E221: a = 4  + 5
E222: a = 4 +  5
E223: a = 4\t+ 5
E224: a = 4 +\t5

                            Continuation line with same indent as next logical line
                            Open

                                                'dormitory')):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Missing whitespace around operator
                            Open

                                                'credit_fight':fights[len(fights)-1]!=''
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace after ','
                            Open

                                                      'exhaust_require': False, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Expected 1 blank line, found 0
                            Open

                                def handle_error(self,force = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Separate top-level function and class definitions with two blank lines.

                            Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                            Multiple statements on one line (colon)
                            Open

                                                if error_count > 3: raise e
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace after ','
                            Open

                                                                         "index": -1, 'current_room': '', 'mood': 24, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Continuation line with same indent as next logical line
                            Open

                                            'current_room'] == room and _operator not in [res['agent'] for res in result] :
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Missing whitespace around operator
                            Open

                                    if next((k for k in self.tasks if k['time'] <datetime.now()+ timedelta(seconds=300)),None) is not None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace after ':'
                            Open

                                                      'exhaust_require': False, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Continuation line with same indent as next logical line
                            Open

                                                __high['name']].keys() and self.agent_base_config[__high['name']]['ExhaustRequire'] == True:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Missing whitespace after ','
                            Open

                                                                     'resting_priority': 'low', "index": -1, 'mood': 24, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace after ','
                            Open

                                def read_screen(self,img, type="mood",limit=24, cord=None, change_color=False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Whitespace before ':'
                            Open

                                            if 'mood' in type :
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Avoid extraneous whitespace.

                            Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                            Missing whitespace around operator
                            Open

                                        if int(m)>60 or int(s)>60:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace after ','
                            Open

                                            return self.read_time(cord,upperlimit, error_count + 1)
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace after ','
                            Open

                                                if data['agent']in ['菲亚梅塔','刻俄柏']:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace after ','
                            Open

                                                data['time'] = self.double_read_time(time_p[i],upperLimit=upperLimit)
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace around operator
                            Open

                                        if self.maa_config['last_execution'] is not None and datetime.now() - timedelta(seconds=self.maa_config['maa_execution_gap']*3600)< self.maa_config['last_execution']:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace after ','
                            Open

                                    if next((k for k in self.tasks if k['time'] <datetime.now()+ timedelta(seconds=300)),None) is not None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Multiple statements on one line (colon)
                            Open

                                    if '' in self.operators.keys(): self.operators['']['current_room'] = ''
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace around operator
                            Open

                                                result[fia_idx]['time'] =datetime.now()
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Continuation line missing indentation or outdented
                            Open

                                            'current_room'].startswith('dormitory'))) and obj not in ['但书', '龙舌兰']), None)
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Test for membership should be 'not in'
                            Open

                                        if not group_name in group_info.keys():
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Negative comparison should be done using "not in" and "is not".

                            Okay: if x not in y:\n    pass
Okay: assert (X in Y or X is Z)
Okay: if not (X in Y):\n    pass
Okay: zz = x is not y
E713: Z = not X in Y
E713: if not X.B in Y:\n    pass
E714: if not X is Y:\n    pass
E714: Z = not X.B is Y

                            Multiple statements on one line (colon)
                            Open

                                        if len(line_conf) == 0 and 'mood' in type: return -1
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Whitespace before ':'
                            Open

                                        else :return res
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Avoid extraneous whitespace.

                            Avoid extraneous whitespace in these situations:
- Immediately inside parentheses, brackets or braces.
- Immediately before a comma, semicolon, or colon.

Okay: spam(ham[1], {eggs: 2})
E201: spam( ham[1], {eggs: 2})
E201: spam(ham[ 1], {eggs: 2})
E201: spam(ham[1], { eggs: 2})
E202: spam(ham[1], {eggs: 2} )
E202: spam(ham[1 ], {eggs: 2})
E202: spam(ham[1], {eggs: 2 })

E203: if x == 4: print x, y; x, y = y , x
E203: if x == 4: print x, y ; x, y = y, x
E203: if x == 4 : print x, y; x, y = y, x

                            Multiple statements on one line (colon)
                            Open

                                        if len(agent) == 0: break;
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Unexpected spaces around keyword / parameter equals
                            Open

                                def handle_error(self,force = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Don't use spaces around the '=' sign in function arguments.

                            Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                            Missing whitespace around operator
                            Open

                                    if next((k for k in self.tasks if k['time'] <datetime.now()+ timedelta(seconds=300)),None) is not None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace after ','
                            Open

                                                        time_result = self.get_agent_from_room(self.operators[agent]['current_room'],[__index])
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Too many blank lines (2)
                            Open

                                def initialize_paddle(self):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Separate top-level function and class definitions with two blank lines.

                            Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                            Missing whitespace around operator
                            Open

                                        if int(m)>60 or int(s)>60:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Multiple statements on one line (colon)
                            Open

                                    if not_return: return
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Statement ends with a semicolon
                            Open

                                        if len(agent) == 0: break;
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Continuation line missing indentation or outdented
                            Open

                                                self.operators[_item_name]['room'].startswith(
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Missing whitespace after ':'
                            Open

                                                                         "index": -1, 'current_room': '', 'mood': 24, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Multiple statements on one line (colon)
                            Open

                                            if i['name'] in self.exaust_agent: continue
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Multiple statements on one line (colon)
                            Open

                                        if not x.startswith('room'): continue
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace around operator
                            Open

                                        while i>=3 and data['agent'] !='' and (next((e for e in result if e['agent'] == data['agent']), None)) is not None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace around operator
                            Open

                                                    if back_count>3:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace around operator
                            Open

                                            _plan= self.maa_config['weekly_plan'][get_server_weekday()]
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Continuation line with same indent as next logical line
                            Open

                                            'stationary_security_service']:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Missing whitespace after ':'
                            Open

                                                'credit_fight':fights[len(fights)-1]!=''
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace after ','
                            Open

                                def handle_error(self,force = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Unexpected spaces around keyword / parameter equals
                            Open

                                def handle_error(self,force = False):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Don't use spaces around the '=' sign in function arguments.

                            Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                            Comparison to true should be 'if cond is true:' or 'if cond:'
                            Open

                                                __high['name']].keys() and self.agent_base_config[__high['name']]['ExhaustRequire'] == True:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Comparison to singletons should use "is" or "is not".

                            Comparisons to singletons like None should always be done
with "is" or "is not", never the equality operators.

Okay: if arg is not None:
E711: if arg != None:
E711: if None == arg:
E712: if arg == True:
E712: if False == arg:

Also, beware of writing if x when you really mean if x is not None
-- e.g. when testing whether a variable or argument that defaults to
None was set to some other value.  The other value might have a type
(such as a container) that could be false in a boolean context!

                            Missing whitespace after ':'
                            Open

                                                                     'resting_priority': 'low', "index": -1, 'mood': 24, "upper_limit": 24,"rest_in_full":False}
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Continuation line under-indented for visual indent
                            Open

                                                          'exhaust_require' in v.keys() and v["exhaust_require"]]
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Continuation lines indentation.

                            Continuation lines should align wrapped elements either vertically
using Python's implicit line joining inside parentheses, brackets
and braces, or using a hanging indent.

When using a hanging indent these considerations should be applied:
- there should be no arguments on the first line, and
- further indentation should be used to clearly distinguish itself
  as a continuation line.

Okay: a = (\n)
E123: a = (\n    )

Okay: a = (\n    42)
E121: a = (\n   42)
E122: a = (\n42)
E123: a = (\n    42\n    )
E124: a = (24,\n     42\n)
E125: if (\n    b):\n    pass
E126: a = (\n        42)
E127: a = (24,\n      42)
E128: a = (24,\n    42)
E129: if (a or\n    b):\n    pass
E131: a = (\n    42\n 24)

                            Blank line contains whitespace
                            Open
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Trailing whitespace is superfluous.

                            The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                            Missing whitespace around operator
                            Open

                                                    back_count+=1
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Expected 2 blank lines, found 1
                            Open

                            class ArrangeOrder(Enum):
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Separate top-level function and class definitions with two blank lines.

                            Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                            Statement ends with a semicolon
                            Open

                                            if any(room in obj["plan"].keys() and 'type' not in obj.keys() for obj in self.tasks): continue;
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Compound statements (on the same line) are generally discouraged.

                            While sometimes it's okay to put an if/for/while with a small body
on the same line, never do this for multi-clause statements.
Also avoid folding such long lines!

Always use a def statement instead of an assignment statement that
binds a lambda expression directly to a name.

Okay: if foo == 'blah':\n    do_blah_thing()
Okay: do_one()
Okay: do_two()
Okay: do_three()

E701: if foo == 'blah': do_blah_thing()
E701: for x in lst: total += x
E701: while t < 10: t = delay()
E701: if foo == 'blah': do_blah_thing()
E701: else: do_non_blah_thing()
E701: try: something()
E701: finally: cleanup()
E701: if foo == 'blah': one(); two(); three()
E702: do_one(); do_two(); do_three()
E703: do_four();  # useless semicolon
E704: def f(x): return 2*x
E731: f = lambda x: 2*x

                            Missing whitespace after ':'
                            Open

                                        else :return res
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Each comma, semicolon or colon should be followed by whitespace.

                            Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                            Missing whitespace around operator
                            Open

                                        while i>=3 and data['agent'] !='' and (next((e for e in result if e['agent'] == data['agent']), None)) is not None:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            Missing whitespace around operator
                            Open

                                            if error_count>4:
                            Severity: Minor
                            Found in arknights_mower/solvers/base_schedule.py by pep8

                            Surround operators with a single space on either side.

                            - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                            There are no issues that match your filters.

                            Category
                            Status