airflow-embedash 0.1.1__tar.gz

airflow_embedash-0.1.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: airflow-embedash
+Version: 0.1.1
+Summary: Add embeded dashboars to Airflow
+Author-email: Rodrigo Carneiro <teoria@gmail.com>
+Project-URL: Homepage, https://github.com/teoria/airflow-embedash
+Project-URL: Documentation, https://github.com/teoria/airflow-embedash
+Project-URL: Source code, https://github.com/teoria/airflow-embedash
+Keywords: airflow,apache-airflow,metabase,grafana,datadog
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Airflow Embedash
+
+A Python package for embedding dashboards in Apache Airflow.
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install airflow-embedash
+```
+
+Or in development mode:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Create new dashboards
+ 
+### Variable
+
+The default menu label is "Dashboards" but can be changed setup `embeded_dashboards_menu_label`variable.	 
+	
+For private dashboars need metabase token `embeded_dashboards_metabase_token`
+
+## Package Structure
+
+- `src/` - Source code directory
+  - `__init__.py` - Package initialization
+  - `airflow_embeded_dashboards.py` - Main module with the main function
+
+## Development
+
+To contribute to this project:
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License.

airflow_embedash-0.1.1/README.md

@@ -0,0 +1,46 @@
+# Airflow Embedash
+
+A Python package for embedding dashboards in Apache Airflow.
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install airflow-embedash
+```
+
+Or in development mode:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Create new dashboards
+ 
+### Variable
+
+The default menu label is "Dashboards" but can be changed setup `embeded_dashboards_menu_label`variable.	 
+	
+For private dashboars need metabase token `embeded_dashboards_metabase_token`
+
+## Package Structure
+
+- `src/` - Source code directory
+  - `__init__.py` - Package initialization
+  - `airflow_embeded_dashboards.py` - Main module with the main function
+
+## Development
+
+To contribute to this project:
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License.

airflow_embedash-0.1.1/airflow_embedash/__init__.py

@@ -0,0 +1,7 @@
+"""Airflow Embedded Dashboards package."""
+ 
+from __future__ import annotations
+ 
+__version__ = "0.1.2" 
+
+ 

airflow_embedash-0.1.1/airflow_embedash/plugin/__init__.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from airflow import __version__ as airflow_version
+from packaging import version
+
+_AIRFLOW3_MAJOR_VERSION = 3
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .airflow2 import EmbededDashPlugin as _EmbededDashPluginType
+    from .airflow3 import EmbededDashAF3Plugin as _EmbededDashAF3PluginType
+
+_EmbededDashPlugin: _EmbededDashPluginType | _EmbededDashAF3PluginType | None = None
+
+
+def __getattr__(name: str) :
+    if name == "EmbededDashPlugin":
+        global _EmbededDashPlugin
+        if _EmbededDashPlugin is None:
+            if version.parse(airflow_version).major < _AIRFLOW3_MAJOR_VERSION:
+                from .airflow2 import EmbededDashPlugin  # type: ignore[assignment]  # noqa: F401
+
+                _EmbededDashPlugin = EmbededDashPlugin  # type: ignore[assignment]
+            else:
+                # _EmbededDashPlugin = EmbededDashPlugin  # type: ignore[assignment]
+                from .airflow3 import EmbededDashAF3Plugin  # type: ignore[assignment]  # noqa: F401
+
+                _EmbededDashPlugin = EmbededDashAF3Plugin  # type: ignore[assignment]
+        return _EmbededDashPlugin
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

airflow_embedash-0.1.1/airflow_embedash/plugin/airflow2.py

