zen-temple 0.0.1__tar.gz

zen_temple-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Reliability and Risk Engineering, ETH Zurich
+
+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.

zen_temple-0.0.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: zen_temple
+Version: 0.0.1
+Summary: The visualization plattform for ZEN Garden
+Author-email: Vinzenz Muser <muserv@ethz.ch>
+Project-URL: Homepage, https://github.com/ZEN-universe/ZEN-temple
+Project-URL: Issues, https://github.com/ZEN-universe/ZEN-temple/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Requires-Dist: fastapi-cache2
+Requires-Dist: python-dotenv
+Requires-Dist: sqlmodel
+Requires-Dist: python-multipart
+Requires-Dist: zen-garden
+
+## ZEN Suite
+
+Run with: `uvicorn src.main:app`
+Develop with: `uvicorn src.main:app --reload --host 0.0.0.0`
+
+If chnages to the models are made, alembic is responsible for the migrations. Use the following steps:
+
+Create change-scripts: `alembic revision --autogenerate -m "<message>"`
+Commit changes: `alembic upgrade head`
+
+Build Docker-Container with `docker build -t example --build-arg ssh_prv_key="$(cat ~/.ssh/id_rsa)" --build-arg ssh_pub_key="$(cat ~/.ssh/id_rsa.pub)" .`
+
+Watch out, this copies your private ssh-key to the container because the required repository (ZEN garden) is private and therefore you need git-authentification.

zen_temple-0.0.1/README.md

@@ -0,0 +1,13 @@
+## ZEN Suite
+
+Run with: `uvicorn src.main:app`
+Develop with: `uvicorn src.main:app --reload --host 0.0.0.0`
+
+If chnages to the models are made, alembic is responsible for the migrations. Use the following steps:
+
+Create change-scripts: `alembic revision --autogenerate -m "<message>"`
+Commit changes: `alembic upgrade head`
+
+Build Docker-Container with `docker build -t example --build-arg ssh_prv_key="$(cat ~/.ssh/id_rsa)" --build-arg ssh_pub_key="$(cat ~/.ssh/id_rsa.pub)" .`
+
+Watch out, this copies your private ssh-key to the container because the required repository (ZEN garden) is private and therefore you need git-authentification.

zen_temple-0.0.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zen_temple"
+version = "0.0.1"
+authors = [
+  { name="Vinzenz Muser", email="muserv@ethz.ch" },
+]
+description = "The visualization plattform for ZEN Garden"
+requires-python= ">=3.10"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "uvicorn",
+    "fastapi",
+    "fastapi-cache2",
+    "python-dotenv",
+    "sqlmodel",
+    "python-multipart",
+    "zen-garden"
+]
+
+[project.urls]
+Homepage = "https://github.com/ZEN-universe/ZEN-temple"
+Issues = "https://github.com/ZEN-universe/ZEN-temple/issues"

zen_temple-0.0.1/setup.cfg

@@ -0,0 +1,17 @@
+[flake8]
+max-line-length = 90
+exclude = migrations,src/config.py
+ignore = E203
+
+[black]
+max-line-length = 90
+
+[mypy]
+python_executable = "venv/bin/python"
+exclude = venv|migrations|tests|public
+strict = True
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

zen_temple-0.0.1/src/zen_temple/config.py

@@ -0,0 +1,23 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Config:
+    def __init__(self) -> None:
+        self.SOLUTION_FOLDER: str = os.getenv("SOLUTION_FOLDER")  # type: ignore
+
+        if self.SOLUTION_FOLDER is None:
+            self.SOLUTION_FOLDER = "../outputs"
+            print(f"Setting default solution folder {self.SOLUTION_FOLDER}")
+
+        self.check()
+
+    def check(self) -> None:
+        for key, val in self.__dict__.items():
+            if val is None:
+                raise Exception(f"Env-Variable {key} is missing!")
+
+
+config = Config()

zen_temple-0.0.1/src/zen_temple/main.py

