Sign upLogin

takuseno/kiox

View on GitHub
Star

Showing 20 of 20 total issues

File server.py has 352 lines of code (exceeds 250 allowed). Consider refactoring.
Open

from concurrent import futures
from multiprocessing import Process, Queue
from typing import Any, Callable, Dict, List, Sequence, Union

import grpc
Severity: Minor
Found in kiox/distributed/server.py - About 4 hrs to fix

    Function kiox_server_process has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
    Open

    def kiox_server_process(
    host: str,
    port: int,
    batch_factory: SharedBatchFactory,
    command_queue: "Queue[str]",
    Severity: Minor
    Found in kiox/distributed/server.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 __init__ has 11 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def __init__(
    Severity: Major
    Found in kiox/distributed/server.py - About 1 hr to fix

      Function kiox_server_process has 10 arguments (exceeds 4 allowed). Consider refactoring.
      Open

      def kiox_server_process(
      Severity: Major
      Found in kiox/distributed/server.py - About 1 hr to fix

        Function create_frame_stack_kiox_from_dataset has 8 arguments (exceeds 4 allowed). Consider refactoring.
        Open

        def create_frame_stack_kiox_from_dataset(
        Severity: Major
        Found in kiox/offline.py - About 1 hr to fix

          Function build_from_dataset has 8 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          def build_from_dataset(
          Severity: Major
          Found in kiox/offline.py - About 1 hr to fix

            Function create_simple_kiox_from_dataset has 7 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            def create_simple_kiox_from_dataset(
            Severity: Major
            Found in kiox/offline.py - About 50 mins to fix

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

                  def append_transition(self, transition: LazyTransition) -> None:
        """Appends LazyTransition object.

        If all transitions are dropped from an episode, the episode and
        included steps will be removed.
              Severity: Minor
              Found in kiox/episode.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

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

              def dump_memory(f: BinaryIO, episodes: Sequence[Episode]) -> None:
    """Dumps data as HDF5.

    Args:
        f: I/O-like object.
              Severity: Minor
              Found in kiox/io.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

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

                  def collect(
              Severity: Minor
              Found in kiox/kiox.py - About 35 mins to fix

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

                    def collect(
                Severity: Minor
                Found in kiox/distributed/step_sender.py - About 35 mins to fix

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

                      def create(
                  Severity: Minor
                  Found in kiox/transition_factory.py - About 35 mins to fix

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

                        def collect(
                    Severity: Minor
                    Found in kiox/step_collector.py - About 35 mins to fix

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

                          def create(self, step, next_step, episode, duration, gamma):
                      Severity: Minor
                      Found in examples/custom_transition.py - About 35 mins to fix

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

                            def __init__(
                        Severity: Minor
                        Found in kiox/distributed/server.py - About 35 mins to fix

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

                              def collect(
                          Severity: Minor
                          Found in kiox/kiox.py - About 35 mins to fix

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

                                def create(
                            Severity: Minor
                            Found in kiox/transition_factory.py - About 35 mins to fix

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

                                  def create(
                              Severity: Minor
                              Found in kiox/transition_factory.py - About 35 mins to fix

                                Function collect has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                    def collect(
        self,
        observation: Item,
        action: Item,
        reward: Item,
                                Severity: Minor
                                Found in kiox/step_collector.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

                                Function zeros_like has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def zeros_like(item: Item) -> Item:
    """Creates identically shaped item filled with zeros.

    Args:
        item: item.
                                Severity: Minor
                                Found in kiox/item.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

                                Severity
                                Category
                                Status
                                Source
                                Language