argus-alm 0.10.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

argus/backend/plugins/core.py

@@ -122,6 +122,24 @@ class PluginModelBase(Model):
 
         return list(rows)
 
+    @classmethod
+    def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE build_id = ? LIMIT ?")
+        rows = cluster.session.execute(query=query, parameters=(build_id, limit))
+
+        return list(rows)
+
+    @classmethod
+    def get_run_meta_by_run_id(cls, run_id: UUID | str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE id = ?")
+        rows = cluster.session.execute(query=query, parameters=(run_id,))
+
+        return list(rows)
+
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'PluginModelBase':
         raise NotImplementedError()

argus/backend/plugins/sct/testrun.py

@@ -45,7 +45,7 @@ class SCTTestRunSubmissionRequest():
 
 
 class SCTTestRun(PluginModelBase):
-    __table_name__ = "test_runs_v8"
+    __table_name__ = "sct_test_run"
     _plugin_name = "scylla-cluster-tests"
 
     # Test Details

argus/backend/plugins/sirenada/model.py

@@ -0,0 +1,113 @@
+from datetime import datetime
+from uuid import UUID, uuid4
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.usertype import UserType
+from cassandra.cqlengine.models import Model
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.web import ArgusRelease
+from argus.backend.plugins.core import PluginModelBase
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, SirenadaPluginException
+from argus.backend.util.enums import TestStatus
+
+
+class SirenadaTest(UserType):
+    test_name = columns.Text()
+    class_name = columns.Text()
+    file_name = columns.Text()
+    browser_type = columns.Text()
+    cluster_type = columns.Text()
+    status = columns.Text()
+    duration = columns.Float()
+    message = columns.Text()
+    start_time = columns.DateTime()
+    stack_trace = columns.Text()
+    screenshot_file = columns.Text()
+    s3_folder_id = columns.Text()
+    requests_file = columns.Text()
+    sirenada_test_id = columns.Text()
+    sirenada_user = columns.Text()
+    sirenada_password = columns.Text()
+
+
+
+class SirenadaRun(PluginModelBase):
+    _plugin_name = "sirenada"
+    __table_name__ = "sirenada_run"
+    logs = columns.Map(key_type=columns.Text(), value_type=columns.Text())
+    # TODO: Legacy field name, should be renamed to product_version and abstracted
+    scylla_version = columns.Text()
+    region = columns.Text()
+    sirenada_test_ids = columns.List(value_type=columns.Text())
+    s3_folder_ids = columns.List(value_type=columns.Tuple(columns.Text(), columns.Text()))
+    browsers = columns.List(value_type=columns.Text())
+    clusters = columns.List(value_type=columns.Text())
+    sct_test_id = columns.UUID()
+    results = columns.List(value_type=columns.UserDefinedType(user_type=SirenadaTest))
+
+    @classmethod
+    def _stats_query(cls) -> str:
+        return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+
+    @classmethod
+    def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:
+        if not cluster:
+            cluster = ScyllaCluster.get()
+        statement = cluster.prepare(f"SELECT scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+        rows = cluster.session.execute(query=statement, parameters=(release.id,))
+        unique_versions = {r["scylla_version"] for r in rows if r["scylla_version"]}
+
+        return sorted(list(unique_versions), reverse=True)
+
+    def submit_product_version(self, version: str):
+        self.scylla_version = version
+
+    def submit_logs(self, logs: dict[str, str]):
+        raise SirenadaPluginException("Log submission is not supported for Sirenada")
+
+    def finish_run(self):
+        raise SirenadaPluginException("Sirenada runs do not need finalization")
+
+    @classmethod
+    def load_test_run(cls, run_id: UUID) -> 'SirenadaRun':
+        return cls.get(id=run_id)
+
+    @classmethod
+    def submit_run(cls, request_data: RawSirenadaRequest) -> 'SirenadaRun':
+        try:
+            run = cls.get(id=UUID(request_data["run_id"]))
+        except cls.DoesNotExist:
+            run = cls()
+            run.id = request_data["run_id"]
+            run.build_id = request_data["build_id"]
+            run.start_time = datetime.utcnow()
+            run.assign_categories()
+            run.build_job_url = request_data["build_job_url"]
+            run.region = request_data["region"]
+            run.status = TestStatus.PASSED.value
+            try:
+                run.assignee = run.get_scheduled_assignee()
+            except Model.DoesNotExist:
+                run.assignee = None
+
+        for raw_case in request_data["results"]:
+            case = SirenadaTest(**raw_case)
+            if case.status in ["failed", "error"] and run.status not in [TestStatus.FAILED.value, TestStatus.ABORTED.value]:
+                run.status = TestStatus.FAILED.value
+            run.results.append(case)
+
+            if case.sirenada_test_id not in run.sirenada_test_ids:
+                run.sirenada_test_ids.append(case.sirenada_test_id)
+
+            if case.browser_type not in run.browsers:
+                run.browsers.append(case.browser_type)
+
+            if case.cluster_type not in run.clusters:
+                run.clusters.append(case.cluster_type)
+
+            if (case.s3_folder_id, case.sirenada_test_id) not in run.s3_folder_ids and case.s3_folder_id:
+                run.s3_folder_ids.append((case.s3_folder_id, case.sirenada_test_id))
+
+        run.save()
+
+        return run

argus/backend/plugins/sirenada/plugin.py

@@ -0,0 +1,17 @@
+from flask import Blueprint
+
+from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
+from argus.backend.plugins.sirenada.model import SirenadaRun, SirenadaTest
+
+
+class PluginInfo(PluginInfoBase):
+    # pylint: disable=too-few-public-methods
+    name: str = "sirenada"
+    model: PluginModelBase = SirenadaRun
+    controller: Blueprint = None
+    all_models = [
+        SirenadaRun
+    ]
+    all_types = [
+        SirenadaTest
+    ]

argus/backend/plugins/sirenada/types.py

@@ -0,0 +1,35 @@
+from typing import TypedDict
+
+
+class RawSirenadaTestCase(TypedDict):
+    test_name: str
+    class_name: str
+    file_name: str
+    browser_type: str
+    cluster_type: str
+    status: str
+    duration: float
+    message: str
+    start_time: str
+    stack_trace: str
+    screenshot_file: str
+    s3_folder_id: str
+    requests_file: str
+    sirenada_test_id: str
+    sirenada_user: str
+    sirenada_password: str
+
+
+class RawSirenadaRequest(TypedDict):
+    build_id: str
+    build_job_url: str
+    run_id: str # UUID
+    region: list[str]
+    browsers: list[str]
+    clusters: list[str]
+    sct_test_id: str
+    results: list[RawSirenadaTestCase]
+
+
+class SirenadaPluginException(Exception):
+    pass

argus/backend/service/stats.py

@@ -3,6 +3,7 @@ import logging
 from datetime import datetime
 from typing import TypedDict
 from uuid import UUID
+
 from argus.backend.plugins.loader import all_plugin_models
 from argus.backend.util.common import get_build_number
 from argus.backend.util.enums import TestStatus, TestInvestigationStatus
@@ -92,16 +93,28 @@ class ReleaseStats:
         self.all_tests = []
 
     def to_dict(self) -> dict:
+        converted_groups = {str(group.group.id): group.to_dict() for group in self.groups}
+        aggregated_investigation_status = {}
+        for group in converted_groups.values():
+            for investigation_status in TestInvestigationStatus:
+                current_status = aggregated_investigation_status.get(investigation_status.value, {})
+                result = {
+                    status.value: current_status.get(status.value, 0) + group.get(investigation_status.value, {}).get(status, 0)
+                    for status in TestStatus
+                }
+                aggregated_investigation_status[investigation_status.value] = result
+
         return {
             "release": dict(self.release.items()),
-            "groups": {str(group.group.id): group.to_dict() for group in self.groups},
+            "groups": converted_groups,
             "total": self.total_tests,
             **self.status_map,
             "disabled": not self.release.enabled,
             "perpetual": self.release.perpetual,
             "lastStatus": self.last_investigation_status,
             "lastInvestigationStatus": self.last_investigation_status,
-            "hasBugReport": self.has_bug_report
+            "hasBugReport": self.has_bug_report,
+            **aggregated_investigation_status
         }
 
     def collect(self, rows: list[TestRunStatRow], limited=False, force=False) -> None:
@@ -144,6 +157,15 @@ class GroupStats:
         self.tests: list[TestStats] = []
 
     def to_dict(self) -> dict:
+        converted_tests = {str(test.test.id): test.to_dict() for test in self.tests}
+        investigation_progress = {}
+        for test in converted_tests.values():
+            progress_for_status = investigation_progress.get(test["investigation_status"], {})
+            status_count = progress_for_status.get(test["status"], 0)
+            status_count += 1
+            progress_for_status[test["status"]] = status_count
+            investigation_progress[test["investigation_status"]] = progress_for_status
+
         return {
             "group": dict(self.group.items()),
             "total": self.total_tests,
@@ -151,7 +173,8 @@ class GroupStats:
             "lastStatus": self.last_status,
             "lastInvestigationStatus": self.last_investigation_status,
             "disabled": self.disabled,
-            "tests": {str(test.test.id): test.to_dict() for test in self.tests}
+            "tests": converted_tests,
+            **investigation_progress
         }
 
     def collect(self, limited=False):

argus/backend/service/testrun.py

@@ -68,14 +68,14 @@ class TestRunService:
         if not plugin:
             return []
 
-        last_runs: list[PluginModelBase] = list(plugin.model.filter(build_id=test.build_system_id).limit(limit).all())
-        last_runs_ids = [run.id for run in last_runs]
+        last_runs: list[dict] = plugin.model.get_run_meta_by_build_id(build_id=test.build_system_id, limit=limit)
+        last_runs_ids = [run["id"] for run in last_runs]
         for added_run in additional_runs:
             if added_run not in last_runs_ids:
-                last_runs.append(plugin.model.get(id=added_run))
+                last_runs.extend(plugin.model.get_run_meta_by_run_id(run_id=added_run))
 
         for row in last_runs:
-            setattr(row, "build_number", get_build_number(build_job_url=row.build_job_url))
+            row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
         return last_runs
 
@@ -391,7 +391,7 @@ class TestRunService:
             response = []
             for issue in all_issues:
                 runs = runs_by_issue.get(issue, [])
-                runs.append(issue.run_id)
+                runs.append({"test_id": issue.test_id, "run_id": issue.run_id})
                 runs_by_issue[issue] = runs
 
             for issue, runs in runs_by_issue.items():

argus/client/sirenada/client.py

@@ -0,0 +1,151 @@
+import json
+import logging
+from glob import glob, escape
+from pathlib import Path
+from typing import TypedDict
+from xml.etree import ElementTree
+
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, RawSirenadaTestCase
+
+from argus.client.base import ArgusClient
+
+
+LOGGER = logging.getLogger(__name__)
+
+class SirenadaEnv(TypedDict):
+    SIRENADA_JOB_ID: str
+    SIRENADA_BROWSER: str
+    SIRENADA_REGION: str
+    SIRENADA_CLUSTER: str
+    WORKSPACE: str
+    BUILD_NUMBER: str
+    BUILD_URL: str
+    JOB_NAME: str
+
+
+class TestCredentials(TypedDict):
+    SIRENADA_TEST_ID: str
+    SIRENADA_USER_NAME: str
+    SIRENADA_USER_PASS: str
+    SIRENADA_OTP_SECRET: str
+    ClusterID: str
+    region: str
+
+class ArgusSirenadaClient(ArgusClient):
+    test_type = "sirenada"
+    schema_version: None = "v1"
+    _junit_xml_filename = "junit_results.xml"
+    _credentials_filename = "test_credentials.json"
+    _bucket_url_template = "https://sirenada-results.s3.us-east-1.amazonaws.com/{s3_id}/{test_results_dir}/{filename}"
+    TEST_TAG_MAPPING = {
+        "failure": "failed",
+        "error": "aborted",
+        "skipped": "skipped"
+    }
+
+    def __init__(self, auth_token: str, base_url: str, api_version="v1") -> None:
+        self.results_path: Path | None = None
+        super().__init__(auth_token, base_url, api_version)
+
+    def _verify_required_files_exist(self, results_path: Path):
+        assert (results_path / self._junit_xml_filename).exists(), "Missing jUnit XML results file!"
+        assert (results_path / self._credentials_filename).exists(), "Missing test credentials file!"
+
+    @staticmethod
+    def _verify_env(env: SirenadaEnv):
+        for key in SirenadaEnv.__annotations__.keys():
+            assert env.get(key), f"Missing required key {key} in the environment"
+
+    def _set_files_for_failed_test(self, test_case: RawSirenadaTestCase):
+        test_results_dir = f"sirenada-{test_case['sirenada_test_id']}"
+        results_dir: Path = self.results_path / test_results_dir
+
+        just_class_name = test_case.get("class_name").split(".")[-1]
+        requests_pattern = f"{just_class_name}-{test_case.get('test_name')}.requests.json"
+        screenshot_pattern = f"{just_class_name}-{escape(test_case.get('test_name'))}-*.png"
+
+        if not results_dir.exists():
+            return
+
+        if not (s3_bucket_id_path := (results_dir / "s3_id")).exists():
+            return
+
+        with open(s3_bucket_id_path, "rt") as s3_id_file:
+            test_case["s3_folder_id"] = s3_id_file.read().strip()
+
+        test_case["requests_file"] = self._bucket_url_template.format(
+            s3_id=test_case.get("s3_folder_id"),
+            test_results_dir=test_results_dir,
+            filename=requests_pattern,
+        )
+
+        screenshots = glob(pathname=screenshot_pattern, root_dir=results_dir)
+        if len(screenshots) > 0:
+            test_case["screenshot_file"] = self._bucket_url_template.format(
+                s3_id=test_case.get("s3_folder_id"),
+                test_results_dir=test_results_dir,
+                filename=screenshots[0],
+            )
+
+    def _set_case_status(self, raw_case: RawSirenadaTestCase, junit_case: ElementTree.Element):
+        subelements = list(junit_case.iter())
+        if len(subelements) == 2:
+            status_node = subelements[1]
+            raw_case["status"] = self.TEST_TAG_MAPPING.get(status_node.tag, "failed")
+            raw_case["message"] = status_node.get("message", "#NO_MESSAGE")
+            raw_case["stack_trace"] = status_node.text
+            self._set_files_for_failed_test(raw_case)
+        else:
+            raw_case["status"] = "passed"
+
+    def _parse_junit_results(self, junit_xml: Path, credentials: TestCredentials, env: SirenadaEnv) -> list[RawSirenadaTestCase]:
+        etree = ElementTree.parse(source=junit_xml)
+        cases = list(etree.iter("testcase"))
+        assert len(cases) > 0, "No test cases found in test results XML."
+
+        parsed_cases: list[RawSirenadaTestCase] = []
+        for case in cases:
+            raw_case: RawSirenadaTestCase = {}
+            raw_case["class_name"] = case.get("classname", "#NO_CLASSNAME")
+            raw_case["file_name"] = case.get("file", "#NO_FILE")
+            raw_case["test_name"] = case.get("name", "#NO_TEST_NAME")
+            raw_case["browser_type"] = env.get("SIRENADA_BROWSER")
+            raw_case["cluster_type"] = env.get("SIRENADA_CLUSTER")
+            raw_case["duration"] = float(case.attrib.get("time", "0.0"))
+            raw_case["sirenada_test_id"] = credentials.get("SIRENADA_TEST_ID")
+            raw_case["sirenada_user"] = credentials.get("SIRENADA_USER_NAME")
+            raw_case["sirenada_password"] = credentials.get("SIRENADA_USER_PASS")
+            self._set_case_status(raw_case, case)
+            parsed_cases.append(raw_case)
+
+        return parsed_cases
+
+    @staticmethod
+    def _read_credentials(credentials_path: Path) -> TestCredentials:
+        with open(credentials_path, "rt") as creds_file:
+            credentials: TestCredentials = json.load(creds_file)
+
+        assert credentials.get("SIRENADA_TEST_ID"), "Credentials are missing required field: SIRENADA_TEST_ID"
+        return credentials
+
+    def submit_sirenada_run(self, env: SirenadaEnv, test_results_path: Path):
+        self.results_path = test_results_path
+        try:
+            self._verify_env(env)
+            self._verify_required_files_exist(self.results_path)
+        except AssertionError as exc:
+            LOGGER.critical("%s", exc.args[0])
+            raise exc
+
+        credentials = self._read_credentials(self.results_path / self._credentials_filename)
+        results = self._parse_junit_results(junit_xml=self.results_path / self._junit_xml_filename, credentials=credentials, env=env)
+        request_body: RawSirenadaRequest = {}
+
+        request_body["run_id"] = env.get("SIRENADA_JOB_ID")
+        request_body["build_id"] = env.get("JOB_NAME")
+        request_body["build_job_url"] = env.get("BUILD_URL")
+        request_body["region"] = env.get("SIRENADA_REGION")
+        request_body["results"] = results
+
+        response = self.submit_run(run_type=self.test_type, run_body=request_body)
+        self.check_response(response)

{argus_alm-0.10.2.dist-info → argus_alm-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.10.2
+Version: 0.11.0
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0
@@ -10,9 +10,8 @@ Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
-Requires-Dist: PyYAML (>=5.4.1,<6.0.0)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
-Requires-Dist: scylla-driver (>=3.24.8,<4.0.0)
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: requests (>=2.26.0,<3.0.0)
 Project-URL: Repository, https://github.com/scylladb/argus
 Description-Content-Type: text/markdown
 

{argus_alm-0.10.2.dist-info → argus_alm-0.11.0.dist-info}/RECORD

@@ -20,7 +20,7 @@ argus/backend/events/event_processors.py,sha256=-GKSE4xNFXtjwR9QuRpWbfA_ixarMrGa
 argus/backend/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/models/web.py,sha256=imXIbp9VSEywzB4hh5uQXf_PlL4wN11XLyalnISbHwU,12069
 argus/backend/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argus/backend/plugins/core.py,sha256=dPSls0ghXbUz2iTSQhTWJHnYKEp8HBCuFUrz0H6vWDI,5604
+argus/backend/plugins/core.py,sha256=VnlCFdWDBYMWi7R-e5Cb-cG3JWFNOlA94Zq98VDsaQQ,6562
 argus/backend/plugins/driver_matrix_tests/controller.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/backend/plugins/driver_matrix_tests/model.py,sha256=DObVIfN8NXLrqdhmx-kPkS0rLvlL_B0eEwlUPXqN8Cs,4748
 argus/backend/plugins/driver_matrix_tests/plugin.py,sha256=NZN6lpHFpNuBkv2D_gGHh03402z0qlOeCWjgZXRs2c4,637
@@ -31,17 +31,20 @@ argus/backend/plugins/sct/controller.py,sha256=psm08pLQQCTTKP8xGdCe6YQS_AQoOBbR1
 argus/backend/plugins/sct/plugin.py,sha256=-ezQ7brAdgQ_YJpZiCaVBNuzP91FtBiKWf_IXy70xgg,902
 argus/backend/plugins/sct/resource_setup.py,sha256=hwfAOu-oKOH42tjtzJhiqwq_MtUE9_HevoFyql8JKqY,10120
 argus/backend/plugins/sct/service.py,sha256=YIyPtiHY0VMW9n6icVWeM7z9OF3WcLNQ7LJZCpF8akE,8723
-argus/backend/plugins/sct/testrun.py,sha256=5MCNT-ZKmYf9ATObV0YBxLVb5L3NaLbRp3R95mCaum0,6556
+argus/backend/plugins/sct/testrun.py,sha256=Amj2-Wg2go2hd8EJc1upuGnff_RhpD4c3KXIoORJQGg,6556
 argus/backend/plugins/sct/udt.py,sha256=j1Q7sidzYXxP8ELkkaT-YeJqhe7qixNU9tbNuzLQ5_8,2420
+argus/backend/plugins/sirenada/model.py,sha256=hZZvpUBp8Ch-hWVGjT_ua3xxhQicEIUK6NLGQGhAkts,4639
+argus/backend/plugins/sirenada/plugin.py,sha256=AlQAakwy3u-OqAqqK3RonUR5oDm-JoiwBUDUF3YEVP4,447
+argus/backend/plugins/sirenada/types.py,sha256=Gm3XMK9YJoozVaeM9XE7n8iRxA6PKBrS23Mo2vJfdLs,697
 argus/backend/service/admin.py,sha256=_VnWl3CkZBOAie_pPbd9sbXZUpBf2SApyNoFZLfB_QI,637
 argus/backend/service/argus_service.py,sha256=hF_-d6dNyHBx_KO-RjH-a7MK8T3cjLI2cR5XoHBObKc,24865
 argus/backend/service/build_system_monitor.py,sha256=ODxU2LxqJPOqU0r0sDSkxk73ZXjlaYngsJeXg4m-O5c,6586
 argus/backend/service/client_service.py,sha256=wvR0PY5nCwKmIXuxrR_kNtY4WR8SLvRk6SOnxVU1myI,2109
 argus/backend/service/notification_manager.py,sha256=h00Ej_-hH9H7pq0wah_1TH8dnpPyPNsgVJNO1rwJi7o,7011
 argus/backend/service/release_manager.py,sha256=v2yg45oWBpK_uwqkHtJHPTPbe21_cJu3skmzeaChVhw,6259
-argus/backend/service/stats.py,sha256=hL4ca5ETZI0PKsfMeQuB0ZQD-usQL4SExBXA5N7b5ZI,11110
+argus/backend/service/stats.py,sha256=R8krmGi2RsOBSV3ZHDS9crkXSogiPqSnDE2LRYy3APs,12274
 argus/backend/service/team_manager_service.py,sha256=zY5dvy3ffvQbJuXBvlWKE5dS5LQ3ss6tkFE-cwFZsdw,3010
-argus/backend/service/testrun.py,sha256=tBpmyjochlqvJsAk_StlvmSHTyBqidZ21RPAzJ7QqlI,17829
+argus/backend/service/testrun.py,sha256=wCHowQoD_PkTdpyXLQ1EXxkU_pfvgpaDde5xOUD5Fn8,17883
 argus/backend/service/user.py,sha256=uvhOOvMgrYJHV1I6RH3P-h1d--TlO55uvum8eOpHyxQ,8858
 argus/backend/template_filters.py,sha256=hD8eDyBYp-X6JVoyQhM-TWYv3MuyorAv0Emz728iGcU,523
 argus/backend/util/common.py,sha256=fmE9cKnJ1CX_Cz4Mw1d_M-T-jwPh8DkKr_fLAx8LY9M,1458
@@ -56,6 +59,7 @@ argus/client/base.py,sha256=q0awF6GX4Ufi-3IjfBTYvh4dZAfBQCqimEKcSxlvMmg,5972
 argus/client/driver_matrix_tests/client.py,sha256=pnyE2YSSyBJ9XZjG-z_hEaKQJV7oP6hFaxDqUjxVY5o,7585
 argus/client/sct/client.py,sha256=mc44QXDwxgXAY51yO0ui9w9V_tNgt4-M_yq__8fvnXQ,8217
 argus/client/sct/types.py,sha256=VLgVe7qPmJtCLqtPnuX8N8kMKZq-iY3SKz68nvU6nJ4,371
+argus/client/sirenada/client.py,sha256=jpvvHsRf5VSQKSmnamvK054ZlVXHM6w8UXDiUhFEF0A,6222
 argus/db/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 argus/db/argus_json.py,sha256=zwu7yug0_oUmt5TbcvIQ58uC1PxloEOj5udqoPJn6jQ,391
 argus/db/cloud_types.py,sha256=KXk6bzFrcIH_0b9L7m9CYiU1YkEeL7ZDpHqH-XKONsY,3702
@@ -64,7 +68,7 @@ argus/db/db_types.py,sha256=iLbmrUaDzrBw0kDCnvW0FSZ9-kNc3uQY-fsbIPymV4E,3612
 argus/db/interface.py,sha256=HroyA1Yijz5cXLdYbxorHCEu0GH9VeMMqB36IHTlcew,17146
 argus/db/testrun.py,sha256=0YG7FIH5FLQeNlYULxC6rhhyru2rziSMe3qKtYzTBnc,26014
 argus/db/utils.py,sha256=YAWsuLjUScSgKgdaL5aF4Sgr13gqH29Mb5cLctX4V_w,337
-argus_alm-0.10.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-argus_alm-0.10.2.dist-info/WHEEL,sha256=FWzWAvOOsDP6aqtZj_z3pIhVEk8S9F03Xwafa0tLqIY,90
-argus_alm-0.10.2.dist-info/METADATA,sha256=pJE21_j1amyGihPVJEI227h9sex5iY9pM9_MxP7xGm8,6858
-argus_alm-0.10.2.dist-info/RECORD,,
+argus_alm-0.11.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+argus_alm-0.11.0.dist-info/METADATA,sha256=Hima5dK6luGSWBfNFa4S2PTLPhsMspRh_w24VlHR1L4,6824
+argus_alm-0.11.0.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+argus_alm-0.11.0.dist-info/RECORD,,

{argus_alm-0.10.2.dist-info → argus_alm-0.11.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.1.0b2
+Generator: poetry-core 1.4.0
 Root-Is-Purelib: true
 Tag: py3-none-any