@@ -0,0 +1,219 @@
+import json
+import os.path as op
+from typing import Any
+from urllib.parse import urlsplit
+from airflow.models import Variable
+
+from airflow.configuration import conf
+from airflow.plugins_manager import AirflowPlugin
+from airflow.security import permissions
+from airflow.www.auth import has_access
+from airflow.www.views import AirflowBaseView
+from flask import abort
+from flask_appbuilder import AppBuilder, expose
+from flask import request, redirect, url_for
+import uuid
+from airflow.www.app import csrf
+
+MENU_ACCESS_PERMISSIONS = [
+    (permissions.ACTION_CAN_READ, permissions.RESOURCE_WEBSITE),
+]
+
+ 
+
+class EmbededView(AirflowBaseView):  # type: ignore
+    default_view = "settings"
+    route_base = "/embedash"
+    template_folder = op.join(op.dirname(__file__), "templates")
+    static_folder = op.join(op.dirname(__file__), "static")
+
+    plugin = None  # type: ignore[assignment]
+
+    def create_blueprint(
+        self, appbuilder: AppBuilder, endpoint: str | None = None, static_folder: str | None = None
+    ) -> None:
+        # Make sure the static folder is not overwritten, as we want to use it.
+        return super().create_blueprint(appbuilder, endpoint=endpoint, static_folder=self.static_folder)  # type: ignore[no-any-return]
+
+    @expose("/settings")  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    def settings(self) -> Any:
+        dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+        return self.render_template("settings.html", dashboards=dashboards)  # type: ignore[no-any-return,no-untyped-call]     
+
+    @expose("/add_dash", methods=['GET', 'POST'])  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    @csrf.exempt
+    def DashboardSettings_add(self) -> Any:
+        if request.method == 'POST':
+            # Get data from the form fields using their 'name' attributes
+            name = request.form.get('name')
+            description = request.form.get('description')
+            url = request.form.get('url')
+            payload = request.form.get('payload',{})
+            if payload == "":
+                payload = {}
+            else:
+                payload = json.loads(payload)
+            # Perform some action with the data (e.g., save to database, validation)
+            if name and description and url:
+                # Create a new dashboard object
+                new_dashboard = {
+                    "id": uuid.uuid4().hex,  # Generate a unique ID for the dashboard
+                    "name": name,
+                    "description": description,
+                    "url": url,
+                    "type": "public" if len(payload.items()) == 0 else "private",
+                    "payload": payload
+                }
+                 
+                dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+                dashboards.append(new_dashboard) 
+                Variable.set(key="embeded_dashboards", value=dashboards, serialize_json=True) 
+                return redirect(url_for('EmbededView.settings'))
+
+            else:
+                return "Invalid credentials, please try again."
+             
+   
+
+    @expose("/adddashboard")  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    def DashboardSettings_add_dash(self) -> Any:
+        return self.render_template("add_dashboard.html")  # type: ignore[no-any-return,no-untyped-call]
+         
+   
+
+    @expose("/editdashboard/<id>")  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    def DashboardSettings_edit(self, id: str) -> Any:
+         
+        dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+        for dashboard in dashboards:
+            if dashboard.get("id") == id:
+                dash = dashboard
+                break
+        else:
+            dash = None
+        return self.render_template("edit_dashboard.html", dashboard=dash)  # type: ignore[no-any-return,no-untyped-call]
+    
+    @expose("/edit_dash/<id>", methods=['GET', 'POST'])  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    @csrf.exempt
+    def DashboardSettings_edit_dash(self, id: str) -> Any:
+        if request.method == 'POST':
+            # Get data from the form fields using their 'name' attributes
+
+            name = request.form.get('name')
+            description = request.form.get('description')
+            url = request.form.get('url')
+            payload = request.form.get('payload',{})
+            if payload == "":
+                payload = {}
+            else:
+                payload = json.loads(payload)
+            # Perform some action with the data (e.g., save to database, validation)
+            if name and description and url:
+                # Create a new dashboard object
+                new_dashboard = {
+                    "id": id,
+                    "name": name,
+                    "description": description,
+                    "url": url,
+                    "type": "public" if len(payload.items()) == 0 else "private",
+                    "payload": payload
+                }
+                 
+                dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+                 
+                for i, dashboard in enumerate(dashboards):
+                    if dashboard.get("id") == id:
+                        dashboards[i] = new_dashboard  # Update the existing dashboard with the new data
+                        break
+ 
+                Variable.set(key="embeded_dashboards", value=dashboards, serialize_json=True) 
+                return redirect(url_for('EmbededView.settings'))
+
+            else:
+                return "Invalid credentials, please try again."
+             
+   
+
+
+
+    @expose("/deletedashboard/<id>")  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    def DashboardSettings_delete(self, id: str) -> Any:
+        # Here you would add logic to delete the dashboard with the given ID from your database
+        # For now, we'll just redirect back to the settings page after "deleting"
+         
+        dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+        new_dashboards = [dashboard for dashboard in dashboards if dashboard.get("id") != id]
+        Variable.set(key="embeded_dashboards", value=new_dashboards, serialize_json=True)
+        embeded_view.plugin.refresh_appbuilder_views()
+        return redirect(url_for('EmbededView.settings'))
+    
+    @expose("/view/<id>")  # type: ignore[untyped-decorator]
+    @has_access(MENU_ACCESS_PERMISSIONS)  # type: ignore[untyped-decorator]
+    def DashboardSettings_view(self, id: str) -> Any:
+          
+        dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+        for dashboard in dashboards:
+            if dashboard.get("id") == id:
+                dash = dashboard
+                break
+        else:
+            dash = None
+
+        if dashboard.get("type") == "private":
+            payload = dashboard.get("payload", {})
+            if payload:
+                
+                import jwt
+                import time
+
+                METABASE_SITE_URL = dashboard.get("url", "")
+                METABASE_SECRET_KEY = Variable.get("embeded_dashboards_metabase_token")
+
+                payload["exp"] = round(time.time()) + (60 * 10) # 10 minute expiration
+                token = jwt.encode(payload, METABASE_SECRET_KEY, algorithm="HS256")
+
+                iframeUrl = METABASE_SITE_URL + "/embed/dashboard/" + token + "#bordered=true&titled=true"
+                dashboard["url"] = iframeUrl
+
+        return self.render_template("view.html", dashboard=dash)  # type: ignore[no-any-return,no-untyped-call]
+      
+
+embeded_view = EmbededView()
+
+
+class EmbededDashPlugin(AirflowPlugin):
+    name = "embeded_dashboards"
+
+    def __init__(self) -> None:  
+        embeded_view.plugin = self  # type: ignore[assignment]
+        self.refresh_appbuilder_views()
+   
+    def refresh_appbuilder_views(self) -> None:
+        # This method can be called to refresh the appbuilder views based on the current dashboards variable
+        menu_label = Variable.get("embeded_dashboards_menu_label", default_var="Dashboards")
+        dashboards = Variable.get("embeded_dashboards", default_var=[], deserialize_json=True)
+        items = []
+        for dashboard in dashboards: 
+            items.append(
+                {
+                    "name": dashboard.get("name", "Unnamed Dashboard"),
+                    "category": menu_label,
+                    "view": embeded_view,
+                    "href": conf.get("webserver", "base_url") + "/embedash/view/"+dashboard.get("id", ""),
+                }
+            )
+        items.append(
+            {
+                "name": "Settings",
+                "category": menu_label,
+                "view": embeded_view,
+                "href": conf.get("webserver", "base_url") + "/embedash/settings",
+            }
+        )
+        self.appbuilder_views = items 

