deepboard 0.2.0__py3-none-any.whl

deepboard/resultTable/table_schema.py

@@ -0,0 +1,135 @@
+import sqlite3
+
+def create_database(db_path):
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    # Create Experiments table
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS Experiments
+        (
+        run_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        experiment varchar(128) NOT NULL,
+        config varchar(128),
+        config_hash varchar(64),
+        cli varchar(512),
+        command varchar(256),
+        comment TEXT,
+        start DATETIME NOT NULL,
+        status TEXT CHECK (status IN ('running', 'finished', 'failed')) DEFAULT 'running',
+        commit_hash varchar(40),
+        diff TEXT,
+        hidden INTEGER NOT NULL DEFAULT 0
+        );
+    """)
+
+    # Create Results table
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS Results
+        (
+            id_ INTEGER PRIMARY KEY AUTOINCREMENT,
+            run_id INTEGER NOT NULL,
+            metric varchar(128) NOT NULL,
+            value NOT NULL,
+            is_hparam INTEGER DEFAULT 0,
+            FOREIGN KEY (run_id) REFERENCES Experiments(run_id)
+        );
+    """)
+
+    # Create Logs table for scalar values
+    # Wall time is in seconds
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS Logs
+    (
+        id_ INTEGER PRIMARY KEY AUTOINCREMENT,
+       run_id INTEGER NOT NULL,
+       epoch INTEGER,
+       step INTEGER NOT NULL,
+       split varchar (128) NOT NULL,
+       label varchar(128) NOT NULL,
+       value REAL NOT NULL,
+       wall_time REAL NOT NULL,
+       run_rep INTEGER NOT NULL,
+       FOREIGN KEY(run_id) REFERENCES Experiments(run_id)
+    );
+    """)
+
+    # Create an Image table to store images
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS Images
+    (
+        id_ INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id INTEGER NOT NULL,
+        step INTEGER NOT NULL,
+        epoch INTEGER,
+        run_rep INTEGER NOT NULL,
+        img_type varchar(64) NOT NULL, -- IMAGE or PLOT
+        split varchar(128),
+        image BLOB NOT NULL,
+        FOREIGN KEY(run_id) REFERENCES Experiments(run_id)
+    );
+    """)
+    # Create a table to store text data
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS Fragments
+    (
+        id_ INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id INTEGER NOT NULL,
+        step INTEGER NOT NULL,
+        epoch INTEGER,
+        run_rep INTEGER NOT NULL,
+        fragment_type varchar(64) NOT NULL, -- RAW or HTML
+        split varchar(128),
+        fragment text NOT NULL,
+        FOREIGN KEY(run_id) REFERENCES Experiments(run_id)
+    );
+    """)
+    # Display Table
+    # This table stores every column of Results, their order and whether they displayed or not
+    # If order is Null, it means that the column is not displayed
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS ResultDisplay
+    (
+        Name varchar(128) NOT NULL, display_order INTEGER, 
+        alias varchar(128) NOT NULL,
+        PRIMARY KEY(Name)
+    );
+    """)  # We can put order to unique, because each NULL value will be unique
+
+    # Add default columns
+    cursor.execute("""
+    INSERT
+    OR IGNORE INTO ResultDisplay (Name, display_order, alias) VALUES
+    ('run_id', 0, 'Run ID'),
+    ('experiment', 1, 'Experiment'),
+    ('config', 2, 'Config'),
+    ('config_hash', NULL, 'Config Hash'),
+    ('cli', NULL, 'Cli'),
+    ('command', NULL, 'Command'),
+    ('comment', 4, 'Comment'),
+    ('start', NULL, 'Start'),
+    ('status', NULL, 'Status'),
+    ('commit_hash', NULL, 'Commit'),
+    ('diff', NULL, 'Diff'),
+    ('hidden', NULL, 'Hidden');
+    """)
+
+    # Create a trigger to add a new metric to the display table
+    cursor.execute("""
+                   CREATE TRIGGER IF NOT EXISTS after_result_insert
+    AFTER INSERT ON Results
+                   BEGIN
+        -- Insert a row into ResultDisplay if the Name does not exist
+        INSERT
+                   OR IGNORE INTO ResultDisplay (Name, display_order, alias)
+                   SELECT NEW.metric,
+                          COALESCE(MAX(display_order), 0) + 1,
+                          NEW.metric
+                   FROM ResultDisplay;
+                   END;
+                   """)
+    # Create index for speed
+    cursor.execute(
+        "CREATE INDEX IF NOT EXISTS idx_config_hash ON Experiments(experiment, config, config_hash, cli, comment);")
+    conn.commit()
+    conn.close()

