ouro-py 0.0.1__py3-none-any.whl

ouro/__init__.py

@@ -0,0 +1,89 @@
+VERSION = "0.0.1"
+
+
+import logging
+import os
+
+
+import requests
+from dotenv import load_dotenv
+from supabase.client import ClientOptions
+
+from supabase import Client, create_client
+from ouro.air import Air
+from ouro.earth import Earth
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+console_handler = logging.StreamHandler()
+log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+formatter = logging.Formatter(log_format)
+console_handler.setFormatter(formatter)
+logger.addHandler(console_handler)
+
+postgres_logger = logging.getLogger("httpx")
+postgres_logger.setLevel(logging.WARNING)
+
+
+load_dotenv()
+
+
+class Ouro:
+    def __init__(self):
+        self.client = None
+        self.public_client = None
+        self.user = None
+        self.token = None
+
+        self.earth = None
+        self.water = None
+        self.air = None
+        self.fire = None
+
+        # Class Instances
+        # self.MakeAirPost = MakeAirPost
+
+    def login(self, api_key: str):
+        url: str = os.environ.get("SUPABASE_URL")
+        key: str = os.environ.get("SUPABASE_ANON_KEY")
+
+        if not api_key:
+            raise Exception("No API key found")
+
+        # Send a request to Ouro Backend to get an access token
+        req = requests.post(
+            f"{os.environ.get('OURO_BACKEND_URL')}/users/get-token",
+            json={"pat": api_key},
+        )
+        json = req.json()
+        self.token = json["token"]
+        self.client: Client = create_client(
+            url,
+            key,
+            options=ClientOptions(
+                schema="datasets",
+                auto_refresh_token=True,
+                persist_session=False,
+            ),
+        )
+        self.public_client: Client = create_client(
+            url,
+            key,
+            options=ClientOptions(
+                auto_refresh_token=True,
+                persist_session=False,
+            ),
+        )
+
+        if not self.token:
+            raise Exception("No user found for this API key")
+
+        self.client.postgrest.auth(self.token)
+        self.public_client.postgrest.auth(self.token)
+
+        self.user = self.client.auth.get_user(self.token).user
+        print(f"Successfully logged in as {self.user.email}.")
+
+        # Instanciate classes
+        self.earth = Earth(config=self)
+        self.air = Air(config=self)

ouro/air/__init__.py

@@ -0,0 +1,182 @@
+
+
+
+from supabase import Client
+import time
+import logging
+import json
+import os
+import requests
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+console_handler = logging.StreamHandler()
+log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+formatter = logging.Formatter(log_format)
+console_handler.setFormatter(formatter)
+logger.addHandler(console_handler)
+
+
+class Post:
+    """Create a new Air post. Formats the data to be viewed with the AirViewer.
+
+    Inspired by https://github.com/didix21/mdutils
+    """
+
+    def __init__(self, data: dict = {}, content: dict = {}):
+        self.data = data        
+        self.content = {
+            "type": "doc",
+            "content": [],
+        }
+
+    def new_header(self, level: int, title: str):
+        element = {
+            "type": "heading",
+            "attrs": {"level": level},
+            "content": [{"text": title, "type": "text"}],
+        }
+        self.content["content"].append(element)
+
+    def new_paragraph(self, text: str):
+        element = {
+            "type": "paragraph",
+            "content": [{"text": text, "type": "text"}],
+        }
+        self.content["content"].append(element)
+
+    def new_line(self):
+        element = {
+            "type": "paragraph",
+            "content": [{"text": "", "type": "text"}],
+        }
+        self.content["content"].append(element)
+
+    def new_code_block(self, code: str, language: str = None):
+        element = {
+            "type": "codeBlock",
+            "attrs": {"language": language},
+            "content": [{"text": code, "type": "text"}],
+        }
+        self.content["content"].append(element)
+
+    def new_table(self, data: pd.DataFrame):
+        element = {
+            "type": "table",
+            "content": [],
+        }
+
+        # Generate the header row
+        header_row = {
+            "type": "tableRow",
+            "content": list(
+                map(
+                    (
+                        lambda x: {
+                            "type": "tableHeader",
+                            "attrs": {"colspan": 1, "rowspan": 1, "colwidth": None},
+                            "content": [
+                                {
+                                    "type": "paragraph",
+                                    "content": [{"text": str(x), "type": "text"}],
+                                }
+                            ],
+                        }
+                    ),
+                    data.columns,
+                )
+            ),
+        }
+        # Generate the rows
+        rows = list(
+            map(
+                (
+                    lambda x: {
+                        "type": "tableRow",
+                        "content": list(
+                            map(
+                                (
+                                    lambda y: {
+                                        "type": "tableCell",
+                                        "attrs": {
+                                            "colspan": 1,
+                                            "rowspan": 1,
+                                            "colwidth": None,
+                                        },
+                                        "content": [
+                                            {
+                                                "type": "paragraph",
+                                                "content": [
+                                                    {
+                                                        "text": str(y),
+                                                        "type": "text",
+                                                    }
+                                                ],
+                                            }
+                                        ],
+                                    }
+                                ),
+                                x[1].values,
+                            )
+                        ),
+                    }
+                ),
+                data.iterrows(),
+            )
+        )
+        # Add the header row and rows to the table
+        element["content"] = [header_row, *rows]
+
+        self.content["content"].append(element)
+
+    def new_inline_image(self, src: str, alt: str):
+        element = {
+            "type": "image",
+            "attrs": {"src": src, "alt": alt},
+        }
+        self.content["content"].append(element)
+
+    def new_inline_asset(
+        self,
+        id: str,
+        asset_type: str,
+        filters: dict = None,
+        view_mode: str = "default",
+    ):
+        element = {
+            # "type": "paragraph",
+            # "content": [
+            #     {
+                    "type": "assetComponent",
+                    "attrs": {
+                        "id": id,
+                        "assetType": asset_type,
+                        "filters": filters,
+                        "viewMode": view_mode,
+                    },
+            #     }
+            # ],
+        }
+        self.content["content"].append(element)
+
+
+class Air:
+    def __init__(self, config):
+        self.config = config
+        self.Post = Post
+
+    def create_post(self, post: Post):
+        request = requests.post(f"{os.environ.get('OURO_BACKEND_URL')}/elements/air/create",
+            headers={
+                "Authorization": f"{self.config.token}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "content": {"json": post.content, "text": ""},
+                "post": post.data
+            },
+        )
+        request.raise_for_status()
+
+        return request.json()