@@ -0,0 +1,44 @@
+from src.routers import solutions
+from collections.abc import AsyncIterator
+
+import uvicorn
+
+from contextlib import asynccontextmanager
+
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+import webbrowser
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+    FastAPICache.init(InMemoryBackend())
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+origins = ["*"]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,  # type: ignore
+    allow_credentials=True,  # type: ignore
+    allow_methods=["*"],  # type: ignore
+    allow_headers=["*"],  # type: ignore
+)
+
+app.include_router(solutions.router)
+app.mount("/explorer", StaticFiles(directory="explorer", html=True), name="explorer")
+
+if __name__ == "__main__":
+    config = uvicorn.Config("main:app", port=8000, log_level="info")
+    server = uvicorn.Server(config)
+    webbrowser.open('http://localhost:8000/explorer', new=2)
+
+    server.run()
+

zen_temple-0.0.1/src/zen_temple/models/__init__.py

@@ -0,0 +1 @@
+from . import solution  # noqa: F401

zen_temple-0.0.1/src/zen_temple/models/solution.py

@@ -0,0 +1,222 @@
+from sqlmodel import Field, Column, String
+from sqlalchemy.dialects import postgresql
+from pydantic import BaseModel
+from typing import Optional
+from enum import Enum
+from src.config import config
+import os
+import json
+from typing import Any
+from zen_garden.model.default_config import System  # type: ignore
+from zen_garden.postprocess.results import Results  # type: ignore
+
+
+class SeriesBehaviour(Enum):
+    sum = "sum"
+    series = "series"
+
+
+class ScenarioDetail(BaseModel):
+    system: System
+    reference_carrier: dict[str, str]
+    carriers_import: list[str]
+    carriers_export: list[str]
+    carriers_input: dict[str, list[str]]
+    carriers_output: dict[str, list[str]]
+    carriers_demand: list[str]
+    edges: dict[str, str]
+
+
+class SolutionDetail(BaseModel):
+    name: str
+    folder_name: str
+    scenarios: dict[str, ScenarioDetail]
+
+    @staticmethod
+    def from_name(name: str) -> "SolutionDetail":
+        results = Results(os.path.join(config.SOLUTION_FOLDER, name))
+        reference_carriers = results.get_df("set_reference_carriers")
+
+        scenario_details = {}
+
+        for scenario_name, scenario in results.solution_loader.scenarios.items():
+            system = scenario.system
+            reference_carrier = reference_carriers[scenario_name].to_dict()
+            df_import = results.get_df("availability_import")[scenario_name]
+            df_export = results.get_df("availability_export")[scenario_name]
+            df_demand = results.get_df("demand")[scenario_name]
+            df_input_carriers = results.get_df("set_input_carriers")[scenario_name]
+            df_output_carriers = results.get_df("set_output_carriers")[scenario_name]
+            edges = results.get_df("set_nodes_on_edges")[scenario_name]
+            edges_dict = edges.to_dict()
+            carriers_input_dict = {
+                key: val.split(",") for key, val in df_input_carriers.to_dict().items()
+            }
+            carriers_output_dict = {
+                key: val.split(",") for key, val in df_output_carriers.to_dict().items()
+            }
+
+            for key in carriers_output_dict:
+                if carriers_output_dict[key] == [""]:
+                    carriers_output_dict[key] = []
+
+            for key in carriers_input_dict:
+                if carriers_input_dict[key] == [""]:
+                    carriers_input_dict[key] = []
+
+            carriers_import = list(
+                df_import.loc[df_import != 0].index.get_level_values("carrier").unique()
+            )
+            carriers_export = list(
+                df_export.loc[df_export != 0].index.get_level_values("carrier").unique()
+            )
+
+            carriers_demand = list(
+                df_demand.loc[df_demand != 0].index.get_level_values("carrier").unique()
+            )
+
+            scenario_details[scenario_name] = ScenarioDetail(
+                system=system,
+                reference_carrier=reference_carrier,
+                carriers_import=carriers_import,
+                carriers_export=carriers_export,
+                carriers_input=carriers_input_dict,
+                carriers_output=carriers_output_dict,
+                carriers_demand=carriers_demand,
+                edges=edges_dict
+            )
+
+        return SolutionDetail(
+            name=name.split("/")[-1],
+            folder_name=name.split("/")[-1],
+            scenarios=scenario_details,
+        )
+
+
+class Solution(BaseModel):
+    folder_name: str
+    name: str
+    nodes: list[str] = Field(default=[], sa_column=Column(postgresql.ARRAY(String())))
+    total_hours_per_year: int
+    optimized_years: int
+    technologies: list[str] = Field(
+        default=[], sa_column=Column(postgresql.ARRAY(String()))
+    )
+    carriers: list[str] = Field(
+        default=[], sa_column=Column(postgresql.ARRAY(String()))
+    )
+    scenarios: list[str] = Field(
+        default=[], sa_column=Column(postgresql.ARRAY(String()))
+    )
+
+    @staticmethod
+    def from_name(name: str) -> "Solution":
+        scenarios = [
+            i
+            for i in os.listdir(os.path.join(config.SOLUTION_FOLDER, name))
+            if i.startswith("scenario_")
+        ]
+
+        if len(scenarios) == 0:
+            scenarios = ["scenario_"]
+
+        system_path = os.path.join(config.SOLUTION_FOLDER, name, "system.json")
+        if not os.path.exists(system_path):
+            system_path = os.path.join(
+                config.SOLUTION_FOLDER, name, "scenario_", "system.json"
+            )
+
+        with open(system_path) as f:
+            system: dict[str, Any] = json.load(f)
+
+        system["carriers"] = system["set_carriers"]
+        system["technologies"] = system["set_technologies"]
+        system["folder_name"] = name.split("/")[-1]
+        system["scenarios"] = scenarios
+        system["nodes"] = system["set_nodes"]
+        system["name"] = name.split("/")[-1]
+        solution = Solution(**system)
+
+        return solution
+
+
+class IndexSet(BaseModel):
+    index_title: str
+    behaviour: SeriesBehaviour = SeriesBehaviour.series
+    indices: list[str] = []
+
+
+class DataRequest(BaseModel):
+    default: SeriesBehaviour = SeriesBehaviour.series
+    index_sets: list[IndexSet] = []
+
+
+class CompleteDataRequest(BaseModel):
+    solution_name: str
+    component: str
+    scenario: str = "scenario_"
+    data_request: DataRequest
+    aggregate_years: bool = False
+
+
+class DataResult(BaseModel):
+    data_csv: str
+    unit: Optional[str]
+
+
+class ResultsRequest(BaseModel):
+    component: str
+    yearly: bool = False
+    node_edit: Optional[str] = None
+    sum_techs: bool = False
+    tech_type: Optional[str] = None
+    reference_carrier: Optional[str] = None
+    scenario: Optional[str] = None
+
+    def to_data_request(self, solution_name: str) -> CompleteDataRequest:
+        data_request = DataRequest()
+        index_sets: list[IndexSet] = []
+
+        if self.node_edit is not None and self.node_edit != "all":
+            index_sets.append(
+                IndexSet(
+                    index_title="node",
+                    behaviour=SeriesBehaviour.series,
+                    indices=[self.node_edit],
+                )
+            )
+
+        if (
+            self.sum_techs is not None or self.tech_type
+        ) is not None and self.tech_type != "all":
+            tech_index = IndexSet(
+                index_title="technology", behaviour=SeriesBehaviour.series
+            )
+            if self.sum_techs:
+                tech_index.behaviour = SeriesBehaviour.sum
+            if self.tech_type is not None:
+                tech_index.indices = [self.tech_type]
+            index_sets.append(tech_index)
+
+        if self.reference_carrier is not None and self.reference_carrier != "all":
+            index_sets.append(
+                IndexSet(
+                    index_title="carrier",
+                    behaviour=SeriesBehaviour.series,
+                    indices=[self.reference_carrier],
+                )
+            )
+
+        data_request.index_sets = index_sets
+
+        request = CompleteDataRequest(
+            solution_name=solution_name,
+            component=self.component,
+            data_request=data_request,
+            aggregate_years=self.yearly,
+        )
+
+        if self.scenario is not None:
+            request.scenario = "scenario_" + self.scenario
+
+        return request

