cdiam-cli 0.1.0__tar.gz

cdiam_cli-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cdiam_cli-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: cdiam-cli
+Version: 0.1.0
+Summary: 
+Author: tungtp99
+Author-email: tungtp181199@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: datetime (>=5.5,<6.0)
+Requires-Dist: idna (==3.4)
+Requires-Dist: numpy (>=1.24.0,<2.0.0)
+Requires-Dist: pandas (>=2.1.0,<3.0.0)
+Requires-Dist: pydantic (==1.10.2)
+Requires-Dist: pymysql (==1.0.2)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: sqlalchemy (==1.4.41)
+Requires-Dist: sqlalchemy2-stubs (==0.0.2a27)
+Requires-Dist: sqlmodel (==0.0.8)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: typing-extensions (==4.3.0)
+Description-Content-Type: text/markdown
+
+# CDIAM CLI
+
+This is a repository for CDIAM CLI. .
+
+## Getting Started
+
+To get started with this project, follow these steps:
+
+### From source
+1. Clone the repository: `git clone github.com/C-DIAM/cdiam-cli.git`
+2. Install: `poetry install` install poetry with https://python-poetry.org/docs/
+
+### From pypip
+Run `pip install cdiam-cli` 
+
+### View CLI command
+Run `cdiam_cli --help`
+
+## Features
+
+- Save token: `python -m cdiam_cli save-token` must provide server endpoint E.g. https://c-diam.com/api and TOKEN get from CDIAM APP
+- Call API: `python -m cdiam_cli call-api <PATH_TO_YAML_OR_JSON_PARAMS>` more detail about params schemas at `<SERVER_ENPOINT>/schemas/docs` E.g. https://c-diam.com/api/schemas/docs
+
+
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+

cdiam_cli-0.1.0/README.md

@@ -0,0 +1,28 @@
+# CDIAM CLI
+
+This is a repository for CDIAM CLI. .
+
+## Getting Started
+
+To get started with this project, follow these steps:
+
+### From source
+1. Clone the repository: `git clone github.com/C-DIAM/cdiam-cli.git`
+2. Install: `poetry install` install poetry with https://python-poetry.org/docs/
+
+### From pypip
+Run `pip install cdiam-cli` 
+
+### View CLI command
+Run `cdiam_cli --help`
+
+## Features
+
+- Save token: `python -m cdiam_cli save-token` must provide server endpoint E.g. https://c-diam.com/api and TOKEN get from CDIAM APP
+- Call API: `python -m cdiam_cli call-api <PATH_TO_YAML_OR_JSON_PARAMS>` more detail about params schemas at `<SERVER_ENPOINT>/schemas/docs` E.g. https://c-diam.com/api/schemas/docs
+
+
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

cdiam_cli-0.1.0/cdiam_cli/__init__.py

@@ -0,0 +1,2 @@
+from . import api
+from . import helper

cdiam_cli-0.1.0/cdiam_cli/__main__.py

@@ -0,0 +1,5 @@
+# python
+
+from .main import main_group
+
+main_group()

cdiam_cli-0.1.0/cdiam_cli/api/__init__.py

@@ -0,0 +1,4 @@
+from .settings import save_token
+from .download import download_data
+from .api_action import call_api
+from . import utils

cdiam_cli-0.1.0/cdiam_cli/api/api_action.py

