esgvoc 0.1.2__py3-none-any.whl

esgvoc/core/service/data_merger.py

@@ -0,0 +1,83 @@
+
+from typing import Dict, List, Set
+from esgvoc.core.data_handler import JsonLdResource
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def merge_dicts(original: list, custom: list) -> dict:
+    """Shallow merge: Overwrites original data with custom data."""
+    b = original[0]
+    a = custom[0]    
+    merged = {**{k: v for k, v in a.items() if k != "@id"}, **{k: v for k, v in b.items() if k != "@id"}}
+    return merged
+
+def merge(uri:str)->Dict:
+    mdm = DataMerger(data=JsonLdResource(uri=uri))
+    return mdm.merge_linked_json()[-1]
+
+class DataMerger:
+    def __init__(self, data: JsonLdResource, allowed_base_uris: Set[str]={"https://espri-mod.github.io/mip-cmor-tables"}, locally_available:dict = {}):
+        self.data = data
+        self.allowed_base_uris = allowed_base_uris
+        self.locally_available = locally_available
+
+    def _should_resolve(self, uri: str) -> bool:
+        """Check if a given URI should be resolved based on allowed URIs."""
+        return any(uri.startswith(base) for base in self.allowed_base_uris)
+
+    def _get_next_id(self, data: dict) -> str | None:
+        """Extract the next @id from the data if it is a valid customization reference."""
+        if isinstance(data,list):
+            data = data[0]
+        if "@id" in data and self._should_resolve(data["@id"]):
+            return data["@id"] + ".json" 
+        return None
+
+    def merge_linked_json(self) -> List[Dict]:
+        """Fetch and merge data recursively, returning a list of progressively merged Data json instances."""
+        result_list = [self.data.json_dict]  # Start with the original json object
+        visited = set(self.data.uri)  # Track visited URIs to prevent cycles
+        current_data = self.data
+        #print(current_data.expanded)
+
+        while True:
+            next_id = self._get_next_id(current_data.expanded[0])
+            if not next_id or next_id in visited or not self._should_resolve(next_id):
+                break
+            visited.add(next_id)
+
+            # Fetch and merge the next customization
+            #do we have it in local ? if so use it instead of remote 
+            for local_repo in self.locally_available.keys():
+                if next_id.startswith(local_repo):
+                    next_id = next_id.replace(local_repo,self.locally_available[local_repo])
+            next_data_instance = JsonLdResource(uri=next_id)
+            merged_json_data = merge_dicts([current_data.json_dict], [next_data_instance.json_dict])
+            next_data_instance.json_dict = merged_json_data
+
+            # Add the merged instance to the result list
+            result_list.append(merged_json_data)
+            current_data = next_data_instance
+
+        return result_list
+
+if __name__ == "__main__":
+    import warnings
+    warnings.simplefilter("ignore")
+
+    # test from institution_id ipsl exapnd and merge with institution ipsl
+    # proj_ipsl = JsonLdResource(uri = "https://espri-mod.github.io/CMIP6Plus_CVs/institution_id/ipsl.json")
+    # allowed_uris = {"https://espri-mod.github.io/CMIP6Plus_CVs/","https://espri-mod.github.io/mip-cmor-tables/"}
+    # mdm = DataMerger(data =proj_ipsl, allowed_base_uris = allowed_uris)
+    #     json_list = mdm.merge_linked_json()
+    #
+    # pprint([res for res in json_list])
+
+    # a = JsonLdResource(uri = ".cache/repos/CMIP6Plus_CVs/institution_id/ipsl.json")
+    # mdm = DataMerger(data=a)
+    # print(mdm.merge_linked_json())
+    #
+    #
+    

esgvoc/core/service/esg_voc.py