airflow_embedash-0.1.1/airflow_embedash/plugin/airflow3.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import html
+import json
+import logging
+import os
+import os.path as op
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+from unittest.mock import patch
+from urllib.parse import urlsplit
+
+import airflow
+from airflow.configuration import conf
+from airflow.plugins_manager import AirflowPlugin 
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse, Response
+from packaging.version import Version
+ 
+
+# Airflow version gating: External views feature for the plugins used here (CosmosAF3Plugin) exist only in >= 3.1
+# Note: We compute AIRFLOW_VERSION locally here (not from constants) so that tests can patch airflow.__version__ and reload this module
+AIRFLOW_VERSION = Version(airflow.__version__)
+
+
+def ensure_airflow_version_supported() -> None:
+    if AIRFLOW_VERSION < Version("3.1.0"):
+        raise RuntimeError(
+            "Cosmos AF3 plugin requires Airflow >= 3.1. External views are unavailable on earlier versions."
+        )
+
+
+API_BASE = conf.get("api", "base_url", fallback="")  # reads AIRFLOW__API__BASE_URL
+API_BASE_PATH = urlsplit(API_BASE).path.rstrip("/")
+
+
+# Note: Airflow 3.1.0 had a limitation where plugins could not resolve connections via the API server.
+# The fix was shipped in Airflow 3.1.1. For 3.1.0, we temporarily expose the connection via env vars inside a context manager.
+@contextmanager
+def connection_env(conn_id: str | None = None) -> Generator[None, None, None]:  # pragma: no cover
+    """
+    Temporarily expose a connection as AIRFLOW_CONN_{CONN_ID} in the environment.
+
+    This allows hooks and SDK code resolving connections via the environment
+    variables backend to find the connection during the scope of the context.
+    """
+    if conn_id is None:
+        yield
+
+    from airflow.models.connection import Connection as ORMConnection
+
+    conn = ORMConnection.get_connection_from_secrets(conn_id)  # type: ignore[arg-type]
+    env_name = f"AIRFLOW_CONN_{conn_id.upper()}"  # type: ignore[union-attr]
+    env_value = conn.get_uri()
+    with patch.dict(os.environ, {env_name: env_value}, clear=False):
+        yield
+
+ 
+ 
+
+def _load_projects_from_conf() -> dict[str, dict[str, str | None]]:
+    """
+    Load dbt docs projects configuration.
+
+    Supports either:
+    - [cosmos] dbt_docs_projects = JSON mapping of project slug to {"dir","conn_id","index"}
+    - Legacy single-project settings: dbt_docs_dir, dbt_docs_conn_id, dbt_docs_index_file_name
+    """
+    projects_raw = conf.get("cosmos", "dbt_docs_projects", fallback=None)
+    projects: dict[str, dict[str, str | None]] = {}
+    if projects_raw:
+        parsed = None
+        try:
+            parsed = json.loads(projects_raw)
+        except json.JSONDecodeError:
+            logging.exception("Invalid JSON in [cosmos] dbt_docs_projects: %s", projects_raw)
+            raise
+
+        if isinstance(parsed, dict):
+            for key, value in parsed.items():
+                if not isinstance(value, dict):  # pragma: no cover
+                    continue
+                projects[str(key)] = {
+                    "dir": value.get("dir"),
+                    "conn_id": value.get("conn_id"),
+                    "index": value.get("index", "index.html"),
+                    "name": value.get("name"),
+                }
+
+    return projects
+
+ 
+
+def create_embedash_fastapi_app() -> FastAPI:  # noqa: C901
+    ensure_airflow_version_supported()
+    app = FastAPI()
+
+    projects = _load_projects_from_conf()
+
+    # Dynamic endpoints for each project
+    for slug, cfg in projects.items():
+        # Simple HTML wrapper to embed the dbt docs UI
+        @app.get(f"/{slug}/view", response_class=HTMLResponse)
+        def dbt_docs_view(slug_alias: str = slug) -> str:  # type: ignore[no-redef]
+            cfg_local = projects.get(slug_alias, {})
+            if not cfg_local.get("dir"):
+                return "<div>dbt Docs are not configured.</div>"
+            iframe_src = f"/embedash/{slug_alias}/dbt_docs_index.html"
+            safe_iframe_src = html.escape(iframe_src, quote=True)
+            return (
+                '<div style="height:100%;display:flex;flex-direction:column;">'
+                f'<iframe src="{safe_iframe_src}" style="border:0;flex:1 1 auto;"></iframe>'
+                "</div>"
+            )
+ 
+    return app
+
+      
+class EmbededDashAF3Plugin(AirflowPlugin):
+    name = "embeded_dashboards"
+
+    # Mount our FastAPI sub-app under /cosmos (initialized in __init__ after version check)
+    fastapi_apps: list[dict[str, Any]] = []
+
+    # Register external views for navigation
+    external_views: list[dict[str, Any]] = []
+
+    listeners = []
+
+    def __init__(self) -> None:
+        super().__init__()
+        ensure_airflow_version_supported()
+        # Initialize FastAPI app only after version support is confirmed
+        self.fastapi_apps = [
+            {
+                "name": "embeded_dashboards",
+                "app": create_embedash_fastapi_app(),
+                "url_prefix": "/embedash",
+            }
+        ]
+        projects = _load_projects_from_conf()
+        for slug, cfg in projects.items():
+            display_name = cfg.get("name") or f"dbt Docs ({slug})"
+            self.external_views.append(
+                {
+                    "name": display_name,
+                    "category": "Browse",
+                    "href": f"{API_BASE_PATH}/embedash/settings",
+                }
+            )

