seer-pas-sdk 0.1.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

seer_pas_sdk/objects/__init__.py

@@ -1 +1,3 @@
 from .platemap import PlateMap
+from .groupanalysis import GroupAnalysisPostData
+from .volcanoplot import *

seer_pas_sdk/objects/groupanalysis.py

@@ -0,0 +1,30 @@
+# Filter group analysis data for only the POST
+class GroupAnalysisPostData:
+    """DTO for Group Analysis Saved Results"""
+
+    def __init__(self, data):
+        if "post" not in data:
+            raise ValueError('Invalid data format. Missing "post" key')
+
+        # Safe check if there are proteins vs peptides
+        num_proteins = (
+            data["post"]
+            .get("protein", {"totalFeature": 0})
+            .get("totalFeature", 0)
+        )
+        num_peptides = (
+            data["post"]
+            .get("peptide", {"totalFeature": 0})
+            .get("totalFeature", 0)
+        )
+
+        if num_proteins > 0:
+            self.type = "protein"
+        elif num_peptides > 0:
+            self.type = "peptide"
+        else:
+            raise ValueError(
+                "Invalid data format. No features found in post data"
+            )
+        self.data = data["post"][self.type]["mergedStats"]
+        self.stat_test = data["post"][self.type]["parameters"]["statTest"]

seer_pas_sdk/objects/platemap.py

@@ -21,10 +21,16 @@ class PlateMap:
         sample_volume=None,
         peptide_concentration=None,
         peptide_mass_sample=None,
+        recon_volume=None,
         dilution_factor=None,
         kit_id=None,
         plate_id=None,
         plate_name=None,
+        assay_version=None,
+        sample_tube_id=None,
+        method_set_id=None,
+        assay_method_id=None,
+        product="XT",
     ):
 
         if not ms_file_name:
@@ -45,30 +51,61 @@ class PlateMap:
         self.sample_volume = sample_volume
         self.peptide_concentration = peptide_concentration
         self.peptide_mass_sample = peptide_mass_sample
+        self.recon_volume = recon_volume
         self.dilution_factor = dilution_factor
         self.kit_id = kit_id
         self.plate_id = plate_id
         self.plate_name = plate_name
-
-        self.__cols = [
-            "MS file name",
-            "Sample name",
-            "Sample ID",
-            "Well location",
-            "Nanoparticle",
-            "Nanoparticle ID",
-            "Control",
-            "Control ID",
-            "Instrument name",
-            "Date sample preparation",
-            "Sample volume",
-            "Peptide concentration",
-            "Peptide mass sample",
-            "Dilution factor",
-            "Kit ID",
-            "Plate ID",
-            "Plate Name",
-        ]
+        self.assay_version = assay_version
+        self.sample_tube_id = sample_tube_id
+        self.method_set_id = method_set_id
+        self.assay_method_id = assay_method_id
+        self.product = product
+
+        if self.product == "XT":
+            self.__map = {
+                "ms_file_name": "MS file name",
+                "sample_name": "Sample name",
+                "sample_id": "Sample ID",
+                "well_location": "Well location",
+                "nanoparticle": "Nanoparticle",
+                "nanoparticle_id": "Nanoparticle ID",
+                "control": "Control",
+                "control_id": "Control ID",
+                "instrument_name": "Instrument name",
+                "date_sample_preparation": "Date sample preparation",
+                "sample_volume": "Sample volume",
+                "peptide_concentration": "Peptide concentration",
+                "peptide_mass_sample": "Peptide mass sample",
+                "recon_volume": "Recon volume",
+                "dilution_factor": "Dilution factor",
+                "kit_id": "Kit ID",
+                "plate_id": "Plate ID",
+                "plate_name": "Plate Name",
+                "assay_version": "Assay",
+            }
+        else:
+            self.__map = {
+                "ms_file_name": "MS file name",
+                "sample_name": "Sample name",
+                "sample_id": "Sample ID",
+                "well_location": "Well location",
+                "nanoparticle": "Nanoparticle set",
+                "nanoparticle_id": "Nanoparticle set ID",
+                "control_id": "Control ID",
+                "instrument_name": "Instrument ID",
+                "date_sample_preparation": "Date assay initiated",
+                "sample_volume": "Sample volume",
+                "peptide_concentration": "Reconstituted peptide concentration",
+                "peptide_mass_sample": "Recovered peptide mass",
+                "recon_volume": "Reconstitution volume",
+                "plate_id": "Plate ID",
+                "plate_name": "Plate Name",
+                "assay_version": "Assay product",
+                "sample_tube_id": "Sample tube ID",
+                "method_set_id": "Method set ID",
+                "assay_method_id": "Assay method ID",
+            }
 
         self.__attrs = [
             "ms_file_name",
@@ -84,10 +121,15 @@ class PlateMap:
             "sample_volume",
             "peptide_concentration",
             "peptide_mass_sample",
+            "recon_volume",
             "dilution_factor",
             "kit_id",
             "plate_id",
             "plate_name",
+            "assay_version",
+            "sample_tube_id",
+            "method_set_id",
+            "assay_method_id",
         ]
 
         for attr in self.__attrs:
