iterative/dvc

View on GitHub

Showing 517 of 578 total issues

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

def notify_refs(
Severity: Minor
Found in dvc/utils/studio.py - About 35 mins to fix

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

        def test_import_empty_dir(self, tmp_dir, dvc, workspace, is_object_storage):
    Severity: Minor
    Found in dvc/testing/workspace_tests.py - About 35 mins to fix

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

          def _make_dataset(
      Severity: Minor
      Found in dvc/testing/benchmarks/fixtures.py - About 35 mins to fix

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

        def test_diff(bench_dvc, tmp_dir, scm, dvc, make_dataset):
        Severity: Minor
        Found in dvc/testing/benchmarks/cli/commands/test_diff.py - About 35 mins to fix

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

          def load(
          Severity: Minor
          Found in dvc/utils/strictyaml.py - About 35 mins to fix

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

                def make(name, *, scm=False, dvc=False, subdir=False):
            Severity: Minor
            Found in dvc/testing/fixtures.py - About 35 mins to fix

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

                  def test_add_to_remote(self, tmp_dir, dvc, remote, workspace):
              Severity: Minor
              Found in dvc/testing/workspace_tests.py - About 35 mins to fix

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

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

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

                  def test_sharing(bench_dvc, tmp_dir, dvc, dataset, remote):
                  Severity: Minor
                  Found in dvc/testing/benchmarks/cli/stories/use_cases/test_sharing.py - About 35 mins to fix

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

                        def add(  # noqa: C901
                    Severity: Minor
                    Found in dvc/output.py - About 35 mins to fix

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

                          def _collect_used_dir_cache(
                      Severity: Minor
                      Found in dvc/output.py - About 35 mins to fix

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

                            def __init__(
                        Severity: Minor
                        Found in dvc/fs/git.py - About 35 mins to fix

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

                              def __init__(
                          Severity: Minor
                          Found in dvc/fs/callbacks.py - About 35 mins to fix

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

                                def __init__(self, repo, path, verify=True, **kwargs):
                            Severity: Minor
                            Found in dvc/dvcfile.py - About 35 mins to fix

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

                                  def dump(self, stage, update_pipeline=True, update_lock=True, **kwargs):
                              Severity: Minor
                              Found in dvc/dvcfile.py - About 35 mins to fix

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

                                    def flat_datapoints(self, revision: str) -> tuple[list[dict], dict]:
                                        """
                                        Convert the DVC Plots content to DVC Render datapoints.
                                        Return both generated datapoints and updated properties.
                                        """
                                Severity: Minor
                                Found in dvc/render/converter/image.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 find_pager has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def find_pager():
                                    from . import Console
                                
                                    if not Console.isatty():
                                        return None
                                Severity: Minor
                                Found in dvc/ui/pager.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 _get_names has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def _get_names(entries: Iterable[Union["QueueEntry", "QueueDoneResult"]]):
                                    names: list[str] = []
                                    for entry in entries:
                                        if isinstance(entry, QueueDoneResult):
                                            if entry.result and entry.result.ref_info:
                                Severity: Minor
                                Found in dvc/repo/experiments/queue/remove.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 transfer has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                    def transfer(self, from_odb, to_odb):
                                        from dvc.fs import HTTPFileSystem, LocalFileSystem
                                        from dvc.fs.callbacks import TqdmCallback
                                
                                        from_fs = from_odb.fs
                                Severity: Minor
                                Found in dvc/stage/cache.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 reproduce has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                    def reproduce(self, interactive=False, **kwargs) -> Optional["Stage"]:
                                        if not (
                                            kwargs.get("force", False)
                                            or self.changed(
                                                kwargs.get("allow_missing", False), kwargs.pop("upstream", None)
                                Severity: Minor
                                Found in dvc/stage/__init__.py - About 35 mins to fix

                                Cognitive Complexity

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

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

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

                                Further reading

                                Severity
                                Category
                                Status
                                Source
                                Language