@@ -0,0 +1,131 @@
+import json
+import click
+from cdiam_cli.helper import yaml_helper, curl_helper
+import subprocess
+from typing import Union, Callable, Any, Dict, overload, Literal
+from .settings import read_api_endpoint, read_api_token
+from cdiam_cli.schemas import AnalysisResult
+from cdiam_cli.schemas import ParamsRequestGetTaskStatus
+from cdiam_cli.schemas import AnalysisResultRead
+from time import sleep
+
+
+def wait_task(task_id: str):
+    while True:
+        sleep(5)
+        print("Load status info")
+        res = run(
+            ParamsRequestGetTaskStatus(api="get_task_status", task_id=task_id).dict()
+        )
+        status = AnalysisResultRead(**res)
+
+        if status.task is None:
+            raise Exception("Task FAILURE")
+        if status.task.status == "FAILURE":
+            raise Exception("Task FAILURE")
+        if status.task.status == "SUCCESS":
+            break
+    return status
+
+
+def parse_and_wait_task(process: Any):
+    analysis_result: AnalysisResult = AnalysisResult(**process)
+    assert analysis_result.task_id is not None
+    print(analysis_result)
+    status = wait_task(task_id=analysis_result.task_id)
+    print(status)
+    return status
+
+
+@overload
+def run(
+    params: Union[str, Dict[Any, Any]],
+    modify_params_callback: Union[Callable[[Any], Any], None] = None,
+    wait_as_analysis: Literal[False] = False,
+) -> Any: ...
+@overload
+def run(
+    params: Union[str, Dict[Any, Any]],
+    modify_params_callback: Union[Callable[[Any], Any], None] = None,
+    wait_as_analysis: Literal[True] = True,
+) -> AnalysisResult: ...
+def run(
+    params: Union[str, Dict[Any, Any]],
+    modify_params_callback: Union[Callable[[Any], Any], None] = None,
+    wait_as_analysis: bool = False,
+):
+    """
+    Runs an API call with the provided parameters and returns the API response.
+
+    Args:
+        params (Union[str, Dict[Any, Any]]): The API parameters, either as a path to a JSON or YAML file, or as a dictionary.
+        More details about api schemas can be found in the documentation at https://c-diam.com/api/schemas/docs or if you are using different endpoint you can find it at https://<your-end-point>/api/schemas/docs.
+        modify_params_callback (Union[Callable[[Any], Any], None]): An optional callback function to modify the API parameters before the call.
+        wait_as_analysis (bool): If True, the function will wait for the API task to complete and return the analysis result.
+
+    Returns:
+        Any: The API response, or an AnalysisResult if wait_as_analysis is True.
+
+    Raises:
+        Exception: If the API call fails.
+    """
+
+    if isinstance(params, str):
+        if params.endswith(".json"):
+            with open(params) as f:
+                data = json.load(f)
+        else:
+            data = yaml_helper.read(params)
+        if modify_params_callback is not None:
+            data = modify_params_callback(data)
+    else:
+        data = params
+
+    if data["api"] in ["upload_matrix"]:  # type: ignore
+        form_data = curl_helper.convert_json_to_form_data(data)
+        command = curl_helper.generate_curl_form_command(
+            form_data, endpoint=f"{read_api_endpoint()}/api_public/{data['api']}"  # type: ignore
+        )
+    else:
+        command = curl_helper.generate_curl_json_command(
+            data, endpoint=f"{read_api_endpoint()}/api_public/{data['api']}"  # type: ignore
+        )
+    command.append("-b")
+    command.append(f"cdiam_session_token={read_api_token()}")
+
+    process = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    process.check_returncode()
+    output = json.loads(process.stdout.decode())
+    if "detail" in output:
+        raise Exception(output)
+
+    if wait_as_analysis:
+        output = parse_and_wait_task(output)
+
+    return output
+
+
+@click.command()
+@click.argument("params", type=click.Path(exists=True), required=True)
+def call_api(params: str):
+    """
+    Calls the API with the provided parameters and returns the API response.
+
+    Args:
+        params (str): The path to a JSON or YAML file containing the API parameters. More details about api schemas can be found in the documentation at https://c-diam.com/api/schemas/docs or if you are using different endpoint you can find it at https://<your-end-point>/api/schemas/docs.
+    Returns:
+        str: The API response.
+
+    Raises:
+        Exception: If the API call fails.
+    """
+
+    process = run(params)
+    return_code = process.returncode
+
+    if return_code == 0:
+        click.echo(process.stdout.decode())
+        return process.stdout.decode()
+    else:
+        click.echo(process.stdout.decode())
+        raise Exception(process.stderr.decode())

cdiam_cli-0.1.0/cdiam_cli/api/download.py