airflow_embedash-0.1.1/airflow_embedash/plugin/cluster_policy.py

@@ -0,0 +1,45 @@
+# from logging import getLogger
+
+# from airflow.models.taskinstance import TaskInstance
+# from airflow.policies import hookimpl
+# from packaging.version import Version
+
+# AIRFLOW_VERSION = 3
+
+# log = getLogger(__name__)
+
+
+# def _is_watcher_sensor(task_instance: TaskInstance) -> bool:
+#     """
+#     Check if the task instance is a watcher sensor.
+
+#     In Airflow 3, task_instance.task is a SerializedBaseOperator, isinstance checks won't work.
+#     Instead, check the task's module path, which is preserved in serialization.
+#     """
+#     from cosmos.operators._watcher.base import BaseConsumerSensor
+
+#     task = task_instance.task
+#     # Get the module, using _task_module if available (serialized tasks) or __module__ as fallback
+#     module = getattr(task, "_task_module", None) or task.__class__.__module__
+
+#     # Check if it's from the watcher operators module
+#     return "cosmos.operators.watcher" in module or isinstance(task, BaseConsumerSensor)
+
+
+# @hookimpl
+# def task_instance_mutation_hook(task_instance: TaskInstance) -> None:
+#     from cosmos.settings import watcher_dbt_execution_queue
+
+#     # In Airflow 3.x the task_instance_mutation_hook try_number starts at None or 0
+#     # in Airflow 2.x it starts at 1
+#     if AIRFLOW_VERSION >= Version("3.0.0"):
+#         retry_number = 1
+#     else:
+#         retry_number = 2
+
+#     if watcher_dbt_execution_queue and task_instance.try_number and _is_watcher_sensor(task_instance):
+#         if task_instance.try_number >= retry_number:
+#             log.info(
+#                 f"Setting task {task_instance.task_id} to use watcher dbt execution queue: {watcher_dbt_execution_queue}",
+#             )
+#             task_instance.queue = watcher_dbt_execution_queue

