sdk-seshat-python 0.3.4__tar.gz

sdk_seshat_python-0.3.4/LICENSE

@@ -0,0 +1,42 @@
+LICENSE AGREEMENT
+
+This License Agreement ("Agreement") is made between Seshat, ("Licensor") and you, the licensee ("Licensee"), effective as of the date of digital acceptance or installation of this software ("Effective Date").
+
+1. GRANT OF LICENSE:
+   Seshat grants to Licensee a non-exclusive, non-transferable, limited license to use [Software Name] ("Software") solely for Licensee's internal business operations subject to the terms of this Agreement.
+
+2. LICENSE RESTRICTIONS:
+   - Licensee shall not modify, make derivative works of, disassemble, reverse compile, or reverse engineer any part of the Software, or attempt to do any of the foregoing.
+   - Licensee shall not sublicense, distribute, sell, or lease the Software.
+   - Licensee may not use the Software for providing time-sharing services, service bureau services, or as part of an application services provider or software as a service offering.
+
+3. PAYMENT:
+   - Licensee agrees to pay Seshat the amount of [Amount] ("License Fee") for the license of the Software as stipulated in [Payment Terms Section or Document].
+
+4. PROPRIETARY RIGHTS:
+   Licensee acknowledges that Seshat owns all right, title, and interest in and to the Software, including all related intellectual property rights. The Software is protected by copyright and other intellectual property laws and treaties.
+
+5. TERM AND TERMINATION:
+   - This Agreement commences on the Effective Date and continues until terminated as provided herein.
+   - Seshat may terminate this Agreement immediately upon notice to Licensee if Licensee breaches any provision of this Agreement.
+   - Upon termination, Licensee must cease all use of the Software and delete all copies.
+
+6. DISCLAIMER OF WARRANTIES:
+   The Software is provided "as is", with all faults and without warranty of any kind. Seshat disclaims all warranties, express or implied, including any implied warranties of merchantability or fitness for a particular purpose.
+
+7. LIMITATION OF LIABILITY:
+   Seshat shall not be liable for any indirect, special, incidental, or consequential damages, including lost profits, arising out of or related to this Agreement or the Software, even if Seshat has been advised of the possibility of such damages.
+
+8. GENERAL:
+   - This Agreement constitutes the entire agreement between the parties relating to the Software and supersedes all prior or contemporaneous oral or written communications, proposals, and representations with respect to its subject matter.
+   - No amendment to or modification of this License will be binding unless in writing and signed by a duly authorized representative of Seshat.
+
+IN WITNESS WHEREOF, the parties hereto have executed this License Agreement as of the Effective Date.
+
+Seshat                                             Licensee
+
+By: ___________________________                    By: ___________________________
+
+Title: _________________________                   Title: _________________________
+
+Date: __________________________                   Date: __________________________

sdk_seshat_python-0.3.4/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: sdk-seshat-python
+Version: 0.3.4
+Summary: Seshat python SDK is a library to help create data pipelines with minimum effort for blockchain data to be trained later for any AI model.
+License: Commercial - see LICENSE.txt
+Author: sajadgilga
+Author-email: majidstic@yahoo.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: flipside-support
+Provides-Extra: postgres-support
+Requires-Dist: flipside (>=2.0.8,<3.0.0) ; extra == "flipside-support"
+Requires-Dist: memory-profiler (>=0.61.0,<0.62.0)
+Requires-Dist: pandas (>=2.2.1,<3.0.0)
+Requires-Dist: pyspark (>=3.5.1,<4.0.0)
+Requires-Dist: scikit-learn (>=1.4.1.post1,<2.0.0)
+Requires-Dist: sqlalchemy (>=2.0.29,<3.0.0)
+Requires-Dist: typer (>=0.12.3,<0.13.0)
+Description-Content-Type: text/markdown
+
+

sdk_seshat_python-0.3.4/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.poetry]
+name = "sdk-seshat-python"
+version = "0.3.4"
+description = "Seshat python SDK is a library to help create data pipelines with minimum effort for blockchain data to be trained later for any AI model."
+authors = ["sajadgilga <majidstic@yahoo.com>", "aliomidvarrr <aliomidvarrrrr@gmail.com>"]
+packages = [{ include = "seshat", from = "." }]
+readme = "README.md"
+license = "Commercial - see LICENSE.txt"
+
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pandas = "^2.2.1"
+scikit-learn = "^1.4.1.post1"
+pyspark = "^3.5.1"
+flipside = { version = "^2.0.8", optional = true }
+sqlalchemy = "^2.0.29"
+memory-profiler = "^0.61.0"
+typer = "^0.12.3"
+
+[tool.poetry.extras]
+flipside_support = ["flipside"]
+postgres_support = ["psycopg2-binary"]
+
+[tool.poetry.group.dev.dependencies]
+flake8 = "^7.0.0"
+black = "^24.3.0"
+pre-commit = "^3.7.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