zen_temple-0.0.1/src/zen_temple/repositories/solution_repository.py

@@ -0,0 +1,134 @@
+from ..config import config
+from zen_garden.postprocess.results import Results  # type: ignore
+from ..models.solution import (
+    Solution,
+    ResultsRequest,
+    CompleteDataRequest,
+    SolutionDetail,
+    DataResult,
+)
+import os
+import pandas as pd
+from time import perf_counter
+from fastapi import HTTPException, UploadFile
+from zipfile import ZipFile
+from typing import Optional, Any
+from functools import cache
+
+
+class SolutionRepository:
+    def get_list(self) -> list[Solution]:
+        ans = []
+        for folder in os.listdir(config.SOLUTION_FOLDER):
+            try:
+                ans.append(Solution.from_name(folder))
+            except (FileNotFoundError, NotADirectoryError):
+                continue
+        return ans
+
+    @cache
+    def get_detail(self, solution_name: str) -> SolutionDetail:
+        return SolutionDetail.from_name(solution_name)
+
+    @cache
+    def get_total(
+        self, solution: str, component: str, scenario: Optional[str] = None
+    ) -> DataResult:
+        solution_folder = os.path.join(config.SOLUTION_FOLDER, solution)
+        results = Results(solution_folder)
+
+        try:
+            unit: pd.Series[Any] | None = results.get_unit(
+                component, scenario_name=scenario
+            )
+        except:
+            unit = None
+
+        total: pd.DataFrame | pd.Series = results.get_total(
+            component, scenario_name=scenario
+        )
+
+        if type(total) is not pd.Series:
+            total = total.loc[~(total == 0).all(axis=1)]
+
+        if unit is not None:
+            unit_csv = unit.to_csv()
+        else:
+            unit_csv = None
+
+        return DataResult(data_csv=str(total.to_csv()), unit=unit_csv)
+
+    def get_energy_balance(
+        self,
+        solution: str,
+        node: str,
+        carrier: str,
+        scenario: Optional[str] = None,
+        year: Optional[int] = None,
+    ) -> dict[str, str]:
+        solution_folder = os.path.join(config.SOLUTION_FOLDER, solution)
+        results = Results(solution_folder)
+
+        if year is None:
+            year = 0
+        energy_balance: dict[str, pd.DataFrame] = results.get_energy_balance_dataframes(
+            node, carrier, year, scenario
+        )
+
+        ans = {key: val.drop_duplicates() for key, val in energy_balance.items()}
+
+        for key, series in ans.items():
+            if key == "demand":
+                continue
+
+            if type(series) is not pd.Series:
+                ans[key] = series.loc[~(series == 0).all(axis=1)]
+
+        ans = {key: val.to_csv() for key, val in ans.items()}
+        return ans
+
+    def get_dataframe(self, solution_name: str, df_request: ResultsRequest) -> str:
+        path = os.path.join(config.SOLUTION_FOLDER, solution_name)
+        argument_dictionary = {
+            key: val for key, val in df_request.dict().items() if val is not None
+        }
+
+        start = perf_counter()
+        results = Results(path)
+        print(f"Loading results took {perf_counter() - start}")
+
+        if "scenario" in argument_dictionary:
+            request_scenario = "scenario_" + argument_dictionary["scenario"]
+            if request_scenario not in results.results:
+                argument_dictionary["scenario"] = None
+            else:
+                argument_dictionary["scenario"] = request_scenario
+
+        start = perf_counter()
+        res: pd.DataFrame = results.get_summary_df(**argument_dictionary)
+        res = res.reset_index()
+        years = [i for i in res.columns if isinstance(i, int)]
+        others = [i for i in res.columns if not isinstance(i, int)]
+        res = pd.melt(res, id_vars=others, var_name="year", value_vars=years)
+
+        return res.to_csv()
+
+    async def upload_file(self, in_file: UploadFile) -> str:
+        file_path = os.path.join("./", str(in_file.filename))
+
+        async def upload() -> None:
+            pass
+            # async with aiofiles.open(file_path, "wb") as out_file:
+            #    while content := await in_file.read():  # async read chunk
+            #        await out_file.write(content)  # async write chunk
+
+        await upload()
+
+        with ZipFile(file_path, "r") as zip:
+            contents: list[str] = zip.namelist()
+            print(contents)
+
+        return "Success"
+
+
+solution_repository = SolutionRepository()

