iterative/dvc

View on GitHub

Showing 400 of 444 total issues

File output.py has 878 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import logging
import os
from collections import defaultdict
from typing import TYPE_CHECKING, Dict, Optional, Set, Type
from urllib.parse import urlparse
Severity: Major
Found in dvc/output.py - About 2 days to fix

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

    import logging
    import os
    import re
    from functools import wraps
    from typing import Dict, Iterable, List, Mapping, Optional, Type
    Severity: Major
    Found in dvc/repo/experiments/__init__.py - About 1 day to fix

      File base.py has 594 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      import logging
      import os
      import pickle
      from abc import ABC, abstractmethod
      from contextlib import contextmanager
      Severity: Major
      Found in dvc/repo/experiments/executor/base.py - About 1 day to fix

        File show.py has 571 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        import argparse
        import logging
        import os
        import re
        from collections import Counter, OrderedDict, defaultdict
        Severity: Major
        Found in dvc/commands/experiments/show.py - About 1 day to fix

          Output has 51 functions (exceeds 20 allowed). Consider refactoring.
          Open

          class Output:
              IS_DEPENDENCY = False
          
              PARAM_PATH = "path"
              PARAM_CACHE = "cache"
          Severity: Major
          Found in dvc/output.py - About 7 hrs to fix

            File context.py has 436 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            import logging
            import os
            from abc import ABC, abstractmethod
            from collections import defaultdict
            from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
            Severity: Minor
            Found in dvc/parsing/context.py - About 6 hrs to fix

              File machine.py has 430 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              import argparse
              
              from dvc.cli.command import CmdBase
              from dvc.cli.utils import append_doc_link, fix_subparsers
              from dvc.commands.config import CmdConfig
              Severity: Minor
              Found in dvc/commands/machine.py - About 6 hrs to fix

                File stage.py has 418 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                import fnmatch
                import logging
                import time
                import typing
                from contextlib import suppress
                Severity: Minor
                Found in dvc/repo/stage.py - About 6 hrs to fix

                  File compare.py has 394 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  from collections import abc
                  from itertools import chain, repeat, zip_longest
                  from operator import itemgetter
                  from typing import (
                      TYPE_CHECKING,
                  Severity: Minor
                  Found in dvc/compare.py - About 5 hrs to fix

                    Function _collect_experiment_commit has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def _collect_experiment_commit(
                        repo,
                        exp_rev,
                        stash=False,
                        sha_only=True,
                    Severity: Minor
                    Found in dvc/repo/experiments/show.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 _collect_rows has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def _collect_rows(
                        base_rev,
                        experiments,
                        all_headers,
                        metric_headers,
                    Severity: Minor
                    Found in dvc/commands/experiments/show.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

                    File dvc.py has 376 lines of code (exceeds 250 allowed). Consider refactoring.
                    Open

                    import logging
                    import ntpath
                    import os
                    import posixpath
                    import threading
                    Severity: Minor
                    Found in dvc/fs/dvc.py - About 5 hrs to fix

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

                      if args.path:
                          pkg = pathlib.Path(args.path)
                      else:
                          pkgs = list(path.glob("*.pkg"))
                          if not pkgs:
                      Severity: Major
                      Found in scripts/fpm/notarize.py and 1 other location - About 4 hrs to fix
                      scripts/fpm/sign.py on lines 25..37

                      Duplicated Code

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

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

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

                      Tuning

                      This issue has a mass of 84.

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

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

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

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

                      Refactorings

                      Further Reading

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

                      if args.path:
                          pkg = pathlib.Path(args.path)
                      else:
                          pkgs = list(path.glob("*.pkg"))
                          if not pkgs:
                      Severity: Major
                      Found in scripts/fpm/sign.py and 1 other location - About 4 hrs to fix
                      scripts/fpm/notarize.py on lines 33..45

                      Duplicated Code

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

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

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

                      Tuning

                      This issue has a mass of 84.

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

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

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

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

                      Refactorings

                      Further Reading

                      File data_sync.py has 366 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

                      import argparse
                      import logging
                      
                      from dvc.cli import completion
                      from dvc.cli.command import CmdBase
                      Severity: Minor
                      Found in dvc/commands/data_sync.py - About 4 hrs to fix

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

                                    processed_files_count = self.repo.push(
                                        targets=self.args.targets,
                                        jobs=self.args.jobs,
                                        remote=self.args.remote,
                                        all_branches=self.args.all_branches,
                        Severity: Major
                        Found in dvc/commands/data_sync.py and 1 other location - About 4 hrs to fix
                        dvc/commands/gc.py on lines 51..61

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 78.

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

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

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

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

                        Refactorings

                        Further Reading

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

                                self.repo.gc(
                                    all_branches=self.args.all_branches,
                                    all_tags=self.args.all_tags,
                                    all_commits=self.args.all_commits,
                                    all_experiments=self.args.all_experiments,
                        Severity: Major
                        Found in dvc/commands/gc.py and 1 other location - About 4 hrs to fix
                        dvc/commands/data_sync.py on lines 58..68

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 78.

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

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

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

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

                        Refactorings

                        Further Reading

                        File ignore.py has 343 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        import logging
                        import os
                        import re
                        from collections import namedtuple
                        from itertools import chain, groupby, takewhile
                        Severity: Minor
                        Found in dvc/ignore.py - About 4 hrs to fix

                          TabularData has 33 functions (exceeds 20 allowed). Consider refactoring.
                          Open

                          class TabularData(MutableSequence[Sequence["CellT"]]):
                              def __init__(self, columns: Sequence[str], fill_value: str = ""):
                                  self._columns: Dict[str, Column] = {name: Column() for name in columns}
                                  self._keys: List[str] = list(columns)
                                  self._fill_value = fill_value
                          Severity: Minor
                          Found in dvc/compare.py - About 4 hrs to fix

                            File plots.py has 331 lines of code (exceeds 250 allowed). Consider refactoring.
                            Open

                            import argparse
                            import json
                            import logging
                            import os
                            
                            
                            Severity: Minor
                            Found in dvc/commands/plots.py - About 3 hrs to fix
                              Severity
                              Category
                              Status
                              Source
                              Language