Showing 452 of 528 total issues
File output.py
has 1012 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
import os
from collections import defaultdict
from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Type
from urllib.parse import urlparse
File base.py
has 625 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
import os
import pickle
from abc import ABC, abstractmethod
from contextlib import contextmanager
File base.py
has 623 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
import os
from abc import ABC, abstractmethod
from dataclasses import asdict, dataclass
from typing import (
File show.py
has 584 lines of code (exceeds 250 allowed). Consider refactoring. Open
import argparse
import logging
import os
import re
from collections import Counter, OrderedDict, defaultdict
Output
has 59 functions (exceeds 20 allowed). Consider refactoring. Open
class Output:
IS_DEPENDENCY = False
PARAM_PATH = "path"
PARAM_CACHE = "cache"
File __init__.py
has 486 lines of code (exceeds 250 allowed). Consider refactoring. Open
import csv
import io
import logging
import os
from collections import OrderedDict, defaultdict
File context.py
has 436 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
from abc import ABC, abstractmethod
from collections import defaultdict
from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
from contextlib import contextmanager
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
File __init__.py
has 413 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
import os
import re
import time
from typing import Dict, Iterable, Optional
File show.py
has 412 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
from collections import OrderedDict, defaultdict
from datetime import datetime
from enum import Enum
from itertools import chain
File index.py
has 406 lines of code (exceeds 250 allowed). Consider refactoring. Open
import logging
import time
from functools import partial
from typing import (
TYPE_CHECKING,
File celery.py
has 395 lines of code (exceeds 250 allowed). Consider refactoring. Open
import hashlib
import locale
import logging
import os
from typing import (
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,
Function _collect_rows
has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring. Open
def _collect_rows( # noqa: C901
base_rev,
experiments,
all_headers,
metric_headers,
- Read upRead up
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 plots.py
has 373 lines of code (exceeds 250 allowed). Consider refactoring. Open
import argparse
import json
import logging
import os
Function move_properties_to_head
has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring. Open
def move_properties_to_head(result: Dict[str, Dict[str, Dict[str, Any]]]):
for _, baseline_results in result.items():
checkpoint: bool = False
head: Dict[str, Any] = {}
for rev, rev_data in baseline_results.items():
- Read upRead up
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 data_sync.py
has 367 lines of code (exceeds 250 allowed). Consider refactoring. Open
import argparse
import logging
from dvc.cli import completion
from dvc.cli.command import CmdBase
Function push
has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring. Open
def push( # noqa: C901
self,
targets=None,
jobs=None,
remote=None,
- Read upRead up
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 _
has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring. Open
def _(obj: dict): # noqa: C901
from dvc.config import Config
config = Config().get("parsing", {})
- Read upRead up
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 ignore.py
has 360 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