ouro/earth/__init__.py

@@ -0,0 +1,161 @@
+from supabase import Client
+import time
+import logging
+import httpx
+import os
+import pandas as pd
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+# console_handler = logging.StreamHandler()
+log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+formatter = logging.Formatter(log_format)
+# console_handler.setFormatter(formatter)
+# logger.addHandler(console_handler)
+
+
+class Earth:
+    def __init__(self, config):
+        self.config = config
+
+    def create_dataset(self, dataset: dict, data: pd.DataFrame):
+        df = data.copy()
+        # Get a sql safe table name from the name
+        table_name = dataset["name"].replace(" ", "_").lower()
+
+        # Reset the index if it exists to use as the primary key
+        index_name = df.index.name
+        if index_name:
+            df.reset_index(inplace=True)
+
+        create_table_sql = pd.io.sql.get_schema(
+            df, name=table_name, schema="datasets", keys=index_name
+        )
+
+        create_table_sql = create_table_sql.replace(
+            "TIMESTAMP", "TIMESTAMP WITH TIME ZONE"
+        )
+        create_table_sql = create_table_sql.replace(
+            "CREATE TABLE", "CREATE TABLE IF NOT EXISTS"
+        )
+
+        logger.info(f"{create_table_sql}")
+
+        request = httpx.post(
+            f"{os.environ.get('OURO_BACKEND_URL')}/elements/earth/create/from-schema",
+            headers={
+                "Authorization": f"{self.config.token}",
+                "Content-Type": "application/json",
+            },
+            json={"dataset": {**dataset, "schema": create_table_sql}},
+        )
+        request.raise_for_status()
+        response = request.json()
+
+        logger.info(response)
+
+        if response["error"]:
+            logger.error(response["error"])
+            raise Exception(response["error"])
+
+        # If we've created the dataset, we can now insert the data
+        # if response["data"] and not response["error"]:
+        created = response["data"]
+        table_name = created["metadata"]["table_name"]
+
+        # Format the DataFrame to be inserted
+        # Manually format any dates to be ISO 8601
+
+        # insert_data = data.to_json(orient="records")
+        # insert_data = pd.read_json(insert_data)
+
+        for column in df.columns:
+            if df[column].dtype == "datetime64[ns]":
+                df[column] = df[column].dt.strftime("%Y-%m-%d")
+
+        # Fill NaN values with None
+        df = df.where(pd.notnull(df), None)
+        df = df.map(lambda x: None if pd.isna(x) or x == "" else x)
+
+        insert_data = df.to_dict(orient="records")
+
+        # Ensure that we're not inserting any NaN values by converting them to None
+        insert_data = [
+            {k: v if not pd.isna(v) else None for k, v in row.items()}
+            for row in insert_data
+        ]
+
+        insert = self.config.client.table(table_name).insert(insert_data).execute()
+        if len(insert.data) > 0:
+            logger.info(f"Inserted {len(insert.data)} rows into {table_name}")
+
+    def get_dataset(self, dataset_id: str):
+        dataset = (
+            self.public_client.table("datasets")
+            .select("*")
+            .eq("id", dataset_id)
+            .limit(1)
+            .single()
+            .execute()
+        ).data
+        return dataset
+
+    def get_dataset_from_name(self, name: str):
+        dataset = (
+            self.public_client.table("datasets")
+            .select("*")
+            .eq("name", name)
+            .limit(1)
+            .single()
+            .execute()
+        ).data
+        return dataset
+
+    def get_dataset_schema(self, dataset_id: str):
+        dataset = (
+            self.public_client.table("datasets")
+            .select("*")
+            .eq("id", dataset_id)
+            .limit(1)
+            .single()
+            .execute()
+        ).data
+        # Get the schema with an RPC call to the database
+        schema = (
+            self.public_client.rpc(
+                "get_table_schema",
+                {"table_schema_name": "datasets", "table_name": dataset["table_name"]},
+            ).execute()
+        ).data
+        return schema
+
+    def load_dataset(self, table_name: str, schema: str = "datasets"):
+        start = time.time()
+
+        row_count = self.client.table(table_name).select("*", count="exact").execute()
+        row_count = row_count.count
+
+        logger.info(f"Loading {row_count} rows from {schema}.{table_name}...")
+        # Batch load the data if it's too big
+        if row_count > 1_000_000:
+            data = []
+            for i in range(0, row_count, 1_000_000):
+                logger.debug(f"Loading rows {i} to {i+1_000_000}")
+                res = (
+                    self.client.table(table_name)
+                    .select("*")
+                    .range(i, i + 1_000_000)
+                    .execute()
+                )
+                data.extend(res.data)
+        else:
+            res = self.client.table(table_name).select("*").limit(1_000_000).execute()
+            data = res.data
+
+        end = time.time()
+        logger.info(f"Finished loading data in {round(end - start, 2)} seconds.")
+
+        self.data = data
+        return data

