redisbench-admin 0.11.50__py3-none-any.whl → 0.11.52__py3-none-any.whl

redisbench_admin/cli.py

@@ -36,15 +36,22 @@ LOG_FORMAT = "%(asctime)s %(levelname)-4s %(message)s"
 LOG_DATEFMT = "%Y-%m-%d %H:%M:%S"
 
 
-def populate_with_poetry_data():
+def populate_with_project_data():
     project_name = "redisbench-admin"
     project_version = __version__
     project_description = None
     try:
-        poetry_data = toml.load("pyproject.toml")["tool"]["poetry"]
-        project_name = poetry_data["name"]
-        project_version = poetry_data["version"]
-        project_description = poetry_data["description"]
+        pyproject_toml = toml.load("pyproject.toml")
+        if "project" in pyproject_toml:
+            project_data = pyproject_toml["project"]
+            project_name = project_data["name"]
+            project_version = project_data["version"]
+            project_description = project_data.get("description")
+        else:
+            poetry_data = pyproject_toml["tool"]["poetry"]
+            project_name = poetry_data["name"]
+            project_version = poetry_data["version"]
+            project_description = poetry_data["description"]
     except FileNotFoundError:
         pass
 
@@ -59,7 +66,7 @@ def main():
         )
         sys.exit(1)
     requested_tool = sys.argv[1]
-    project_name, project_description, project_version = populate_with_poetry_data()
+    project_name, project_description, project_version = populate_with_project_data()
     parser = argparse.ArgumentParser(
         description=project_description,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,

redisbench_admin/compare/args.py

@@ -114,26 +114,6 @@ def create_compare_arguments(parser):
         type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
         default=START_TIME_NOW_UTC,
     )