@@ -0,0 +1,79 @@
+
+import logging
+import os
+from rich.logging import RichHandler
+from rich.console import Console
+import shutil
+import esgvoc.core.service as service 
+
+_LOGGER = logging.getLogger(__name__)
+
+rich_handler = RichHandler(rich_tracebacks=True)
+_LOGGER.addHandler(rich_handler)
+
+
+def reset_init_repo():
+    service_settings = service.service_settings 
+    if (service_settings.universe.local_path) and os.path.exists(service_settings.universe.local_path):
+        shutil.rmtree(service_settings.universe.local_path)
+
+    for _, proj in service_settings.projects.items():    
+        if (proj.local_path) and os.path.exists(proj.local_path):
+            shutil.rmtree(proj.local_path)
+    service.state_service.get_state_summary()
+
+def reset_init_db():
+    service_settings = service.service_settings 
+    if (service_settings.universe.db_path) and os.path.exists(service_settings.universe.db_path):
+        os.remove(service_settings.universe.db_path)
+    for _, proj in service_settings.projects.items():    
+        if (proj.db_path) and os.path.exists(proj.db_path):
+            os.remove(proj.db_path)
+    service.state_service.get_state_summary()
+
+def reset_init_all():
+    reset_init_db()
+    reset_init_repo()
+
+def display(table):
+    console = Console(record=True,width=200)
+    console.print(table)
+
+def install():
+    service.state_service.synchronize_all()
+
+
+
+
+
+
+if __name__ == "__main__":
+
+    def Nothing(): # IT WORKS
+        reset_init_all()
+        display(service.state_service.table())
+        service.state_service.universe.sync()
+        display(service.state_service.table())
+        for _,proj in service.state_service.projects.items():
+            proj.sync()
+        display(service.state_service.table())
+   
+    def OnlyLocal(): #IT ALSO WORKS
+        reset_init_db()
+        service.state_service.universe.github_access = False
+        for _,proj in service.state_service.projects.items():
+            proj.github_access = False
+        display(service.state_service.table())
+
+        service.state_service.universe.sync()
+        display(service.state_service.table())
+        for _,proj in service.state_service.projects.items():
+            proj.sync()
+        display(service.state_service.table())
+
+    # TODO Some other test to do to be complete:
+    # Change the settings ... for now .. let say nobody change the settings ! 
+
+    OnlyLocal()
+    # service.state_service.synchronize_all()
+    

esgvoc/core/service/settings.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel, Field
+from typing import Dict, Optional
+from pathlib import Path
+import toml
+
+
+SETTINGS_FILE = Path(__file__) / "settings.toml"
+
+class ProjectSettings(BaseModel):
+    project_name: str
+    github_repo: str
+    branch: Optional[str] = "main"
+    local_path: Optional[str] = None
+    db_path: Optional[str] = None
+
+class UniverseSettings(BaseModel):
+    github_repo: str
+    branch: Optional[str] = None
+    local_path: Optional[str] = None
+    db_path: Optional[str] = None
+
+class ServiceSettings(BaseModel):
+    universe: UniverseSettings
+    projects: Dict[str, ProjectSettings] = Field(default_factory=dict)
+
+    @classmethod
+    def load_from_file(cls, file_path: str) -> "ServiceSettings":
+        data = toml.load(file_path)
+        projects = {p['project_name']: ProjectSettings(**p) for p in data.pop('projects', [])}
+        return cls(universe=UniverseSettings(**data['universe']), projects=projects)
+
+    def save_to_file(self, file_path: str):
+        data = {
+            "universe": self.universe.model_dump(),
+            "projects": [p.model_dump() for p in self.projects.values()]
+        }
+        with open(file_path, "w") as f:
+            toml.dump(data, f)
+
+def load_settings() -> ServiceSettings:
+    """Load the settings from the TOML file."""
+    if SETTINGS_FILE.exists():
+        return ServiceSettings.load_from_file(str(SETTINGS_FILE))
+    else:
+        default_settings = ServiceSettings(
+        universe=UniverseSettings(
+            github_repo="https://github.com/ESPRI-Mod/mip-cmor-tables",
+            branch="uni_proj_ld",
+            local_path=".cache/repos/mip-cmor-tables",
+            db_path=".cache/dbs/universe.sqlite"
+        ),
+        projects={"cmip6plus":ProjectSettings(
+                project_name="CMIP6Plus_CVs",
+                github_repo="https://github.com/ESPRI-Mod/CMIP6Plus_CVs",
+                branch="uni_proj_ld",
+                local_path=".cache/repos/CMIP6Plus_CVs",
+                db_path=".cache/dbs/cmip6plus.sqlite"
+                )
+            }
+        
+    )
+
+        default_settings.save_to_file(str(SETTINGS_FILE))
+        return default_settings

