dashiyaml 0.0.2__py3-none-any.whl

dashi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

dashi/charts/__init__.py

@@ -0,0 +1,6 @@
+from .bar import BarChart
+from .line import LineChart
+from .pie import PieChart
+from .chart import BaseChart
+from .scatter import ScatterChart
+from .registry import CHARTS

dashi/charts/bar.py

@@ -0,0 +1,18 @@
+from .chart import BaseChart
+import plotly.express as px
+import polars as pl
+
+
+class BarChart(BaseChart):
+    def build(
+        self,
+        chart_name: str,
+        df: pl.DataFrame,
+        x: str,
+        y: str,
+        options: dict[str, str] | None = None,
+    ):
+        fig = px.bar(data_frame=df, x=x, y=y, title=chart_name)
+        if options is not None:
+            self.update_layout(fig, options)
+        return fig

dashi/charts/chart.py

@@ -0,0 +1,23 @@
+import polars as pl
+from abc import ABC
+
+
+class BaseChart(ABC):
+    def build(
+        self,
+        chart_name: str,
+        df: pl.DataFrame,
+        x: str,
+        y: str,
+        options: dict[str, str] | None,
+    ):
+        raise NotImplementedError
+
+    def update_layout(self, fig, options: dict):
+        try:
+            fig.update_layout(**options)
+            return fig
+        except ValueError:
+            raise ValueError(
+                "One of the options provided in the chart definition is incorrect"
+            )

dashi/charts/line.py

@@ -0,0 +1,18 @@
+from .chart import BaseChart
+import polars as pl
+import plotly.express as px
+
+
+class LineChart(BaseChart):
+    def build(
+        self,
+        chart_name: str,
+        df: pl.DataFrame,
+        x: str,
+        y: str,
+        options: dict[str, str] | None = None,
+    ):
+        fig = px.line(df, x=x, y=y, title=chart_name)
+        if options is not None:
+            self.update_layout(fig, options)
+        return fig

dashi/charts/pie.py

@@ -0,0 +1,20 @@
+import plotly.express as px
+import polars as pl
+
+from .chart import BaseChart
+
+
+class PieChart(BaseChart):
+    def build(
+        self,
+        chart_name: str,
+        df: pl.DataFrame,
+        x: str,
+        y: str,
+        options: dict[str, str] | None = None,
+    ):
+        fig = px.pie(data_frame=df, values=x, names=y, title=chart_name)
+        if options is not None:
+            fig = fig.update_layout(options)
+
+        return fig

dashi/charts/registry.py

@@ -0,0 +1,13 @@
+from .pie import PieChart
+from .table import Table
+from .bar import BarChart
+from .line import LineChart
+from .scatter import ScatterChart
+
+CHARTS = {
+    "line": LineChart(),
+    "bar": BarChart(),
+    "pie": PieChart(),
+    "scatter": ScatterChart(),
+    "table": Table(),
+}

dashi/charts/scatter.py

@@ -0,0 +1,19 @@
+import plotly.express as px
+import polars as pl
+
+from .chart import BaseChart
+
+
+class ScatterChart(BaseChart):
+    def build(
+        self,
+        chart_name: str,
+        df: pl.DataFrame,
+        x: str,
+        y: str,
+        options: dict[str, str] | None = None,
+    ):
+        fig = px.scatter(df, x=x, y=y, title=chart_name)
+        if options is not None:
+            self.update_layout(fig, options)
+        return fig

dashi/charts/table.py

@@ -0,0 +1,13 @@
+import polars as pl
+from plotly import graph_objects as go
+from typing import List
+
+
+class Table:
+    def build(self, title: str, df: pl.DataFrame, columns: List[str]) -> go.Figure:
+        headers = [col for col in df.columns if col in columns]
+        data = [col for col in df.select(headers).to_dict(as_series=False).values()]
+        table = go.Figure(
+            data=go.Table(header=dict(values=headers), cells=dict(values=data))
+        )
+        return table

dashi/cli.py