ouro/utils/__init__.py

@@ -0,0 +1,37 @@
+
+def ouro_field(key, value):
+    def decorator(func):
+        if not hasattr(func, "ouro_fields"):
+            func.ouro_fields = {}
+        func.ouro_fields[key] = value
+        return func
+    return decorator
+
+def get_custom_openapi(app, get_openapi):
+    def custom_openapi():
+        if app.openapi_schema:
+            return app.openapi_schema
+        
+        openapi_schema = get_openapi(
+            title=app.title,
+            version=app.version,
+            summary=app.summary,
+            description=app.description,
+            routes=app.routes,
+        )
+
+        for path, path_item in openapi_schema["paths"].items():
+            for method, operation in path_item.items():
+                endpoint = app.routes[0]
+                for route in app.routes:
+                    if route.path == path and method.upper() in route.methods:
+                        endpoint = route.endpoint
+                        break
+                
+                if hasattr(endpoint, "ouro_fields"):
+                    operation.update(endpoint.ouro_fields)
+
+        app.openapi_schema = openapi_schema
+        return app.openapi_schema
+    
+    return custom_openapi

ouro_py-0.0.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.3
+Name: ouro-py
+Version: 0.0.1
+Summary: Python wrapper for the Ouro API
+Project-URL: Homepage, https://github.com/ourofoundation/ouro-py
+Project-URL: PyPI, https://pypi.org/project/ouro-py
+Author-email: Matt Moderwell <matt@ouro.foundation>
+License-Expression: MIT
+Keywords: ouro
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: httpx
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: postgrest
+Requires-Dist: python-dotenv
+Requires-Dist: supabase
+Description-Content-Type: text/markdown
+
+# `ouro-py`
+
+Python client for [Ouro](https://ouro.foundation)
+
+- Documentation: [ouro.foundation/docs](https://ouro.foundation/docs)
+
+## Usage
+
+Generate an API key from your account settings by going to [ouro.foundation/app/settings/api-keys](https://ouro.foundation/app/settings/api-keys).
+
+Set your Ouro environment variables in a dotenv file, or using the shell:
+
+```bash
+export USER_API_KEY="your_ouro_api_key"
+```
+
+Init client:
+
+```python
+import os
+from ouro import Ouro
+
+api_key = os.environ.get("USER_API_KEY")
+ouro = Ouro()
+ouro.login(api_key)
+```
+
+Use the client to interface with the Ouro framework.
+
+### Create a dataset
+
+```python
+data = pd.DataFrame([
+    {"name": "Bob", "age": 30},
+    {"name": "Alice", "age": 27},
+    {"name": "Matt", "age": 26},
+
+])
+
+dataset = ouro.earth.create_dataset({
+    "name": "unique_dataset_name",
+    "visibility": "private",
+    },
+    data
+)
+```
+
+## Contributing
+
+Contributing to the Python library is a great way to get involved with the Ouro community. Reach out to us on our [Github Discussions](https://github.com/orgs/ourofoundation/discussions) page if you want to get involved.
+
+## Set up a Local Development Environment
+
+### Clone the Repository
+
+```bash
+git clone git@github.com:ourofoundation/ouro-py.git
+cd ouro-py
+```
+
+### Create and Activate a Virtual Environment
+
+We recommend activating your virtual environment. Click [here](https://docs.python.org/3/library/venv.html) for more about Python virtual environments and working with [conda](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#activating-an-environment) and [poetry](https://python-poetry.org/docs/basic-usage/).
+
+Using venv (Python 3 built-in):
+
+```bash
+python3 -m venv env
+source env/bin/activate  # On Windows, use .\env\Scripts\activate
+```
+
+Using conda:
+
+```bash
+conda create --name ouro-py
+conda activate ouro-py
+```
+
+### PyPi installation
+
+Install the package (for > Python 3.7):
+
+```bash
+# with pip
+pip install ouro
+```
+
+### Local installation
+
+You can also install locally after cloning this repo. Install Development mode with `pip install -e`, which makes it so when you edit the source code the changes will be reflected in your python module.
+
+## Badges
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?label=license)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/ourofoundation/ouro-py/actions/workflows/ci.yml/badge.svg)](https://github.com/ourofoundation/ouro-py/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/pypi/pyversions/ouro-py)](https://pypi.org/project/ouro-py)
+[![Version](https://img.shields.io/pypi/v/ouro-py?color=%2334D058)](https://pypi.org/project/ouro-py)
+[![Codecov](https://codecov.io/gh/ourofoundation/ouro-py/branch/develop/graph/badge.svg)](https://codecov.io/gh/ourofoundation/ouro-py)
+[![Last commit](https://img.shields.io/github/last-commit/ourofoundation/ouro-py.svg?style=flat)](https://github.com/ourofoundation/ouro-py/commits)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/ourofoundation/ouro-py)](https://github.com/ourofoundation/ouro-py/commits)
+[![Github Stars](https://img.shields.io/github/stars/ourofoundation/ouro-py?style=flat&logo=github)](https://github.com/ourofoundation/ouro-py/stargazers)
+[![Github Forks](https://img.shields.io/github/forks/ourofoundation/ouro-py?style=flat&logo=github)](https://github.com/ourofoundation/ouro-py/network/members)
+[![Github Watchers](https://img.shields.io/github/watchers/ourofoundation/ouro-py?style=flat&logo=github)](https://github.com/ourofoundation/ouro-py)
+[![GitHub contributors](https://img.shields.io/github/contributors/ourofoundation/ouro-py)](https://github.com/ourofoundation/ouro-py/graphs/contributors)

ouro_py-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+ouro/__init__.py,sha256=4Hg5ciwZrF1JtFnO2v6lFjGUgNgaxKWddHTQLaVtY34,2342
+ouro/ouro.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ouro/air/__init__.py,sha256=SWrcJ93qtssU_6Llga51QRX1bxNqZqalCGmSinifugM,5665
+ouro/earth/__init__.py,sha256=482sMs0g_IAtL8YEy2wLfw51LZK_Ic6n7fJv3b1ibAM,5198
+ouro/utils/__init__.py,sha256=6B2o7RUus6G7MWy4y3eYbTxRZFiQJWjbC7CL0EekjjU,1174
+ouro_py-0.0.1.dist-info/METADATA,sha256=rk_6_Y_nuaFoL21sKLFFxMWXUDNSMPuHa-Otn5Nos-A,4406
+ouro_py-0.0.1.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+ouro_py-0.0.1.dist-info/RECORD,,

ouro_py-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.24.2
+Root-Is-Purelib: true
+Tag: py3-none-any