@@ -0,0 +1,28 @@
+import click
+import requests
+import pandas as pd
+from urllib.request import urlopen
+from .settings import read_api_endpoint, read_api_token
+
+
+@click.command()
+@click.argument("object_id", type=str)
+def download_data(object_id: str):
+    """This api download data of given objec_id"""
+    res = requests.get(
+        f"{read_api_endpoint()}/data/data/download-file/{object_id}",
+        cookies={"cdiam_session_token": read_api_token()},
+    )
+
+    if res.status_code != 200:
+        print(res.json())
+    else:
+        for url in res.json()["url"]:
+            response = urlopen(url)
+            file_name = response.headers.get_filename()
+            with requests.get(url, stream=True) as r:
+                r.raise_for_status()
+                with open(file_name, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)

cdiam_cli-0.1.0/cdiam_cli/api/settings.py

@@ -0,0 +1,59 @@
+import click
+import os
+from os.path import expanduser
+import json
+
+
+def get_path_settings():
+    home = expanduser("~")
+    return os.path.join(home, ".cdiam_cli")
+
+
+def read_api_endpoint():
+    if not os.path.exists(get_path_settings()):
+        raise Exception("Run save-settings first")
+    with open(get_path_settings(), "r") as f:
+        settings = json.load(f)
+        if "endpoint" not in settings:
+            raise Exception(
+                "Cannot found endpoint setting. Please run save-settings first"
+            )
+        return settings["endpoint"]
+
+
+def read_api_token():
+    if not os.path.exists(get_path_settings()):
+        raise Exception("Run save-settings first")
+    with open(get_path_settings(), "r") as f:
+        settings = json.load(f)
+        if "token" not in settings:
+            raise Exception(
+                "Cannot found token setting. Please run save-settings first"
+            )
+        return settings["token"]
+
+
+class HiddenPassword(object):
+    def __init__(self, password=""):
+        self.password = password
+
+    def __str__(self):
+        return "*" * len(self.password)
+
+
+@click.command()
+def save_token():
+    """This api save your endpoint and your token in your machine"""
+    endpoint = click.prompt(
+        "Please enter the server endpoint E.g. https://c-diam.com/api", type=str
+    )
+    value = click.prompt("Please enter the token", type=HiddenPassword, hide_input=True)
+    with open(get_path_settings(), "w") as f:
+        json.dump(
+            {
+                "endpoint": endpoint,
+                "token": value.password,
+            },
+            f,
+        )
+    print(f"Save settings at {get_path_settings()}")

cdiam_cli-0.1.0/cdiam_cli/helper/__init__.py

@@ -0,0 +1,3 @@
+from . import yaml_helper
+from . import curl_helper
+from . import json_helper

cdiam_cli-0.1.0/cdiam_cli/helper/curl_helper.py

@@ -0,0 +1,42 @@
+import json
+from typing import Any, Dict
+
+
+def _convert(data: Any, ret: Dict[str, str], key: str):
+    if isinstance(data, dict):
+        for k in data.keys():
+            _convert(data[k], ret, f"{key}[{k}]" if key != "" else k)
+    elif isinstance(data, list):
+        for index, k in enumerate(data):
+            _convert(data[index], ret, f"{key}[{index}]")
+    else:
+        if data is not None:
+            ret[key] = data
+
+
+def generate_curl_form_command(form_data: Dict[str, str], endpoint: str):
+    command = ["curl", "-X", "POST", "-H", "Content-Type: multipart/form-data"]
+    for k, v in form_data.items():
+
+        command.append("-F")
+        if v is None or v.startswith("@"):
+            command.append(f'{k}={"null" if v is None  else v}')
+        else:
+            command.append(f'{k}="{v}"')
+
+    command.append(endpoint)
+    return command
+
+
+def generate_curl_json_command(json_data: Dict[str, str], endpoint: str):
+    command = ["curl", "-X", "POST", "-H", "Content-Type: application/json"]
+    command.append("-d")
+    command.append(json.dumps(json_data))
+    command.append(endpoint)
+    return command
+
+
+def convert_json_to_form_data(json_object: Any):
+    ret = {}
+    _convert(json_object, ret, "")
+    return ret