zen_temple-0.0.1/src/zen_temple/routers/solutions.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter
+from ..repositories.solution_repository import solution_repository
+from ..models.solution import Solution, CompleteDataRequest, SolutionDetail, DataResult
+from ..models.solution import ResultsRequest
+from fastapi import UploadFile, status
+from typing import Optional
+from fastapi_cache.decorator import cache
+
+
+router = APIRouter(prefix="/solutions", tags=["Solutions"])
+
+
+@router.get("/list")
+async def get_list() -> list[Solution]:
+    return solution_repository.get_list()
+
+
+@router.get("/get_detail/{solution_name}")
+async def get_detail(solution_name: str) -> SolutionDetail:
+    ans = solution_repository.get_detail(solution_name)
+    return ans
+
+
+@router.get("/get_total/{solution_name}/{component_name}")
+async def get_total(
+    solution_name: str, component_name: str, scenario: Optional[str] = None
+) -> DataResult:
+    ans = solution_repository.get_total(solution_name, component_name, scenario)
+    return ans
+
+
+@router.get("/get_energy_balance/{solution_name}/{node_name}/{carrier_name}")
+@cache(expire=30000)
+async def get_energy_balance(
+    solution_name: str,
+    node_name: str,
+    carrier_name: str,
+    scenario: Optional[str] = None,
+    year: Optional[int] = 0,
+) -> dict[str, str]:
+    ans = solution_repository.get_energy_balance(
+        solution_name, node_name, carrier_name, scenario, year
+    )
+    return ans
+
+
+@router.post("/upload", status_code=status.HTTP_201_CREATED)
+async def upload(in_file: UploadFile) -> str:
+    """
+    Creates a dataset with files
+    :param in_file: zip file containing the files to be uploaded
+    :param title: title of the dataset
+    """
+    ans = await solution_repository.upload_file(in_file)
+
+    return ans