esgvoc/core/service/settings.toml

@@ -0,0 +1,12 @@
+[[projects]]
+project_name = "cmip6plus"
+github_repo = "https://github.com/ESPRI-Mod/CMIP6Plus_CVs"
+branch = "uni_proj_ld"
+local_path = ".cache/repos/CMIP6Plus_CVs"
+db_path = ".cache/dbs/cmip6plus.sqlite"
+
+[universe]
+github_repo = "https://github.com/ESPRI-Mod/mip-cmor-tables"
+branch = "uni_proj_ld"
+local_path = ".cache/repos/mip-cmor-tables"
+db_path = ".cache/dbs/universe.sqlite"

esgvoc/core/service/settings_default.toml

@@ -0,0 +1,20 @@
+
+# [[projects]]
+# project_name = "TestProject"
+# github_repo = "XXX"
+# branch = "XXX"
+# local_path = "XXX"
+# db_path = "./cache/dbs/XXXX.sqlite"
+
+[[projects]]
+project_name = "cmip6plus"
+github_repo = "https://github.com/ESPRI-Mod/CMIP6Plus_CVs"
+branch = "uni_proj_ld"
+local_path = ".cache/repos/CMIP6Plus_CVs"
+db_path = ".cache/dbs/cmip6plus.sqlite"
+
+[universe]
+github_repo = "https://github.com/ESPRI-Mod/mip-cmor-tables"
+branch = "uni_proj_ld"
+local_path = ".cache/repos/mip-cmor-tables"
+db_path = ".cache/dbs/universe.sqlite"

esgvoc/core/service/state.py

