lyrasense 0.0.1__tar.gz

lyrasense-0.0.1/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+lyrasense_cache.db

lyrasense-0.0.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024-present Dimitrios Kirtsios <dimkirts@gmail.com>
+
+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.

lyrasense-0.0.1/PACKAGE_README.md

@@ -0,0 +1,57 @@
+# Lyrasense Platform - Python SDK
+
+This library is a Python SDK that can be used to interface with the Lyrasense Earth Observation(EO) platform.
+
+## Example Usage
+
+First install the library in your environment:
+
+```bash
+pip install lyrasense
+```
+
+Then you need to login on the Lyrasense platform and create an API key.
+To get access to the platform contact us at: <info@lyrasense.com>
+
+<image>
+
+Then you can the lyrasense decorators to wrap functions that you want to be deployed in the Lyrasense platform and execute them on demand.
+
+```python
+from lyrasense import Lyrasense
+
+# Initialize Lyrasense with your API base URL and key
+Lyrasense.init(
+    "http://<base url>",
+    "<your api key>>",
+)
+
+# Use the environment configuration if needed
+Lyrasense.env(
+    baseImage="python:3.9"
+)
+
+@Lyrasense.function
+def addition(a, b):
+    return a + b
+
+
+if __name__ == "__main__":
+    # If you call the wrapped function normally, it will be executed locally
+    result_local_def = addition(5, 3)
+    print(f"Local result: {result_local_def}")
+
+    # You can also explicitly call the wrapped function locally by using .local()
+    result_local = addition.local(5, 3)
+    print(f"Local result: {result_local}")
+
+    # You can execute the wrapped function remotely by using .remote()
+    # This will first deploy the function and then call it
+    result_remote = additionlowercase.remote(5, 3)
+    print(f"Remote result: {result_remote}")
+
+```
+
+**Notes:**
+- The initial function deployment needs some time to create the function, any further function calls should be fast.
+- If the function code changes the updated function with the new code will be re-deployed.

lyrasense-0.0.1/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.3
+Name: lyrasense
+Version: 0.0.1
+Summary: The Python SDK for the Lyrasense EO platform.
+Project-URL: Homepage, https://www.lyrasense.com/
+Author-email: Dimitrios Kirtsios <dimkirts@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: requests>=2.25.0
+Description-Content-Type: text/markdown
+
+# Lyrasense Platform - Python SDK
+
+This library is a Python SDK that can be used to interface with the Lyrasense Earth Observation(EO) platform.
+
+## Example Usage
+
+First install the library in your environment:
+
+```bash
+pip install lyrasense
+```
+
+Then you need to login on the Lyrasense platform and create an API key.
+To get access to the platform contact us at: <info@lyrasense.com>
+
+<image>
+
+Then you can the lyrasense decorators to wrap functions that you want to be deployed in the Lyrasense platform and execute them on demand.
+
+```python
+from lyrasense import Lyrasense
+
+# Initialize Lyrasense with your API base URL and key
+Lyrasense.init(
+    "http://<base url>",
+    "<your api key>>",
+)
+
+# Use the environment configuration if needed
+Lyrasense.env(
+    baseImage="python:3.9"
+)
+
+@Lyrasense.function
+def addition(a, b):
+    return a + b
+
+
+if __name__ == "__main__":
+    # If you call the wrapped function normally, it will be executed locally
+    result_local_def = addition(5, 3)
+    print(f"Local result: {result_local_def}")
+
+    # You can also explicitly call the wrapped function locally by using .local()
+    result_local = addition.local(5, 3)
+    print(f"Local result: {result_local}")
+
+    # You can execute the wrapped function remotely by using .remote()
+    # This will first deploy the function and then call it
+    result_remote = additionlowercase.remote(5, 3)
+    print(f"Remote result: {result_remote}")
+
+```
+
+**Notes:**
+- The initial function deployment needs some time to create the function, any further function calls should be fast.
+- If the function code changes the updated function with the new code will be re-deployed.

lyrasense-0.0.1/README.md