@@ -0,0 +1,61 @@
+import typer
+import plotly.io as pio
+
+from .structure.cleaner import clean_builds
+from .datasources import Datasources
+from .dashboard import Dashboard
+from .render import render_dashboard
+from .serve import serve as serve_dashboard
+from .structure.initializer import (
+    create_dashboard_template,
+    structure_already_present,
+    create_structure,
+)
+
+app = typer.Typer()
+
+
+@app.command()
+def init() -> None:
+    """
+    Initializes dashi folder structure.
+    If the structure is already present, it will be skipped.
+    After creating the structure, creates the dashboard template, which will be used to generate new dashboards.
+    """
+    if not structure_already_present():
+        create_structure()
+    else:
+        print("Structure is already present, skipping creation")
+
+    create_dashboard_template()
+
+
+@app.command()
+def build() -> None:
+    data_sources = Datasources()
+    dashboard = Dashboard(data_sources)
+    charts = [
+        {"id": f"chart_{i}", "figure": pio.to_json(chart)}
+        for i, chart in enumerate(dashboard.charts)
+    ]
+    render_dashboard(dashboard, charts)
+
+
+@app.command()
+def serve() -> None:
+    """
+    Creates a simple server to display the generated dashboards
+    """
+    serve_dashboard()
+
+
+@app.command()
+def clean() -> None:
+    """
+    Cleans the dashboard folder from the generated dashboards.
+    """
+    clean_builds()
+
+
+if __name__ == "__main__":
+    app()

dashi/config/__init__.py

@@ -0,0 +1 @@
+from .yaml_parser import parse_yaml, NoConfigFile

dashi/config/yaml_parser.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from typing import Any
+import yaml
+
+try:
+    from yaml import CLoader as Loader, CDumper as Dumper
+except ImportError:
+    from yaml import Loader, Dumper
+
+
+class NoConfigFile(Exception):
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__()
+
+
+def parse_yaml(file_path: Path, file_type: str) -> dict:
+    """
+    Parses the yaml files in the provided file_path and returns their content as a dict
+    Args:
+        file_path: a Path object representing the folder to parse
+        file_type: the type of file parsed, which is used for the function to
+            return the sub-dictionnary with the actual content
+    Returns:
+        a dictionnary representing the content of the yaml file
+    """
+    files: list = list(file_path.glob("*.y*ml"))
+
+    if not files:
+        raise NoConfigFile(f"No YAML config found in {file_path}")
+
+    file = files[0]
+    with open(file, "r") as f:
+        config: dict[Any, Any] | None = yaml.load(f, Loader=Loader)
+
+    if config is None:
+        raise ValueError(f"{file} is empty")
+    try:
+        return config[file_type]
+    except KeyError:
+        raise ValueError(
+            "There is a problem with the datasource file (the format is incorrect)"
+        )

dashi/dashboard.py

@@ -0,0 +1,88 @@
+from .charts.chart import BaseChart
+from .helpers import prettify_title
+from .transforms.transforms import apply_transforms
+from .config.yaml_parser import parse_yaml
+from .charts.registry import CHARTS
+from pathlib import Path
+from .datasources import Datasources
+from plotly.graph_objs import Figure
+from typing import List
+import polars as pl
+
+
+class NoChartType(ValueError):
+    pass
+
+
+class Dashboard:
+    DASHBOARD_FOLDER = Path.cwd() / "dashboards"
+
+    def __init__(self, data_sources: Datasources) -> None:
+        self.dash_data: dict = self.load_dashboard()
+        self.title: str = self.dash_data["title"]
+        self.rows: int = self.dash_data["layout"].get("rows", 1)
+        self.cols: int = self.dash_data["layout"].get("columns", 1)
+        self.datasources: Datasources = data_sources
+        self.charts: List[Figure] = [
+            self.generate_chart(chart) for chart in self.dash_data["charts"]
+        ]
+
+    def load_dashboard(self) -> dict[str, str]:
+        """Retrieve the yaml parametrization from the dashboard folder and return the parametrization as a dict.
+        Returns:
+            A dict mapping keys to a corresponding dashboard parameter, or chart.
+            Example: {"title": "sample_dashboard"}
+        """
+        data: dict[str, str] = parse_yaml(self.DASHBOARD_FOLDER, "dashboard")
+        return data
+
+    def generate_chart(self, chart_data: dict) -> Figure:
+        """Create the Plotly figure based on chart data retrieved from the yaml.
+        The chart data contains chart type, data source, values for x and y. The actual data has to be fetched from the datasource, which should be kept
+        as an instance of the class Datasource.
+        Args:
+            chart_data: a dictionnary representing the chart parametrization
+            Example: {"name": "example_chart", "type": "line", "datasource": "sample_datasource", "x": "x_data", "y": "y_data"}
+        Returns:
+            A Plotly figure, with its type corresponding to the value of the "type" key in the passed chart_data dict
+        """
+        chart_name: str = chart_data["name"]
+        chart_type: str = chart_data["type"]
+        chart_datasource: pl.DataFrame = self.datasources.find_datasource(
+            chart_data["datasource"]
+        ).load_data()
+
+        chart_settings = {}
+
+        if chart_type != "table":
+            chart_transform = chart_data.get("transform", None)
+
+            if chart_transform is not None:
+                chart_datasource = apply_transforms(chart_datasource, chart_transform)
+
+            chart_settings["x"] = (
+                chart_data.get("x")
+                if chart_data.get("x") is not None
+                else chart_data.get("values")
+            )
+            chart_settings["y"] = (
+                chart_data.get("y")
+                if chart_data.get("y") is not None
+                else chart_data.get("names")
+            )
+
+            if chart_settings["x"] is None or chart_settings["y"] is None:
+                raise ValueError(
+                    "The dashboard parametrization is missing x/values or y/names"
+                )
+
+            chart_settings["options"] = chart_data.get("options", None)
+        else:
+            table_cols = chart_data.get("columns")
+            chart_settings["columns"] = table_cols
+
+        builder: BaseChart = CHARTS[chart_type]
+
+        return builder.build(
+            prettify_title(chart_name), chart_datasource, **chart_settings
+        )