@@ -0,0 +1,222 @@
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from esgvoc.core.repo_fetcher import RepoFetcher
+from esgvoc.core.service.settings import UniverseSettings, ProjectSettings, ServiceSettings
+from esgvoc.core.db.connection import DBConnection
+
+from rich.table import Table
+from sqlalchemy.exc import NoResultFound
+from sqlmodel import select
+from esgvoc.core.db.models.universe import Universe
+from esgvoc.core.db.models.project import Project
+
+logger = logging.getLogger(__name__)
+
+class BaseState:
+    def __init__(self, github_repo: str, branch: str = "main", local_path: Optional[str] = None, db_path: Optional[str] = None):
+    
+        self.github_repo = github_repo
+        self.branch = branch
+        self.github_access = True # False if we dont have internet and some other cases 
+        self.github_version = None
+        
+        self.local_path = local_path
+        self.local_access = True # False if we dont have cloned the remote repo yet
+        self.local_version = None
+        
+        self.db_path = db_path
+        self.db_access = True  # False if we cant access the db for some reason
+        self.db_version = None
+        
+        self.rf = RepoFetcher()
+        self.db_connection:DBConnection|None = None
+        self.db_sqlmodel = None
+    
+    def fetch_version_local(self):
+         if self.local_path:
+            try:
+                self.local_version = self.rf.get_local_repo_version(self.local_path, self.branch)
+                logger.debug(f"Local repo commit: {self.local_version}")
+                self.local_access = True
+            except Exception as e:
+                logger.exception(f"Failed to fetch local repo version: {e}")
+                self.local_access=False
+
+    def fetch_version_remote(self):
+        if self.github_repo:
+            owner = None
+            repo = None
+            try:
+                owner, repo = self.github_repo.lstrip("https://github.com/").split("/")
+                self.github_version = self.rf.get_github_version(owner, repo, self.branch) 
+                self.github_access = True
+                logger.debug(f"Latest GitHub commit: {self.github_version}")
+            except Exception as e:
+                logger.exception(f"Failed to fetch GitHub version: {e} ,for {self.github_repo},owner : {owner}, repo : {repo},branch : {self.branch}")
+                self.github_access = False
+            if self.github_version is None:
+                self.github_access = False
+
+    def fetch_version_db(self):
+        if self.db_path:
+            if not os.path.exists(self.db_path):
+                self.db_version = None
+                self.db_access = False
+            else:
+                try:
+                    self.db_connection =DBConnection(db_file_path= Path(self.db_path)) 
+                    with self.db_connection.create_session() as session:
+                        self.db_version = session.exec(select(self.db_sqlmodel.git_hash)).one()
+                        self.db_access = True
+                except NoResultFound :
+                    logger.debug(f"Unable to find git_hash in {self.db_path}")
+                except Exception as e:
+                    logger.debug(f"Unable to find git_has in {self.db_path} cause {e}" )
+
+        else:
+            self.db_version = None
+            self.db_access = False
+
+
+    def fetch_versions(self):
+        self.fetch_version_remote()
+        self.fetch_version_local()
+        self.fetch_version_db()
+              
+    def check_sync_status(self):
+        self.fetch_versions()
+        return {
+            "github_local_sync": self.github_version == self.local_version if self.github_access and self.github_version and self.local_version else None,
+            "local_db_sync": self.local_version == self.db_version if self.local_access and self.local_version and self.db_version else None,
+
+            "github_db_sync": self.github_version == self.db_version if self.github_access and self.github_version and self.db_version else None
+        }
+
+    def clone_remote(self):
+        owner, repo = self.github_repo.lstrip("https://github.com/").split("/")
+        #TODO add destination "local_path" in clone_repo 
+        self.rf.clone_repository(owner, repo, self.branch)
+        self.fetch_version_local()
+
+    
+    def build_db(self):
+        from esgvoc.core.db.project_ingestion import ingest_project
+        from esgvoc.core.db.universe_ingestion import ingest_metadata_universe
+        from esgvoc.core.db.models.project import project_create_db
+        from esgvoc.core.db.models.universe import universe_create_db 
+        from esgvoc.core.db.universe_ingestion import ingest_universe
+
+        if self.db_path :
+            if os.path.exists(self.db_path):
+                os.remove(self.db_path)
+            else:
+                os.makedirs(Path(self.db_path).parent,exist_ok=True)
+
+            if self.db_sqlmodel == Universe: # Ugly 
+                universe_create_db(Path(self.db_path))
+                ingest_metadata_universe(DBConnection(Path(self.db_path)),self.local_version)
+                ingest_universe(Path(self.local_path), Path(self.db_path))
+
+            elif self.db_sqlmodel == Project:
+                project_create_db(Path(self.db_path))
+                ingest_project(Path(self.local_path),Path(self.db_path),self.local_version)
+        self.fetch_version_db()
+
+
+
+
+        
+
+    def sync(self):
+        summary = self.check_sync_status()
+        if self.github_access and summary["github_db_sync"] is None and summary["local_db_sync"]is None and summary["github_local_sync"] is None:
+            self.clone_remote()
+            self.build_db()
+        elif self.github_access and not summary["github_db_sync"]:
+            if not summary["local_db_sync"] and summary["local_db_sync"] is not None:
+                self.clone_remote()
+                self.build_db()
+            else: # can be simply build in root and clone if neccessary
+                self.build_db()
+        elif self.local_access:
+            if not summary["local_db_sync"] and summary is not None:
+                self.build_db()
+        elif not self.db_access: # it can happen if the db is created but not filled
+            self.build_db()
+        
+
+        """
+        if self.github_version and self.github_version != self.local_version:
+            owner, repo = self.github_repo.lstrip("https://github.com/").split("/")
+            self.rf.clone_repository(owner, repo, self.branch)
+            #self.fetch_versions()
+
+        if self.local_version != self.db_version:
+            # delete and redo the DB? 
+            pass
+        """
+class StateUniverse(BaseState):
+    def __init__(self, settings: UniverseSettings):
+        super().__init__(**settings.model_dump())
+        self.db_sqlmodel=Universe
+
+class StateProject(BaseState):
+    def __init__(self, settings: ProjectSettings):
+        mdict = settings.model_dump()
+        self.project_name = mdict.pop("project_name")
+        super().__init__(**mdict)
+        self.db_sqlmodel = Project
+
+class StateService:
+    def __init__(self, service_settings: ServiceSettings):
+        self.universe= StateUniverse(service_settings.universe)
+        self.projects = {name: StateProject(proj) for name, proj in service_settings.projects.items()}
+        self.connect_db()
+        
+    def get_state_summary(self):
+        universe_status = self.universe.check_sync_status()
+        project_statuses = {name: proj.check_sync_status() for name, proj in self.projects.items()}
+        return {"universe": universe_status, "projects": project_statuses}
+
+    def connect_db(self):
+        self.universe.fetch_versions()
+        for _,proj_state in self.projects.items():
+            proj_state.fetch_versions()
+
+    def synchronize_all(self):
+        self.universe.sync()
+        for project in self.projects.values():
+            project.sync()
+    def table(self):
+        table = Table(show_header=False, show_lines=True)
+        table.add_row("","Remote github repo","Local repository","Cache Database")
+        table.add_row("Universe path",self.universe.github_repo,self.universe.local_path,self.universe.db_path)
+        table.add_row("Version",self.universe.github_version,self.universe.local_version,self.universe.db_version)
+        for proj_name,proj in self.projects.items():
+
+            #table.add_row("","Remote github repo","Local repository","Cache Database")
+            table.add_row(f"{proj_name} path",proj.github_repo,proj.local_path,proj.db_path)
+            table.add_row("Version",proj.github_version,proj.local_version,proj.db_version)
+        return table
+
+if __name__ == "__main__":
+    # Load settings from file
+    service_settings = ServiceSettings.load_from_file("src/esgvoc/core/service/settings.toml")
+    
+    # Initialize StateService
+    state_service = StateService(service_settings)
+    state_service.get_state_summary()
+
+    # Synchronize all
+    state_service.synchronize_all()
+
+    # pprint(state_service.universe.github_version)
+    # pprint(state_service.universe.local_version)
+    # pprint(state_service.universe.db_version)
+
+    
+    # Check for differences
+    #pprint(state_service.find_version_differences())