zen_temple-0.0.1/src/zen_temple.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: zen_temple
+Version: 0.0.1
+Summary: The visualization plattform for ZEN Garden
+Author-email: Vinzenz Muser <muserv@ethz.ch>
+Project-URL: Homepage, https://github.com/ZEN-universe/ZEN-temple
+Project-URL: Issues, https://github.com/ZEN-universe/ZEN-temple/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Requires-Dist: fastapi-cache2
+Requires-Dist: python-dotenv
+Requires-Dist: sqlmodel
+Requires-Dist: python-multipart
+Requires-Dist: zen-garden
+
+## ZEN Suite
+
+Run with: `uvicorn src.main:app`
+Develop with: `uvicorn src.main:app --reload --host 0.0.0.0`
+
+If chnages to the models are made, alembic is responsible for the migrations. Use the following steps:
+
+Create change-scripts: `alembic revision --autogenerate -m "<message>"`
+Commit changes: `alembic upgrade head`
+
+Build Docker-Container with `docker build -t example --build-arg ssh_prv_key="$(cat ~/.ssh/id_rsa)" --build-arg ssh_pub_key="$(cat ~/.ssh/id_rsa.pub)" .`
+
+Watch out, this copies your private ssh-key to the container because the required repository (ZEN garden) is private and therefore you need git-authentification.

zen_temple-0.0.1/src/zen_temple.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+src/zen_temple/__init__.py
+src/zen_temple/config.py
+src/zen_temple/main.py
+src/zen_temple.egg-info/PKG-INFO
+src/zen_temple.egg-info/SOURCES.txt
+src/zen_temple.egg-info/dependency_links.txt
+src/zen_temple.egg-info/requires.txt
+src/zen_temple.egg-info/top_level.txt
+src/zen_temple/models/__init__.py
+src/zen_temple/models/solution.py
+src/zen_temple/repositories/__init__.py
+src/zen_temple/repositories/solution_repository.py
+src/zen_temple/routers/__init__.py
+src/zen_temple/routers/solutions.py

zen_temple-0.0.1/src/zen_temple.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zen_temple-0.0.1/src/zen_temple.egg-info/requires.txt

@@ -0,0 +1,7 @@
+uvicorn
+fastapi
+fastapi-cache2
+python-dotenv
+sqlmodel
+python-multipart
+zen-garden

zen_temple-0.0.1/src/zen_temple.egg-info/top_level.txt

@@ -0,0 +1 @@
+zen_temple