cdiam_cli-0.1.0/cdiam_cli/helper/json_helper.py

@@ -0,0 +1,6 @@
+import json
+
+def read(path: str):
+    with open(path ,'r') as f:
+        return json.load(f)
+            

cdiam_cli-0.1.0/cdiam_cli/helper/yaml_helper.py

@@ -0,0 +1,10 @@
+import yaml
+
+def read(path: str):
+    with open(path) as stream:
+        try:
+            return yaml.safe_load(stream)
+        except yaml.YAMLError as exc:
+            print(exc)
+            raise Exception(exc)
+            

cdiam_cli-0.1.0/cdiam_cli/main.py

@@ -0,0 +1,15 @@
+import click
+from . import api
+
+
+@click.group
+def main_group():
+    pass
+
+
+main_group.add_command(api.save_token)
+main_group.add_command(api.call_api)
+
+
+if __name__ == "__main__":
+    main_group()

cdiam_cli-0.1.0/cdiam_cli/schemas/__init__.py

@@ -0,0 +1 @@
+from .schemas import *

cdiam_cli-0.1.0/cdiam_cli/schemas/schemas.py

@@ -0,0 +1,213 @@
+from pydantic import BaseModel
+from typing import Literal, Optional
+from sqlmodel import (
+    Field,
+    SQLModel,
+    ForeignKeyConstraint,
+    Column,
+    DateTime,
+    func,
+    Relationship,
+    UniqueConstraint,
+    BigInteger,
+)
+import sqlalchemy as sa
+from pydantic import validator, BaseModel
+from datetime import datetime
+from typing import Union, Callable, ClassVar, Optional, List, Dict, Any
+import json
+
+
+class ProjectSettings(BaseModel):
+    class Config:
+        orm_mode = True
+
+    cpdb: List[str] = []
+    enrichment: List[str] = []
+
+    @staticmethod
+    def encode_settings(settings: Union[Dict[str, Any], "ProjectSettings"]) -> str:
+        return ProjectSettings.parse_obj(settings).json()
+
+    @staticmethod
+    def decode_setting(settings: str) -> "ProjectSettings":
+        if settings is None:
+            settings = "{}"
+        return ProjectSettings.parse_obj(json.loads(settings))
+
+
+class ProjectBase(SQLModel):
+    name: str = Field(max_length=128, nullable=False)
+
+
+class Project(ProjectBase, table=True):
+    __tablename__: ClassVar[Union[str, Callable[..., str]]] = "project"
+    id: str = Field(
+        max_length=128, nullable=False, primary_key=True, index=True, unique=True
+    )
+    tombstone: Optional[bool] = Field(
+        default=False,
+        nullable=False,
+        description="Deleted marker of the project. True = deleted",
+    )
+    time_created: datetime = Field(
+        default=None,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+        description="Time added",
+    )
+    is_public: bool = Field(
+        default=False,
+        nullable=False,
+        description="If the project is public",
+    )
+    delete_date: Optional[datetime] = Field(
+        default=None, sa_column=Column(sa.DateTime(timezone=True), nullable=True)
+    )
+    settings: Optional[str] = Field(
+        default=None,
+        max_length=10240,
+        nullable=True,
+    )
+    storage_used: int = Field(
+        sa_column=Column(BigInteger),
+        nullable=True,
+        description="Non-zero expression values",
+    )
+    created_by: str = Field(
+        max_length=128,
+        nullable=False,
+        index=True,
+        foreign_key="user.email",
+    )
+
+    @validator("settings")
+    def validate_settings(cls, v: str):
+        if v == "nan":
+            v = "{}"
+        if v is None:
+            v = "{}"
+        return ProjectSettings.encode_settings(ProjectSettings.decode_setting(v))
+
+    @validator("tombstone")
+    def validate_tombstone(cls, v):
+        if not v:
+            return False
+        return v
+
+
+class ParamsRequestGetTaskStatus(BaseModel):
+    """
+    Represents the parameters for a request to get the status of an analysis task.
+
+    :param api: The API endpoint being called, which should be "get_task_status".
+    :param task_id: The unique identifier of the analysis task.
+    """
+
+    api: Literal["get_task_status"]
+    task_id: str
+
+
+class TaskStatus(BaseModel):
+    status: str = "UNKNOWN"
+
+
+class AnalysisResultBase(SQLModel):
+    result_id: str = Field(
+        max_length=128,
+        nullable=False,
+        primary_key=True,
+        description="ID of the analysis",
+    )
+    data_id: str = Field(max_length=128, nullable=False, description="ID of the data")
+    analysis: int = Field(
+        nullable=False,
+        foreign_key="analysis_catalog.id",
+        description="Reference to the analysis",
+    )
+    task_id: str = Field(
+        max_length=128,
+        nullable=False,
+        sa_column_kwargs={"server_default": ""},
+        description="ID of task in celery",
+    )
+    args: str = Field(
+        max_length=10240,
+        default="{}",
+        nullable=False,
+        description="Args of the analysis",
+        sa_column_kwargs={"server_default": "{}"},
+    )
+    project_id: str = Field(
+        max_length=128,
+        nullable=False,
+        description="ID of project this analysis belong to",
+    )
+    user_email: Optional[str] = Field(max_length=256, nullable=True)
+
+
+class AnalysisCatalogBase(SQLModel):
+    name: str = Field(nullable=False, description="Name of the analysis")
+    description: Optional[str] = Field(
+        max_length=4096, description="Detailed information about this analysis"
+    )
+
+
+class AnalysisCatalog(AnalysisCatalogBase, table=True):
+    """
+    This table stores available analyses type
+    that the App supports.
+    """
+
+    __tablename__: ClassVar[Union[str, Callable[..., str]]] = "analysis_catalog"
+    id: int = Field(primary_key=True)
+    time_created: datetime = Field(
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+        description="Time added",
+    )
+    time_modified: datetime = Field(
+        sa_column=Column(
+            DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+        ),
+        description="Time modified",
+    )
+    """A list of all analysis results of this type"""
+    results: List["AnalysisResult"] = Relationship(back_populates="analysis_orm")
+
+    __table_args__ = (UniqueConstraint("name", name="_name_analysis_uc"),)
+
+
+class AnalysisResultRead(AnalysisResultBase):
+    """
+    A response model of an anlysis result
+    """
+
+    time_created: datetime
+    time_modified: datetime
+    task: Optional[TaskStatus]
+    result_data_status: Optional[str]
+
+
+class AnalysisResult(AnalysisResultBase, table=True):
+    __tablename__: ClassVar[Union[str, Callable[..., str]]] = "analysis_result"
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["project_id"], ["project.id"], onupdate="CASCADE", ondelete="CASCADE"
+        ),
+    )
+    """
+    This table stores all analyses that had been produced for a data 
+    The analysis reference points to the description of the analysis.
+    The result_id reference points to the detail result of the analysis
+    """
+    time_created: datetime = Field(
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+        description="Time added",
+    )
+    time_modified: datetime = Field(
+        sa_column=Column(
+            DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+        ),
+        description="Time modified",
+    )
+    """An object of the analysis type"""
+    analysis_orm: AnalysisCatalog = Relationship(back_populates="results")

cdiam_cli-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[tool.poetry]
+name = "cdiam-cli"
+version = "0.1.0"
+description = ""
+authors = ["tungtp99 <tungtp181199@gmail.com>"]
+readme = "README.md"
+packages = [{include = "cdiam_cli"}]
+
+[scripts]
+cdiam-cli = "cdiam_cli.main:main_group"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+click = "^8.1.7"
+pyyaml = "^6.0.1"
+tabulate = "^0.9.0"
+
+
+datetime = "^5.5"
+numpy = "^1.24.0"
+pandas = "^2.1.0"
+pydantic = "1.10.2"
+sqlmodel = "0.0.8"
+typing-extensions = "4.3.0"
+sqlalchemy = "1.4.41"
+sqlalchemy2-stubs = "0.0.2a27"
+pymysql = "1.0.2"
+idna = "3.4"
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry.scripts]
+cdiam-cli = 'cdiam_cli.main:main_group'