@@ -0,0 +1,83 @@
+# Lyrasense Python SDK
+
+This is the repository for the Python SDK that allows you to interface with the Lyrasense Earth Observation platform.
+
+## Packaging Instructions
+
+Make sure you have access to an API key to push in PyPI, ask <dimkirts@gmail.com> for one.
+Make sure you have installed PyPA's build, and Twine:
+
+```bash
+python3 -m pip install --upgrade build
+python3 -m pip install --upgrade twine
+```
+
+Then build your library by running in the root of the project directory:
+
+```bash
+python3 -m build
+```
+
+This should create two files in a `dist` folder that look like:
+
+```txt
+lyrasense-0.0.1.tar.gz
+lyrasense-0.0.1-py3-none-any.whl
+```
+
+Now to push these files to PyPI:
+
+```bash
+python3 -m twine upload --repository pypi dist/*
+```
+
+You are good to go!
+
+Reference: <https://packaging.python.org/en/latest/tutorials/packaging-projects/>
+
+## Virtual Environment
+
+We assume that you have Python installed on your system.
+
+Create a fresh virtual environment:
+
+```bash
+rm -rf .venv
+python3 -m venv .venv
+```
+
+Activate the virtual environment:
+
+```bash
+source .venv/bin/activate
+# confirm that you are in your venv
+which python
+```
+
+To exit your venv:
+
+```bash
+deactivate
+```
+
+## Running locally on editable mode for testing
+
+- Go to the root folder of the project
+- Create a virtualenv and activate it
+- Install the library in editable mode `pip install -e .`
+- Now you can either execute the example, run or write unit tests
+
+## Installing the library and running the example
+
+First create and activate a virtualenv as mentioned above.
+Then install the library inside the activated virtualenv like this:
+
+```bash
+pip install lyrasense
+```
+
+Then run the example like this:
+
+```bash
+python3 examples/example.py
+```

lyrasense-0.0.1/examples/example.py

@@ -0,0 +1,26 @@
+from lyrasense import Lyrasense
+
+# Initialize Lyrasense with your API base URL and key
+Lyrasense.init(
+    "http://35.214.166.85",
+    "w9eFPBG9D0K6mFLel_CgSTeYGDr8cyoSDwPhnJeblckb__jy1dD7LbHZCWnR",
+    debug=True,
+)
+
+# Use the environment configuration if needed
+Lyrasense.env(baseImage="python:3.9")
+
+
+@Lyrasense.function
+def additionlowercase(a, b):
+    return a + b
+
+
+if __name__ == "__main__":
+    # Use the function locally
+    result_local = additionlowercase.local(5, 3)
+    print(f"Local result: {result_local}")
+
+    # Use the function remotely
+    result_remote = additionlowercase.remote(5, 3)
+    print(f"Remote result: {result_remote}")

lyrasense-0.0.1/old/lib.py