@@ -109,8 +151,11 @@ class PlateMap:
     def to_dict(self):
         res = {}
 
-        for i in range(len(self.__attrs)):
-            res[self.__cols[i]] = getattr(self, self.__attrs[i])
+        supported_cols = self.__map.keys()
+
+        for attr in self.__attrs:
+            if attr in supported_cols:
+                res[self.__map[attr]] = getattr(self, attr)
 
         for entry in res:
             res[entry] = {i: res[entry][i] for i in range(len(res[entry]))}

seer_pas_sdk/objects/volcanoplot.py

@@ -0,0 +1,290 @@
+import numpy as np
+import json
+import pandas as pd
+from typing import List as _List, Dict as _Dict
+from .groupanalysis import GroupAnalysisPostData
+
+
+class VolcanoPlotSettings:
+    """Class to hold the settings information for the Volcano Plot"""
+
+    def __init__(
+        self,
+        significance_threshold: float = 0.05,
+        fold_change_threshold: float = 1,
+        label_by: str = "fold_change",
+    ):
+        """Initialize the VolcanoPlotSettings object
+
+        Args:
+            significance_threshold (float, optional): Cutoff value for the p-value to determine significance. Defaults to 0.05.
+            fold_change_threshold (float, optional): Cutoff value for the fold change to determine significance. Defaults to 1.
+            label_by (str, optional): Metric to sort result data. Defaults to "fold_change".
+
+        Raises:
+            ValueError: "Invalid label_by value, must be one of ['euclidean', 'fold_change', 'significance']"
+        """
+        if label_by not in ["euclidean", "fold_change", "significance"]:
+            raise ValueError(
+                "Invalid label_by value, must be one of ['euclidean', 'fold_change', 'significance']"
+            )
+        self.significance_threshold = significance_threshold
+        self.fold_change_threshold = fold_change_threshold
+        self.label_by = label_by
+
+    @property
+    def values(self):
+        return {
+            "significance_threshold": self.significance_threshold,
+            "fold_change_threshold": self.fold_change_threshold,
+            "label_by": self.label_by,
+        }
+
+    @classmethod
+    def get_settings(cls):
+        return [
+            "significance_threshold",
+            "fold_change_threshold",
+            "label_by",
+        ]
+
+    @classmethod
+    def get_label_by_map(cls):
+        return dict(
+            euclidean="euclideanDistance",
+            fold_change="logFD",
+            significance="negativeLog10P",
+        )
+
+
+class VolcanoPlotBuilder:
+    """
+    Builder class for the Volcano Plot
+    Can be used to reuse the same GroupAnalysisResults data to build multiple Volcano Plots with different settings.
+
+    """
+
+    PROTEIN_GROUP_INDEX = "pg"
+    PEPTIDE_INDEX = "peptide"
+
+    def __init__(
+        self,
+        data: _List[_Dict],
+        significance_threshold: float = 0.05,
+        fold_change_threshold: float = 1,
+        label_by: str = "fold_change",
+    ):
+        """Initialize the VolcanoPlotBuilder object
+
+        Args:
+            data (list[dict]): The complete set of group analysis result data
+            significance_threshold (float, optional): Cutoff value for the p-value to determine significance. Defaults to 0.05.
+            fold_change_threshold (float, optional): Cutoff value for the fold change to determine significance. Defaults to 1.
+            label_by (str, optional): Metric to sort result data. Defaults to "fold_change".
+
+        Raises:
+            ValueError: "Invalid label_by value, must be one of ['euclidean', 'fold_change', 'significance']"
+
+        Returns:
+            None
+        """
+
+        self.settings = VolcanoPlotSettings(
+            significance_threshold=significance_threshold,
+            fold_change_threshold=fold_change_threshold,
+            label_by=label_by,
+        )
+
+        parsed_data = GroupAnalysisPostData(data)
+
+        self.type = parsed_data.type
+        self.stat_test = parsed_data.stat_test
+        self.data = parsed_data.data
+        self.minusLog10PSigValue = -np.log10(
+            self.settings.significance_threshold
+        )
+        self.sort_param = VolcanoPlotSettings.get_label_by_map()[
+            self.settings.label_by
+        ]
+        self.max_logFD, self.max_negative_log10_p = self._get_max_values(
+            self.data
+        )
+        self.protein_gene_map = dict()
+        self.feature_type_index = (
+            self.PROTEIN_GROUP_INDEX
+            if self.type == "protein"
+            else self.PEPTIDE_INDEX
+        )
+        self.volcano_plot = self.build()
+
+    def build(self):
+        """Build the volcano plot
+
+        Returns:
+            list[dict]: sorted volcano plot data
+        """
+        result = []
+        for i, row in enumerate(self.data):
+            result.append(self.build_row(i, row))
+        sorted_result = sorted(
+            result,
+            key=lambda x: (
+                x[self.sort_param]
+                if self.sort_param != "logFD"
+                else np.abs(x[self.sort_param])
+            ),
+            reverse=True,
+        )
+        return sorted_result
+
+    def build_row(self, i, data):
+        """Build a row for the volcano plot
+
+        Args:
+            i (int): The index of the row
+            data (dict): a group analysis result entry
+
+        Returns:
+            dict: The row data
+        """
+        self.protein_gene_map[data[self.feature_type_index]] = data["gene"]
+
+        row = dict(
+            logFD=data["logFD"],
+            negativeLog10P=data["negativeLog10P"],
+            dataIndex=i,
+            rowID=json.dumps(data),
+            gene=data["gene"],
+            group=self.get_contrast_group_string(data),
+            significant=self.get_significance_class(data),
+            euclideanDistance=self.calculate_euclidean_distance(
+                data["logFD"] / self.max_logFD,
+                data["negativeLog10P"] / self.max_negative_log10_p,
+            ),
+        )
+        row[self.type] = data[self.feature_type_index]
+        return row
+
+    def is_significant_point(self, data):
+        return (
+            data["negativeLog10P"] >= self.minusLog10PSigValue
+            and np.abs(data["logFD"]) >= self.settings.fold_change_threshold
+        )
+
+    def get_significance_class(self, data):
+        """Get the significance class
+
+        Args:
+            data (dict): the row data
+
+        Returns:
+            int: 0 if not significant, 1 if (logFD >= 1), -1 if (logFD <= -1)
+        """
+        if not self.is_significant_point(data):
+            return 0
+        elif data["logFD"] >= 1:
+            return 1
+        elif data["logFD"] <= -1:
+            return -1
+
+    def get_contrast_group_string(self, obj):
+        """Get the contrast group string
+
+        Args:
+            obj (dict): The row data
+
+        Returns:
+            str: The contrast group string
+        """
+        if (
+            obj
+            and obj.get("contrastGroup", None)
+            and obj["contrastGroup"].get("G1", None)
+            and obj["contrastGroup"].get("G2", None)
+        ):
+            return "/".join(
+                [obj["contrastGroup"]["G1"], obj["contrastGroup"]["G2"]]
+            )
+
+    def calculate_euclidean_distance(self, x, y):
+        """Calculate the euclidean distance
+
+        Args:
+            x (float): The x value
+            y (float): The y value
+
+        Returns:
+            float: The euclidean distance
+        """
+        return np.sqrt(x**2 + y**2)
+
+    def _get_max_values(self, data):
+        """For euclidean distance, get the max logFD and negativeLog10P values to normalize the data
+
+        Args:
+            data (list[dict]): The complete set of group analysis result data
+
+        Returns:
+            tuple: The max logFD and negativeLog10P values.
+        """
+        max_logFD = -np.inf
+        max_negative_log10_p = -np.inf
+        for row in data:
+            max_logFD = max(max_logFD, row["logFD"])
+            max_negative_log10_p = max(
+                max_negative_log10_p, row["negativeLog10P"]
+            )
+        return max_logFD, max_negative_log10_p
+
+    def update(
+        self,
+        significance_threshold=None,
+        fold_change_threshold=None,
+        label_by=None,
+    ):
+        """Updates the settings and recalculates the volcano plot
+
+        Args:
+            significance_threshold (float, optional): Cutoff value for the p-value to determine significance
+            fold_change_threshold (float, optional): Cutoff value for the fold change to determine significance
+            label_by (str, optional): Metric to sort result data
+
+        Raises:
+            ValueError: "Invalid label_by value, must be one of ['euclidean', 'fold_change', 'significance']"
+
+        Returns:
+            None
+        """
+        if not significance_threshold:
+            significance_threshold = self.settings.significance_threshold
+        if not fold_change_threshold:
+            fold_change_threshold = self.settings.fold_change_threshold
+        if not label_by:
+            label_by = self.settings.label_by
+
+        self.settings = VolcanoPlotSettings(
+            significance_threshold=significance_threshold,
+            fold_change_threshold=fold_change_threshold,
+            label_by=label_by,
+        )
+        self.minusLog10PSigValue = -np.log10(
+            self.settings.significance_threshold
+        )
+        self.sort_param = VolcanoPlotSettings.get_label_by_map()[
+            self.settings.label_by
+        ]
+        self.volcano_plot = self.build()
+
+    def to_df(self):
+        """Convert the volcano plot data to a DataFrame"""
+        return pd.DataFrame(self.volcano_plot)
+
+    def get_significant_rows(self):
+        """Get the significant proteins
+
+        Returns:
+            List: The list of significant proteins
+        """
+        return [
+            row[self.type] for row in self.volcano_plot if row["significant"]
+        ]