-    parser.add_argument(
-        "--from-date-baseline",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--to-date-baseline",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--from-date-comparison",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
-    parser.add_argument(
-        "--to-date-comparison",
-        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
-        default=None,
-    )
     parser.add_argument(
         "--metric_mode",
         type=str,

redisbench_admin/compare/compare.py

@@ -314,10 +314,6 @@ def compare_command_logic(args, project_name, project_version):
         first_n_baseline,
         first_n_comparison,
         grafana_link_base,
-        args.from_date_baseline,
-        args.to_date_baseline,
-        args.from_date_comparison,
-        args.to_date_comparison,
     )
     comment_body = ""
     if total_comparison_points > 0:
@@ -597,99 +593,24 @@ def compute_regression_table(
     first_n_baseline=-1,
     first_n_comparison=-1,
     grafana_link_base=None,
-    from_date_baseline=None,
-    to_date_baseline=None,
-    from_date_comparison=None,
-    to_date_comparison=None,
 ):
     START_TIME_NOW_UTC, _, _ = get_start_time_vars()
     START_TIME_LAST_MONTH_UTC = START_TIME_NOW_UTC - datetime.timedelta(days=31)
-
-    # Handle separate baseline and comparison date ranges (takes precedence if defined)
-    if (
-        from_date_baseline is not None
-        or to_date_baseline is not None
-        or from_date_comparison is not None
-        or to_date_comparison is not None
-    ):
-        # Use separate date ranges for baseline and comparison
-        from_date_baseline = (
-            from_date_baseline
-            if from_date_baseline is not None
-            else START_TIME_LAST_MONTH_UTC
-        )
-        to_date_baseline = (
-            to_date_baseline if to_date_baseline is not None else START_TIME_NOW_UTC
-        )
-        from_date_comparison = (
-            from_date_comparison
-            if from_date_comparison is not None
-            else START_TIME_LAST_MONTH_UTC
-        )
-        to_date_comparison = (
-            to_date_comparison if to_date_comparison is not None else START_TIME_NOW_UTC
-        )
-
-        from_ts_ms_baseline = int(from_date_baseline.timestamp() * 1000)
-        to_ts_ms_baseline = int(to_date_baseline.timestamp() * 1000)
-        from_ts_ms_comparison = int(from_date_comparison.timestamp() * 1000)
-        to_ts_ms_comparison = int(to_date_comparison.timestamp() * 1000)
-
-        from_human_str_baseline = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms_baseline / 1000)
-        )
-        to_human_str_baseline = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms_baseline / 1000)
-        )
-        from_human_str_comparison = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms_comparison / 1000)
-        )
-        to_human_str_comparison = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms_comparison / 1000)
-        )
-
-        logging.info(
-            "Using separate time ranges - Baseline: {} to {}, Comparison: {} to {}".format(
-                from_human_str_baseline,
-                to_human_str_baseline,
-                from_human_str_comparison,
-                to_human_str_comparison,
-            )
-        )
-
-        # Use baseline range for legacy compatibility (will be overridden in data queries)
-        from_ts_ms = from_ts_ms_baseline
-        to_ts_ms = to_ts_ms_baseline
-
-        # Set legacy variables for table headers (show separate ranges info)
-        from_human_str = f"Baseline: {from_human_str_baseline} to {to_human_str_baseline}, Comparison: {from_human_str_comparison} to {to_human_str_comparison}"
-        to_human_str = to_human_str_baseline
-    else:
-        # Use legacy single date range for both baseline and comparison
-        if from_date is None:
-            from_date = START_TIME_LAST_MONTH_UTC
-        if to_date is None:
-            to_date = START_TIME_NOW_UTC
-        if from_ts_ms is None:
-            from_ts_ms = int(from_date.timestamp() * 1000)
-        if to_ts_ms is None:
-            to_ts_ms = int(to_date.timestamp() * 1000)
-
-        # Use same range for both baseline and comparison
-        from_ts_ms_baseline = from_ts_ms
-        to_ts_ms_baseline = to_ts_ms
-        from_ts_ms_comparison = from_ts_ms
-        to_ts_ms_comparison = to_ts_ms
-
-        from_human_str = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
-        )
-        to_human_str = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(to_ts_ms / 1000)
-        )
-        logging.info(
-            "Using a time-delta from {} to {}".format(from_human_str, to_human_str)
-        )
+    if from_date is None:
+        from_date = START_TIME_LAST_MONTH_UTC
+    if to_date is None:
+        to_date = START_TIME_NOW_UTC
+    if from_ts_ms is None:
+        from_ts_ms = int(from_date.timestamp() * 1000)
+    if to_ts_ms is None:
+        to_ts_ms = int(to_date.timestamp() * 1000)
+    from_human_str = humanize.naturaltime(
+        dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
+    )
+    to_human_str = humanize.naturaltime(dt.datetime.utcfromtimestamp(to_ts_ms / 1000))
+    logging.info(
+        "Using a time-delta from {} to {}".format(from_human_str, to_human_str)
+    )
     baseline_str, by_str_baseline, comparison_str, by_str_comparison = get_by_strings(
         baseline_branch,
         comparison_branch,
@@ -773,10 +694,6 @@ def compute_regression_table(
         comparison_tag,
         from_date,
         to_date,
-        from_ts_ms_baseline,
-        to_ts_ms_baseline,
-        from_ts_ms_comparison,
-        to_ts_ms_comparison,
     )
     logging.info(
         "Printing differential analysis between {} and {}".format(
@@ -1027,56 +944,7 @@ def from_rts_to_regression_table(
     comparison_tag=None,
     from_date=None,
     to_date=None,
-    from_ts_ms_baseline=None,
-    to_ts_ms_baseline=None,
-    from_ts_ms_comparison=None,
-    to_ts_ms_comparison=None,
 ):
-    # Use separate timestamp ranges if provided, otherwise use legacy single range
-    if (
-        from_ts_ms_baseline is not None
-        and to_ts_ms_baseline is not None
-        and from_ts_ms_comparison is not None
-        and to_ts_ms_comparison is not None
-    ):
-        # Use separate ranges for baseline and comparison
-        baseline_from_ts = from_ts_ms_baseline
-        baseline_to_ts = to_ts_ms_baseline
-        comparison_from_ts = from_ts_ms_comparison
-        comparison_to_ts = to_ts_ms_comparison
-        baseline_from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(baseline_from_ts / 1000)
-        )
-        baseline_to_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(baseline_to_ts / 1000)
-        )
-        comparison_from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(comparison_from_ts / 1000)
-        )
-        comparison_to_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(comparison_to_ts / 1000)
-        )
-        logging.info(
-            "Using separate timestamp ranges - Baseline: {} to {}, Comparison: {} to {}".format(
-                baseline_from_human, baseline_to_human, comparison_from_human, comparison_to_human
-            )
-        )
-    else:
-        # Use legacy single range for both
-        baseline_from_ts = from_ts_ms
-        baseline_to_ts = to_ts_ms
-        comparison_from_ts = from_ts_ms
-        comparison_to_ts = to_ts_ms
-        from_human = humanize.naturaltime(
-            dt.datetime.utcfromtimestamp(from_ts_ms / 1000)
-        )
-        to_human = humanize.naturaltime(dt.datetime.utcfromtimestamp(to_ts_ms / 1000))
-        logging.info(
-            "Using single timestamp range for both baseline and comparison: {} to {}".format(
-                from_human, to_human
-            )
-        )
-
     print_all = print_regressions_only is False and print_improvements_only is False
     table = []
     detected_regressions = []