sdk_seshat_python-0.3.4/seshat/__init__.py

@@ -0,0 +1,43 @@
+import os.path
+
+import typer
+
+from seshat.general.command.base import RECOMMENDATION, SetUpProjectCommand
+
+app = typer.Typer()
+
+state = {"verbose": False}
+
+
+@app.command(name="create-project")
+def create_project(name: str, usecase=typer.Option(default=RECOMMENDATION)):
+    command = SetUpProjectCommand(name, usecase, os.getcwd(), report=state["verbose"])
+    try:
+        command.handle()
+    except Exception as exc:
+        cli_msg = typer.style(
+            f"Setup project in usecase {usecase} failed because of {str(exc)}",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+    else:
+        cli_msg = typer.style(
+            f"""
+            Setup project in usecase {usecase} done!\n
+            You can deploy your project by this command 🚀:
+            'python -m seshat deploy`
+            """,
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+    typer.echo(cli_msg)
+
+
+@app.callback()
+def main(verbose: bool = False):
+    state["verbose"] = verbose
+
+
+@app.command()
+def deploy():
+    pass

sdk_seshat_python-0.3.4/seshat/__main__.py

@@ -0,0 +1,11 @@
+import sys
+
+from seshat import app
+
+rc = 1
+try:
+    app()
+    rc = 0
+except Exception as e:
+    print("Error: %s" % e, file=sys.stderr)
+sys.exit(rc)

sdk_seshat_python-0.3.4/seshat/data_class/__init__.py

@@ -0,0 +1,9 @@
+from pandas import DataFrame
+from pyspark.sql import DataFrame as PySparkDataFrame
+
+from .base import SFrame, GroupSFrame
+from .pandas import DFrame
+from .pyspark import SPFrame
+
+SF_MAP = {DFrame.frame_name: DFrame, SPFrame.frame_name: SPFrame}
+RAW_MAP = {DFrame.frame_name: DataFrame, SPFrame.frame_name: PySparkDataFrame}

sdk_seshat_python-0.3.4/seshat/data_class/base.py

@@ -0,0 +1,267 @@
+import copy
+from typing import Dict, Iterable, Type, List
+
+from seshat.general import configs
+from seshat.general.exceptions import (
+    SFrameDoesNotExistError,
+    UnknownDataClassError,
+    InvalidArgumentsError,
+)
+
+
+class SFrame:
+    """
+    An interface for Seshat frames, providing a unified interface
+    for either pandas or PySpark dataframes or others.
+    This class facilitates additional functionalities over the standard dataframe operations,
+    making it versatile for various data manipulation tasks.
+
+    Attributes
+    ----------
+    data : pandas.DataFrame or pyspark.sql.DataFrame
+        The actual dataframe object that is wrapped by this class.
+        Depending on initialization,this can be a pandas or PySpark dataframe.
+    frame_name : str
+        A name assigned to the dataframe. This name is used to identify the dataframe
+        and can be particularly useful working with multiple dataframes simultaneously.
+    """
+
+    frame_name: str
+    data: object
+
+    def __init__(self, data=None, *args, **kwargs):
+        self.data = data
+
+    def __add__(self, other):
+        if other:
+            self.extend(other.data)
+        return self
+
+    def __copy__(self):
+        return type(self)(self.data)
+
+    def __deepcopy__(self, memo):
+        return type(self)(copy.deepcopy(self.data, memo))
+
+    def to_raw(self) -> object:
+        return self.data
+
+    def set_raw(self, key: str, data: object):
+        self.data = data
+
+    def get(self, key: str) -> "SFrame":
+        return self
+
+    def get_columns(self, *args) -> Iterable[str]:
+        pass
+
+    def to_dict(self, *cols: str, key: str = configs.DEFAULT_SF_KEY) -> List[Dict]:
+        pass
+
+    def iterrows(self, column_name: str, key: str = configs.DEFAULT_SF_KEY):
+        pass
+
+    def make_group(self, default_key=configs.DEFAULT_SF_KEY):
+        pass
+
+    def convert(
+        self, to: "SFrame", default_key: str = configs.DEFAULT_SF_KEY
+    ) -> "SFrame":
+        """
+        Converts the current SFrame to match to the another SFrame.
+
+        Parameters
+        ----------
+        to: SFrame
+            The SFrame to which the current SFrame's data will be converted.
+
+        Returns
+        -------
+        SFrame
+            A converted SFrame instance.
+        """
+        if self.frame_name == to.frame_name:
+            return self
+        return self._convert(to)
+
+    def _convert(self, to: "SFrame") -> "SFrame":
+        return self.call_conversion_handler(self, to)
+
+    def extend_from_csv(self, path, *args, **kwargs):
+        new_data = self.read_csv(path, *args, **kwargs)
+        self.extend(new_data)
+
+    def extend(
+        self,
+        other: object,
+        axis: int = 0,
+        on: str = None,
+        left_on: str = None,
+        right_on: str = None,
+        how: str = "left",
+    ) -> object:
+        if self.data is None:
+            self.data = other
+        elif axis == 0:
+            self.extend_vertically(other)
+        elif axis == 1:
+            self.extend_horizontally(other, on, left_on, right_on, how)
+
+        return self.data
+
+    def extend_vertically(self, other: object):
+        pass
+
+    def extend_horizontally(
+        self, other: object, on: str, left_on: str, right_on: str, how: str
+    ):
+        if on is None and (left_on is None or right_on is None):
+            raise InvalidArgumentsError(
+                "`on` or `left_on` and `right_on` cannot be None while trying to extend horizontally"
+            )
+
+    @classmethod
+    def read_csv(cls, path, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def call_conversion_handler(from_: "SFrame", to: "SFrame") -> "SFrame":
+        handler_name = f"to_{to.frame_name}"
+        try:
+            handler = getattr(from_, handler_name)
+            return handler()
+        except AttributeError:
+            raise NotImplementedError(
+                "handler for conversion to %s is not implemented" % to.frame_name
+            )
+
+    @classmethod
+    def from_raw(cls, *args, **kwargs) -> "SFrame":
+        return cls(*args, **kwargs)
+
+    def __getitem__(self, item):
+        return self
+
+    def __setitem__(self, key, value):
+        self.data = value.to_raw()
+
+
+class GroupSFrame(SFrame):
+    """
+    A specialized class derived from SFrame that manages a collection of SFrames
+    stored in a dictionary. Each SFrame within the dictionary can be accessed
+    using a unique key. This class is designed to handle grouped data where
+    each group is represented as an individual SFrame, allowing for operations
+    to be performed on specific subsets of data efficiently.
+
+    Parameters
+    ----------
+    children : dict
+        A dictionary where each key-value pair consists of a string key
+        and an SFrame as the value. This structure allows for easy access
+        to each group's sframe by using its corresponding key.
+    """
+
+    # TODO: handle multiple types as children
+    def __init__(
+        self,
+        children: Dict[str, SFrame] = None,
+        sframe_class: Type[SFrame] = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__()
+        if children is None:
+            children = {}
+
+        self.children = children
+        self.sframe_class = sframe_class or self.find_sframe_class(
+            raise_exception=False
+        )
+
+    def __copy__(self):
+        return GroupSFrame(self.children, self.sframe_class)
+
+    def __deepcopy__(self, memo):
+        return type(self)(copy.deepcopy(self.children, memo), self.sframe_class)
+
+    def to_raw(self) -> Dict[str, object]:
+        raw = {}
+        for key, sf in self.children.items():
+            raw[key] = sf.to_raw()
+        return raw
+
+    def set_raw(self, key, data: object):
+        if self.sframe_class is None:
+            self.sframe_class = self.find_sframe_class()
+        if not isinstance(data, SFrame):
+            data = self.sframe_class.from_raw(data)
+        self.children[key] = data
+
+    def get(self, key: str) -> SFrame:
+        return self.children.get(key)
+
+    def set_frame(self, key: str, new_frame: "SFrame") -> None:
+        if isinstance(new_frame, GroupSFrame):
+            for k, v in new_frame.children.items():
+                self.children[k] = v
+        else:
+            self.children[key] = new_frame
+
+    def get_columns(self, key) -> Iterable[str]:
+        return self.get(key).get_columns()
+
+    def to_dict(self, *cols: str, key: str = configs.DEFAULT_SF_KEY) -> List[Dict]:
+        return self.get(key).to_dict(*cols)
+
+    def iterrows(self, column_name: str, key: str = configs.DEFAULT_SF_KEY):
+        return self.get(key).iterrows(column_name)
+
+    def convert(
+        self, to: "GroupSFrame", default_key: str = configs.DEFAULT_SF_KEY
+    ) -> SFrame:
+        if not isinstance(to, GroupSFrame):
+            to = to.make_group(default_key)
+        return super().convert(to)
+
+    def _convert(self, to: "GroupSFrame") -> SFrame:
+        for k, v in self.children.items():
+            to[k] = self.call_conversion_handler(v, to)
+        return to
+
+    def make_group(self, default_key=configs.DEFAULT_SF_KEY):
+        return self
+
+    def raise_unknown_sf_exception(self):
+        raise UnknownDataClassError(
+            "one of the `children` or `sframe_class` must be set while calling `set_raw`"
+        )
+
+    def find_sframe_class(self, raise_exception=True):
+        if hasattr(self, "children") and len(self.children) > 0:
+            return list(self.children.values())[0].__class__
+        if raise_exception:
+            raise self.raise_unknown_sf_exception()
+
+    @property
+    def keys(self):
+        for key in self.children.keys():
+            yield key
+
+    @property
+    def frame_name(self) -> str:
+        if self.sframe_class is None:
+            self.sframe_class = self.find_sframe_class()
+        return self.sframe_class.frame_name
+
+    def __getitem__(self, key):
+        try:
+            return self.children[key]
+        except KeyError:
+            raise SFrameDoesNotExistError(self.__class__.__name__, key)
+
+    def __setitem__(self, key, value):
+        self.children[key] = value
+
+    def __add__(self, other):
+        return {**self.children, **other.children}

sdk_seshat_python-0.3.4/seshat/data_class/pandas.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Dict
+
+import pandas as pd
+from pandas import DataFrame
+from pyspark.sql import SparkSession
+
+from seshat.data_class import SFrame
+from seshat.data_class.base import GroupSFrame
+from seshat.general import configs
+
+
+class DFrame(SFrame):
+    frame_name = "df"
+    data: DataFrame
+
+    def make_group(self, default_key=configs.DEFAULT_SF_KEY):
+        return GroupSFrame({default_key: self}, sframe_class=self.__class__)
+
+    def get_columns(self, *args) -> Iterable[str]:
+        return self.data.columns
+
+    def to_dict(self, *cols: str, key=configs.DEFAULT_SF_KEY) -> List[Dict]:
+        selected = self.data[list(cols)] if cols else self.data
+        selected = selected.loc[selected.astype(str).drop_duplicates().index]
+        return selected.to_dict("records")
+
+    def iterrows(self, column_name: str, key: str = configs.DEFAULT_SF_KEY):
+        for row in self.data[column_name]:
+            yield row
+
+    def to_spf(self) -> SFrame:
+        from seshat.data_class import SPFrame
+
+        spark = SparkSession.builder.appName(configs.SPARK_APP_NAME).getOrCreate()
+        return SPFrame.from_raw(spark.createDataFrame(self.data))
+
+    def extend_vertically(self, other: DataFrame):
+        super().extend_vertically(other)
+        self.data = pd.concat([self.data, other], axis=0)
+
+    def extend_horizontally(
+        self, other: DataFrame, on: str, left_on: str, right_on: str, how: str
+    ):
+        super().extend_horizontally(other, on, left_on, right_on, how)
+        self.data = pd.merge(
+            self.data,
+            other,
+            on=on,
+            left_on=left_on,
+            right_on=right_on,
+            how=how,
+        )
+
+    @classmethod
+    def read_csv(cls, path, *args, **kwargs) -> "DataFrame":
+        kwargs.setdefault("on_bad_lines", "skip")
+        return pd.read_csv(path, *args, **kwargs)
+
+    @classmethod
+    def from_raw(cls, data, *args, **kwargs) -> "DFrame":
+        if not isinstance(data, DataFrame):
+            data = DataFrame(data)
+        return cls(data)

sdk_seshat_python-0.3.4/seshat/data_class/pyspark.py

@@ -0,0 +1,63 @@
+from typing import Iterable, List, Dict
+
+from pandas import DataFrame
+from pyspark.sql import DataFrame as PySparkDataFrame, SparkSession
+
+from seshat.data_class import SFrame, DFrame
+from seshat.data_class.base import GroupSFrame
+from seshat.general import configs
+
+
+class SPFrame(SFrame):
+    frame_name = "spf"
+    data: PySparkDataFrame
+
+    def make_group(self, default_key=configs.DEFAULT_SF_KEY):
+        return GroupSFrame({default_key: self}, sframe_class=self.__class__)
+
+    def get_columns(self, *args) -> Iterable[str]:
+        return self.data.columns
+
+    def to_dict(self, *cols: str, key: str = configs.DEFAULT_SF_KEY) -> List[Dict]:
+        selected = self.data.select(*cols).distinct() if cols else self.data
+        return [row.asDict() for row in selected.collect()]
+
+    def iterrows(self, column_name: str, key: str = configs.DEFAULT_SF_KEY):
+        for row in self.data.collect():
+            yield row[column_name]
+
+    def to_df(self) -> SFrame:
+        from seshat.data_class import DFrame
+
+        return DFrame.from_raw(self.data.toPandas())
+
+    def extend_vertically(self, other: PySparkDataFrame):
+        super().extend_vertically(other)
+        self.data = self.data.unionByName(other)
+
+    def extend_horizontally(
+        self, other: PySparkDataFrame, on: str, left_on: str, right_on: str, how: str
+    ):
+        super().extend_horizontally(other, on, left_on, right_on, how)
+
+        if left_on and right_on:
+            on = getattr(self.data, left_on) == getattr(other, right_on)
+
+        self.data = self.data.drop_duplicates().join(
+            other.drop_duplicates(), on=on, how=how
+        )
+
+    @classmethod
+    def read_csv(cls, path, *args, **kwargs) -> "PySparkDataFrame":
+        kwargs.setdefault("header", True)
+        return cls.get_spark().read.csv(path, *args, **kwargs)
+
+    @classmethod
+    def from_raw(cls, data, *args, **kwargs) -> "SPFrame":
+        if isinstance(data, DataFrame):
+            data = DFrame.from_raw(data).convert(cls).to_raw()
+        return cls(data)
+
+    @staticmethod
+    def get_spark():
+        return SparkSession.builder.appName(configs.SPARK_APP_NAME).getOrCreate()

sdk_seshat_python-0.3.4/seshat/evaluation/__init__.py

@@ -0,0 +1 @@
+from .base import Evaluation

sdk_seshat_python-0.3.4/seshat/evaluation/base.py

@@ -0,0 +1,42 @@
+import os
+from typing import List, Callable
+
+from seshat.data_class import SFrame
+from seshat.evaluation.evaluator import Evaluator
+from seshat.general.exceptions import InvalidArgumentsError
+
+
+class Evaluation:
+    evaluators: List[Evaluator]
+    test_sf: SFrame
+    prediction_sf: SFrame
+    model_func: Callable
+    report_path: str
+
+    def __init__(self, evaluators, report_path):
+        self.evaluators = evaluators
+        self.report_path = report_path
+
+    def __call__(self, test_sf, model_func=None, **prediction_kwargs):
+        if not prediction_kwargs and not model_func:
+            raise InvalidArgumentsError(
+                "Must provide either prediction_kwargs or mode_func"
+            )
+        elif not prediction_kwargs:
+            prediction_kwargs = model_func(test_sf)
+
+        report = {}
+        for evaluator in self.evaluators:
+            report |= evaluator(test_sf=test_sf, **prediction_kwargs)
+        self.write_report(report, self.report_path)
+        return report
+
+    @staticmethod
+    def write_report(report, report_path):
+        report_content = ""
+        for metric, result in report.items():
+            report_content += f"Metric {metric}: {result}\n"
+        directory = os.path.dirname(report_path)
+        os.makedirs(directory, exist_ok=True)
+        with open(report_path, "w") as file:
+            file.write(report_content)

sdk_seshat_python-0.3.4/seshat/evaluation/evaluator/__init__.py

@@ -0,0 +1 @@
+from .base import Evaluator

sdk_seshat_python-0.3.4/seshat/evaluation/evaluator/base.py

@@ -0,0 +1,15 @@
+from typing import Dict
+
+from seshat.data_class import SFrame
+from seshat.general import configs
+from seshat.utils.mixin import SFHandlerDispatcherMixin
+
+
+class Evaluator(SFHandlerDispatcherMixin):
+    HANDLER_NAME = "evaluate"
+    input_sf: SFrame
+    DEFAULT_GROUP_KEYS: Dict[str, str] = {"test": configs.DEFAULT_SF_KEY}
+
+    def __call__(self, test_sf: SFrame, **prediction_kwargs: object):
+        test_kwargs = self.extract_raw(test_sf)
+        return self.call_handler(test_sf, **prediction_kwargs, **test_kwargs)

sdk_seshat_python-0.3.4/seshat/evaluation/evaluator/general/__init__.py

@@ -0,0 +1,3 @@
+from .classification import ClassificationEvaluator
+from .clustering import ClusteringEvaluator
+from .regression import RegressionEvaluator