deepboard/resultTable/utils.py

@@ -0,0 +1,50 @@
+import sqlite3
+from datetime import datetime, date
+from typing import *
+import subprocess
+
+def adapt_date_iso(val):
+    """Adapt datetime.date to ISO 8601 date."""
+    return val.isoformat()
+
+def adapt_datetime_iso(val):
+    """Adapt datetime.datetime to timezone-naive ISO 8601 date."""
+    return val.isoformat()
+
+sqlite3.register_adapter(datetime.date, adapt_date_iso)
+sqlite3.register_adapter(datetime, adapt_datetime_iso)
+
+def convert_date(val):
+    """Convert ISO 8601 date to datetime.date object."""
+    return date.fromisoformat(val.decode())
+
+def convert_datetime(val):
+    """Convert ISO 8601 datetime to datetime.datetime object."""
+    return datetime.fromisoformat(val.decode())
+
+sqlite3.register_converter("date", convert_date)
+sqlite3.register_converter("datetime", convert_datetime)
+
+def get_last_commit() -> Optional[str]:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None
+
+def get_diff() -> Optional[str]:
+    try:
+        result = subprocess.run(
+            ["git", "diff", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None

deepboard-0.2.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: deepboard
+Version: 0.2.0
+Summary: Organize your research project like a pro with Deepboard
+Project-URL: Homepage, https://github.com/anthol42/deepboard
+Project-URL: Issues, https://github.com/anthol42/deepboard/issues
+Author-email: Anthony Lavertu <alavertu2@gmail.com>
+Keywords: board,deep,deepboard,jax,pytorch,tensorboard,tensorflow,torch
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: pillow
+Provides-Extra: full
+Requires-Dist: fh-plotly; extra == 'full'
+Requires-Dist: markupsafe; extra == 'full'
+Requires-Dist: python-fasthtml; extra == 'full'
+Description-Content-Type: text/markdown
+
+# Deepboard
+This package include two modules that are work together: 
+`deepboard gui` and `resultTable`. The `resultTable` module 
+keeps track of all of your experiment and helps you organize 
+your code to make results reproducible. The `deepboard gui` module
+implement a webUI to visualize the training details and training 
+curves of any runs. In addition, it lets you commpare training curves
+between runs. You can even download the charts that you have generated:)
+## 🔥 Screenshots 🔥
+![](./assets/main_view.png)
+
+
+![](./assets/compare_view.png)
+
+
+![](./assets/full_table_view.png)
+## 🌟 Project Philosophy
+Before diving in, it’s important to understand the philosophy behind this project. In deep learning, it’s easy to get 
+swept up in the excitement — experimenting with countless configurations in search of the perfect setup. 🔬✨ 
+Eventually, we stumble upon something that works well... only to keep tweaking and lose track of what actually worked 
+best. This package is built to help you stay focused, organized, and efficient — so you never lose track of that perfect 
+combination again. 🧠✅
+
+The idea is simple: always make your code reproducible!
+Sure, easier said than done... 😅 My recommended approach is to use a multi-level configuration system. Let me explain 
+how it works! 👇
+
+Before jumping into experiments, we usually know the minimal set of parameters required for a project to run.
+For instance, if you're training a Transformer model, you already know you'll need to specify things like the number of 
+layers, number of attention heads, learning rate, and so on. All these known parameters can (and should) be stored in a 
+configuration file — I personally prefer using YAML for its readability. 📄 When running the experiment, we simply load 
+this config file and use it to parameterize each part of the code. Usually, the parameters stored in the config gives 
+us the baseline.
+
+Once we’ve established a baseline, it’s natural to want to improve it — whether it's by testing out a new technique from
+a paper or an idea that came to us in a dream. 🚀 But here's the challenge: how do we add new functionality to our code 
+without breaking compatibility with earlier runs? In other words, if we use the same config file and script parameters, 
+we should still get the exact same results as before. My solution? Add new parameters to functions with sensible 
+default values — specifically, defaults that reflect the original behavior. You can then include these parameters in 
+your configuration file and toggle them on or off to test their effect. For example, say you’re building an image 
+classifier and want to try `MixUp`. Your training function might look like this:
+```python
+def train_model(..., use_mixup: bool = False):
+    ...
+```
+By setting the default to False, your baseline run remains intact. Only when `use_mixup` is explicitly set to True will 
+the new logic kick in. This approach ensures clean, reproducible experimentation with minimal disruption. ✅
+
+Sometimes, we don’t want to modify the configuration file directly — for example, when we've decided that a particular 
+config represents a fixed setup for a specific model or training strategy.
+In these cases, it's often more convenient to override a few parameters via the command line. 🧪
+To do this, I use Python’s built-in argparse module. It adds an extra layer of configuration that’s ideal for quick 
+experiments — without changing the original YAML file. And just like before, the same principle applies: always use 
+default values that reproduce the results of previous runs. This ensures your experiments stay flexible and reproducible. 🔁
+
+This project promotes a simple but powerful principle: make your deep learning experiments reproducible — without 
+slowing down iteration or innovation. To achieve that, it recommends a multi-level configuration system:
+1. YAML Configuration Files – Store all known parameters for a clean, reproducible baseline. 📄
+2. Function Defaults – Add new features with default values that preserve past behavior. This ensures that re-running 
+with the same config and cli parameters always gives the same result. ✅
+3. CLI Overrides – For quick tweaks, use cli parameters to add new functionalities or to override config's parameters 
+without editing the base config. Perfect for fast experimentation. 🧪
+
+This layered setup keeps your workflow organized, traceable, and easy to extend, so you can explore new ideas without 
+losing sight of what actually works. 🔁
+
+If you're feeling a bit overwhelmed or would like a project example, the 
+[torchbuilder](https://github.com/anthol42/torchbuilder/tree/dev) app can generate various project templates. The 
+default template implements this philosophy, including the resultTable, making it a great starting point! 🚀
+
+## 🛠️ Installation
+To install only the `resultTable` module, which allows you to log your results inside a single file, you can run:
+```shell
+pip install deepboard
+```
+
+To also install the `GUI` module, which allows you to visualize your results in a web UI, you can run:
+```shell
+pip install deepboard[full]
+```
+
+## 🚀 How to Use
+For your project, you will only need the `resultTable` module, as the `deepboard` module is primarily for the UI.
+
+### ResultTable
+First, import the `ResultTable` class from `deepboard.resultTable`, then create a new run. You can also create a debug run. 
+A **debug run** will be logged in the result table like any other run, but all results will be overwritten by the next 
+debug run. This helps keep the result table clean by containing only the runs you intend to test, rather than those 
+meant solely for verifying if the code executed correctly.
+
+Note: **Debug runs always have a runID of -1.** 🔧
+```python
+from deepboard.resultTable import ResultTable
+    
+rtable = ResultTable("results/resultTable.db")
+if DEBUG:
+    resultSocket = rtable.new_debug_run("Experiment1", "path/to/config", cli=vars(args).copy())
+else:
+    resultSocket = rtable.new_run("Experiment1", "path/to/config", cli=vars(args).copy())
+```
+
+Next, you can specify hyperparameters that will appear in the table
+```python
+resultSocket.add_hparams(
+        lr=config["training"]["learning_rate"],
+        wd=...,
+        min_lr=...,
+        dropout2d=...,
+        dropout=...
+    )
+```
+
+During training, we can log scalars associated to the run with:
+```python
+resultSocket.add_scalar(f'Train/Accuracy', 0.99, step)
+```
+
+Finally, you can log the final evaluation results that will be included into the table with:
+```python
+resultSocket.write_result(accuracy=final_accuracy, crossEntropy=final_loss)
+```
+
+Note: If you want to do multiple training iterations of the same run (to test variance for example), you can call the 
+```resultSocket.new_repetition``` method after each repetition. 
+```python
+for rep in range(number_of_repetitions):
+    for epoch in range(n_epochs):
+        ... # Train here
+    resultSocket.new_repetition()
+
+# Finally, write the final results once:
+resultSocket.write_result(accuracy=accuracies.mean(), crossEntropy=losses.mean())
+```
+
+### Deepboard UI
+To launch deepboard Web UI, simply run the command `deepboard` in your terminal with the path to your resultTable db:
+```shell
+deepboard /path/to/resultTable.db
+```

deepboard-0.2.0.dist-info/RECORD

@@ -0,0 +1,69 @@
+deepboard/__init__.py,sha256=nMXg9GFsk8gCcyBnh1MAeUPvo4Zcuv3sdwGHZrxfpPE,36
+deepboard/__version__.py,sha256=73xmj_rtt0boRuIZ0h5wqHItFsCNZHTC-Wa0tSeAxyY,171
+deepboard/gui/THEME.yml,sha256=Cj7iDLGOYi_rmj6O7REadkukoiZkut-faNPDlD9qkII,645
+deepboard/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepboard/gui/entry.py,sha256=GPG5BJ2nOVqRfTlPFL-wYIcvySZEotk6gO52Ww_LUxA,576
+deepboard/gui/main.py,sha256=gT6zMGa3AdrWKvblIBEfkyT42YN9iCvgSgY87jcaiF4,3406
+deepboard/gui/requirements.txt,sha256=pOXbI6s6re_6zBe8rAWlx7VxxTYJucyoJ9wCespWu3M,51
+deepboard/gui/utils.py,sha256=9z9LOhXW2LA5heQEpI7nEeK463O6INSypOotPLdQnHI,9235
+deepboard/gui/assets/artefacts.css,sha256=5B-uBbwZ2-1aLVNShb61OejFQjMgS_9tzXmhCgLSLSE,2414
+deepboard/gui/assets/base.css,sha256=V341OJirGVse8hbw1B8_xwMm41idkehYaF5p7QR5vD8,3994
+deepboard/gui/assets/base.js,sha256=6CinWmaHwTRQJemXdjRTp7HVfAIH2gMkm6CQ-6pkuSA,2682
+deepboard/gui/assets/charts.css,sha256=_PgD1QHQUWYapeH6gJDS96dFsYz0YSOSMjF0TtBvwi4,3719
+deepboard/gui/assets/compare.css,sha256=u5BSr38ZdPlon7TaheHhV5K2jwloYnkShN5C9IdB7y0,1932
+deepboard/gui/assets/datagrid.css,sha256=_OTQqjrRY28A8uI9FFcr2fIWVR7Uxu-qVRfWH5T9zO4,2358
+deepboard/gui/assets/fileview.css,sha256=a_WKfqIBCCqJkrpUA7U2O-2_4dPDjW9pcMeUKeX2Ldk,250
+deepboard/gui/assets/right_panel.css,sha256=55bnhRBfXHGv0ELQK-0fU7PtYz9Wjk0vmiVCrFtSftM,5016
+deepboard/gui/assets/theme.css,sha256=WKq9dGm0R850xRCoCFN5OkSXRzq738tSQJva7zJHcpM,2622
+deepboard/gui/components/__init__.py,sha256=67VIta8hGT67m5kFT_k9isr9edGdkKfjQxb23R3ETPQ,271
+deepboard/gui/components/artefact_group.py,sha256=0OTbCFRyD7Oh9ScUZKsfNtu4iou0AMSTp0bEYTwZPok,331
+deepboard/gui/components/chart_type.py,sha256=fGjeT8Emw4HzGJd7pl1lij1pvV-9-cN0Dem_Tk8T9nc,1135
+deepboard/gui/components/legend.py,sha256=yznW0VYGMB7MeHSdV6Lb3rly_IcbzNa1r6-GQtE6Ktk,1427
+deepboard/gui/components/log_selector.py,sha256=pJBtkRyRQ3wS5h7d7q06Ga5yHOsiXAcGjuGv4BH0m9E,1134
+deepboard/gui/components/modal.py,sha256=B7QsqRctawL55u5YKm9HMlAuVjC-uZ2HR8s53-kV4Uk,515
+deepboard/gui/components/smoother.py,sha256=cNAD4B-efUSJsY3hGA5Rz1WkCsJd3Yt5siDKEOcxmc4,954
+deepboard/gui/components/split_selector.py,sha256=j_vwMuNduQ4afq5CHKSkesvL6cu9o4Q-0Fq7kDqK0io,818
+deepboard/gui/components/stat_line.py,sha256=B0uBRlooxMgFeRWjx92x7KOr25jOH3zViRWSFMdD7LY,298
+deepboard/gui/pages/__init__.py,sha256=VV7KBURlxVm953dMxR29doXaYQaPB-0t_ifs3YOwGYU,33
+deepboard/gui/pages/not_found.py,sha256=qTNcMG2okmdklZOCVeI6K6OmZ717Tn8TekUNSRX1izc,152
+deepboard/gui/pages/compare_page/__init__.py,sha256=0RIIQ6mXWr1ztOYAcpbsccQXAjbQhCnGH7sdaiiBMGI,273
+deepboard/gui/pages/compare_page/compare_page.py,sha256=UDLqKTK9F5cK7ynMVrjb0RX0XDdJG-z4pst1z5HYZCI,643
+deepboard/gui/pages/compare_page/routes.py,sha256=FtUotUJq1tKUL-07Cbpw1E7xzdt4sQZP97mCkrw9PfI,2554
+deepboard/gui/pages/compare_page/components/__init__.py,sha256=eKlD7qn2jtBLQqqNsnkwVxDMp-Ln4Z39X5AGMvcWBns,149
+deepboard/gui/pages/compare_page/components/card_list.py,sha256=MaZyqHM75UA1VPOfzoKfPi2N1rdVLfiwnLFBlxh-dvo,785
+deepboard/gui/pages/compare_page/components/chart.py,sha256=4KZlYOwr0wRemSUjrD1glBnGizEh2kUgmeUGU9_pM7A,2219
+deepboard/gui/pages/compare_page/components/compare_setup.py,sha256=mf-qChvLsjcoIJW_pcfHtHb2VuGgmw7fwX7jNarlij0,1564
+deepboard/gui/pages/compare_page/components/split_card.py,sha256=nABAKLtOL_xBDGsvGAkxHQnjf3-EkQFRcgUj_cENiyE,2140
+deepboard/gui/pages/compare_page/components/utils.py,sha256=MfM7gu4hCqF1Mps9uzKwY3cssgsp2tWPrhkFJYkQokg,750
+deepboard/gui/pages/main_page/__init__.py,sha256=yu7LEqMe2cu0bmxgu7V4fRV0FJjCeb82sHzjAnTAeeE,159
+deepboard/gui/pages/main_page/handlers.py,sha256=BTZaKmlBIZXmlfwMo70Kx0mKR6pls-Hqj5rvqpdghks,600
+deepboard/gui/pages/main_page/main_page.py,sha256=lrHkrXzUvwTfuLI9lrSyW-R5ADO5cLAso-VDtfHHhVg,769
+deepboard/gui/pages/main_page/routes.py,sha256=r7YgV_6xv7e0sOCa8fkhyH-gq-6Q2T7O_n9AP1Gn1kE,770
+deepboard/gui/pages/main_page/datagrid/__init__.py,sha256=wVP6ETJVFJmVOOxHeyP90KHNSdlMw9eCsb3JyEcqnrQ,234
+deepboard/gui/pages/main_page/datagrid/compare_button.py,sha256=-_BwxpKMvvYWmBUD1v0ZFEa9cVOWzyfsu2Co3FTfyuw,839
+deepboard/gui/pages/main_page/datagrid/datagrid.py,sha256=WxVzGzJIlmLx6s-FrMwtG5lw6PAyc9hSvFQ_vvz09M8,2721
+deepboard/gui/pages/main_page/datagrid/handlers.py,sha256=kp6hx7qXeBNokCHay9tcAt-ZMG2YOFCZSuBWKI7vj5U,2760
+deepboard/gui/pages/main_page/datagrid/header.py,sha256=OzhfkokmCfga_VEnUdL2UDxZkU8TiELZatoQihqdKZY,1436
+deepboard/gui/pages/main_page/datagrid/routes.py,sha256=2I-eKm-DKZUaD5bUJnlZOr66SGlsiUJnzlDChH-Rwlo,3656
+deepboard/gui/pages/main_page/datagrid/row.py,sha256=aUKmet_BuYAC39nvCzh57p2U7RvdE3jD3phualu5MPg,742
+deepboard/gui/pages/main_page/datagrid/sortable_column_js.py,sha256=NyzULiCjUtcvrOcIS68hbo7UPtJwCoa4WTqdlGvNszk,1586
+deepboard/gui/pages/main_page/datagrid/utils.py,sha256=xgTju4w7gacVQhDMPN3bxY2qZedhTlC2jeAOgXT2yTg,299
+deepboard/gui/pages/main_page/right_panel/__init__.py,sha256=L4zdoW-0HJtP49rS8l52D4Prbv6S7pLBMm0ufZf64Mc,413
+deepboard/gui/pages/main_page/right_panel/config.py,sha256=Qtk7kXXvlzLpBMEnCBojXSHrij7uEBnMACj5KoQ2g5Q,1567
+deepboard/gui/pages/main_page/right_panel/fragments.py,sha256=XcPs3TKzHEF-GreDpnKwHs2G2xJAWtNtv0SQCVg1TXQ,4503
+deepboard/gui/pages/main_page/right_panel/hparams.py,sha256=KrLpUEccGMn-rCBA2tztcM0XxV6MD2oUsx3UbJ2XZYQ,605
+deepboard/gui/pages/main_page/right_panel/images.py,sha256=Phf8vY8-Md3vFTI-7Ri5wwK-WNzVuyCKrCpTyLudGs0,11698
+deepboard/gui/pages/main_page/right_panel/run_info.py,sha256=UqJZWz4i32bOQirVAlEjrDraYVaHsVNevV3Bng35TqU,2820
+deepboard/gui/pages/main_page/right_panel/scalars.py,sha256=psJj5xUqYyZjJA62ymz3CYzck9EF5TkVcA0Z4_UVHqs,9835
+deepboard/gui/pages/main_page/right_panel/template.py,sha256=zI4ShVwadXi6Dwe-mB_cIN5ZU7GHnb7_Ow_ezGD-b-o,5756
+deepboard/resultTable/__init__.py,sha256=qjeK7bIYHeWTM6Lp9V1HLB_8gCeEMonKDvjHXfBWeSA,86
+deepboard/resultTable/cursor.py,sha256=YZrCQeISPqXcH9KhKhearK5LEyM2rc_fqH8axnFUXPY,699
+deepboard/resultTable/logwritter.py,sha256=iXbPkfp5t0dd4Ojydw0zWKEpgKE7SXEmmasSfmPjegM,27046
+deepboard/resultTable/resultTable.py,sha256=e_xSAZmA6xAKL7sdKo_43ToDUsr6JI0TgHL7x3paltQ,24584
+deepboard/resultTable/scalar.py,sha256=6pakiOafTxoj2yCTCn0Y300ECK23KKQ-orTHvWT5pLI,1347
+deepboard/resultTable/table_schema.py,sha256=EYdP3c8WcimmcA50ecX10tyd5jcry2aVZBN--DICbck,4322
+deepboard/resultTable/utils.py,sha256=3K0rt5QDHv0aOld8KiXFGXvTUBiTskgnNxEjAApqCFQ,1424
+deepboard-0.2.0.dist-info/METADATA,sha256=PsYCOM1VyigWLn5M7kUSGh7oOqgJGxrIjk-PtmCyXOU,8340
+deepboard-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+deepboard-0.2.0.dist-info/entry_points.txt,sha256=SFQjQXlWt2867B5_Lu9PVzB8pIUYbCSpPsViqyRZCyk,55
+deepboard-0.2.0.dist-info/RECORD,,

deepboard-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

deepboard-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deepboard = deepboard.gui.entry:main