dashi/datasources/__init__.py

@@ -0,0 +1,6 @@
+from .base_datasource import BaseDatasource
+from .csv_datasource import CsvDatasource
+from .json_datasource import JsonDatasource
+from .datasources import Datasources
+from .postgres_datasource import PostgresDatasource
+from .duckdb_datasource import DuckDBDatasource

dashi/datasources/base_datasource.py

@@ -0,0 +1,18 @@
+import polars as pl
+from abc import ABC
+from pathlib import Path
+
+
+class BaseDatasource(ABC):
+    STAGING_DATA_PATH = Path.cwd() / "staging_data"
+
+    def __init__(self, source_def: dict, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.name: str = source_def["name"]
+        self.data_type: str = source_def["type"]
+
+    def __repr__(self) -> str:
+        return f"Datasource {self.name}, from {self.data_type}"
+
+    def load_data(self) -> pl.DataFrame:
+        raise NotImplementedError

dashi/datasources/csv_datasource.py

@@ -0,0 +1,10 @@
+from .base_datasource import BaseDatasource
+from .file_datasource import FileDatasource
+import polars as pl
+
+
+class CsvDatasource(FileDatasource):
+    def load_data(self) -> pl.DataFrame:
+        schema: dict = self.load_schema()
+        data: pl.DataFrame = pl.read_csv(self.path, schema=schema)
+        return data

dashi/datasources/datasources.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from typing import List, Any
+from dashi.config.yaml_parser import parse_yaml, NoConfigFile
+from .registry import DATASOURCES
+from .base_datasource import BaseDatasource
+
+
+class Datasources:
+    DATA_SOURCES_PATH = Path.cwd() / "data_sources"
+
+    def __init__(self) -> None:
+        self.sources: List[BaseDatasource] = self.load_sources()
+
+    def load_sources(self):
+        sources = []
+
+        try:
+            data: dict[Any, Any] = parse_yaml(self.DATA_SOURCES_PATH, "datasources")
+
+            for ds_settings in data:
+                sources.append(DATASOURCES[ds_settings["type"]](ds_settings))
+
+        except NoConfigFile as e:
+            print(e.message)
+        return sources
+
+    def find_datasource(self, source_name: str) -> BaseDatasource:
+        try:
+            return [source for source in self.sources if source.name == source_name][0]
+        except IndexError:
+            raise IndexError(
+                "The name of the datasource in the dashboard configuration doesn't correspond to any existing datasource"
+            )
+
+
+if __name__ == "__main__":
+    datasoures = Datasources()
+
+    for source in datasoures.sources:
+        print(source.data)

dashi/datasources/duckdb_datasource.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from .sql_datasource import SqlDatasource
+import duckdb
+import polars as pl
+
+
+class DuckDBDatasource(SqlDatasource):
+    def __init__(self, source_def: dict) -> None:
+        super().__init__(source_def)
+        self.path: Path = self.STAGING_DATA_PATH / f"{source_def['name']}.duckdb"
+
+    def load_data(self) -> pl.DataFrame:
+        con = duckdb.connect(database=self.path)
+        df: pl.DataFrame = con.sql(self.query).pl()
+        return df

dashi/datasources/file_datasource.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from typing import List, Union
+from .base_datasource import BaseDatasource
+from polars.datatypes import String, Float32, Int32, Date, Unknown
+
+
+class FileDatasource(BaseDatasource):
+    STAGING_DATA_PATH = Path.cwd() / "staging_data"
+
+    def __init__(
+        self,
+        source_def: dict,
+    ) -> None:
+        super().__init__(source_def)
+        self.columns: List[dict] = source_def["columns"]
+        if source_def.get("path") is None:
+            self.path: Path = (
+                self.STAGING_DATA_PATH / f"{source_def['name']}.{source_def['type']}"
+            )
+        else:
+            self.path = source_def["path"]
+
+    def load_schema(self) -> dict:
+        schema: dict = {
+            col["name"]: self.convert_type_to_pl_datatype(col["type"])
+            for col in self.columns
+        }
+        return schema
+
+    @staticmethod
+    def convert_type_to_pl_datatype(
+        datatype: str,
+    ) -> dict[
+        str, Union[type[String], type[Int32], type[Float32], type[Date], type[Unknown]]
+    ]:
+        datatypes_dict = {
+            "string": String,
+            "integer": Int32,
+            "int32": Int32,
+            "float32": Float32,
+            "float": Float32,
+            "date": Date,
+        }
+        return datatypes_dict.get(datatype, Unknown)

dashi/datasources/json_datasource.py

@@ -0,0 +1,9 @@
+from .base_datasource import BaseDatasource
+from .file_datasource import FileDatasource
+import polars as pl
+
+
+class JsonDatasource(FileDatasource):
+    def load_data(self) -> pl.DataFrame:
+        schema: dict = self.load_schema()
+        return pl.read_json(self.path, schema=schema)

dashi/datasources/login_mixin.py

@@ -0,0 +1,21 @@
+from abc import ABC
+
+
+class LoginMixin(ABC):
+    def build_connection(self, source_def: dict) -> dict[str, str]:
+        host = source_def.get("host")
+        port = source_def.get("port")
+        username = source_def.get("username")
+        password = source_def.get("password")
+        dbname = source_def.get("dbname")
+        connection_info: dict = {
+            "dbname": dbname,
+            "host": host,
+            "port": port,
+            "user": username,
+            "password": password,
+        }
+        return connection_info
+
+    def login(self, connection_info: dict):
+        raise NotImplementedError

dashi/datasources/postgres_datasource.py

@@ -0,0 +1,59 @@
+import polars as pl
+from .login_mixin import LoginMixin
+from .sql_datasource import SqlDatasource
+
+
+class PostgresDatasource(SqlDatasource, LoginMixin):
+    DATATYPES: dict[str, type] = {
+        "bool": bool,
+        "varchar": str,
+        "text": str,
+        "float4": float,
+        "float8": float,
+        "money": float,
+        "date": str,
+        "time": str,
+        "timestamp": str,
+        "numeric": float,
+        "char": str,
+        "int8": int,
+        "int4": int,
+        "int2": int,
+    }
+
+    def __init__(self, source_def: dict) -> None:
+        super().__init__(source_def)
+        self.connection_info = self.build_connection(source_def)
+        self.conn = self.login(self.connection_info)
+        self._datatypes = self._load_datatypes()
+
+    def login(self, connection_info: dict):
+        try:
+            import psycopg2
+        except ImportError:
+            raise ImportError(
+                "psycopg2 is required for PostgreSQL support. "
+                'Install it with: pip install "dashi[postgres]'
+            )
+        try:
+            return psycopg2.connect(**connection_info)
+        except psycopg2.DatabaseError as err:
+            raise err
+
+    def load_data(self) -> pl.DataFrame:
+        with self.conn.cursor() as curs:
+            curs.execute(self.query)
+            res = curs.fetchall()
+            meta = {info[0]: self._datatypes.get(info[1]) for info in curs.description}
+        self.conn.close()
+        df = pl.DataFrame(data=res, schema=meta, orient="row")
+        return df
+
+    def _load_datatypes(self) -> dict:
+        with self.conn.cursor() as curs:
+            curs.execute("select oid,typname from pg_type")
+            res = curs.fetchall()
+            return {dtype[0]: self._pg_datatype_to_python(dtype[1]) for dtype in res}
+
+    def _pg_datatype_to_python(self, pg_datatype: str):
+        return self.DATATYPES.get(pg_datatype)

dashi/datasources/registry.py

@@ -0,0 +1,12 @@
+from .postgres_datasource import PostgresDatasource
+from .csv_datasource import CsvDatasource
+from .json_datasource import JsonDatasource
+from .sql_datasource import SqlDatasource
+from .duckdb_datasource import DuckDBDatasource
+
+DATASOURCES = {
+    "csv": CsvDatasource,
+    "json": JsonDatasource,
+    "duckdb": DuckDBDatasource,
+    "postgres": PostgresDatasource,
+}

dashi/datasources/sql_datasource.py

@@ -0,0 +1,12 @@
+import polars as pl
+from .base_datasource import BaseDatasource
+from abc import ABC
+
+
+class SqlDatasource(BaseDatasource, ABC):
+    def __init__(self, source_def: dict, *args, **kwargs) -> None:
+        super().__init__(source_def, *args, **kwargs)
+        self.query: str = source_def["query"]
+
+    def load_data(self) -> pl.DataFrame:
+        raise NotImplementedError

dashi/helpers.py

@@ -0,0 +1,2 @@
+def prettify_title(title: str) -> str:
+    return " ".join(word.capitalize() for word in title.split("_"))

dashi/render.py

@@ -0,0 +1,13 @@
+from jinja2 import Environment, FileSystemLoader
+
+
+def render_dashboard(dashboard, charts):
+    env = Environment(loader=FileSystemLoader("templates"))
+    template = env.get_template("dashboard_template.html")
+
+    html = template.render(
+        title=dashboard.title, rows=dashboard.rows, cols=dashboard.cols, charts=charts
+    )
+
+    with open(f"builds/{dashboard.title}.html", "w") as f:
+        f.write(html)

dashi/serve.py

@@ -0,0 +1,16 @@
+import http.server
+import socketserver
+import os
+from pathlib import Path
+
+PORT = 8000
+
+
+def serve() -> None:
+    handler = http.server.SimpleHTTPRequestHandler
+
+    os.chdir(Path.cwd() / "builds")
+
+    with socketserver.TCPServer(("", PORT), handler) as httpd:
+        print(f"Serving on http://localhost:{PORT}")
+        httpd.serve_forever()

dashi/structure/cleaner.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+def clean_builds() -> None:
+    """
+    Deletes the existing files in the builds directory.
+    """
+    builds_path = Path.cwd() / "builds"
+    for file in builds_path.glob("*.html"):
+        file.unlink()

dashi/structure/initializer.py

@@ -0,0 +1,139 @@
+from pathlib import Path
+
+DASHI_FOLDERS = ["data_sources", "staging_data", "dashboards", "templates"]
+
+
+def structure_already_present() -> bool:
+    """
+    Checks if any of the DASHI_FOLDERS is alread present in the current project structure
+    Return:
+        A boolean value indicating if any folder from the DASHI_FOLDERS is found in the project structure
+    """
+    if any([Path.exists(Path.cwd() / folder) for folder in DASHI_FOLDERS]):
+        return True
+    return False
+
+
+def create_structure() -> None:
+    """
+    Creates the wanted folder structure for dashi to work.
+    To do this, the function creates folders in the constant DASHI_FOLDERS
+    """
+    root = Path.cwd()
+    for folder in DASHI_FOLDERS:
+        new_folder = Path(root / folder)
+        new_folder.mkdir()
+
+
+def create_dashboard_template() -> None:
+    """
+    Creates the dashboard template which will be used to generate new dashboards
+    """
+    dashboard_template_file = Path().cwd() / "templates" / "dashboard_template.html"
+
+    with open(dashboard_template_file, "w") as f:
+        f.write(
+            """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+
+    <script src="https://cdn.plot.ly/plotly-2.30.0.min.js"></script>
+    <link rel="stylesheet" href="static/style.css"/>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=PT+Sans:ital,wght@0,400;0,700;1,400;1,700&family=PT+Serif:ital,wght@0,400;0,700;1,400;1,700&family=Silkscreen:wght@400;700&display=swap" rel="stylesheet">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,300..800;1,300..800&display=swap" rel="stylesheet">
+</head>
+
+<body>
+
+  <header>
+    <h1>Dashi</h1>
+    
+  </header>
+
+  <main>
+    <h2>{{ title }}</h2>
+    <div class="grid" style="grid-template-columns: repeat({{cols}}, 1fr);">
+      
+      {% for chart in charts %}
+      <div id="{{ chart.id }}" class="chart"></div>
+      {% endfor %}
+
+    </div>
+  </main>
+  <script>
+    {% for chart in charts %}
+
+    const fig_{{ loop.index }} = {{ chart.figure | safe }};
+
+    Plotly.newPlot(
+        "{{ chart.id }}",
+        fig_{{ loop.index }}.data,
+        fig_{{ loop.index }}.layout
+    );
+
+    {% endfor %}
+  </script>
+
+  </body>
+</html>
+            """
+        )
+
+
+def create_stylesheet() -> None:
+    """
+    Creates the css stylesheet used for the dashboards
+    """
+    staticfile = Path().cwd() / "builds" / "static" / "style.css"
+
+    with open(staticfile, "w") as f:
+        f.write(
+            """
+body, html { 
+  margin: 0;
+  padding: 0;
+  display: block;
+}
+
+.grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+}
+
+.chart {
+    border: 1px solid #eee;
+    padding: 10px;
+    display: flex;
+    justify-content: center;
+}
+
+header {
+  background-color: black;
+  height: 4rem;
+  display: flex;
+  align-items:center;
+}
+
+h1 {
+  font-family: "Silkscreen", sans-serif;
+  color: white;
+  margin: 2rem;
+  align-items: center;
+}
+
+h2 {
+  font-family: "Open Sans", sans-serif;
+}
+
+main {
+  padding: 0.5rem 2rem;
+}
+            """
+        )

dashi/transforms/transforms.py

@@ -0,0 +1,31 @@
+import polars as pl
+
+
+def apply_transforms(dataframe: pl.DataFrame, transforms: dict) -> pl.DataFrame:
+    """
+    Takes a Dataframe and applies transformations if needed.
+    Args:
+        dataframe: A polars dataframe
+        transforms: A list of transformations to apply (group_by, sum, count ...)
+    Returns:
+        A polars dataframe updated with the applied transforms
+    """
+    groupby = transforms.get("groupby")
+    metrics = transforms.get("metrics")
+
+    if not groupby:
+        return dataframe
+
+    aggs = []
+
+    for col, op in metrics.items():
+        if op == "sum":
+            aggs.append(pl.col(col).sum())
+        if op == "count":
+            aggs.append(pl.col(col).count())
+        if op == "average":
+            aggs.append(pl.col(col).mean())
+        if op == "median":
+            aggs.append(pl.col(col).median())
+
+    return dataframe.group_by(groupby).agg(aggs)

dashiyaml-0.0.2.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: dashiyaml
+Version: 0.0.2
+Summary: Dashboard as code tool - turn YAML configs into standalone HTML dashboards
+Author: Corentin Dupriez
+License: MIT
+Project-URL: Homepage, https://github.com/Corentin-dupriez/dashi
+Project-URL: Bug Tracker, https://github.com/Corentin-dupriez/dashi/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+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
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: polars
+Requires-Dist: plotly
+Requires-Dist: numpy
+Requires-Dist: pyyaml
+Requires-Dist: jinja2
+Requires-Dist: typer
+Requires-Dist: duckdb
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary; extra == "postgres"
+Dynamic: license-file
+
+# dashi
+
+dashi is a dashboard-as-code application that allows you to create dashboards
+from yaml files. It used Polars for fast and efficient dataframe processing,
+and Plotly for visualisation.
+
+## Status
+
+⚠️ dashi is currently in early development.
+The API and configuration format may change.
+
+## Philosophy
+
+dashi follows a **dashboard-as-code** approach.
+
+Instead of building dashboards through a GUI, dashboards are defined
+as YAML files that can be versioned, reviewed, and deployed like code.
+
+This allows dashboards to be:
+
+- version controlled
+- reproducible
+- easy to review in pull requests
+
+## How to use
+
+### Install Dashi
+
+First, make sure Python 3.9 or above is installed:
+`python --version`
+
+Install dashi from Pypi:
+`pip install dashiyaml`
+
+For PostgreSQL datasource support, install the optional extra:
+`pip install dashi[postgres]`
+
+### Initialize folder structure
+
+After having cloned the repo and installed dependencies, you can initiate the
+folder structure with
+
+`dashi init`
+
+This will create the following structure (if it doesn't already exist)
+
+```txt
++ data_sources
++ staging_data
++ templates
+  + dashboard_template.html
++ builds
+  + static
+    + style.css
+```
+
+### Configuring data sources
+
+The first step of creating visualisations is done by defining data sources.
+This should be done in the data_sources folder as a yaml file. This file
+should contain the parametrization listed below.
+
+#### Csv and JSON datasources
+
+Csv and JSON
+
+```yaml
+datasources:
+  - name: sample_data
+    type: csv
+    columns:
+      - name: id
+        type: integer
+      - name: name
+        type: string
+```
+
+For the moment, only the csv, json, duckdb and PostgreSQL datasource types are supported,
+but more formats will be supported soon.
+The datasource name must match the filename (without the extension)
+of the data file stored in the `staging_data` folder.
+When using the `dashi build` command, dashi
+will then look within the staging_data folder, and generate a polars dataframe
+by using the defined schema.
+
+### Configuring the dashboards
+
+Once the datasources are defined, the dashboard itself can be defined within the
+`dashboards` folder as a yaml file. Each yaml file should correspond to
+one dashboard, but each dashboard is composed of several charts.
+The file should contain the dashboard name, as well as a list of charts.
+Each chart should be defined with:
+
+- title
+- chart type (ex: line, bar)
+- datasource (corresponding to a datasource defined in `data_sources`)
+- x (corresponding to a column defined for the datasource)
+- y (corresponding to a column defined for the datasource)
+- options: allow a pass through of plotly options to the widget. For example:
+  - theme
+  - title
+  - font
+- transforms: contains instructions on transformation of the data before plotting.
+This includes:
+  - group by
+  - sum
+  - average
+  - count
+
+All the options that can be passed can be seen [on the Plotly documentation](https://plotly.com/python/reference/layout/)
+
+```yaml
+dashboard: 
+  title: sample_dashboard
+
+  charts: 
+    - name: sample_chart
+      type: bar
+      datasource: sample_data
+      x: channel
+      y: orders
+      options: 
+        title: Orders by channel
+        template: plotly_white
+      transform:
+        groupby: channel
+        metrics:
+          orders: sum
+
+```
+
+### dashi build
+
+Once both datasources and dashboards have been defined, the `dashi build`
+command can be used to create the dashboards based on the provided definitions.
+
+This command will create html files under the `builds` folder.
+
+WARNING: `dashi build` will override previous version of the dashboards
+you have already exported
+
+### dashi serve
+
+The command `dashi serve` will create a simple http server on the port 8000
+by default. The created dashboards can be accessed from there.
+
+### dashi clean
+
+If you wish to clean up the created dashboards, you can use the `dashi clean` command.
+It will delete every html file within the `builds` folder

dashiyaml-0.0.2.dist-info/RECORD

@@ -0,0 +1,38 @@
+dashi/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+dashi/cli.py,sha256=rOczR1z5caUCq7zj0MF2wdVQJ0PZR4E_qTnXyvIhZCI,1417
+dashi/dashboard.py,sha256=-BbKnQ4af3TPUcYGfQPLqdIV8GrYJaOO9rteEyTQY4A,3474
+dashi/helpers.py,sha256=JWfi35JuoC9OHJcpV0SICDF87zCNotvr58iocP7KWUg,107
+dashi/render.py,sha256=pbBEBQiIiNgeA61Nq3ovlPj9D4K_1fnz6glwoXF2mGk,415
+dashi/serve.py,sha256=gNrrwcVotfczTY9m6VJ0d133Z_bV_9oWVTdNlDr0UEo,345
+dashi/charts/__init__.py,sha256=CFCw7C80JXcO9Z5SRZxsnLunvnj_sRMKCUdcjH4NI4Y,172
+dashi/charts/bar.py,sha256=EE87oVtjCsobdlgIienzwpLEFDNkTvJr1riQBQbhVkI,432
+dashi/charts/chart.py,sha256=tjVJVOByKEX9jblNlttL6qFrB3lHjbrzXfGYE9-PLrc,538
+dashi/charts/line.py,sha256=X3fzHByS5ik-rXZGpKQw2XNohqCgzubU3DP-zxXooWg,423
+dashi/charts/pie.py,sha256=lvgZm-XECNLU7ZdbdZOZGpAJukVnmlBruoFKUwUPlxQ,443
+dashi/charts/registry.py,sha256=kzuD3OwC_Zgemu84u1LD7qxGYNsyraflHGTGxLE0z-o,277
+dashi/charts/scatter.py,sha256=6h9ebcEOzLkloNfenObZqP10EXiD6Wwp4NBbj-eRSKc,430
+dashi/charts/table.py,sha256=n6f6LHvMOzmQuP98JO3PDuvk9TiXAzccfNPs2tTNUc4,469
+dashi/config/__init__.py,sha256=oCbeEGPmY9IO8lEaSQzxbZNG2VVC-aUJPtCBDBRSLOQ,50
+dashi/config/yaml_parser.py,sha256=oJsTfPxQBSZ6sFfYokQRuN8ObBjy1b5a5HhjRnue4GQ,1281
+dashi/datasources/__init__.py,sha256=lgKBhcw2gMLnqZB_txdDn-hFC3sLQu7cQKyzvZQBdus,267
+dashi/datasources/base_datasource.py,sha256=b-4SatW_Fc5heKucy-mNV_r3G2LXMMM5dgDCICr2jEg,521
+dashi/datasources/csv_datasource.py,sha256=2CFgRzaMK_pcUaEyN5K7DkV7A8UfBr_Tiw107J76gPM,317
+dashi/datasources/datasources.py,sha256=StGvkY-ZsunzlUmPKv74e7TFfiUWAkkWTxle2a9TBL4,1205
+dashi/datasources/duckdb_datasource.py,sha256=9HL7dXMSlYu6-8P1AJ9HtUbO2kDgqT7CiwuFYUPfQCg,472
+dashi/datasources/file_datasource.py,sha256=_UXtEqZpGk751DXUHgM6oL-Chus6oc09VfdqbeXfzRw,1314
+dashi/datasources/json_datasource.py,sha256=81888IrRiu2wzC7Ta-_NR8ISP_MbHPWvjmVBy_z6Z2Q,285
+dashi/datasources/login_mixin.py,sha256=ydebahhde_2NJGgM_DGjOwzmor6iQq5_U-q1wp0734o,623
+dashi/datasources/postgres_datasource.py,sha256=opwey-NK3FUMFo5vwxUB5KGmhwug1IxK-NzbXW0US4E,1905
+dashi/datasources/registry.py,sha256=l2QbM0SiT2FaLP6siEaT3gTnEQJUaLpPTI0pIo_hS6U,369
+dashi/datasources/sql_datasource.py,sha256=CgOzHtjUruH5TfIkJfRIwcqQYDhaC2Tnt_ALS5EPGqI,371
+dashi/structure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dashi/structure/cleaner.py,sha256=nSTPgj7Dw106ZwEFFRIhP0bqF875lnQ9rDYvFKrdq1E,233
+dashi/structure/initializer.py,sha256=tHVLBISoTL4tlkoJSbNQazRQIh1P7QY8evLVuCJc82I,3307
+dashi/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dashi/transforms/transforms.py,sha256=6Xq2wQ4UNoTxzSkwpy-QnI-XLsGpTuPTTM8kEQPcWf4,897
+dashiyaml-0.0.2.dist-info/licenses/LICENSE,sha256=4-rUbcwMRML61WaPkVTFs26HWOM6aOUUYOof19KK-D8,1073
+dashiyaml-0.0.2.dist-info/METADATA,sha256=9E2RGnWWrJKW5W66-S8FuNF_xnhugIJ6Js5sAVM_-78,5187
+dashiyaml-0.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dashiyaml-0.0.2.dist-info/entry_points.txt,sha256=MCZLxxuccCTRcOgxsuAx9N1iVNOu1So7Pd6QBYx4x9Y,40
+dashiyaml-0.0.2.dist-info/top_level.txt,sha256=fZou1xoOz4q69Gsx9SoVHLxsq7Ky3P90g9_geulqLPE,6
+dashiyaml-0.0.2.dist-info/RECORD,,

dashiyaml-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dashiyaml-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dashi = dashi.cli:app

dashiyaml-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Corentin Dupriez
+
+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.

dashiyaml-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+dashi