esgvoc-0.1.2.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.3
+Name: esgvoc
+Version: 0.1.2
+Summary: python library and CLI to interact with WCRP CV
+Project-URL: Repository, https://github.com/ESPRI-Mod/cmipld
+Author-email: TROUSSELLIER Laurent <laurent.troussellier@ipsl.fr>, Gardoll Sébastien <sebastien@gardoll.fr>
+Requires-Python: >=3.12
+Requires-Dist: idna>=3.10
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: pyld>=2.0.4
+Requires-Dist: requests>=2.32.3
+Requires-Dist: sqlalchemy>=2.0.36
+Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: toml>=0.10.2
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+
+# Esgvoc Library
+
+Esgvoc is a Python library designed to simplify interaction with controlled vocabularies (CVs) used in climate data projects. It supports querying, caching, and validating terms across various CV repositories like the Universe and project-specific repositories (e.g., CMIP6Plus).
+
+---
+
+## Features
+
+- **Query controlled vocabularies**:
+  - Retrieve terms, collections, or descriptors.
+  - Perform cross-validation and search operations.
+
+- **Caching**:
+  - Download CVs to a local database for offline use.
+  - Keep the local cache up-to-date.
+
+- **Validation**:
+  - Validate strings against CV terms and templates.
+  - Supports case-sensitive, wildcard, and approximate matching.
+
+---
+
+## Installation
+
+Esgvoc is available on PyPI. Install it with pip:
+
+```bash
+pip install esgvoc
+```
+
+in order to get the latest possible CV 
+
+
+```bash
+esgvoc install
+```