airflow_embedash-0.1.1/airflow_embedash/plugin/snippets.py

@@ -0,0 +1,24 @@
+IFRAME_SCRIPT = """
+<script>
+  // Prevent parent hash changes from sending a message back to the parent.
+  // This is necessary for making sure the browser back button works properly.
+  let hashChangeLock = true;
+
+  window.addEventListener('hashchange', function () {
+    if (!hashChangeLock) {
+      window.parent.postMessage(window.location.hash);
+    }
+    hashChangeLock = false;
+  });
+
+  window.addEventListener('message', function (event) {
+    let msgData = event.data;
+    if (typeof msgData === 'string' && msgData.startsWith('#!')) {
+      let updateUrl = new URL(window.location);
+      updateUrl.hash = msgData;
+      hashChangeLock = true;
+      history.replaceState(null, null, updateUrl);
+    }
+  });
+</script>
+"""

airflow_embedash-0.1.1/airflow_embedash/plugin/storage.py

@@ -0,0 +1,23 @@
+"""Utility functions for Cosmos plugins."""
+
+
+def get_storage_type_from_path(path: str) -> str:
+    """Determine the storage type from the path.
+
+    Args:
+        path: Storage path (e.g., 's3://bucket/path', '/local/path')
+
+    Returns:
+        Storage type identifier: 's3', 'gcs', 'azure', 'http', or 'local'
+    """
+    path = path.strip()
+    if path.startswith("s3://"):
+        return "s3"
+    elif path.startswith("gs://"):
+        return "gcs"
+    elif path.startswith("wasb://"):
+        return "azure"
+    elif path.startswith("http://") or path.startswith("https://"):
+        return "http"
+    else:
+        return "local"