@@ -0,0 +1,235 @@
+import sqlite3
+import hashlib
+import base64
+import requests
+import time
+import random
+import inspect
+import re
+from functools import wraps
+## TODO: Figure out if we can simply install the nuclio SDK without the jupyter baggage to avoid unused dependencies
+import nuclio
+
+class LyrasenseCache:
+    def __init__(self, db_path='lyrasense_cache.db'):
+        self.conn = sqlite3.connect(db_path)
+        self.create_table()
+
+    def create_table(self):
+        cursor = self.conn.cursor()
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS function_cache (
+            function_name TEXT PRIMARY KEY,
+            function_hash TEXT,
+            deployed_url TEXT
+        )
+        ''')
+        self.conn.commit()
+
+    def get_function_hash(self, func):
+        func_code = inspect.getsource(func)
+        return base64.b64encode(hashlib.sha256(func_code.encode()).digest()).decode()
+
+    def get_deployed_url(self, func_name):
+        cursor = self.conn.cursor()
+        cursor.execute('SELECT deployed_url FROM function_cache WHERE function_name = ?', (func_name,))
+        result = cursor.fetchone()
+        return result[0] if result else None
+
+    def update_cache(self, func_name, func_hash, deployed_url):
+        cursor = self.conn.cursor()
+        cursor.execute('''
+        INSERT OR REPLACE INTO function_cache (function_name, function_hash, deployed_url)
+        VALUES (?, ?, ?)
+        ''', (func_name, func_hash, deployed_url))
+        self.conn.commit()
+
+    def is_deployment_needed(self, func):
+        func_name = func.__name__
+        new_hash = self.get_function_hash(func)
+        cursor = self.conn.cursor()
+        cursor.execute('SELECT function_hash FROM function_cache WHERE function_name = ?', (func_name,))
+        result = cursor.fetchone()
+        return result is None or result[0] != new_hash
+
+def retry_on_exception(max_retries=10, delay=1, backoff=2, exceptions=(Exception,)):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            retry_delay = delay
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    if attempt == max_retries - 1:
+                        raise  # Re-raise the last exception if all retries failed
+                    print(f"Attempt {attempt + 1} failed: {str(e)}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                    retry_delay *= backoff
+                    # Add some jitter to avoid thundering herd problem
+                    retry_delay += random.uniform(0, 1)
+        return wrapper
+    return decorator
+
+@retry_on_exception(max_retries=3, delay=2, backoff=2, exceptions=(Exception,))
+def deploy_function_with_retry(data):
+    print('[deploy_function] The config is: {}'.format(Lyrasense.config))
+    print('[deploy_function] The data is: {}'.format(data))
+    print("[deploy_function] This deploys the function!")
+
+    userfunction_def=Lyrasense.function_extraction(data['func_source'])
+    userfunction_name=data['func_name']
+
+    indented_function = '\n'.join('    ' + line for line in userfunction_def.split('\n'))
+
+
+    function_template = f'''
+def handler(context, event):
+    body = event.body
+    context.logger.info('[lyrasense][{userfunction_name}] Executing function with args: ' + str(body['args']))
+
+    ## USER DEFINED CODE - START ##
+{indented_function}
+
+    result = {userfunction_name}(*body['args'])
+    ## USER DEFINED CODE - END ##
+
+    return context.Response(body={{ "function": "{userfunction_name}", "result": result }},
+                            headers={{}},
+                            content_type='application/json',
+                            status_code=200)
+'''
+
+    print(function_template)
+        
+    spec = nuclio.ConfigSpec(
+        config= {
+            'spec.build.baseImage': 'python:3.9',
+        },
+        cmd=['pip install msgpack']
+    )
+
+    addr = nuclio.deploy_code(
+        function_template,
+        name='projectName-{}'.format(userfunction_name),
+        project='lyrasense',
+        verbose=True,
+        spec=spec
+    )
+
+    print(f"Deploying function: {data['func_name']}")
+    print(addr)
+
+    if Lyrasense.ENV == 'LOCAL':
+        pattern = r'^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):(\d+)$'
+
+        # Replace IP with localhost, keeping the port
+        addr = re.sub(pattern, r'localhost:\2', addr[0])
+    return addr
+
+
+"""
+TODO:
+a) Security: Serializing and deserializing functions can be a security risk if not handled properly. Ensure that you have proper authentication and authorization mechanisms in place.
+b) Error Handling: Add more robust error handling for network issues, API errors, etc.
+c) Asynchronous Execution: Consider implementing an asynchronous approach for long-running tasks.
+"""
+class LyrasenseFunction:
+    cache = LyrasenseCache()
+
+    def __init__(self, func):
+        self.func = func
+        self.deployed_url = None
+
+    def __call__(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+
+    def deploy(self):
+        if self.cache.is_deployment_needed(self.func):
+            print(f"Deploying function: {self.func.__name__}")
+            
+            func_source = inspect.getsource(self.func)
+            data = {
+                "func_source": func_source,
+                "func_name": self.func.__name__,
+            }
+
+            self.deployed_url = 'http://' + str(Lyrasense.deploy_function(data))
+            func_hash = self.cache.get_function_hash(self.func)
+            self.cache.update_cache(self.func.__name__, func_hash, self.deployed_url)
+        else:
+            print(f"Function {self.func.__name__} is up to date, no deployment needed")
+            self.deployed_url = self.cache.get_deployed_url(self.func.__name__)
+        return self.deployed_url
+
+    def local(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+
+    def remote(self, *args, **kwargs):
+        if not self.deployed_url:
+            #raise ValueError("Function hasn't been deployed yet. Call .deploy() first.")
+            self.deploy()
+
+        data = {
+            "args": args,
+            "kwargs": kwargs
+        }
+        
+        response = requests.post(self.deployed_url, json=data)
+        
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Remote execution failed: {response.text}")
+
+class Lyrasense:
+    # Config
+    ## TODO: Add logic to switch environments
+    ENV = 'LOCAL'
+    config = { 'env': 'Python', 'baseImage': 'None' }
+
+    def env(baseImage='python'):
+        print('[env] Defines an environment, that you can use to attach functions on it')
+        print('[env] The config is: {}'.format(Lyrasense.config))
+        Lyrasense.config['baseImage'] = baseImage
+
+    @staticmethod
+    def function_extraction(function_code):
+        # The updated regex pattern
+        pattern = r'(def\s+.*?$)(?:\n(\s+).*?)*$'
+
+        # Find the match
+        match = re.search(pattern, function_code, re.MULTILINE | re.DOTALL)
+
+        if match:
+            # Extract the function definition
+            function_lines = match.group(0).split('\n')
+            
+            # Get the indentation of the first line after the function definition
+            if len(function_lines) > 1:
+                indentation = re.match(r'\s*', function_lines[1]).group(0)
+            else:
+                indentation = ''
+            
+            # Join the lines, preserving indentation
+            extracted_function = '\n'.join([function_lines[0]] + [line if line.startswith(indentation) else indentation + line for line in function_lines[1:]])
+            
+            print("Extracted function:")
+            print(extracted_function)
+            return extracted_function
+        else:
+            raise Exception('Something went wrong with the function extraction!')            
+
+
+    @staticmethod
+    def function_code(func):
+        return LyrasenseFunction(func)
+
+    @staticmethod
+    def deploy_function(data):
+        try:
+            return deploy_function_with_retry(data)
+        except Exception as e:
+            print(f"Deployment failed after multiple attempts: {str(e)}")
+            # Here you can add any additional error handling or user notification
+            raise

lyrasense-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+build-backend = "hatchling.build"
+requires = ["hatchling"]
+
+[project]
+authors = [
+  {name = "Dimitrios Kirtsios", email = "dimkirts@gmail.com"},
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  "requests>=2.25.0",
+]
+description = "The Python SDK for the Lyrasense EO platform."
+name = "lyrasense"
+readme = "PACKAGE_README.md"
+requires-python = ">=3.11"
+version = "0.0.1"
+
+[project.urls]
+"Homepage" = "https://www.lyrasense.com/"

lyrasense-0.0.1/src/lyrasense/__init__.py

@@ -0,0 +1,3 @@
+from .lyrasense import Lyrasense
+
+__all__ = ["Lyrasense"]

lyrasense-0.0.1/src/lyrasense/lyrasense.py

@@ -0,0 +1,155 @@
+import requests
+import time
+import inspect
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LyrasenseFunction:
+    def __init__(self, func):
+        self.func = func
+        self.function_id = None
+        self.deployed_url = None
+
+    def __call__(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+
+    def _function_extraction(self, function_code):
+        # The updated regex pattern
+        pattern = r"(def\s+.*?$)(?:\n(\s+).*?)*$"
+
+        # Find the match
+        match = re.search(pattern, function_code, re.MULTILINE | re.DOTALL)
+
+        if match:
+            # Extract the function definition
+            function_lines = match.group(0).split("\n")
+
+            # Get the indentation of the first line after the function definition
+            if len(function_lines) > 1:
+                indentation = re.match(r"\s*", function_lines[1]).group(0)
+            else:
+                indentation = ""
+
+            # Join the lines, preserving indentation
+            extracted_function = "\n".join(
+                [function_lines[0]]
+                + [
+                    line if line.startswith(indentation) else indentation + line
+                    for line in function_lines[1:]
+                ]
+            )
+
+            logger.debug("Extracted function:\n%s", extracted_function)
+            return extracted_function
+        else:
+            raise Exception("Something went wrong with the function extraction!")
+
+    def deploy(self):
+        func_source = self._function_extraction(inspect.getsource(self.func))
+
+        logger.debug("In deploy, func source:\n%s", func_source)
+        data = {
+            "name": self.func.__name__,
+            "code": func_source,
+            "runtime_config": {"PYTHON_VERSION": "3.11"},
+        }
+
+        logger.debug("In deploy calling PUT /api/v1/functions/")
+        response = requests.put(
+            f"{Lyrasense.api_base_url}/api/v1/functions/",
+            json=data,
+            headers={"api-key": Lyrasense.api_key},
+        )
+        response.raise_for_status()
+
+        function_data = response.json()
+
+        logger.debug("In deploy PUT response: %s", function_data)
+        self.function_id = function_data["id"]
+
+        # Poll until the function is deployed or deployment fails
+        while True:
+            # TODO: FIX: LRS-84
+            time.sleep(5)
+
+            logger.debug("In deploy, started polling, calling GET")
+            status = self.get_function_status()
+
+            logger.debug("Poll response: %s", status)
+            if status == "deployed":
+                self.deployed_url = function_data["deployed_url"]
+                logger.info("Function %s deployed successfully.", self.func.__name__)
+                break
+            elif status == "deployment_failed":
+                raise DeploymentFailedException(
+                    f"Deployment failed for function {self.func.__name__}"
+                )
+
+        return self.deployed_url
+
+    def get_function_status(self):
+        response = requests.get(
+            f"{Lyrasense.api_base_url}/api/v1/functions/{self.function_id}",
+            headers={"api-key": Lyrasense.api_key},
+        )
+        response.raise_for_status()
+
+        return response.json()["status"]
+
+    def local(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+
+    def remote(self, *args, **kwargs):
+        if not self.function_id:
+            logger.debug("In remote method - no function id, calling deploy")
+            self.deploy()
+
+        logger.debug("In remote method - function id present, calling execute")
+        data = {"args": args or kwargs}
+
+        response = requests.post(
+            f"{Lyrasense.api_base_url}/api/v1/functions/{self.function_id}/execute",
+            json=data,
+            headers={"api-key": Lyrasense.api_key},
+        )
+        response.raise_for_status()
+        return response.json()["result"]
+
+
+class Lyrasense:
+    api_base_url = None
+    api_key = None
+    debug = False
+
+    @staticmethod
+    def init(api_base_url, api_key, debug=False):
+        Lyrasense.api_base_url = api_base_url
+        Lyrasense.api_key = api_key
+        Lyrasense.debug = debug
+
+        logging.basicConfig(level=logging.DEBUG if debug else logging.INFO)
+        logger.setLevel(logging.DEBUG if debug else logging.INFO)
+
+        logger.info("Lyrasense initialized with API base URL: %s", api_base_url)
+        if debug:
+            logger.debug("Debug mode is ON")
+
+    @staticmethod
+    def function(func):
+        if not Lyrasense.api_base_url or not Lyrasense.api_key:
+            raise ValueError(
+                "Lyrasense has not been initialized. Call Lyrasense.init() first."
+            )
+        return LyrasenseFunction(func)
+
+    @staticmethod
+    def env(baseImage="python"):
+        # We can add env specific params here in the future.
+        pass
+
+
+class DeploymentFailedException(Exception):
+    pass

lyrasense-0.0.1/tests/test__lib.py

@@ -0,0 +1,22 @@
+import unittest
+from unittest.mock import patch
+from src.lib import Lyrasense
+
+class TestLyrasenseLib(unittest.TestCase):
+
+    @patch('requests.post')
+    def test_simple_function(self, mock_post):
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.json.return_value = {"job_id": "1234"}
+        
+        @Lyrasense.function
+        def add(a, b):
+            return a + b
+        
+        job_id = add(3, 5)
+        self.assertEqual(job_id, "1234")
+        mock_post.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()