esgvoc-0.1.2.dist-info/RECORD

@@ -0,0 +1,66 @@
+esgvoc/__init__.py,sha256=kPejgt5LFlzacS1O0vGN5JC7AlpRpWCmGIHUcBr_6-M,35
+esgvoc/api/__init__.py,sha256=yjrmVpHAR5_OChzzWziebIeUYh_6qyXBJx3VUimaFkE,2933
+esgvoc/api/_utils.py,sha256=eIVP7d3jbr7u_LNliLoM2Up3Zl5rcxIw_hjqLdfaxUA,1390
+esgvoc/api/projects.py,sha256=JZuqDTeAv7GcJ4IclyHU1bKWrGdqGafvxQAJ8fgux-8,38629
+esgvoc/api/report.py,sha256=MFMN9oVG9WWRvPtBeQj4o7XDahPu-Fq302Qy2G8Qt2Q,2875
+esgvoc/api/search.py,sha256=JYTegv0ebdm8AqK8V6DccPR88K2vWVtHXnstJmG07xE,3501
+esgvoc/api/universe.py,sha256=YGphsws7iSQZKYfRx4XfiZOuBylc0HYFG2KItsjyVjM,9609
+esgvoc/api/data_descriptors/__init__.py,sha256=K-qzokgt3bdiwSJcnBzAub4Duw87cHTX9VdF-RU-pQ8,2910
+esgvoc/api/data_descriptors/activity.py,sha256=o-RlmAFJkIb9TkUZIjEJaHi9dnQ70GHH5-5bKACRwMI,1371
+esgvoc/api/data_descriptors/consortium.py,sha256=fhAaEqxBpBDSmO7rIya1nnEz9aRyhQQFnIBExcyQxQM,1467
+esgvoc/api/data_descriptors/date.py,sha256=q4YXqaEryrcXO3ndk4SwyKwn56iGuBiJbHs8JSUpXJU,781
+esgvoc/api/data_descriptors/experiment.py,sha256=DCPYhgGWgD7LKgheqreXKGd5_0pQ6a1GnJ17IDt5WXY,1838
+esgvoc/api/data_descriptors/forcing_index.py,sha256=m2SBobNTN8P_TFS-uIwMyqbJ9d6CNr21bzW7qT3MVe0,796
+esgvoc/api/data_descriptors/frequency.py,sha256=XIu1v5NIcaNKj-9K3WNa4jH_Lds5XO5CP4M79nNVuVE,842
+esgvoc/api/data_descriptors/grid_label.py,sha256=i7bZJv_Y1s8gx2TR5D02i3Xify1rMu9lXRAwvYRugEY,846
+esgvoc/api/data_descriptors/initialisation_index.py,sha256=TtxvKO0IaD4ZEzm6LKCqKEaRYFHtLyTKo4UGj4kL9fI,809
+esgvoc/api/data_descriptors/institution.py,sha256=sr4pgTrNIEnl_GcaJeNndsYfYXSMKwFybzZDquD0qdM,1316
+esgvoc/api/data_descriptors/license.py,sha256=4hQiAQoBbecYZbApAzr2mnR8063yL13j7b_VSKgkIhA,933
+esgvoc/api/data_descriptors/mip_era.py,sha256=P7Vyen9uFCoOhh4qooPy-hDJ_jcP-1ISl25cmZBC9KI,824
+esgvoc/api/data_descriptors/model_component.py,sha256=WGsv_bd5TrNeyBx1a6f-wjXRXDMMf5C5hyJtTknjk68,864
+esgvoc/api/data_descriptors/organisation.py,sha256=dyB2l1lYDb3SMCuO4Ptsz9gImooeD3fqaTr6Ih2N_vg,855
+esgvoc/api/data_descriptors/physic_index.py,sha256=S_G-0hrbbGFqWj0xks6kAIwKkjPYRrRCDHaeZqvOdYk,794
+esgvoc/api/data_descriptors/product.py,sha256=rYhmSZy5vPwzZ2ZYIQXkoW5E-FeG8lAS_1lPaU7sDtg,805
+esgvoc/api/data_descriptors/realisation_index.py,sha256=spmDj6fBYfnqFiTJRH_OHJbm9gRmq-QqEvt1UJMXwl8,805
+esgvoc/api/data_descriptors/realm.py,sha256=GAebWcwyR48EyZiuapLD8eZxYEv3oGQ6Cndeho0DVAs,799
+esgvoc/api/data_descriptors/resolution.py,sha256=70eg9lAYGFS7Qws5mL2QwrU9N7tleA0YQp-V5ZIMj0E,841
+esgvoc/api/data_descriptors/source.py,sha256=1wWZY63NXk-8b3io8OYdsaZpVaXHS1d-M1bBhf54Ysc,1898
+esgvoc/api/data_descriptors/source_type.py,sha256=1GRDoFun3ncRLcAhjRvl3OgGL2ieq7Cv8v1_hcI60BU,793
+esgvoc/api/data_descriptors/sub_experiment.py,sha256=Z-GxS96201hIYtDgGnymHpkpKt16xjvk4QQnY_vSjr0,799
+esgvoc/api/data_descriptors/table.py,sha256=bhh-bSx7UYAAETmMAGNOIfwkyvywIhX0HlJh9a2njV0,1009
+esgvoc/api/data_descriptors/time_range.py,sha256=bBVRwmc7NEeGacV-UA0vadQXsyrlwBjyjVoYTw26rYA,630
+esgvoc/api/data_descriptors/variable.py,sha256=2Y6MfDzRvLF3FR5bhhJ6jTmPc2NTZVsoGF1Y2SEGeLU,2145
+esgvoc/api/data_descriptors/variant_label.py,sha256=ExP68t3v1xtjFEjOgVr2NFEOkQVGmf9GzStRlSPmNMU,931
+esgvoc/apps/drs/__init__.py,sha256=uNkxKa7wbUAHlldtrCxTZraJJ2Y9NQEdpWTy-lLrGAY,562
+esgvoc/apps/drs/models.py,sha256=ZWTXkgMKTCvMkmOB2c-l_npl_9ph0qXewa0e5J02mAI,937
+esgvoc/apps/drs/parser.py,sha256=DlCnVn0cguu5_I-gKinw_Hd_gomfET90AqMlZlawVz8,734
+esgvoc/cli/config.py,sha256=JCUppLaMPO6Xa3pZ-RL-meWy4wwTw1hr_IJM3LL1vac,2877
+esgvoc/cli/get.py,sha256=60W-MSrIUvQkAmGB2HXr2qGKYbel-_IKDL5N_uEIr8Y,5122
+esgvoc/cli/install.py,sha256=tJl9Z9UoBbRXK8dMAehTTHfH9aT6fAqtEX7tt5Wl0F8,236
+esgvoc/cli/main.py,sha256=jXJ9rNzI276cYJaZ8LxKBsblxHLw51_OK0_OyAGPe8A,490
+esgvoc/cli/status.py,sha256=_6Wx3bGzsoxv_Hv0ENO-NcFJzzzUpLTlsUlQH-E3d-o,465
+esgvoc/cli/valid.py,sha256=C_z1nrAP7mD3Iws0esVJsXpbiwjWZBtgXmikJruRRtY,7057
+esgvoc/core/constants.py,sha256=b9GoM3pTICki95gMCnUZbg4_mMiywKhJX5ME01pgwMs,431
+esgvoc/core/convert.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+esgvoc/core/data_handler.py,sha256=BmcD_dSvX5fCkUEGAQnadPTeuKA7IvgMmQtesMXKh5g,5004
+esgvoc/core/logging.conf,sha256=GK52lsTu17CfC2tKiMAIvkuHkIt5tqPmkWv68COOilc,278
+esgvoc/core/logging_handler.py,sha256=NhqKX2nFYVi01EhZPysFZ4UWBWJwgxafC_pWtd28YlU,115
+esgvoc/core/repo_fetcher.py,sha256=m0Qh2kBAa-ij2ZJ7uEYYW-CakoLs5deFHl7zniLgW5Y,9738
+esgvoc/core/db/__init__.py,sha256=gjAT_lUJtPqxsc8WnwbG_sxDqSIFAlG8vEKxdGyH82w,150
+esgvoc/core/db/connection.py,sha256=dhnCy1mwytUUvt149WHk7eYW0KSP64IaF3kMvKOQSJE,877
+esgvoc/core/db/project_ingestion.py,sha256=Sx63UhHjZ_2b5hkObDci2X7VB9f3DfU7-uKtqgl12Rk,6114
+esgvoc/core/db/universe_ingestion.py,sha256=weF8f4AUF20NHiDoUe8paQmxOpuNUe8QSTslEtOfKGA,5148
+esgvoc/core/db/models/mixins.py,sha256=M4gP42fydNcrZO9Z9wfKVU_1tK__fc2NosWumpU9lc0,291
+esgvoc/core/db/models/project.py,sha256=KHnVsaFbA67e28doJ4TFCDkW04x4Es-uv3fDL3WDup4,2349
+esgvoc/core/db/models/universe.py,sha256=32oWFvzqqFr86M14phbfvfmEzlldi3DSTAALjTigR_8,2199
+esgvoc/core/service/__init__.py,sha256=ByAE1LhD5cKIcwrSIH0Y___KP2Ewh55P57sAMQ4CHeM,308
+esgvoc/core/service/data_merger.py,sha256=GNFp5DTV2jlBVJZNpILngi6jCbUvVGcqka4EMWKj_Os,3456
+esgvoc/core/service/esg_voc.py,sha256=5G0P4_xmQzoI_RG_agpq-yHoYYZx220P27v2nPrpyNs,2420
+esgvoc/core/service/settings.py,sha256=oNA4BKgZopxLA51R2PlRJ9rpqHgOqhGWLx-pffVUOlk,2160
+esgvoc/core/service/settings.toml,sha256=XzcnD3l4xk5UXNxgod7uSbQ_iYFn2CjyLvVPlQ88Edw,383
+esgvoc/core/service/settings_default.toml,sha256=lxHkuLn3T65SxWh5owxqREMQ88LwIgoQ85-5HaDVuRo,529
+esgvoc/core/service/state.py,sha256=RPzgGTPyhqizbDKSEHbPGmNRss7iSi_bZnDafJokrEI,9203
+esgvoc-0.1.2.dist-info/METADATA,sha256=GGTJeCE71fd-SDGePr6LkmRFkz2_0WfHpqMFfeMQ6-k,1456
+esgvoc-0.1.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+esgvoc-0.1.2.dist-info/entry_points.txt,sha256=ZXufSC7Jlx1lb52U6Buv9IitJMcqAAXOerR2V9DaIto,48
+esgvoc-0.1.2.dist-info/RECORD,,

esgvoc-0.1.2.dist-info/WHEEL

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

esgvoc-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+esgvoc = esgvoc.cli.main:main