tg-prepare 1.0.0__py3-none-any.whl → 2.1.0b1__py3-none-any.whl

{tg_prepare-1.0.0.dist-info → tg_prepare-2.1.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tg_prepare
-Version: 1.0.0
+Version: 2.1.0b1
 Summary: Simple UI to handle TextGrid imports visually.
 Author: Ralf Klammer, Moritz Wilhelm
 Author-email: ralf.klammer@tu-dresden.de, moritz.wilhelm@tu-dresden.de
@@ -8,8 +8,8 @@ License-File: LICENSE
 Requires-Dist: click
 Requires-Dist: flask
 Requires-Dist: flask_json
-Requires-Dist: tg_model>=3.6.0
-Requires-Dist: tgclients==0.17.0
+Requires-Dist: tg_model==3.8.0.b2
+Requires-Dist: tgclients
 Requires-Dist: tgadmin
 Requires-Dist: nextcloud-api-wrapper
 Dynamic: author

tg_prepare-2.1.0b1.dist-info/RECORD

@@ -0,0 +1,54 @@
+tg_prepare-2.1.0b1.dist-info/licenses/LICENSE,sha256=deYu6g1OGKm0VUwhM4Octoh8qlzjsiHHxoI-KkCBVBE,11351
+tg_prepare-2.1.0b1.dist-info/projects/.secret_key,sha256=PF3sI74fctNP5J8NoHmvl6nRsvyTeGMU82UTY_E3re4,66
+tgp_backend/__init__.py,sha256=Hsy1huPlOgpNffJVJpxGZzUKdHU8X837K-cOW_DkEy0,373
+tgp_backend/auth.py,sha256=hUPd0rc01BTT003xpkdmhNc6o0JztbAdimyDb0B9oTQ,2293
+tgp_backend/cli.py,sha256=iw_gknn-_m_UFZZUKfkV9aJixG3sVcHIONybNtOG40I,551
+tgp_backend/config.py,sha256=9rFr7bxZN4r1OOKaxs8eBYUnZ0_ccVHU6oqoEsNTKBE,922
+tgp_backend/directories.py,sha256=wNmwc2Uhd9ivZYIM9UkfCv2HkQY8pmDQk2y39wOgBQo,2366
+tgp_backend/interfaces.py,sha256=SO7mOdhkd1f7irUBrwFhp5aKx3UKkkUzU9QBYDl0Tvc,91
+tgp_backend/nextcloud.py,sha256=JNhyJfuR26o33r5QV37ClTALQm_fMQn451SMV5lixNc,5133
+tgp_backend/project.py,sha256=_qebCEkC_wRfSknOIL-c4BAPG830EUZ5m4HW_gkHRn4,12707
+tgp_backend/session_manager.py,sha256=pQGhnXtGPqwdw6xQhZItjGgurx9JBUsIW8mzfSKk_WM,1395
+tgp_backend/tgclient.py,sha256=QG2iFPrv2qLL4FRXoEfXzEMJriroiIaNL9rkreGtzuQ,2961
+tgp_backend/util.py,sha256=4lTaC3liik2ixRcx5wDQS4-FW3QpPhRdXQm32_64J_E,3648
+tgp_ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgp_ui/app.py,sha256=6elwUZ_hSM08_FstTerrLX2rB4QurQUSqu359rkhxrI,3704
+tgp_ui/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgp_ui/routes/collection.py,sha256=NzfLnF-ZDlZI23ulDhvLXJXELlTlcJw0Z_LONHcU2bA,7861
+tgp_ui/routes/data.py,sha256=xnw-0v72SK8Z2zjwCYNAHp8omkfsZKRtvUKr3YZSSFg,6891
+tgp_ui/routes/project.py,sha256=AyCYI76V4vkEfZQPjSgXmPOIWClpryEEBTQoSjxSXkM,2794
+tgp_ui/routes/publication.py,sha256=K_wDy3t_iwL9TMLLFXR7P2PdDWyHNQUMY9FArJBsmN4,3791
+tgp_ui/routes/tabs.py,sha256=JaZpoY03S_p8uz_sVRCR-fIOfl-ml0M6CJ7_KaYN9aI,908
+tgp_ui/routes/views.py,sha256=ZgxcfEZoyE_4ABrnRtHc8FFR11Rufs8HVaUr4cOBshA,1814
+tgp_ui/static/css/bootstrap-icons.min.css,sha256=XxUvYRPQvG4RTCkukUmXwvf1N0YF9KQ_ocuWV6O1dk8,85797
+tgp_ui/static/css/bootstrap.min.css,sha256=djO3wMl9GeaC_u6K-ic4Uj_LKhRUSlUFcsruzS7v5ms,155845
+tgp_ui/static/css/main.css,sha256=EK8euwgxX8I3qsBiDmIvj8UBIxkSKQZz1mo_OX4Q1FQ,2641
+tgp_ui/static/css/navbar.css,sha256=D68mfVJ88zruV1sRH1D6zjwQ2MoHRy2HQ7BAn_8OSkc,1609
+tgp_ui/static/css/simpleXML.css,sha256=dfY7UZCiC79BkNOT1hM0GQ6v_yLSxhKCnmV0RZIT9S8,961
+tgp_ui/static/js/bootstrap.bundle.min.js,sha256=fh8VA992XMpeCZiRuU4xii75UIG6KvHrbUF8yIS_2_4,78743
+tgp_ui/static/js/collectionManager.js,sha256=gbeXe7CtEdCdka3WLfBx7cVRcT8cveUP_t3TDwRdgvo,2291
+tgp_ui/static/js/fileManager.js,sha256=_plx7zrC039-3y0ZqLd77ymDhTtAiJC3XOLSeAooYAc,7095
+tgp_ui/static/js/jquery.min.js,sha256=_xUj-3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej_m4,89501
+tgp_ui/static/js/main.js,sha256=VCaLVlGFml8ObO0mbyV_kT1aDVH-OB4jqVlzsfT42xM,1107
+tgp_ui/static/js/modalManager.js,sha256=8q4Dtx88aO4zbG5EgZ6Nw1NJa36-RKoRcVzy4DVHEVg,4030
+tgp_ui/static/js/navbarManager.js,sha256=E1_SF262uU4I405vxVCrEXhAE7aEZt9ASixG7huL1As,6713
+tgp_ui/static/js/projectManager.js,sha256=LoT8lZnyvrgquSD7aSNkYaAdggH5kUZYRXVFD-d3dzk,2296
+tgp_ui/static/js/require.js,sha256=DCwpJYECNmnwjgb2xsUmuvSrkNPXRYgYADz7nlUc_-Y,20781
+tgp_ui/static/js/sidebarManager.js,sha256=sfYPwLvKUQA8vMhyVKsA7CJe5cUJliCao8ccwfLKAV0,928
+tgp_ui/static/js/simpleXML.js,sha256=jEkZe3TuiHuEt6V7If_1EmqYIgTywssJ3OwOQzOFYNg,8065
+tgp_ui/static/js/tabManager.js,sha256=spS-Hr-LylqpW0nQz7ontsPfX64b3whilr6038VMq18,3304
+tgp_ui/templates/file_tree.html,sha256=IKWp5MLUvnFF65cIUIxU4Jf5wi9Fg8koSXD96Mk328E,1640
+tgp_ui/templates/layout.html,sha256=ClI6xHMBy6auir72i3Sm6SCJI97XUXhpPrzJSgf_7wM,2727
+tgp_ui/templates/macros.html,sha256=3qetLd7wC__iAoWZ6g4--82Zd2t36XOZcwiLbi7DEAA,4463
+tgp_ui/templates/nxc_login.html,sha256=tDxqHYPZqsY2ZNnkn4a5bMOYiD8ybcNRpzSq7MvMWCo,1269
+tgp_ui/templates/nxc_tab.html,sha256=9HWCa7UZKxL0fZasT_g6uozI64L-497Y2LppPPTHF2M,517
+tgp_ui/templates/project_main.html,sha256=Vdvr9QDfpnc9EU38uTm0H4pT0pzLdi7DckL3d9DC_u4,1878
+tgp_ui/templates/project_navbar.html,sha256=WyS8WNI7tgNDdYOkuFaXeu9A58ER3OK7puVNO-Sfz-0,4412
+tgp_ui/templates/projects_main.html,sha256=2c6PNdomNV1w6j6e-FH27bvdwVNfrzTf5DY1pNzHuMM,2530
+tgp_ui/templates/publication.html,sha256=TXCHCE2198cHFmN4_l4JNmq0nQoy8GwnESePjRfjliU,9357
+tgp_ui/templates/tab_final_upload.html,sha256=Nn1pwxI_Y_XBB81N5l2G8P_pSsVOyS2AQLsp8IE9a4s,1663
+tg_prepare-2.1.0b1.dist-info/METADATA,sha256=sZRgS2wsd54fQOGcyShPWkEBMqpj0C08w8xXTzhfLrs,529
+tg_prepare-2.1.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tg_prepare-2.1.0b1.dist-info/entry_points.txt,sha256=mbsfiEA8_fQdrFUE_oabDi-Syw8jjli37Ms7tawDDhs,78
+tg_prepare-2.1.0b1.dist-info/top_level.txt,sha256=ueOyX_KdozreQJD_HRs6kAsvGNO4vfM9B_QqqhdyRPI,19
+tg_prepare-2.1.0b1.dist-info/RECORD,,

{tg_prepare-1.0.0.dist-info → tg_prepare-2.1.0b1.dist-info}/WHEEL

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

tg_prepare-2.1.0b1.dist-info/projects/.secret_key

@@ -0,0 +1 @@
+"94c9d50a8949b627be9608827a66d0025919e013d89236b092de90dd0b79fd12"

tgp_backend/__init__.py

@@ -4,15 +4,14 @@
 
 import logging
 
-from .util import config
+from .config import LOG_LEVEL
 
 log = logging.getLogger(__name__)
 
-log_level = config("log", "level", default="INFO")
 log_config = dict(
-    level=log_level,
+    level=LOG_LEVEL,
     format="%(asctime)s %(name)-10s %(levelname)-4s %(message)s",
 )
 
 logging.basicConfig(**log_config)
-logging.getLogger("").setLevel(log_level)
+logging.getLogger("").setLevel(LOG_LEVEL)

tgp_backend/config.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2024 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+import logging
+
+from configparser import ConfigParser
+
+log = logging.getLogger(__name__)
+
+
+def get_config_value(section, parameter, default=None):
+    _config = ConfigParser()
+    _config.read("config.ini")
+
+    if section not in _config:
+        log.warn("Section: %s not in *.ini -> using default" % section)
+        return default
+    config_val = _config[section].get(parameter)
+    if not config_val:
+        log.info(
+            "Parameter: %s not in section: (%s) of *.ini -> using default: %s"
+            % (parameter, section, default)
+        )
+        return default
+    else:
+        return config_val
+
+
+LOG_LEVEL = get_config_value("log", "level", default="INFO")
+MAIN_PATH = get_config_value("main", "path", default="./projects")
+MAX_FILENAME_LENGTH = get_config_value("main", "maxFileNameLength", default=15)

tgp_backend/directories.py

@@ -6,13 +6,11 @@ import logging
 import os
 import re
 
-from tgp_backend.util import config, get_file_extension
-
+from tgp_backend.config import MAX_FILENAME_LENGTH
+from tgp_backend.util import get_file_extension
 
 log = logging.getLogger(__name__)
 
-maxFileNameLength = config("main", "maxFileNameLength", default=15)
-
 
 def generateList(path=None):
     # path = path if path else config("main", "path", default="/tmp")
@@ -28,7 +26,6 @@ def generateList(path=None):
     for name in os.listdir(path):
         fullpath = "%s/%s" % (path, name)
         if not name.startswith("."):
-            print(name)
             if os.path.isdir(fullpath):
                 dList.append({"fullpath": fullpath, "name": name})
             else:
@@ -39,12 +36,12 @@ def generateList(path=None):
     curDir = path
 
     for d in dList:
-        if len(d["name"]) > maxFileNameLength:
+        if len(d["name"]) > MAX_FILENAME_LENGTH:
             dots = "..."
         else:
             dots = ""
         temp_dir = {}
-        temp_dir["f"] = d["name"][0:maxFileNameLength] + dots
+        temp_dir["f"] = d["name"][0:MAX_FILENAME_LENGTH] + dots
         temp_dir["name"] = d["name"]
         temp_dir["f_url"] = re.sub("#", "|HASHTAG|", d["fullpath"])
         temp_dir["currentDir"] = curDir
@@ -62,12 +59,12 @@ def generateList(path=None):
             pass
         if not image:
             image = "files_icon/unknown-icon.png"
-        if len(f["name"]) > maxFileNameLength:
+        if len(f["name"]) > MAX_FILENAME_LENGTH:
             dots = "..."
         else:
             dots = ""
         temp_file = {}
-        temp_file["f"] = f["name"][0:maxFileNameLength] + dots
+        temp_file["f"] = f["name"][0:MAX_FILENAME_LENGTH] + dots
         temp_file["name"] = f["name"]
         temp_file["name_stripped"] = f["name"].replace(f".{tp}", "")
         temp_file["f_url"] = re.sub("#", "|HASHTAG|", f["fullpath"])
@@ -79,7 +76,4 @@ def generateList(path=None):
 
         file_list_dict.append(temp_file)
 
-    # log.debug("generateList - dir_list_dict: %s" % dir_list_dict)
-    # print("generateList - file_list_dict: %s" % file_list_dict)
-    # print(tp_dict)
     return dir_list_dict, file_list_dict

tgp_backend/nextcloud.py

@@ -4,7 +4,6 @@
 # moritz.wilhelm@tu-dresden.de
 
 import logging
-
 import nextcloud
 import os
 
@@ -14,21 +13,21 @@ log = logging.getLogger(__name__)
 class Nextcloud:
     def __init__(
         self,
-        nextcloud_url=None,
+        url=None,
         username=None,
         password=None,
-        root_dir=None,
+        folder=None,
         **kwargs,
     ):
         self._nxc = None
         self._root = None
-        self.nextcloud_url = nextcloud_url
+        self.url = url
         self.username = username
         self.password = password
-        self.root_dir = root_dir
+        self.root_dir = folder
 
     def test_connection(self):
-        if all([self.nextcloud_url, self.username, self.password]):
+        if all([self.url, self.username, self.password]):
             return str(self.nxc.list_folders().status_code).startswith("2")
         return False
 
@@ -36,7 +35,7 @@ class Nextcloud:
     def nxc(self):
         if self._nxc is None:
             self._nxc = nextcloud.NextCloud(
-                endpoint=self.nextcloud_url,
+                endpoint=self.url,
                 user=self.username,
                 password=self.password,
             )
@@ -51,29 +50,51 @@ class Nextcloud:
                 raise "Could not find the Root Directory"
         return self._root
 
-    def nxc_list_files_and_folders(self):
+    def nxc_list_files_and_folders(self, get_selectable=False):
+
+        selectable_folders = []
 
-        def _list_rec(item):
+        def recursive_list(item, depth=0):
             items = []
             for d in item.list():
                 if d.isdir():
-                    children = _list_rec(d)
+                    children = recursive_list(d, depth=depth + 1)
+                    contains_xml = any(
+                        f.get("name", "").endswith(".xml") for f in children
+                    )
+                    item = {
+                        "type": "folder",
+                        "name": d.basename(),
+                        "depth": depth,
+                        "path": d.get_relative_path(),
+                        "contains_xml": contains_xml,
+                        "children": {
+                            "count": len(children),
+                            "list": children,
+                        },
+                    }
+                    items.append(item)
+                    if contains_xml:
+                        selectable_folders.append(item)
+                else:
                     items.append(
                         {
-                            "type": "folder",
+                            "type": "file",
                             "name": d.basename(),
-                            "path": d.get_relative_path(),
-                            "children": {
-                                "count": len(children),
-                                "list": children,
-                            },
+                            "depth": depth,
                         }
                     )
-                else:
-                    items.append({"type": "file", "name": d.basename()})
             return items
 
-        return _list_rec(self.root)
+        result = recursive_list(self.root)
+        if get_selectable:
+            return selectable_folders
+        else:
+            return result
+
+    def get_selectable_folders(self):
+
+        return self.nxc_list_files_and_folders(get_selectable=True)
 
     def download_nxc_files(self, file_paths, projectname):
         for path in file_paths:

tgp_backend/project.py

@@ -3,10 +3,15 @@
 # ralf.klammer@tu-dresden.de
 # moritz.wilhelm@tu-dresden.de
 import logging
+
+import json
 import os
 import subprocess
 
+from datetime import datetime
+
 from tg_model.collection import CollectionModeler  # type: ignore
+from tg_model.project import Project as ProjectHandler  # type: ignore
 from tg_model.tei import TEIParser  # type: ignore
 
 from tg_model.yaml import (  # type: ignore
@@ -16,91 +21,172 @@ from tg_model.yaml import (  # type: ignore
     ProjectConfig,
 )
 
+from tgp_backend.config import MAIN_PATH
 from tgp_backend.tgclient import TGclient
-from tgp_backend.util import config, list_files_and_folders
+from tgp_backend.util import (
+    list_files_and_folders,
+    get_selectable_folders,
+)
 
 log = logging.getLogger(__name__)
 
-MAIN_PATH = config("main", "path", default="./projects")
-
 
 class Project(object):
-    def __init__(self, projectname):
-        self.name = projectname
-        self.fullpath = f"{MAIN_PATH}/{projectname}"
-        self.datapath = f"{self.fullpath}/data"
-        self.metadatapath = f"{self.fullpath}/metadata"
-        self._main_config = None
+    def __init__(self, path):
+        self.path = path
+        self._project_config = None
         self._collections = None
         self._nextcloud = None
+        self.tgm_project = TGMProject(self.metadatapath)
+
+    @property
+    def name(self):
+        log.warning("Project.name is deprecated, use Project.path instead")
+        return self.path
+
+    @property
+    def fullpath(self):
+        return f"{MAIN_PATH}/{self.path}"
+
+    @property
+    def title(self):
+        return self.project_config.title
+
+    @property
+    def description(self):
+        return self.project_config.description
+
+    @property
+    def collectors(self):
+        return self.project_config.collectors
+
+    @property
+    def path_data(self):
+        return os.path.join(self.fullpath, "data")
+
+    @property
+    def path_metadata(self):
+        return os.path.join(self.fullpath, "metadata")
+
+    @property
+    def path_otherfiles(self):
+        return os.path.join(self.path_metadata, "other_files")
 
     def create(self):
         if not os.path.exists(self.fullpath):
             os.makedirs(self.fullpath)
-            os.makedirs(self.datapath)
-            os.makedirs(self.metadatapath)
+            os.makedirs(self.path_data)
+            os.makedirs(self.path_metadata)
         else:
             log.warning("Project already exists!")
 
+    @property
+    def avatar(self):
+        if self.project_config.avatar:
+            return os.path.join(
+                self.path_otherfiles, self.project_config.avatar
+            )
+
+    @property
+    def xslt(self):
+        if self.project_config.xslt:
+            return os.path.join(self.path_otherfiles, self.project_config.xslt)
+
+    def save_avatar(self, file):
+        if file.filename and file.filename != "":
+            file.save(os.path.join(self.path_otherfiles, file.filename))
+            self.project_config.avatar = file.filename
+
+    def save_xslt(self, file):
+        if file.filename and file.filename != "":
+            file.save(os.path.join(self.path_otherfiles, file.filename))
+            self.project_config.xslt = file.filename
+
+    def clear_xslt(self):
+        self.project_config.xslt = None
+        self.project_config.save()
+
+    def update(self, title, description, collectors, avatar, xslt):
+        self.project_config.title = title
+        self.project_config.description = description
+        self.project_config.collectors = collectors
+
+        if avatar:
+            self.save_avatar(avatar)
+        self.save_xslt(xslt)
+
+        self.project_config.save()
+
     def clone_git_project(self, url):
         repo_name = url.split("/")[-1].replace(".git", "")
-        repo_path = os.path.join(self.datapath, repo_name)
+        repo_path = os.path.join(self.path_data, repo_name)
 
         if not os.path.exists(repo_path):
             subprocess.run(["git", "clone", url, repo_path])
         else:
-            log.warning("Repository already exists!")
+            log.info("Repository already exists!")
 
     def file_upload(self, files):
         for file in files:
             if file:
                 filename = file.filename
-                filepath = os.path.join(self.datapath, filename)
+                filepath = os.path.join(self.path_data, filename)
                 directory = os.path.dirname(filepath)
                 if not os.path.exists(directory):
                     os.makedirs(directory)
                 file.save(filepath)
 
     def list_files_and_folders(self):
-        print(self.datapath)
-        return list_files_and_folders(self.datapath)
+        return list_files_and_folders(self.path_data)
+
+    def get_selectable_folders(self):
+        selectable_folders = get_selectable_folders(self.path_data)
+        for folder in selectable_folders:
+            folder["relative_path"] = folder["path"].replace(
+                self.path_data, ""
+            )
+        return selectable_folders
 
     @property
     def main_config(self):
-        if not self._main_config:
-            self._main_config = ProjectConfig(projectpath=self.metadatapath)
-        return self._main_config
-
-    @main_config.setter
-    def main_config(self, tei_directories):
-        self._main_config = ProjectConfigTemplate(self.metadatapath).render(
-            tei_directories=tei_directories
+        log.warning(
+            "Project.main_config is deprecated, use Project.project_config instead"
         )
+        return self.project_config
 
-    def init_configs(self, tei_directories):
-        if not self.main_config.exists():
-            self.main_config = tei_directories
-        else:
-            self.main_config.update(tei_directories=tei_directories)
-            # for tei_dir in tei_directories:z
-            #     # if not self.main_config.get_subproject(inpath=tei_dir):
-            #     break
-        self._set_collections()
+    @property
+    def project_config(self):
+        if not self._project_config:
+            self._project_config = ProjectConfig(
+                projectpath=self.path_metadata
+            )
+            if not self._project_config.exists():
+                self._project_config = ProjectConfigTemplate(
+                    self.path_metadata
+                ).render()
+                self._project_config.title = self.path
+                self._project_config.save()
+
+        return self._project_config
+
+    @property
+    def project_handler(self):
+        return ProjectHandler(self.path_metadata)
 
     def get_subproject_inpath(self, name):
-        for subproject in self.main_config.content["subprojects"]:
+        for subproject in self.project_config.content["subprojects"]:
             if subproject["name"] == name:
                 return subproject["inpath"]
         return None
 
     def _set_collections(self):
         self._collections = {}
-        if self.main_config.exists():
-            for subproject in self.main_config.content["subprojects"]:
+        if self.project_config.exists():
+            for subproject in self.project_config.content["subprojects"]:
                 collection_config = CollectionConfig(subproject["basepath"])
                 if not collection_config.exists():
                     collection_config = CollectionConfigTemplate(
-                        projectpath=self.metadatapath,
+                        projectpath=self.path_metadata,
                         subproject=subproject,
                         files=[
                             TEIParser(fullpath=file)
@@ -113,7 +199,7 @@ class Project(object):
                     "paths": subproject,
                     "parser": CollectionParser(collection_config),
                     "modeler": CollectionModeler(
-                        subproject, self.metadatapath
+                        subproject, self.path_metadata
                     ),
                 }
 
@@ -132,6 +218,49 @@ class Project(object):
     def get_tgp(self, instance):
         return TGProject(self, instance)
 
+    def _save_validation_results(self, results, filepath):
+        """
+        Saves the validation results to a JSON file.
+        Adds the date of the last execution.
+        """
+        results["last_run"] = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(results, f, indent=4, ensure_ascii=False)
+
+        log.info(f"Validation results saved to {filepath}")
+
+    def _run_validation(self):
+        validation_results = self.project_handler.validate()
+        self._save_validation_results(validation_results, self.validation_file)
+        return validation_results
+
+    @property
+    def validation_file(self):
+        """
+        Returns the path to the validation results file.
+        """
+        return os.path.join(self.path_metadata, "validation_results.json")
+
+    def get_validation_results(self, refresh=False):
+        """
+        Returns stored validation results.
+        If no results are saved or `refresh=True`, a new validation will
+        be performed.
+        """
+        # If `refresh` is set or file doesn't exist, perform new validation
+        if refresh or not os.path.exists(self.validation_file):
+            validation_results = self._run_validation()
+        else:
+            # Load results from file
+            with open(self.validation_file, "r", encoding="utf-8") as f:
+                validation_results = json.load(f)
+
+        if "ready_for_publication" not in validation_results:
+            validation_results = self._run_validation()
+
+        return validation_results
+
 
 class TGProject(object):
 
@@ -141,7 +270,7 @@ class TGProject(object):
         else:
             self.project = Project(project)
         self.instance = instance
-        self.main_config = self.project.main_config
+        self.project_config = self.project.project_config
         self.collections = self.project.collections
         self._tg_client = None
         self._tg_session_id = None
@@ -150,7 +279,7 @@ class TGProject(object):
     @property
     def tg_session_id(self):
         if not self._tg_session_id:
-            self._tg_session_id = self.main_config.get_tg_session_id(
+            self._tg_session_id = self.project_config.get_tg_session_id(
                 self.instance
             )
         return self._tg_session_id
@@ -158,12 +287,12 @@ class TGProject(object):
     @tg_session_id.setter
     def tg_session_id(self, session_id):
         self._tg_session_id = session_id
-        self.main_config.set_tg_session_id(session_id, self.instance)
+        self.project_config.set_tg_session_id(session_id, self.instance)
 
     @property
     def tg_project_id(self):
         if not self._tg_project_id:
-            self._tg_project_id = self.main_config.get_tg_project_id(
+            self._tg_project_id = self.project_config.get_tg_project_id(
                 self.instance
             )
         return self._tg_project_id
@@ -171,7 +300,7 @@ class TGProject(object):
     @tg_project_id.setter
     def tg_project_id(self, project_id):
         self._tg_project_id = project_id
-        self.main_config.set_tg_project_id(project_id, self.instance)
+        self.project_config.set_tg_project_id(project_id, self.instance)
 
     @property
     def tg_client(self):
@@ -206,22 +335,21 @@ class TGProject(object):
         if self.tg_session_id:
             return self.tg_client.get_project_content(project_id).hits
 
-    def publish_tg_project(self, instance="test"):
+    def upload_tg_project(self, instance="test"):
         if not self.tg_session_id:
             return False
 
         # step 1: create required metadata
-        for c_name in self.collections:
-            collection = self.collections[c_name]
-            collection["modeler"].render_collection()
+        self.project.tgm_project.render_project()
 
         # step 2: push project to textgrid server
         for collection_name in self.collections:
             collection = self.collections[collection_name]
-            self.tg_client.put_aggregation(
-                self.tg_project_id,
-                collection["modeler"].get_collection_path(),
-            )
+            print(collection["modeler"].get_collection_path())
+            # self.tg_client.put_aggregation(
+            #     self.tg_project_id,
+            #     collection["modeler"].get_collection_path(),
+            # )
 
 
 class CollectionParser(object):
@@ -247,7 +375,6 @@ class CollectionParser(object):
         results = []
         for element in self.elements:
             result = element["tei_parser"].find(xpath)
-            print(result)
             if result is not None:
                 results.append(
                     {