@@ -1177,7 +1045,7 @@ def from_rts_to_regression_table(
         try:
             for ts_name_baseline in baseline_timeseries:
                 datapoints_inner = rts.ts().revrange(
-                    ts_name_baseline, baseline_from_ts, baseline_to_ts
+                    ts_name_baseline, from_ts_ms, to_ts_ms
                 )
                 baseline_datapoints.extend(datapoints_inner)
             (
@@ -1196,7 +1064,7 @@ def from_rts_to_regression_table(
             )
             for ts_name_comparison in comparison_timeseries:
                 datapoints_inner = rts.ts().revrange(
-                    ts_name_comparison, comparison_from_ts, comparison_to_ts
+                    ts_name_comparison, from_ts_ms, to_ts_ms
                 )
                 comparison_datapoints.extend(datapoints_inner)
 
@@ -1665,11 +1533,9 @@ def check_client_side_latency(
             comparison_ts = comparison_client_ts[0]
 
             # Get client-side latency data
-            baseline_client_data = rts.ts().revrange(
-                baseline_ts, baseline_from_ts, baseline_to_ts
-            )
+            baseline_client_data = rts.ts().revrange(baseline_ts, from_ts_ms, to_ts_ms)
             comparison_client_data = rts.ts().revrange(
-                comparison_ts, comparison_from_ts, comparison_to_ts
+                comparison_ts, from_ts_ms, to_ts_ms
             )
 
             if len(baseline_client_data) == 0 or len(comparison_client_data) == 0:
@@ -2012,15 +1878,11 @@ def perform_variance_and_p99_analysis(
             comparison_p99_data = []
 
             for ts_name in baseline_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, baseline_from_ts, baseline_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 baseline_p99_data.extend(datapoints)
 
             for ts_name in comparison_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, comparison_from_ts, comparison_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 comparison_p99_data.extend(datapoints)
 
             if len(baseline_p99_data) < 3 or len(comparison_p99_data) < 3:
@@ -2368,15 +2230,11 @@ def check_latency_for_unstable_throughput(
             comparison_latency_data = []
 
             for ts_name in baseline_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, baseline_from_ts, baseline_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 baseline_latency_data.extend(datapoints)
 
             for ts_name in comparison_ts_list:
-                datapoints = rts.ts().revrange(
-                    ts_name, comparison_from_ts, comparison_to_ts
-                )
+                datapoints = rts.ts().revrange(ts_name, from_ts_ms, to_ts_ms)
                 comparison_latency_data.extend(datapoints)
 
             if len(baseline_latency_data) == 0 or len(comparison_latency_data) == 0:

redisbench_admin/export/export.py

@@ -76,7 +76,6 @@ def export_command_logic(args, project_name, project_version):
                 exporter_timemetric_path,
                 _,
                 _,
-                _,
             ) = get_defaults(exporter_spec_file)
     arch = args.architecture
     logging.info("Using the following architecture on the timeseries: {}".format(arch))

redisbench_admin/profilers/daemon.py

@@ -16,7 +16,7 @@ import botocore
 import daemonize
 from flask import Flask, request
 
-from redisbench_admin.cli import populate_with_poetry_data
+from redisbench_admin.cli import populate_with_project_data
 from redisbench_admin.profilers.perf import Perf
 from redisbench_admin.profilers.perf_daemon_caller import PERF_DAEMON_LOGNAME
 from redisbench_admin.profilers.profilers_local import local_profilers_platform_checks
@@ -282,7 +282,7 @@ class PerfDaemon:
 
 
 def main():
-    _, project_description, project_version = populate_with_poetry_data()
+    _, project_description, project_version = populate_with_project_data()
     project_name = "perf-daemon"
     parser = argparse.ArgumentParser(
         description=project_description,