diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml index 024de04..5071523 100644 --- a/docker-compose.prod.yml +++ b/docker-compose.prod.yml @@ -11,16 +11,23 @@ services: - jupyter - api - minio + - streamlit-ca + - streamlit-sysdyn networks: - dissmodel-net + #sudo chmod -R 775 ./workspace jupyter: build: context: ./services/frontend dockerfile: Dockerfile container_name: dissmodel-jupyter restart: unless-stopped - command: ["start-notebook.sh", "--NotebookApp.token=''", "--ServerApp.base_url=/dissmodel/jupyter/"] + command: + - start-notebook.sh + - --ServerApp.base_url=/dissmodel/jupyter/ + - --ServerApp.token= + - --ServerApp.trust_xheaders=True volumes: - ./workspace:/home/jovyan/work - ./data/inputs:/data/inputs:ro @@ -42,7 +49,6 @@ services: - configs-sync networks: - dissmodel-net - # Sobrescreve o healthcheck do Dockerfile para usar a nova base_url healthcheck: test: ["CMD", "curl", "-f", "http://localhost:8888/dissmodel/jupyter/api"] interval: 30s @@ -117,6 +123,36 @@ services: - minio - configs-sync + # ── Streamlit CA Explorer ───────────────────────────────────────────────── + streamlit-ca: + build: + context: ./services/streamlit-ca + dockerfile: Dockerfile + container_name: dissmodel-streamlit-ca + restart: unless-stopped + networks: + - dissmodel-net + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8501/dissmodel/ca/healthz"] + interval: 30s + timeout: 10s + retries: 3 + + # ── Streamlit SysDyn Explorer ───────────────────────────────────────────── + streamlit-sysdyn: + build: + context: ./services/streamlit-sysdyn + dockerfile: Dockerfile + container_name: dissmodel-streamlit-sysdyn + restart: unless-stopped + networks: + - dissmodel-net + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8501/dissmodel/sysdyn/healthz"] + interval: 30s + timeout: 10s + retries: 3 + minio: image: minio/minio:RELEASE.2024-01-01T16-36-33Z container_name: dissmodel-minio @@ -127,7 +163,6 @@ services: environment: - MINIO_ROOT_USER=${MINIO_ROOT_USER:-inpe_admin} - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-inpe_secret_2024} - # URL pública do Console do MinIO (suporta subcaminhos) - MINIO_BROWSER_REDIRECT_URL=${MINIO_BROWSER_REDIRECT_URL:-http://localhost/dissmodel/minio/ui} env_file: - .env @@ -186,4 +221,4 @@ volumes: redis-data: name: dissmodel-prod-redis-data configs-data: - name: dissmodel-prod-configs-data + name: dissmodel-prod-configs-data \ No newline at end of file diff --git a/services/nginx/nginx.conf b/services/nginx/nginx.conf index 9057931..90cc7ba 100644 --- a/services/nginx/nginx.conf +++ b/services/nginx/nginx.conf @@ -34,7 +34,7 @@ http { # Jupyter location /dissmodel/jupyter/ { - proxy_pass http://jupyter:8888; + proxy_pass http://jupyter:8888/dissmodel/jupyter/; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; @@ -47,6 +47,32 @@ http { proxy_read_timeout 86400; } + # Streamlit CA Explorer + location /dissmodel/ca/ { + proxy_pass http://streamlit-ca:8501/dissmodel/ca/; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection $connection_upgrade; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_read_timeout 86400; + } + + # Streamlit SysDyn Explorer + location /dissmodel/sysdyn/ { + proxy_pass http://streamlit-sysdyn:8501/dissmodel/sysdyn/; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection $connection_upgrade; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_read_timeout 86400; + } + # MinIO API location /dissmodel/minio/ { # Importante: O trailing slash no proxy_pass remove o prefixo /dissmodel/minio/ diff --git a/services/streamlit-ca/Dockerfile b/services/streamlit-ca/Dockerfile new file mode 100644 index 0000000..5a60b7c --- /dev/null +++ b/services/streamlit-ca/Dockerfile @@ -0,0 +1,21 @@ +FROM python:3.11-slim + +WORKDIR /app + +RUN apt-get update && apt-get install -y \ + libgdal-dev gcc git \ + && rm -rf /var/lib/apt/lists/* + +RUN git clone --depth 1 https://github.com/DisSModel/dissmodel-ca.git /tmp/repo \ + && pip install --no-cache-dir dissmodel /tmp/repo streamlit matplotlib \ + && cp /tmp/repo/src/dissmodel_ca/streamlit/ca_all.py /app/app.py \ + && rm -rf /tmp/repo + +EXPOSE 8501 + +CMD ["streamlit", "run", "app.py", \ + "--server.address", "0.0.0.0", \ + "--server.port", "8501", \ + "--server.headless", "true", \ + "--server.baseUrlPath", "/dissmodel/ca", \ + "--browser.gatherUsageStats", "false"] \ No newline at end of file diff --git a/services/streamlit-sysdyn/Dockerfile b/services/streamlit-sysdyn/Dockerfile new file mode 100644 index 0000000..1553430 --- /dev/null +++ b/services/streamlit-sysdyn/Dockerfile @@ -0,0 +1,21 @@ +FROM python:3.11-slim + +WORKDIR /app + +RUN apt-get update && apt-get install -y \ + libgdal-dev gcc git \ + && rm -rf /var/lib/apt/lists/* + +RUN git clone --depth 1 https://github.com/DisSModel/dissmodel-sysdyn.git /tmp/repo \ + && pip install --no-cache-dir dissmodel /tmp/repo streamlit matplotlib \ + && cp /tmp/repo/src/dissmodel_sysdyn/streamlit/sysdyn_all.py /app/app.py \ + && rm -rf /tmp/repo + +EXPOSE 8501 + +CMD ["streamlit", "run", "app.py", \ + "--server.address", "0.0.0.0", \ + "--server.port", "8501", \ + "--server.headless", "true", \ + "--server.baseUrlPath", "/dissmodel/sysdyn", \ + "--browser.gatherUsageStats", "false"] \ No newline at end of file diff --git a/workspace/ca_game_of_life.ipynb b/workspace/ca_game_of_life.ipynb new file mode 100755 index 0000000..c763a6d --- /dev/null +++ b/workspace/ca_game_of_life.ipynb @@ -0,0 +1,633 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "SbhAaNnHZK9m" + }, + "source": [ + "# Conway's Game of Life\n", + "### A spatial cellular automaton with dissmodel\n", + "\n", + "Conway's Game of Life is a classic example of how simple local rules\n", + "produce complex emergent behavior. Each cell is either **alive** (1)\n", + "or **dead** (0), and its next state depends only on its 8 neighbors." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tvwImGdeZK-E" + }, + "source": [ + "## Rules\n", + "\n", + "| Current state | Live neighbors | Next state |\n", + "|:---:|:---:|:---:|\n", + "| Alive | < 2 | Dies (underpopulation) |\n", + "| Alive | 2 or 3 | Survives |\n", + "| Alive | > 3 | Dies (overpopulation) |\n", + "| Dead | exactly 3 | Born |\n", + "\n", + "> All other cells remain dead." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "8vk2WG6UotqS" + }, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import random\n", + "from typing import Any\n", + "\n", + "from libpysal.weights import Queen\n", + "\n", + "from dissmodel.geo import FillStrategy, fill\n", + "from dissmodel.geo.vector.cellular_automaton import CellularAutomaton\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Built-in patterns\n", + "# ---------------------------------------------------------------------------\n", + "\n", + "#: Classic Game of Life patterns organized by category.\n", + "#: Can be imported and used independently of :class:`GameOfLife`.\n", + "PATTERNS: dict[str, list[list[int]]] = {\n", + " # --- Oscillators ---\n", + " \"blinker\": [ # period 2\n", + " [1, 1, 1],\n", + " ],\n", + " \"toad\": [ # period 2\n", + " [0, 1, 1, 1],\n", + " [1, 1, 1, 0],\n", + " ],\n", + " \"beacon\": [ # period 2\n", + " [1, 1, 0, 0],\n", + " [1, 1, 0, 0],\n", + " [0, 0, 1, 1],\n", + " [0, 0, 1, 1],\n", + " ],\n", + " \"pulsar\": [ # period 3 — requires grid >= 15x15\n", + " [0,0,1,1,1,0,0,0,1,1,1,0,0],\n", + " [0,0,0,0,0,0,0,0,0,0,0,0,0],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [0,0,1,1,1,0,0,0,1,1,1,0,0],\n", + " [0,0,0,0,0,0,0,0,0,0,0,0,0],\n", + " [0,0,1,1,1,0,0,0,1,1,1,0,0],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [1,0,0,0,0,1,0,1,0,0,0,0,1],\n", + " [0,0,0,0,0,0,0,0,0,0,0,0,0],\n", + " [0,0,1,1,1,0,0,0,1,1,1,0,0],\n", + " ],\n", + " # --- Spaceships ---\n", + " \"glider\": [ # moves diagonally\n", + " [0, 1, 0],\n", + " [0, 0, 1],\n", + " [1, 1, 1],\n", + " ],\n", + " \"lwss\": [ # lightweight spaceship\n", + " [0, 1, 0, 0, 1],\n", + " [1, 0, 0, 0, 0],\n", + " [1, 0, 0, 0, 1],\n", + " [1, 1, 1, 1, 0],\n", + " ],\n", + " # --- Still lifes ---\n", + " \"block\": [ # never changes\n", + " [1, 1],\n", + " [1, 1],\n", + " ],\n", + " \"beehive\": [ # never changes\n", + " [0, 1, 1, 0],\n", + " [1, 0, 0, 1],\n", + " [0, 1, 1, 0],\n", + " ],\n", + " \"loaf\": [ # never changes\n", + " [0, 1, 1, 0],\n", + " [1, 0, 0, 1],\n", + " [0, 1, 0, 1],\n", + " [0, 0, 1, 0],\n", + " ],\n", + "}\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Model\n", + "# ---------------------------------------------------------------------------\n", + "\n", + "class GameOfLife(CellularAutomaton):\n", + "\n", + "\n", + " def setup(self) -> None:\n", + " \"\"\"Build the Queen neighborhood for the grid.\"\"\"\n", + " self.create_neighborhood(strategy=Queen, use_index=True)\n", + "\n", + " def initialize(self) -> None:\n", + " \"\"\"\n", + " Fill the grid with a random initial state.\n", + "\n", + " Uses a 60/40 live/dead split with a fixed seed for reproducibility.\n", + " Override this method to define a custom initial state.\n", + " \"\"\"\n", + " fill(\n", + " strategy=FillStrategy.RANDOM_SAMPLE,\n", + " gdf=self.gdf,\n", + " attr=\"state\",\n", + " data={1: 0.6, 0: 0.4},\n", + " seed=42,\n", + " )\n", + "\n", + " def initialize_patterns(\n", + " self,\n", + " patterns: list[str] | None = None,\n", + " ) -> None:\n", + " \"\"\"\n", + " Place classic Game of Life patterns at random positions on the grid.\n", + "\n", + " Parameters\n", + " ----------\n", + " patterns : list of str, optional\n", + " Pattern names to place. If ``None``, all patterns in\n", + " :data:`PATTERNS` are used. Available keys: ``\"blinker\"``,\n", + " ``\"toad\"``, ``\"beacon\"``, ``\"pulsar\"``, ``\"glider\"``,\n", + " ``\"lwss\"``, ``\"block\"``, ``\"beehive\"``, ``\"loaf\"``.\n", + "\n", + " Notes\n", + " -----\n", + " Assumes a square grid. The ``\"pulsar\"`` pattern requires a grid\n", + " of at least 15x15 to avoid out-of-range placement.\n", + " \"\"\"\n", + " selected = (\n", + " {k: PATTERNS[k] for k in patterns if k in PATTERNS}\n", + " if patterns\n", + " else PATTERNS\n", + " )\n", + "\n", + " grid_dim = int(len(self.gdf) ** 0.5)\n", + "\n", + " for pattern in selected.values():\n", + " start_x = random.randint(0, grid_dim - len(pattern[0])) # col _ offset bounded by n_cols\n", + " start_y = random.randint(0, grid_dim - len(pattern)) # row offset bounded by n_rows\n", + "\n", + " fill(\n", + " strategy=FillStrategy.PATTERN,\n", + " gdf=self.gdf,\n", + " attr=\"state\",\n", + " pattern=pattern,\n", + " start_x=start_x,\n", + " start_y=start_y,\n", + " )\n", + "\n", + " def rule(self, idx: Any) -> int:\n", + "\n", + " state = self.gdf.loc[idx, self.state_attr]\n", + " live_neighbors = (self.neighbor_values(idx, self.state_attr)).sum()\n", + "\n", + " if state == 1:\n", + " return 1 if 2 <= live_neighbors <= 3 else 0\n", + " return 1 if live_neighbors == 3 else 0\n", + "\n", + "\n", + "_" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GEhvzl8GZK-M" + }, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "K97t9-AtZK-M" + }, + "outputs": [], + "source": [ + "from matplotlib.colors import ListedColormap\n", + "\n", + "from dissmodel.core import Environment\n", + "from dissmodel.geo import vector_grid\n", + "from dissmodel.visualization.map import Map" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QNwLW5cqZK-P" + }, + "source": [ + "## Setting up the grid\n", + "\n", + "We create a 20x20 abstract grid where every cell begins dead (`state=0`)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 237 + }, + "executionInfo": { + "elapsed": 43, + "status": "ok", + "timestamp": 1776076261056, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "LFxTRZf4ZK-Q", + "outputId": "21ed98fe-7d70-4f17-a219-d324a50ada18" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
geometrystate
id
0-0POLYGON ((1 0, 1 1, 0 1, 0 0, 1 0))0
1-0POLYGON ((1 1, 1 2, 0 2, 0 1, 1 1))0
2-0POLYGON ((1 2, 1 3, 0 3, 0 2, 1 2))0
3-0POLYGON ((1 3, 1 4, 0 4, 0 3, 1 3))0
4-0POLYGON ((1 4, 1 5, 0 5, 0 4, 1 4))0
\n", + "
" + ], + "text/plain": [ + " geometry state\n", + "id \n", + "0-0 POLYGON ((1 0, 1 1, 0 1, 0 0, 1 0)) 0\n", + "1-0 POLYGON ((1 1, 1 2, 0 2, 0 1, 1 1)) 0\n", + "2-0 POLYGON ((1 2, 1 3, 0 3, 0 2, 1 2)) 0\n", + "3-0 POLYGON ((1 3, 1 4, 0 4, 0 3, 1 3)) 0\n", + "4-0 POLYGON ((1 4, 1 5, 0 5, 0 4, 1 4)) 0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf = vector_grid(dimension=(20, 20), resolution=1, attrs={\"state\": 0})\n", + "gdf.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7xnb98pTZK-S" + }, + "source": [ + "## Available patterns\n", + "\n", + "dissmodel ships with classic Game of Life patterns grouped by category:\n", + "\n", + "- **Oscillators** — return to initial state after N steps (`blinker`, `toad`, `beacon`, `pulsar`)\n", + "- **Spaceships** — move across the grid (`glider`, `lwss`)\n", + "- **Still lifes** — never change (`block`, `beehive`, `loaf`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 4, + "status": "ok", + "timestamp": 1776076137780, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "xI5h67zKZK-T", + "outputId": "83f470cb-0357-4b69-80af-e8d564e0d5a4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "blinker — 1x3\n", + "toad — 2x4\n", + "beacon — 4x4\n", + "pulsar — 13x13\n", + "glider — 3x3\n", + "lwss — 4x5\n", + "block — 2x2\n", + "beehive — 3x4\n", + "loaf — 4x4\n" + ] + } + ], + "source": [ + "for name, pattern in PATTERNS.items():\n", + " print(f\"{name:10} — {len(pattern)}x{len(pattern[0])}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wYHrxcPyZK-O" + }, + "source": [ + "## ⚠️ Important: instantiation order\n", + "\n", + "The `Environment` must always be created **before** any model (`GameOfLife`, `Map`, `Chart`).\n", + "Models connect to the active environment automatically when instantiated —\n", + "if no environment exists yet, the connection fails.\n", + "\n", + "```\n", + "Environment → GameOfLife → Map\n", + " ↑ ↑ ↑\n", + " first second third\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lfFSFE3YZK-U" + }, + "source": [ + "Initializing the model\n", + "\n", + "Two initialization options are available:\n", + "\n", + "- `initialize()` — random 60/40 live/dead split\n", + "- `initialize_patterns([...])` — place classic patterns at random positions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UTQ0ZbReZK-U" + }, + "source": [ + "Visualization\n", + "\n", + "The `Map` model redraws the grid at every simulation step.\n", + "It connects to the same environment and runs in sync with `GameOfLife`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 625, + "referenced_widgets": [ + "247e5858045e47f89ac0eed02e349f27", + "980f7212e8a646f6aedff604d858a73c" + ] + }, + "executionInfo": { + "elapsed": 10315, + "status": "ok", + "timestamp": 1776076396893, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "UnSth_CZZK-U", + "outputId": "3bc4f095-d56f-424a-f9fc-471557480a29" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "af137770eb954899997df483e514c08f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running from 0 to 15 (duration: 15)\n" + ] + } + ], + "source": [ + "# 1. Environment must be created first\n", + "env = Environment(start_time=0, end_time=15)\n", + "# 2. Model connects to the active environment automatically\n", + "gol = GameOfLife(gdf=gdf)\n", + "# Choose one:\n", + "gol.initialize_patterns([\"glider\", \"blinker\", \"toad\", \"beacon\"])\n", + "# gol.initialize() # ← uncomment for random initialization\n", + "# 3. Map also connects to the active environment automatically\n", + "cmap = ListedColormap([\"white\", \"black\"])\n", + "Map(\n", + " gdf=gdf,\n", + " plot_params={\"column\": \"state\", \"cmap\": cmap, \"ec\": \"gray\"}, save_frames=False\n", + ")\n", + "# run simulation\n", + "env.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "l4YyaXArZK-V" + }, + "source": [ + "## Try it yourself\n", + "\n", + "Go back and experiment:\n", + "\n", + "- Change `end_time` in `Environment` to run more steps\n", + "- Change `dimension` in `vector_grid` for a larger grid\n", + "- Try `initialize_patterns([\"pulsar\"])` with a grid >= 15x15\n", + "- Try `initialize()` for a fully random start" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "247e5858045e47f89ac0eed02e349f27": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_980f7212e8a646f6aedff604d858a73c", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + }, + "980f7212e8a646f6aedff604d858a73c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/workspace/carregando_resultado.ipynb b/workspace/carregando_resultado.ipynb old mode 100644 new mode 100755 index 677e292..275711d --- a/workspace/carregando_resultado.ipynb +++ b/workspace/carregando_resultado.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "id": "65a41424-3757-4882-9ca9-2bcc14674cfb", "metadata": {}, "outputs": [], @@ -13,97 +13,178 @@ "from IPython.display import display, Markdown\n", "import json\n", "\n", - "# Configuração da sua plataforma LambdaGeo\n", - "s3 = S3FileSystem(\n", - " key='inpe_admin',\n", - " secret='inpe_secret_2024',\n", - " client_kwargs={'endpoint_url': 'http://minio:9000'}\n", + "from getpass import getpass\n", + "secret = \"inpe_secret_2024\"\n", + "# secret = getpass(\"Secret key: \")\n", + "\n", + "minio = Minio(\n", + " \"minio:9000\",\n", + " access_key=\"inpe_admin\",\n", + " secret_key=secret,\n", + " secure=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 3, "id": "5bf30488-f457-4d02-95fc-aca070bac40e", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Lendo profiling em: s3://dissmodel-outputs/experiments/81aff60ba0c64e81b8b7fb1917946146/profiling_81aff60b.md\n" + "ename": "PermissionError", + "evalue": "Forbidden", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mClientError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:114\u001b[0m, in \u001b[0;36m_error_wrapper\u001b[0;34m(func, args, kwargs, retries)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 114\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m S3_RETRYABLE_ERRORS \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/aiobotocore/context.py:36\u001b[0m, in \u001b[0;36mwith_current_context..decorator..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m resolve_awaitable(hook())\n\u001b[0;32m---> 36\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/aiobotocore/client.py:424\u001b[0m, in \u001b[0;36mAioBaseClient._make_api_call\u001b[0;34m(self, operation_name, api_params)\u001b[0m\n\u001b[1;32m 423\u001b[0m error_class \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexceptions\u001b[38;5;241m.\u001b[39mfrom_code(error_code)\n\u001b[0;32m--> 424\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m error_class(parsed_response, operation_name)\n\u001b[1;32m 425\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[0;31mClientError\u001b[0m: An error occurred (403) when calling the HeadObject operation: Forbidden", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mPermissionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 44\u001b[0m\n\u001b[1;32m 36\u001b[0m USO_COLORS \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 37\u001b[0m MANGUE: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#006400\u001b[39m\u001b[38;5;124m\"\u001b[39m, VEGETACAO_TERRESTRE: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#808000\u001b[39m\u001b[38;5;124m\"\u001b[39m, MAR: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#00008b\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 38\u001b[0m AREA_ANTROPIZADA: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#ffd700\u001b[39m\u001b[38;5;124m\"\u001b[39m, SOLO_DESCOBERTO: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#ffdead\u001b[39m\u001b[38;5;124m\"\u001b[39m, SOLO_INUNDADO: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#000000\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 39\u001b[0m AREA_ANTROPIZADA_INUNDADA: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#323232\u001b[39m\u001b[38;5;124m\"\u001b[39m, MANGUE_MIGRADO: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#00ff00\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 40\u001b[0m MANGUE_INUNDADO: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#ff0000\u001b[39m\u001b[38;5;124m\"\u001b[39m, VEG_TERRESTRE_INUNDADA: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m#000000\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 41\u001b[0m }\n\u001b[1;32m 43\u001b[0m \u001b[38;5;66;03m# ── 3. LEITURA DOS METADADOS E PROFILING ────────────────────────────────────\u001b[39;00m\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43ms3\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrecord_uri\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mr\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 45\u001b[0m record_data \u001b[38;5;241m=\u001b[39m json\u001b[38;5;241m.\u001b[39mload(f)\n\u001b[1;32m 47\u001b[0m profiling_uri \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbase_uri\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/profiling_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mshort_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.md\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/spec.py:1298\u001b[0m, in \u001b[0;36mAbstractFileSystem.open\u001b[0;34m(self, path, mode, block_size, cache_options, compression, **kwargs)\u001b[0m\n\u001b[1;32m 1290\u001b[0m mode \u001b[38;5;241m=\u001b[39m mode\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mt\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 1292\u001b[0m text_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 1293\u001b[0m k: kwargs\u001b[38;5;241m.\u001b[39mpop(k)\n\u001b[1;32m 1294\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124merrors\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnewline\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1295\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m kwargs\n\u001b[1;32m 1296\u001b[0m }\n\u001b[1;32m 1297\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m io\u001b[38;5;241m.\u001b[39mTextIOWrapper(\n\u001b[0;32m-> 1298\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1299\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1300\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1301\u001b[0m \u001b[43m \u001b[49m\u001b[43mblock_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mblock_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1302\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1303\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcompression\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1304\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1305\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 1306\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mtext_kwargs,\n\u001b[1;32m 1307\u001b[0m )\n\u001b[1;32m 1308\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1309\u001b[0m ac \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mautocommit\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_intrans)\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/spec.py:1310\u001b[0m, in \u001b[0;36mAbstractFileSystem.open\u001b[0;34m(self, path, mode, block_size, cache_options, compression, **kwargs)\u001b[0m\n\u001b[1;32m 1308\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1309\u001b[0m ac \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mautocommit\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_intrans)\n\u001b[0;32m-> 1310\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_open\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1311\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1312\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1313\u001b[0m \u001b[43m \u001b[49m\u001b[43mblock_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mblock_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1314\u001b[0m \u001b[43m \u001b[49m\u001b[43mautocommit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mac\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1315\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1316\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1317\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1318\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m compression \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1319\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mfsspec\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcompression\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m compr\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:699\u001b[0m, in \u001b[0;36mS3FileSystem._open\u001b[0;34m(self, path, mode, block_size, acl, version_id, fill_cache, cache_type, autocommit, size, requester_pays, cache_options, **kwargs)\u001b[0m\n\u001b[1;32m 696\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cache_type \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 697\u001b[0m cache_type \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefault_cache_type\n\u001b[0;32m--> 699\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mS3File\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 700\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 701\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 702\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 703\u001b[0m \u001b[43m \u001b[49m\u001b[43mblock_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mblock_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 704\u001b[0m \u001b[43m \u001b[49m\u001b[43macl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43macl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[43m \u001b[49m\u001b[43mversion_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mversion_id\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 706\u001b[0m \u001b[43m \u001b[49m\u001b[43mfill_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfill_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 707\u001b[0m \u001b[43m \u001b[49m\u001b[43ms3_additional_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 708\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 709\u001b[0m \u001b[43m \u001b[49m\u001b[43mautocommit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mautocommit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 710\u001b[0m \u001b[43m \u001b[49m\u001b[43mrequester_pays\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequester_pays\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 711\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 712\u001b[0m \u001b[43m \u001b[49m\u001b[43msize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 713\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:2238\u001b[0m, in \u001b[0;36mS3File.__init__\u001b[0;34m(self, s3, path, mode, block_size, acl, version_id, fill_cache, s3_additional_kwargs, autocommit, cache_type, requester_pays, cache_options, size)\u001b[0m\n\u001b[1;32m 2236\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdetails \u001b[38;5;241m=\u001b[39m s3\u001b[38;5;241m.\u001b[39minfo(path)\n\u001b[1;32m 2237\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mversion_id \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdetails\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mVersionId\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 2238\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2239\u001b[0m \u001b[43m \u001b[49m\u001b[43ms3\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2240\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2241\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2242\u001b[0m \u001b[43m \u001b[49m\u001b[43mblock_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2243\u001b[0m \u001b[43m \u001b[49m\u001b[43mautocommit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mautocommit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2244\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2245\u001b[0m \u001b[43m \u001b[49m\u001b[43mcache_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2246\u001b[0m \u001b[43m \u001b[49m\u001b[43msize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2247\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39ms3 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfs \u001b[38;5;66;03m# compatibility\u001b[39;00m\n\u001b[1;32m 2250\u001b[0m \u001b[38;5;66;03m# when not using autocommit we want to have transactional state to manage\u001b[39;00m\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/spec.py:1884\u001b[0m, in \u001b[0;36mAbstractBufferedFile.__init__\u001b[0;34m(self, fs, path, mode, block_size, autocommit, cache_type, cache_options, size, **kwargs)\u001b[0m\n\u001b[1;32m 1882\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m=\u001b[39m size\n\u001b[1;32m 1883\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1884\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetails\u001b[49m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msize\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1885\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcache \u001b[38;5;241m=\u001b[39m caches[cache_type](\n\u001b[1;32m 1886\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mblocksize, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fetch_range, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcache_options\n\u001b[1;32m 1887\u001b[0m )\n\u001b[1;32m 1888\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/spec.py:1897\u001b[0m, in \u001b[0;36mAbstractBufferedFile.details\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1894\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m 1895\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdetails\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 1896\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_details \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1897\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_details \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minfo\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1898\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_details\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/asyn.py:118\u001b[0m, in \u001b[0;36msync_wrapper..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 117\u001b[0m \u001b[38;5;28mself\u001b[39m \u001b[38;5;241m=\u001b[39m obj \u001b[38;5;129;01mor\u001b[39;00m args[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m--> 118\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/asyn.py:103\u001b[0m, in \u001b[0;36msync\u001b[0;34m(loop, func, timeout, *args, **kwargs)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m FSTimeoutError \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mreturn_result\u001b[39;00m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(return_result, \u001b[38;5;167;01mBaseException\u001b[39;00m):\n\u001b[0;32m--> 103\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m return_result\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 105\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m return_result\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/fsspec/asyn.py:56\u001b[0m, in \u001b[0;36m_runner\u001b[0;34m(event, coro, result, timeout)\u001b[0m\n\u001b[1;32m 54\u001b[0m coro \u001b[38;5;241m=\u001b[39m asyncio\u001b[38;5;241m.\u001b[39mwait_for(coro, timeout\u001b[38;5;241m=\u001b[39mtimeout)\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 56\u001b[0m result[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m coro\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m ex:\n\u001b[1;32m 58\u001b[0m result[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m ex\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:1426\u001b[0m, in \u001b[0;36mS3FileSystem._info\u001b[0;34m(self, path, bucket, key, refresh, version_id)\u001b[0m\n\u001b[1;32m 1424\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m key:\n\u001b[1;32m 1425\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1426\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_s3(\n\u001b[1;32m 1427\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhead_object\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 1428\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwargs,\n\u001b[1;32m 1429\u001b[0m Bucket\u001b[38;5;241m=\u001b[39mbucket,\n\u001b[1;32m 1430\u001b[0m Key\u001b[38;5;241m=\u001b[39mkey,\n\u001b[1;32m 1431\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mversion_id_kw(version_id),\n\u001b[1;32m 1432\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreq_kw,\n\u001b[1;32m 1433\u001b[0m )\n\u001b[1;32m 1434\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 1435\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mETag\u001b[39m\u001b[38;5;124m\"\u001b[39m: out\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mETag\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1436\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLastModified\u001b[39m\u001b[38;5;124m\"\u001b[39m: out\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLastModified\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1442\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mContentType\u001b[39m\u001b[38;5;124m\"\u001b[39m: out\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mContentType\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1443\u001b[0m }\n\u001b[1;32m 1444\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:371\u001b[0m, in \u001b[0;36mS3FileSystem._call_s3\u001b[0;34m(self, method, *akwarglist, **kwargs)\u001b[0m\n\u001b[1;32m 369\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCALL: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m - \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m - \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, method\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m, akwarglist, kw2)\n\u001b[1;32m 370\u001b[0m additional_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_s3_method_kwargs(method, \u001b[38;5;241m*\u001b[39makwarglist, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 371\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m _error_wrapper(\n\u001b[1;32m 372\u001b[0m method, kwargs\u001b[38;5;241m=\u001b[39madditional_kwargs, retries\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mretries\n\u001b[1;32m 373\u001b[0m )\n", + "File \u001b[0;32m/opt/conda/lib/python3.11/site-packages/s3fs/core.py:146\u001b[0m, in \u001b[0;36m_error_wrapper\u001b[0;34m(func, args, kwargs, retries)\u001b[0m\n\u001b[1;32m 144\u001b[0m err \u001b[38;5;241m=\u001b[39m e\n\u001b[1;32m 145\u001b[0m err \u001b[38;5;241m=\u001b[39m translate_boto_error(err)\n\u001b[0;32m--> 146\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m err\n", + "\u001b[0;31mPermissionError\u001b[0m: Forbidden" ] - }, - { - "data": { - "text/markdown": [ - "# Profiling Report: coastal_raster\n", - "\n", - "**Experiment ID:** `81aff60ba0c64e81b8b7fb1917946146`\n", - "**Date:** `2026-04-08T14:36:39.825548`\n", - "**Execution Node:** `Cloud Worker`\n", - "\n", - "## Execution Times\n", - "\n", - "| Phase | Time (seconds) | % of Total |\n", - "|---|---|---|\n", - "| **Validate** | 0.000 | 0.0% |\n", - "| **Run** | 5.478 | 93.2% |\n", - "| **Save** | 0.397 | 6.8% |\n", - "| **Total** | **5.875** | **100%** |\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "# O caminho do JSON que o worker salvou (ID de 8 caracteres)\n", - "experiment_id_short = \"81aff60b\"\n", - "base_uri = f\"s3://dissmodel-outputs/experiments/81aff60ba0c64e81b8b7fb1917946146\"\n", - "record_uri = f\"{base_uri}/{experiment_id_short}.record.json\"\n", - "\n", - "# ── 1. Ler os Metadados (O GPS do experimento) ──\n", - "with s3.open(record_uri, 'r') as f:\n", - " record_data = json.load(f)\n", - "\n", - "# O ID curto que usamos nos nomes dos arquivos\n", - "short_id = record_data['experiment_id'][:8]\n", - "\n", - "# ── 2. Mostrar o Profiling (Reconstruindo o caminho) ──\n", - "# Em vez de pegar de record_data['artifacts']['profiling'] (que é o hash),\n", - "# nós usamos o padrão: base_dir/profiling_ID.md\n", - "profiling_uri = f\"{base_uri}/profiling_{short_id}.md\"\n", - "\n", - "print(f\"Lendo profiling em: {profiling_uri}\")\n", - "\n", - "with s3.open(profiling_uri, 'r') as f:\n", - " display(Markdown(f.read()))\n", - "\n", - "# ── 3. Visualizar o Mapa ──\n", - "# O output_path geralmente já está completo no JSON\n", - "tif_uri = record_data['output_path']\n", - "\n", - "with s3.open(tif_uri, 'rb') as f:\n", - " with rasterio.open(f) as src:\n", - " data = src.read(1)\n", - " plt.figure(figsize=(10, 7))\n", - " plt.imshow(data, cmap='terrain')\n", - " plt.axis('off')\n", - " plt.show()" + "experiment_id = \"3939ef6630ce4b748af9f60a1b033480\"\n", + "short_id = experiment_id[:8]\n", + "\n", + "bucket = \"dissmodel-outputs\"\n", + "\n", + "base_path = f\"experiments/{experiment_id}\"\n", + "\n", + "record_path = f\"{base_path}/{short_id}.record.json\"\n", + "profiling_path = f\"{base_path}/profiling_{short_id}.md\"\n", + "\n", + "# ── 3. CONSTANTES DE USO E SOLO ────────────────────────────────────────────\n", + "\n", + "MANGUE = 1\n", + "VEGETACAO_TERRESTRE = 2\n", + "MAR = 3\n", + "AREA_ANTROPIZADA = 4\n", + "SOLO_DESCOBERTO = 5\n", + "SOLO_INUNDADO = 6\n", + "AREA_ANTROPIZADA_INUNDADA = 7\n", + "MANGUE_MIGRADO = 8\n", + "MANGUE_INUNDADO = 9\n", + "VEG_TERRESTRE_INUNDADA = 10\n", + "\n", + "USO_LABELS = {\n", + " MANGUE: \"Mangue\",\n", + " VEGETACAO_TERRESTRE: \"Veg. Terrestre\",\n", + " MAR: \"Mar\",\n", + " AREA_ANTROPIZADA: \"Área Antropizada\",\n", + " SOLO_DESCOBERTO: \"Solo Descoberto\",\n", + " SOLO_INUNDADO: \"Solo Inundado\",\n", + " AREA_ANTROPIZADA_INUNDADA: \"Área Antrop. Inundada\",\n", + " MANGUE_MIGRADO: \"Mangue Migrado\",\n", + " MANGUE_INUNDADO: \"Mangue Inundado\",\n", + " VEG_TERRESTRE_INUNDADA: \"Veg. Terrestre Inundada\"\n", + "}\n", + "\n", + "USO_COLORS = {\n", + " MANGUE: \"#006400\",\n", + " VEGETACAO_TERRESTRE: \"#808000\",\n", + " MAR: \"#00008b\",\n", + " AREA_ANTROPIZADA: \"#ffd700\",\n", + " SOLO_DESCOBERTO: \"#ffdead\",\n", + " SOLO_INUNDADO: \"#000000\",\n", + " AREA_ANTROPIZADA_INUNDADA: \"#323232\",\n", + " MANGUE_MIGRADO: \"#00ff00\",\n", + " MANGUE_INUNDADO: \"#ff0000\",\n", + " VEG_TERRESTRE_INUNDADA: \"#8b4513\"\n", + "}\n", + "\n", + "# ── 4. LEITURA DO RECORD.JSON ──────────────────────────────────────────────\n", + "\n", + "obj = minio.get_object(bucket, record_path)\n", + "\n", + "record_data = json.loads(obj.read().decode(\"utf-8\"))\n", + "\n", + "print(\"Record carregado:\")\n", + "print(json.dumps(record_data, indent=2))\n", + "\n", + "# ── 5. LEITURA DO PROFILING ────────────────────────────────────────────────\n", + "\n", + "obj = minio.get_object(bucket, profiling_path)\n", + "\n", + "profiling_md = obj.read().decode(\"utf-8\")\n", + "\n", + "display(Markdown(profiling_md))\n", + "\n", + "# ── 6. LEITURA DO RASTER ───────────────────────────────────────────────────\n", + "\n", + "# Exemplo:\n", + "# s3://dissmodel-outputs/experiments/.../resultado.tif\n", + "\n", + "tif_uri = record_data[\"output_path\"]\n", + "\n", + "# Remove prefixo s3://bucket/\n", + "tif_object = tif_uri.replace(f\"s3://{bucket}/\", \"\")\n", + "\n", + "obj = minio.get_object(bucket, tif_object)\n", + "\n", + "# Rasterio precisa de arquivo-like\n", + "raster_bytes = io.BytesIO(obj.read())\n", + "\n", + "with rasterio.open(raster_bytes) as src:\n", + "\n", + " data = src.read(1)\n", + "\n", + " present_values = sorted([\n", + " v for v in np.unique(data)\n", + " if v in USO_COLORS\n", + " ])\n", + "\n", + " colors_list = [USO_COLORS[v] for v in present_values]\n", + " labels_list = [USO_LABELS[v] for v in present_values]\n", + "\n", + " cmap = mcolors.ListedColormap(colors_list)\n", + "\n", + " norm = mcolors.BoundaryNorm(\n", + " np.append(present_values, present_values[-1] + 1),\n", + " cmap.N\n", + " )\n", + "\n", + " fig, ax = plt.subplots(figsize=(12, 8))\n", + "\n", + " im = ax.imshow(\n", + " data,\n", + " cmap=cmap,\n", + " norm=norm,\n", + " interpolation='none'\n", + " )\n", + "\n", + " cbar = fig.colorbar(\n", + " im,\n", + " ax=ax,\n", + " ticks=np.array(present_values) + 0.5\n", + " )\n", + "\n", + " cbar.ax.set_yticklabels(labels_list)\n", + " cbar.set_label('Uso e Cobertura da Terra')\n", + "\n", + " plt.title(f\"Resultado DisSModel - ID: {short_id}\")\n", + "\n", + " plt.axis('off')\n", + "\n", + " plt.show()" ] }, { diff --git a/workspace/floodmodel.ipynb b/workspace/floodmodel.ipynb old mode 100644 new mode 100755 index 74a98ca..f228b36 --- a/workspace/floodmodel.ipynb +++ b/workspace/floodmodel.ipynb @@ -7,40 +7,7 @@ "metadata": {}, "outputs": [], "source": [ - "\"\"\"\n", - "flood_vector_model.py — Hydrological Model (GeoDataFrame version)\n", - "=================================================================\n", - "\n", - "Vector-based version of FloodRasterModel using GeoDataFrame + SpatialModel,\n", - "designed for direct comparison with the NumPy implementation\n", - "(flood_raster_model.py).\n", - "\n", - "Same logic, different substrate:\n", - "\n", - " flood_raster_model.py RasterBackend (NumPy, vectorized)\n", - " flood_vector_model.py ← GeoDataFrame (libpysal, cell-by-cell)\n", - "\n", - "Why NOT use CellularAutomaton\n", - "------------------------------\n", - "CellularAutomaton.rule(idx) computes the new state of a cell based\n", - "on itself and its neighbors (pull model). The hydrological process\n", - "is source-oriented: flooded cells propagate flow and flooding to\n", - "their neighbors — the logic is the opposite (push model).\n", - "\n", - "For this reason we inherit directly from SpatialModel and implement\n", - "execute() freely.\n", - "\n", - "Usage\n", - "-----\n", - " from dissmodel.core import Environment\n", - " from coastal_dynamics.vector.flood_vector_model import FloodModel\n", - " import geopandas as gpd\n", - "\n", - " gdf = gpd.read_file(\"flood_model.shp\")\n", - " env = Environment(start_time=1, end_time=88)\n", - " FloodModel(gdf=gdf, taxa_elevacao=0.011)\n", - " env.run()\n", - "\"\"\"\n", + "\n", "from __future__ import annotations\n", "\n", "import geopandas as gpd\n", @@ -263,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "c982ca83-014e-41d4-97d0-d9d56ff82065", "metadata": {}, "outputs": [ @@ -386,7 +353,7 @@ "4 POLYGON ((500500 9705900, 500400 9705900, 5004... " ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -395,9 +362,12 @@ "from minio import Minio\n", "import io, geopandas as gpd\n", "\n", + "from getpass import getpass\n", + "secret = \"inpe_secret_2024\" # = getpass(\"Secret key: \")\n", + "\n", "minio = Minio(\"minio:9000\",\n", " access_key=\"inpe_admin\",\n", - " secret_key=\"inpe_secret_2024\",\n", + " secret_key=secret,\n", " secure=False)\n", "\n", "# baixa o zip do MinIO para memória\n", @@ -411,15 +381,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "d56ca4d5-1fc9-4331-b3c4-1bec87c90909", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ecc1416db8fd45589fb39b345b41e29d", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Output()" ] }, "metadata": {}, @@ -429,6 +403,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "Running from 1 to 10 (duration: 9)\n", "✅ Resultado salvo no MinIO\n" ] } diff --git a/workspace/sysdyn_sir.ipynb b/workspace/sysdyn_sir.ipynb new file mode 100755 index 0000000..e8fd3cd --- /dev/null +++ b/workspace/sysdyn_sir.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "goF9rfVCYV5P", + "metadata": { + "id": "goF9rfVCYV5P" + }, + "source": [ + "# SIR Epidemiological Model\n", + "### A deterministic compartmental model with dissmodel\n", + "\n", + "The SIR model tracks the spread of an infectious disease through a population\n", + "divided into three compartments:\n", + "\n", + "- **S**usceptible — healthy individuals who can be infected\n", + "- **I**nfected — individuals who carry and spread the disease\n", + "- **R**ecovered — individuals who have recovered and gained immunity" + ] + }, + { + "cell_type": "markdown", + "id": "P8CmSSKDYV5U", + "metadata": { + "id": "P8CmSSKDYV5U" + }, + "source": [ + "## How it works\n", + "\n", + "At each time step, the model computes:\n", + "\n", + "| Variable | Formula | Description |\n", + "|:---|:---|:---|\n", + "| α | `contacts × probability` | Force of infection |\n", + "| ΔI | `I × α × (S / N)` | New infections |\n", + "| ΔR | `I / duration` | New recoveries |\n", + "\n", + "Where **N = S + I + R** is the total population." + ] + }, + { + "cell_type": "markdown", + "id": "4PW_059KYV5U", + "metadata": { + "id": "4PW_059KYV5U" + }, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2hiYbfeJYV5V", + "metadata": { + "executionInfo": { + "elapsed": 1046, + "status": "ok", + "timestamp": 1776076140090, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "2hiYbfeJYV5V" + }, + "outputs": [], + "source": [ + "from dissmodel.core import Environment\n", + "from dissmodel.visualization import Chart" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "suR9olCAYYIJ", + "metadata": { + "executionInfo": { + "elapsed": 21, + "status": "ok", + "timestamp": 1776076140405, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "suR9olCAYYIJ" + }, + "outputs": [], + "source": [ + "\n", + "from dissmodel.core import Model\n", + "from dissmodel.visualization import track_plot\n", + "\n", + "\n", + "@track_plot(\"Susceptible\", \"green\")\n", + "@track_plot(\"Infected\", \"red\")\n", + "@track_plot(\"Recovered\", \"blue\")\n", + "class SIR(Model):\n", + " \n", + " #: Number of susceptible individuals.\n", + " susceptible: float\n", + "\n", + " #: Number of infected individuals.\n", + " infected: float\n", + "\n", + " #: Number of recovered individuals.\n", + " recovered: float\n", + "\n", + " #: Average number of steps an individual remains infectious.\n", + " duration: int\n", + "\n", + " #: Average number of contacts per individual per step.\n", + " contacts: int\n", + "\n", + " #: Probability of transmission per contact.\n", + " probability: float\n", + "\n", + " def setup(\n", + " self,\n", + " susceptible: int = 9998,\n", + " infected: int = 2,\n", + " recovered: int = 0,\n", + " duration: int = 2,\n", + " contacts: int = 6,\n", + " probability: float = 0.25,\n", + " ) -> None:\n", + " \"\"\"\n", + " Configure the model parameters.\n", + "\n", + " Parameters\n", + " ----------\n", + " susceptible : int, optional\n", + " Initial number of susceptible individuals, by default 9998.\n", + " infected : int, optional\n", + " Initial number of infected individuals, by default 2.\n", + " recovered : int, optional\n", + " Initial number of recovered individuals, by default 0.\n", + " duration : int, optional\n", + " Average number of steps an individual remains infectious,\n", + " by default 2.\n", + " contacts : int, optional\n", + " Average number of contacts per individual per step,\n", + " by default 6.\n", + " probability : float, optional\n", + " Probability of transmission per contact, by default 0.25.\n", + " \"\"\"\n", + " self.susceptible = susceptible\n", + " self.infected = infected\n", + " self.recovered = recovered\n", + " self.duration = duration\n", + " self.contacts = contacts\n", + " self.probability = probability\n", + "\n", + " def execute(self) -> None:\n", + " \"\"\"\n", + " Advance the model by one time step.\n", + "\n", + " Computes new infections and recoveries, then updates the\n", + " susceptible, infected, and recovered compartments.\n", + " \"\"\"\n", + " total = self.susceptible + self.infected + self.recovered\n", + " alpha = self.contacts * self.probability\n", + "\n", + " new_infected = self.infected * alpha * (self.susceptible / total)\n", + " new_recovered = self.infected / self.duration\n", + "\n", + " self.susceptible -= new_infected\n", + " self.infected += new_infected - new_recovered\n", + " self.recovered += new_recovered\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "gba_NBwSYV5W", + "metadata": { + "id": "gba_NBwSYV5W" + }, + "source": [ + "## ⚠️ Important: instantiation order\n", + "\n", + "The `Environment` must always be created **before** any model (`SIR`, `Chart`).\n", + "Models connect to the active environment automatically when instantiated —\n", + "if no environment exists yet, the connection fails.\n", + "\n", + "```\n", + "Environment → SIR → Chart\n", + " ↑ ↑ ↑\n", + " first second third\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "Qt6v4AcXYV5W", + "metadata": { + "id": "Qt6v4AcXYV5W" + }, + "source": [ + "## Setting up the model\n", + "\n", + "The SIR model accepts the following parameters:\n", + "\n", + "| Parameter | Description | Default |\n", + "|:---|:---|:---|\n", + "| `susceptible` | Initial susceptible population | 9998 |\n", + "| `infected` | Initial infected population | 2 |\n", + "| `recovered` | Initial recovered population | 0 |\n", + "| `duration` | Steps an individual remains infectious | 2 |\n", + "| `contacts` | Average contacts per individual per step | 6 |\n", + "| `probability` | Transmission probability per contact | 0.25 |" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "G_fdP2GtYV5X", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 504, + "referenced_widgets": [ + "692d902ac2fb49c493e3ccd3a9119256", + "40b29b45ff42484abbb358165d7a951a" + ] + }, + "executionInfo": { + "elapsed": 10873, + "status": "ok", + "timestamp": 1776076525203, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "G_fdP2GtYV5X", + "outputId": "a7a8627b-6981-4200-db10-87de9ff50650" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac72fbaf17f24f07b665ed101f696151", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running from 0 to 30 (duration: 30)\n" + ] + } + ], + "source": [ + "# 1. Environment must be created first\n", + "env = Environment()\n", + "\n", + "# 2. Model connects to the active environment automatically\n", + "SIR(\n", + " susceptible=9998,\n", + " infected=2,\n", + " recovered=0,\n", + " duration=2,\n", + " contacts=6,\n", + " probability=0.25,\n", + ")\n", + "\n", + "# 3. Chart also connects to the active environment automatically\n", + "Chart(show_legend=True, show_grid=True, title=\"SIR Model\")\n", + "\n", + "env.run(30)" + ] + }, + { + "cell_type": "markdown", + "id": "hJbiD029YV5X", + "metadata": { + "id": "hJbiD029YV5X" + }, + "source": [ + "## Visualization\n", + "\n", + "The `Chart` model redraws the time series at every simulation step.\n", + "It automatically tracks `susceptible`, `infected`, and `recovered`\n", + "because the `SIR` class is decorated with `@track_plot` — no extra\n", + "configuration needed." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "qGteZ_dlYV5Y", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 504, + "referenced_widgets": [ + "93cd6d0ce4684741b8d88bed194cd369", + "a92d0059c1d44c40af6a0636d150cec3" + ] + }, + "executionInfo": { + "elapsed": 18, + "status": "ok", + "timestamp": 1776076140447, + "user": { + "displayName": "Sergio Souza Costa", + "userId": "13030673997839113868" + }, + "user_tz": 180 + }, + "id": "qGteZ_dlYV5Y", + "outputId": "2bda3afb-c9c2-4937-cf4f-60f3ebc81698" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93cd6d0ce4684741b8d88bed194cd369", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": { + "application/vnd.jupyter.widget-view+json": { + "colab": { + "custom_widget_manager": { + "url": "https://ssl.gstatic.com/colaboratory-static/widgets/colab-cdn-widget-manager/2b70e893a8ba7c0f/manager.min.js" + } + } + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Chart (chart.0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "QaDMtgglYV5Y", + "metadata": { + "id": "QaDMtgglYV5Y" + }, + "source": [ + "## Try it yourself\n", + "\n", + "Go back and experiment:\n", + "\n", + "- Increase `contacts` to simulate a more contagious disease\n", + "- Increase `duration` to make the disease last longer\n", + "- Decrease `probability` to simulate a less transmissible disease\n", + "- Try starting with more `infected` individuals\n", + "- Change `env.run(30)` to run for more steps" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "40b29b45ff42484abbb358165d7a951a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "692d902ac2fb49c493e3ccd3a9119256": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_40b29b45ff42484abbb358165d7a951a", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + }, + "93cd6d0ce4684741b8d88bed194cd369": { + "model_module": "@jupyter-widgets/output", + "model_module_version": "1.0.0", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_a92d0059c1d44c40af6a0636d150cec3", + "msg_id": "", + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": "
" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "tabbable": null, + "tooltip": null + } + }, + "a92d0059c1d44c40af6a0636d150cec3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}