seer_pas_sdk-3.0.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: seer-pas-sdk
+Version: 3.0.0
+Summary: SDK for Seer Proteograph Analysis Suite (PAS)
+Author-email: Ryan Sun <rsun@seer.bio>
+License: 
+                                         Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+Project-URL: Issues, https://github.com/seerbio/seer-pas-sdk/issues
+Keywords: seer,sdk,pas,mass spectrometry,proteomics
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: boto3>=1.26.152
+Requires-Dist: botocore>=1.29.152
+Requires-Dist: pandas>=2.0.1
+Requires-Dist: numpy<2.0.0,>=1.5.3
+Requires-Dist: PyJWT>=2.8.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: Requests>=2.31.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: deprecation
+Dynamic: license-file
+
+# Seer PAS Python SDK
+
+[![Test](https://github.com/seerbio/seer-pas-sdk/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/seerbio/seer-pas-sdk/actions/workflows/test.yml)
+[![Lint](https://github.com/seerbio/seer-pas-sdk/actions/workflows/lint.yml/badge.svg?branch=main)](https://github.com/seerbio/seer-pas-sdk/actions/workflows/lint.yml)
+
+This SDK permits interaction with the Seer Proteograph Analysis Suite using Python.
+
+## Installation
+
+```shell
+pip install seer-pas-sdk
+```
+
+## Usage
+
+To import and set up the SDK:
+
+```python
+from seer_pas_sdk import SeerSDK
+
+# Instantiate an SDK object with your credentials:
+sdk = SeerSDK(USERNAME, PASSWORD)
+```
+
+You can then use the SDK's methods to create, query, or retrieve projects, plates, samples, and analyses.
+
+For complete documentation of this SDK, visit [https://seerbio.github.io/seer-pas-sdk/](https://seerbio.github.io/seer-pas-sdk/ "Documentation").