airflow_embedash-0.1.1/airflow_embedash.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: airflow-embedash
+Version: 0.1.1
+Summary: Add embeded dashboars to Airflow
+Author-email: Rodrigo Carneiro <teoria@gmail.com>
+Project-URL: Homepage, https://github.com/teoria/airflow-embedash
+Project-URL: Documentation, https://github.com/teoria/airflow-embedash
+Project-URL: Source code, https://github.com/teoria/airflow-embedash
+Keywords: airflow,apache-airflow,metabase,grafana,datadog
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Airflow Embedash
+
+A Python package for embedding dashboards in Apache Airflow.
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install airflow-embedash
+```
+
+Or in development mode:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Create new dashboards
+ 
+### Variable
+
+The default menu label is "Dashboards" but can be changed setup `embeded_dashboards_menu_label`variable.	 
+	
+For private dashboars need metabase token `embeded_dashboards_metabase_token`
+
+## Package Structure
+
+- `src/` - Source code directory
+  - `__init__.py` - Package initialization
+  - `airflow_embeded_dashboards.py` - Main module with the main function
+
+## Development
+
+To contribute to this project:
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License.

airflow_embedash-0.1.1/airflow_embedash.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+airflow_embedash/__init__.py
+airflow_embedash.egg-info/PKG-INFO
+airflow_embedash.egg-info/SOURCES.txt
+airflow_embedash.egg-info/dependency_links.txt
+airflow_embedash.egg-info/entry_points.txt
+airflow_embedash.egg-info/top_level.txt
+airflow_embedash/plugin/__init__.py
+airflow_embedash/plugin/airflow2.py
+airflow_embedash/plugin/airflow3.py
+airflow_embedash/plugin/cluster_policy.py
+airflow_embedash/plugin/snippets.py
+airflow_embedash/plugin/storage.py

airflow_embedash-0.1.1/airflow_embedash.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

airflow_embedash-0.1.1/airflow_embedash.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[airflow.plugins]
+airflow-embedash = airflow_embedash.plugin:EmbededDashPlugin

airflow_embedash-0.1.1/airflow_embedash.egg-info/top_level.txt

@@ -0,0 +1 @@
+airflow_embedash

airflow_embedash-0.1.1/pyproject.toml

@@ -0,0 +1,61 @@
+
+[project]
+name = "airflow-embedash"
+version = "0.1.1"
+description = "Add embeded dashboars to Airflow"
+readme = "README.md"
+authors = [{ name = "Rodrigo Carneiro", email = "teoria@gmail.com" }]
+keywords = ["airflow", "apache-airflow", "metabase", "grafana", "datadog"]
+requires-python = ">=3.9"  
+ 
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "ruff>=0.11.7",
+]
+
+
+[project.urls]
+Homepage = "https://github.com/teoria/airflow-embedash"
+Documentation = "https://github.com/teoria/airflow-embedash"
+"Source code" = "https://github.com/teoria/airflow-embedash"
+
+[tool.hatch.version]
+path = "airflow_embedash/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["/airflow_embedash"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["/airflow_embedash"]
+
+[tool.pytest.ini_options]
+#addopts = "-n 8" # run tests in parallel, you can disable parallel test execution with "pytest -n0" command
+log_level = "INFO"
+#log_cli = "true" #  activate live logging, do not use with -n 8 xdist option for parallel test execution: https://github.com/pytest-dev/pytest-xdist/issues/402
+log_cli_level = "INFO"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+extend-select = [
+    "I",   # re-order imports in alphabetic order
+]
+
+ 
+[project.entry-points."airflow.plugins"]
+airflow-embedash = "airflow_embedash.plugin:EmbededDashPlugin"
+
+ 

airflow_embedash-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+