'Refactored by Sourcery'

src/whylogs/app/logger.py

@@ -124,9 +124,8 @@ def segmented_profiles(self, ) -> Dict[str, DatasetProfile]:
 
     def get_segment(self, segment: Segment) -> Optional[DatasetProfile]:
         hashed_seg = hash_segment(segment)
-        segment_profile = self._profiles[-1]["segmented_profiles"].get(
+        return self._profiles[-1]["segmented_profiles"].get(
             hashed_seg, None)
-        return segment_profile
 
     def set_segments(self, segments: Union[List[Segment], List[str]]) -> None:
         if segments:
@@ -159,45 +158,44 @@ def _intialize_profiles(self,
             {"full_profile": full_profile, "segmented_profiles": {}})
 
     def _set_rotation(self, with_rotation_time: str = None):
-        if with_rotation_time is not None:
-            self.with_rotation_time = with_rotation_time.lower()
-
-            m = re.match(r'^(\d*)([smhd])$', with_rotation_time.lower())
-            if m is None:
-                raise TypeError("Invalid rotation interval, expected integer followed by one of 's', 'm', 'h', or 'd'")
-
-            interval = 1 if m.group(1) == '' else int(m.group(1))
-            if m.group(2) == 's':
-                self.suffix = "%Y-%m-%d_%H-%M-%S"
-            elif m.group(2) == 'm':
-                interval *= 60  # one minute
-                self.suffix = "%Y-%m-%d_%H-%M"
-            elif m.group(2) == 'h':
-                interval *= 60 * 60  # one hour
-                self.suffix = "%Y-%m-%d_%H"
-            elif m.group(2) == 'd':
-                interval *= 60 * 60 * 24  # one day
-                self.suffix = "%Y-%m-%d"
-            else:
-                raise TypeError("Invalid rotation interval, expected integer followed by one of 's', 'm', 'h', or 'd'")
-            # time in seconds
-            current_time = int(datetime.datetime.utcnow().timestamp())
-            self.interval = interval * self.interval_multiplier
-            self.rotate_at = self.rotate_when(current_time)
+        if with_rotation_time is None:
+            return
+
+        self.with_rotation_time = with_rotation_time.lower()
+
+        m = re.match(r'^(\d*)([smhd])$', with_rotation_time.lower())
+        if m is None:
+            raise TypeError("Invalid rotation interval, expected integer followed by one of 's', 'm', 'h', or 'd'")
+
+        interval = 1 if m.group(1) == '' else int(m.group(1))
+        if m.group(2) == 's':
+            self.suffix = "%Y-%m-%d_%H-%M-%S"
+        elif m.group(2) == 'm':
+            interval *= 60  # one minute
+            self.suffix = "%Y-%m-%d_%H-%M"
+        elif m.group(2) == 'h':
+            interval *= 60 * 60  # one hour
+            self.suffix = "%Y-%m-%d_%H"
+        elif m.group(2) == 'd':
+            interval *= 60 * 60 * 24  # one day
+            self.suffix = "%Y-%m-%d"
+        else:
+            raise TypeError("Invalid rotation interval, expected integer followed by one of 's', 'm', 'h', or 'd'")
+        # time in seconds
+        current_time = int(datetime.datetime.utcnow().timestamp())
+        self.interval = interval * self.interval_multiplier
+        self.rotate_at = self.rotate_when(current_time)
 
     def rotate_when(self, time):
-        result = time + self.interval
-        return result
+        return time + self.interval
 
     def should_rotate(self, ):
 
         if self.with_rotation_time is None:
             return False
 
         current_time = int(datetime.datetime.utcnow().timestamp())
-        if current_time >= self.rotate_at:
-            return True
-        return False
+        return current_time >= self.rotate_at
 
     def _rotate_time(self):
         """
@@ -212,7 +210,7 @@ def _rotate_time(self):
             time_tuple.strftime(self.suffix), self.suffix)
 
         # modify the segment datetime stamps
-        if (self.segments is None) or ((self.segments is not None) and self.profile_full_dataset):
+        if self.segments is None or self.profile_full_dataset:
             self._profiles[-1]["full_profile"].dataset_timestamp = log_datetime
         if self.segments is not None:
             for _, each_prof in self._profiles[-1]["segmented_profiles"].items():
@@ -255,11 +253,10 @@ def flush(self, rotation_suffix: str = None):
                 for hashseg, each_seg_prof in self._profiles[-1]["segmented_profiles"].items():
                     seg_suffix = hashseg
                     full_suffix = "_" + seg_suffix
-                    if rotation_suffix is None:
-                        writer.write(each_seg_prof, full_suffix)
-                    else:
+                    if rotation_suffix is not None:
                         full_suffix += rotation_suffix
-                        writer.write(each_seg_prof, full_suffix)
+
+                    writer.write(each_seg_prof, full_suffix)
 
     def full_profile_check(self, ) -> bool:
         """
@@ -413,7 +410,7 @@ def log_local_dataset(self, root_dir, folder_feature_name="folder_feature", imag
             if isinstance(data, pd.DataFrame):
                 self.log_dataframe(data)
 
-            elif isinstance(data, Dict) or isinstance(data, list):
+            elif isinstance(data, (Dict, list)):
                 self.log_annotation(annotation_data=data)
             elif isinstance(data, ImageType):
                 if image_feature_transforms:
@@ -508,10 +505,11 @@ def log_segments_keys(self, data):
         for each_segment in segments:
             try:
                 segment_df = grouped_data.get_group(each_segment)
-                segment_tags = []
-                for i in range(len(self.segments)):
-                    segment_tags.append(
-                        {"key": self.segments[i], "value": each_segment[i]})
+                segment_tags = [
+                    {"key": self.segments[i], "value": each_segment[i]}
+                    for i in range(len(self.segments))
+                ]
+
                 self.log_df_segment(segment_df, segment_tags)
             except KeyError:
                 continue
@@ -522,7 +520,7 @@ def log_fixed_segments(self, data):
         for segment_tag in self.segments:
             # create keys
             segment_keys = [feature["key"] for feature in segment_tag]
-            seg = tuple([feature["value"] for feature in segment_tag])
+            seg = tuple(feature["value"] for feature in segment_tag)
 
             grouped_data = data.groupby(segment_keys)