Sign upLogin

whylabs/whylogs-python

View on GitHub
Star
python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py

Summary

Maintainability
C
7 hrs
Test Coverage

Function _write_pending has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
Open

    def _write_pending(self) -> None:
        new_state: Dict[Writer, List[PendingWritable]] = {}
        for writer, pending in self._writers.items():
            failures: List[PendingWritable] = []
            self._logger.info(f"Writing out result set with {type(writer).__name__}")
Severity: Minor
Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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

ThreadRollingLogger has 21 functions (exceeds 20 allowed). Consider refactoring.
Open

class ThreadRollingLogger(ThreadActor[LoggerMessage], DataLogger[LoggerStatus]):
    """
    A logger that manages profiles and segments for various dataset timestamps.

    This logger manages a map of dataset timestamp to dataset profile/segment and handles proper
Severity: Minor
Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py - About 2 hrs to fix

    Function _process_status_message has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

        def _process_status_message(self, message: StatusMessage) -> None:
        profiles = 0
        segment_caches = 0
        views: List[bytes] = []
        for container in self._cache.values():
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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 __init__ has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(
        self,
        aggregate_by: TimeGranularity = TimeGranularity.Hour,
        write_schedule: Optional[Schedule] = Schedule(cadence=TimeGranularity.Minute, interval=10),
        schema: Optional[DatasetSchema] = None,
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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 _process_flush_message has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
    Open

        def _process_flush_message(self, message: FlushMessage) -> None:
        for dataset_timestamp, container in self._cache.items():
            self._logger.debug(f"Generating result set for dataset timestamp {dataset_timestamp}")

            result_set = container.to_result_set()
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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 _track_segments has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
    Open

        def _track_segments(self, data: TrackData) -> None:
        if self._schema is None:
            raise Exception("Schema missing in logger while using segments")

        if not isinstance(self._target, SegmentCache):
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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 process_batch has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
    Open

        def process_batch(self, batch: List[LoggerMessage], batch_type: Type[LoggerMessage]) -> None:
        if batch_type == TrackMessage:
            self._process_track_messages(cast(List[TrackMessage], batch))
        elif batch_type == FlushMessage:
            self._process_flush_messages(cast(List[FlushMessage], batch))
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.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

    TODO found
    Open

                # TODO consider porting out the aggregation logic that the process rolling logger uses to batch up
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by fixme

    Line too long (81 > 79 characters)
    Open

    from whylogs.api.logger.experimental.logger.actor.thread_actor import ThreadActor
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (102 > 79 characters)
    Open

                return [it for it in [result_set.view(segment) for segment in segments] if it is not None]
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (88 > 79 characters)
    Open

        def __init__(self, dataset_timestamp: int, schema: Optional[DatasetSchema]) -> None:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (96 > 79 characters)
    Open

        This logger manages a map of dataset timestamp to dataset profile/segment and handles proper
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (109 > 79 characters)
    Open

        The logger is associated with one or no dataset schema as well. That will determine if the logger creates
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (96 > 79 characters)
    Open

                if write_schedule.cadence == TimeGranularity.Minute and write_schedule.interval < 5:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (118 > 79 characters)
    Open

                            self._logger.info(f"Writing failed too many times ({p.attempts}) for {type(writer).__name__}")
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (81 > 79 characters)
    Open

            Get all of the profile views for each dataset timestamp being maintained.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (115 > 79 characters)
    Open

        Trigger a flush, converting all managed profiles to result sets and attempt to write them if there are writers.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (97 > 79 characters)
    Open

        def process_batch(self, batch: List[LoggerMessage], batch_type: Type[LoggerMessage]) -> None:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (80 > 79 characters)
    Open

    from whylogs.api.logger.experimental.logger.actor.future_util import wait_result
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (101 > 79 characters)
    Open

        This can only be used to manage a single entity for a given time. For example, this can represent
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (98 > 79 characters)
    Open

            dataset_timestamps: The amount of dataset timestamps being managed. Each of these will map
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (105 > 79 characters)
    Open

            - That dataset timestamp is used as the key to either create a dataset profile/segment, or to add
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (109 > 79 characters)
    Open

        The logger also periodically attempts to write out the internal state according to the write_schedule. It
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

            write_schedule: Optional[Schedule] = Schedule(cadence=TimeGranularity.Minute, interval=10),
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (85 > 79 characters)
    Open

                self._logger.info(f"Writing out result set with {type(writer).__name__}")
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (95 > 79 characters)
    Open

                    logging since the only errors that can be responded to are data format related.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (83 > 79 characters)
    Open

                raise Exception("Segment cache missing in logger while using segments")
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (85 > 79 characters)
    Open

                    segment_processing(self._schema, row=row, segment_cache=self._target)
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (110 > 79 characters)
    Open

                each time period that the logger is configured to manage. For example, if the logger is configured
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (108 > 79 characters)
    Open

            if not isinstance(data, pd.DataFrame) and not isinstance(data, list) and not isinstance(data, dict):
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (84 > 79 characters)
    Open

                    return self._target.flush(dataset_timestamp=self._dataset_timestamp)
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

                if write_schedule.cadence == TimeGranularity.Second and write_schedule.interval <= 300:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (117 > 79 characters)
    Open

                sync: Whether or not to perform this action synchronously. By default, this is an asynchronous operation.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (97 > 79 characters)
    Open

            result: an optional Future that is fulfilled when the track has completed. It will either
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (96 > 79 characters)
    Open

            Flush the internal state, causing everything to be written using the configured writers.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (97 > 79 characters)
    Open

    LoggerMessage = Union[TrackMessage, FlushMessage, StatusMessage, GetResultsMessage, CloseMessage]
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (93 > 79 characters)
    Open

                self._logger.debug(f"Generating views for dataset timestamp {dataset_timestamp}")
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (102 > 79 characters)
    Open

        This does the work of deciding how to track data and how to create profiles given a DatasetSchema.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (82 > 79 characters)
    Open

                        pending.append(PendingWritable(attempts=0, writable=writable))
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (86 > 79 characters)
    Open

            timestamp_ms: Optional[int] = None,  # The timestamp that the data happened at
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (114 > 79 characters)
    Open

                    You can make this synchronous in order to react to errors. Mostly useful when initially setting up
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (110 > 79 characters)
    Open

            self.send(TrackMessage(data=data, timestamp_ms=timestamp_ms or self.current_time_ms(), result=result))
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (107 > 79 characters)
    Open

            - The timestamp_ms will be truncated to the start of the day/hour (depending on aggregate_by). This
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (88 > 79 characters)
    Open

    from whylogs.core.view.segmented_dataset_profile_view import SegmentedDatasetProfileView
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (103 > 79 characters)
    Open

            if self.has_segments() and schema is not None:  # Need the duplicate None check for type safety
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (80 > 79 characters)
    Open

            This doesn't have any side effects. It generates a ResultSet of whatever
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (100 > 79 characters)
    Open

        logging to each type. Given a TimeGranularity to aggregate by, for each call to track(), roughly
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (88 > 79 characters)
    Open

        def _get_profile_container(self, dataset_timestamp: int) -> DatasetProfileContainer:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (92 > 79 characters)
    Open

                # data and minimize the amount of track calls. It makes a really big difference.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (88 > 79 characters)
    Open

    from whylogs.api.logger.experimental.logger.actor.actor import CloseMessage, QueueConfig
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (102 > 79 characters)
    Open

        This returns various metadata about the current state. Useful for logging, testing, and debugging.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

        will attempt to write three times before considering a result set unwritable and dropping it. o
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (122 > 79 characters)
    Open

                data: The data to log. This can either be a pandas data frame, a row (dictionary of str to str/int/float/etc),
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (100 > 79 characters)
    Open

            pending_writables: The amount of items that have been flushed but have not yet been written.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (80 > 79 characters)
    Open

    class ThreadRollingLogger(ThreadActor[LoggerMessage], DataLogger[LoggerStatus]):
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (98 > 79 characters)
    Open

                self._logger.debug(f"Generating result set for dataset timestamp {dataset_timestamp}")
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (116 > 79 characters)
    Open

                timestamp_ms: The timestamp of the data. If this isn't supplied then it is assumed to have happened now.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (84 > 79 characters)
    Open

    from whylogs.api.logger.segment_processing import segment_processing  # type: ignore
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

                self._target = DatasetProfile(dataset_timestamp=self._dataset_timestamp, schema=schema)
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

            dataset_profiles: The amount of dataset profiles being managed. One of these is created for
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (84 > 79 characters)
    Open

                self._process_get_results_messages(cast(List[GetResultsMessage], batch))
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (108 > 79 characters)
    Open

                self._cache[dataset_timestamp] = DatasetProfileContainer(dataset_timestamp, schema=self._schema)
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (99 > 79 characters)
    Open

            self._dataset_timestamp = datetime.fromtimestamp(dataset_timestamp / 1000.0, tz=tz.tzutc())
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (95 > 79 characters)
    Open

                result_set = self._target.get_result_set(dataset_timestamp=self._dataset_timestamp)
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (106 > 79 characters)
    Open

                to aggregate by hour and TrackMessages come in for two hours, then there will be two of these.
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (109 > 79 characters)
    Open

                    "No write schedule defined for logger. Profiles will only be written after calls to flush()."
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (87 > 79 characters)
    Open

        def _process_get_results_messages(self, messages: List[GetResultsMessage]) -> None:
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    Line too long (110 > 79 characters)
    Open

                # TODO consider porting out the aggregation logic that the process rolling logger uses to batch up
    Severity: Minor
    Found in python/whylogs/api/logger/experimental/logger/actor/thread_rolling_logger.py by pep8

    Limit all lines to a maximum of 79 characters.

    There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

    There are no issues that match your filters.

    Category
    Status