ledgerdata 0.1.0.dev6__py3-none-any.whl

ledgerdata/__init__.py

@@ -0,0 +1,15 @@
+"""
+Set up module access for the base package
+"""
+
+from .actors import Actors
+from .client import Client
+from .datasource import Datasource
+from .emissions import Emissions
+from .gdp import GDP
+from .initiatives import Initiatives
+from .population import Population
+from .sector import Sector
+from .targets import Targets
+
+__all__ = ["GDP", "Actors", "Client", "Datasource", "Emissions", "Initiatives", "Population", "Sector", "Targets"]

ledgerdata/actors.py

@@ -0,0 +1,204 @@
+import warnings
+
+import httpx
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Actors(Base):
+    """Provides methods to retrieve actor and actor-part data from the LEDGER API."""
+
+    def get_all_actors(self, *args, **kwargs):
+        """Retrieve all actors.
+
+        Sends a GET request to the `/actors` endpoint and returns the response
+        as a JSON dictionary.
+
+        Returns:
+            dict: A JSON response containing actor data.
+        """
+        endpoint = "/actor"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        # Add query parameters as a dict
+        response = requests.get(url, headers=headers).json()
+        # data_list = response.get("data", None)
+        return response
+
+    def parts_of_actor(self, actor_id=str, type: str | None = None, *args, **kwargs):
+        """Retrieve parts (sub-actors) of a given actor.
+
+        Sends a GET request to the `/parts_of/{actor_id}` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            type (Optional[str]): Optional filter for part type.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        endpoint = f"/actor/{actor_id}/parts"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        params = {"type": type} if type else {}
+        response = requests.get(url, headers=headers, params=params).json()
+        # data_list = response.get("data", None)
+        return response
+
+    def population(self, actor_id=str, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/population` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        endpoint = f"/actor/{actor_id}/population"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+
+    def gdp(self, actor_id=str, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/gdp` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        endpoint = f"/actor/{actor_id}/gdp"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+
+    def energy_consumption(self, actor_id=str, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/energy_consumption` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        endpoint = f"/actor/{actor_id}/energy_consumption"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+
+    def targets(self, actor_id=str, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/targets` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        endpoint = f"/actor/{actor_id}/targets"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+
+    def emissions(self, actor_id=str, ignore_warnings: bool = False, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/emissions` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        (
+            warnings.simplefilter("ignore")
+            if ignore_warnings
+            else warnings.simplefilter("default")
+        )
+        endpoint = f"/actor/{actor_id}/emissions"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+
+
+    def emissions_total_sector(self, actor_id=str, ignore_warnings: bool = False, *args, **kwargs):
+        """Retrieve actor population
+
+        Sends a GET request to the `/actor/{actor_id}/emissions_total_sector` endpoint and returns
+        the response as a JSON dictionary.
+
+        Args:
+            actor_id (str): The code for the actor whose parts you want to retrieve.
+            *args: Additional positional arguments (currently unused).
+            **kwargs: Additional keyword arguments (currently unused).
+
+        Returns:
+            dict: A JSON response containing actor-part data.
+        """
+        (
+            warnings.simplefilter("ignore")
+            if ignore_warnings
+            else warnings.simplefilter("default")
+        )
+        endpoint = f"/actor/{actor_id}/emissions_total_sector"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response
+    
+    async def emissions_async(
+        self, actor_id: str, ignore_warnings: bool = False, *args, **kwargs
+    ):
+        """Retrieve actor emissions asynchronously."""
+        if ignore_warnings:
+            warnings.simplefilter("ignore")
+        else:
+            warnings.simplefilter("default")
+
+        endpoint = f"/actor/{actor_id}/emissions"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            return response.json()

ledgerdata/base.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+from pydantic import HttpUrl
+from pydantic.dataclasses import dataclass
+
+
+class Env(str, Enum):
+    dev = "dev"
+    prod = "prod"
+
+
+@dataclass
+class Base:
+    version: str = "/api/v0"
+    env: Env = Env.prod
+
+    def __post_init__(self):
+        urls = {
+            Env.dev: "http://127.0.0.1:8000",
+            Env.prod: "https://orca-app-5ivtt.ondigitalocean.app",
+        }
+        self.base_url: HttpUrl = urls[self.env]
+        self.server = f"{self.base_url}{self.version}"

ledgerdata/client.py

@@ -0,0 +1,225 @@
+import asyncio
+from dataclasses import dataclass
+
+import pandas as pd
+
+from .actors import Actors
+from .base import Base
+from .datasource import Datasource
+from .gwp import GWP
+from .initiatives import Initiatives
+from .sector import Sector
+
+
+@dataclass
+class Client(Base):
+    """ledgerdata client class
+
+    a high-level class to interact with the ledger database
+
+    Attributes:
+        version: str = API version (default "/api/v0)
+        env: str = "prod" for production server or "dev" for local development  (default "prod")
+    """
+
+    # Limit concurrency to 10 requests at once, adjust as needed
+    _sem = asyncio.Semaphore(10)
+
+    def get_all_actors(
+        self,
+    ) -> pd.DataFrame:
+        """retreive all actors
+
+        this method is used to retriece a dataframe of all actors and their codes
+
+        Returns:
+            DataFrame: data of all actors
+        """
+        return pd.DataFrame(Actors(env=self.env, version=self.version).get_all_actors())
+
+    def parts_of_actor(
+        self, actor_id: str, part_type: str | None = None, *args, **kwargs
+    ) -> pd.DataFrame:
+        """retreive actor parts
+
+        returns subnational, cities, companies, etc. within an actor_id
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+            part_type (str): retrieve actors from administrative part ['planet', 'country', 'adm1', 'adm2', 'city', 'organization', 'site']
+
+        Returns:
+            DataFrame: dataframe of actors parts
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).parts_of_actor(
+                actor_id=actor_id, type=part_type
+            )
+        )
+
+    def gwp(
+        self,
+        assessment_report=None,
+    ) -> pd.DataFrame:
+        """retreive global warming potentials
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+
+        Returns:
+            DataFrame: data for GWPs
+        """
+        return pd.DataFrame(
+            GWP(env=self.env, version=self.version).gwp(
+                assessment_report=assessment_report
+            )
+        )
+
+    def datasource(
+        self,
+        datasource_id=None,
+    ) -> pd.DataFrame:
+        """retrieve data sources
+
+        Args:
+            datasource_id (str|List[str]): code for datasource
+
+        Returns:
+            DataFrame: data for datasources
+        """
+        return pd.DataFrame(
+            Datasource(env=self.env, version=self.version).datasource(
+                datasource_id=datasource_id
+            )
+        )
+
+    def sector(self) -> pd.DataFrame:
+        """retrieve sectors
+
+        Returns:
+            DataFrame: data for sectors
+        """
+        return pd.DataFrame(Sector(env=self.env, version=self.version).sector())
+
+    def emissions(
+        self,
+        actor_id: str,
+    ) -> pd.DataFrame:
+        """retreive actor emissions
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).emissions(actor_id=actor_id)
+        )
+
+    
+    def emissions_total_sector(
+        self,
+        actor_id: str,
+    ) -> pd.DataFrame:
+        """retreive actor emissions by sector
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).emissions_total_sector(actor_id=actor_id)
+        )
+
+    def emissions_raw(
+        self,
+        actor_id: str,
+    ) -> pd.DataFrame:
+        """retreive actor emissions raw
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        return Actors(env=self.env, version=self.version).emissions(actor_id=actor_id)
+
+    def targets(self, actor_id: str) -> pd.DataFrame:
+        """retreive actor targets
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+
+        Returns:
+            DataFrame: dataframe of targets
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).targets(actor_id=actor_id)
+        )
+
+
+    def initiatives(self, initiative: str) -> pd.DataFrame:
+        """retrieve initiatives
+
+        Args:
+            initiative (str|List[str]): initiative namme
+
+        Returns:
+            DataFrame: dataframe of initiatives
+        """
+        return pd.DataFrame(
+            Initiatives(env=self.env, version=self.version).initiatives(initiative=initiative)
+        )
+    
+    def population(self, actor_id: str) -> pd.DataFrame:
+        """retreive actor population
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: dataframe of population
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).population(actor_id=actor_id)
+        )
+
+    def gdp(self, actor_id: str) -> pd.DataFrame:
+        """retreive actor gdp
+
+        Args:
+            actor_id (str|List[str]): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: dataframe of gdp
+        """
+        return pd.DataFrame(
+            Actors(env=self.env, version=self.version).gdp(actor_id=actor_id)
+        )
+
+    async def emissions_async(self, actor_id: str) -> pd.DataFrame:
+        data = await Actors(env=self.env, version=self.version).emissions_async(
+            actor_id=actor_id
+        )
+        return pd.DataFrame(data)
+
+    async def _emissions_with_sem(self, actor_id: str) -> pd.DataFrame:
+        async with self._sem:
+            return await self.emissions_async(actor_id)
+
+    async def emissions_many(self, actor_ids: list[str]) -> list[pd.DataFrame]:
+        tasks = [self._emissions_with_sem(actor_id) for actor_id in actor_ids]
+        return await asyncio.gather(*tasks)
+
+    # sync wrappers that run the async code in an event loop
+    def emissions_sync(self, actor_id: str) -> pd.DataFrame:
+        return asyncio.run(self.emissions_async(actor_id))
+
+    def emissions_many_sync(self, actor_ids: list[str]) -> list[pd.DataFrame]:
+        return asyncio.run(self.emissions_many(actor_ids))

ledgerdata/datasource.py

@@ -0,0 +1,37 @@
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Datasource(Base):
+    """retrieve emissions
+
+    Returns:
+        object
+    """
+
+    def datasource(self, datasource_id=None, *args, **kwargs):
+        """retrieve actor emissions
+
+        Args:
+            datasource_id (str): code for datasource
+
+        Returns:
+            DataFrame:
+        """
+        endpoint = "/datasource/"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        # Add query parameters
+        params = {}
+        if datasource_id:
+            params["datasource_id"] = datasource_id
+
+        response = requests.get(url, headers=headers, params=params).json()
+        return response

ledgerdata/emissions.py

@@ -0,0 +1,64 @@
+import warnings
+
+import httpx
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Emissions(Base):
+    """retrieve emissions
+
+    Returns:
+        object
+    """
+
+    def emissions(self, actor_id: str, ignore_warnings: bool = False, *args, **kwargs):
+        """retreive actor emissions
+
+        Args:
+            actor_id (str): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        (
+            warnings.simplefilter("ignore")
+            if ignore_warnings
+            else warnings.simplefilter("default")
+        )
+        endpoint = f"/actor/{actor_id}/emissions"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        response = requests.get(url, headers=headers).json()
+        # data_list = response.get("data", None)
+        # df = pd.DataFrame(response).sort_values(by=["year"])
+        return response
+
+    async def emissions_async(
+        self, actor_id: str, ignore_warnings: bool = False, *args, **kwargs
+    ):
+        """Retrieve actor emissions asynchronously."""
+        if ignore_warnings:
+            warnings.simplefilter("ignore")
+        else:
+            warnings.simplefilter("default")
+
+        endpoint = f"/actor/{actor_id}/emissions"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            return response.json()

ledgerdata/gdp.py

@@ -0,0 +1,36 @@
+import warnings
+from typing import ClassVar
+
+import pandas as pd
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class ActorData(Base):
+    endpoint: ClassVar[str]
+
+    def fetch(
+        self,
+        actor_id: str,
+        ignore_warnings: bool = False,
+        *args,
+        **kwargs,
+    ):
+        """Retrieve actor data for the given endpoint."""
+        if ignore_warnings:
+            warnings.simplefilter("ignore")
+        else:
+            warnings.simplefilter("default")
+
+        url = f"{self.server}{self.endpoint}/{actor_id}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return pd.DataFrame(response)
+
+
+@dataclass
+class GDP(ActorData):
+    endpoint: ClassVar[str] = "/gdp"

ledgerdata/gwp.py

@@ -0,0 +1,38 @@
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class GWP(Base):
+    """retrieve emissions
+
+    Returns:
+        object
+    """
+
+    def gwp(self, assessment_report=None, *args, **kwargs):
+        """retreive actor emissions
+
+        Args:
+            actor_id (str): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        endpoint = "/gwp/"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        # Add query parameters
+        params = {}
+        if assessment_report:
+            params["assessment_report"] = assessment_report
+
+        response = requests.get(url, headers=headers, params=params).json()
+        return response

ledgerdata/initiatives.py

@@ -0,0 +1,37 @@
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Initiatives(Base):
+    """retrieve emissions
+
+    Returns:
+        object
+    """
+
+    def initiatives(self, initiative="us_climate_alliance", *args, **kwargs):
+        """retreive actors part of an initiative
+
+        Args:
+            initiative (str): InitiativeType 
+
+        Returns:
+            DataFrame: data for selected initiative
+        """
+        endpoint = "/initiatives/"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        # Add query parameters
+        params = {}
+        if initiative:
+            params["initiative"] = initiative
+
+        response = requests.get(url, headers=headers, params=params).json()
+        return response

ledgerdata/population.py

@@ -0,0 +1,37 @@
+import warnings
+
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Population(Base):
+    """ActorOveriew API class
+    get overview information of an actor
+
+    Returns:
+        object
+    """
+
+    def population(self, actor_id: str, ignore_warnings: bool = False, *args, **kwargs):
+        """retrieve population data
+
+        Args:
+            actor_id (str): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        (
+            warnings.simplefilter("ignore")
+            if ignore_warnings
+            else warnings.simplefilter("default")
+        )
+        endpoint = f"/population/{actor_id}"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response

ledgerdata/sector.py

@@ -0,0 +1,34 @@
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Sector(Base):
+    """retrieve sectors
+
+    Returns:
+        object
+    """
+
+    def sector(self, *args, **kwargs):
+        """retrieve sectors
+
+        Returns:
+            DataFrame:
+        """
+        endpoint = "/sector/"
+        url = f"{self.server}{endpoint}"
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "python-httpx/1.0",
+        }
+
+        # Add query parameters
+        params = {}
+        # if datasource_id:
+        #    params["datasource_id"] = datasource_id
+
+        response = requests.get(url, headers=headers, params=params).json()
+        return response

ledgerdata/targets.py

@@ -0,0 +1,36 @@
+import warnings
+
+import requests
+from pydantic.dataclasses import dataclass
+
+from .base import Base
+
+
+@dataclass
+class Targets(Base):
+    """retrieve emission targets
+
+    Returns:
+        object
+    """
+
+    def targets(self, actor_id: str, ignore_warnings: bool = False, *args, **kwargs):
+        """retreive actor emissions
+
+        Args:
+            actor_id (str): code for actor your want to retrieve
+            ignore_warnings (bool): ignore warning messages
+
+        Returns:
+            DataFrame: data for each emissions dataset
+        """
+        (
+            warnings.simplefilter("ignore")
+            if ignore_warnings
+            else warnings.simplefilter("default")
+        )
+        endpoint = f"/targets/{actor_id}"
+        url = f"{self.server}{endpoint}"
+        headers = {"Accept": "application/json"}
+        response = requests.get(url, headers=headers).json()
+        return response

ledgerdata-0.1.0.dev6.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.5
+Name: ledgerdata
+Version: 0.1.0.dev6
+Summary: Python client for LEDGER database
+Author-email: Luke Gloege <lucas.gloege@yale.edu>
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pandas>=3.0.6
+Requires-Dist: psycopg>=3.3.6
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: requests>=2.34.2
+Requires-Dist: ruff>=0.17.2
+Description-Content-Type: text/markdown
+
+# ledgerdata: The LEDGER Python Client
+
+This Repo contains the LEDGER Python Client
+
+## Installation
+
+```bash
+uv add git+https://github.com/LEDGER-project/ledgerdata.git@main 
+```
+
+or with pip
+
+```bash
+pip install git+https://github.com/LEDGER-project/ledgerdata.git@main
+```
+
+## Documentation
+
+The official documentation for the entire LEDGER project is available at: [https://ledger-project.github.io/](https://ledger-project.github.io/)

ledgerdata-0.1.0.dev6.dist-info/RECORD

@@ -0,0 +1,17 @@
+ledgerdata/__init__.py,sha256=kQkuE0d_JWQxmbZUPRLUeB2Y0QSg045ejs3WMI8oKpU,438
+ledgerdata/actors.py,sha256=fJLKa40Hu9OSS8yDmH9BYaejv9nYBejjJp6dwFwSNj0,7600
+ledgerdata/base.py,sha256=yzbVcouYXPDcyf5SqhbXIZ7CigE-tjMGWjX9hoUuspM,504
+ledgerdata/client.py,sha256=4vhnSyo5T0fHnijlm4FAs5tibnDAiCsQJ4XGygBfjrs,6577
+ledgerdata/datasource.py,sha256=n-0qQILAXxjDBS2ckdY67uoqnk142ozvfg4EpPYALG8,828
+ledgerdata/emissions.py,sha256=6P_vuMpNsF0EhL5qKhlDSUwnmNM0zu65FQHXSwuaeCg,1813
+ledgerdata/gdp.py,sha256=O0u03vvF8Y7aoivHdQF9obngbrkXikYYXxVRz4depKQ,811
+ledgerdata/gwp.py,sha256=YhjvlO5kPynt5IsD5qyg2r16LcnOufihWI1gOWbOX4Y,927
+ledgerdata/initiatives.py,sha256=L1UfrQAPtts95-GA3llFf7sU46c3UfyYEuwwdd2uYBU,871
+ledgerdata/population.py,sha256=Plo-IfvrnAmwTUjAGhztprvWcPU8sj50bX0wpKGb9Xc,961
+ledgerdata/sector.py,sha256=KKF0SsgMgP5OH1C_OyLD2CBQ9yax3SkQQyahsx1wp4A,721
+ledgerdata/targets.py,sha256=P9fMl4C9lAN0GtkvUBL20AnMWgw4qKMTGQ4UvkaqKT8,914
+ledgerdata-0.1.0.dev6.dist-info/METADATA,sha256=3OvPuUAqpgV60qfajpc4aUmJN_Looaed_VKjsAkewTE,858
+ledgerdata-0.1.0.dev6.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+ledgerdata-0.1.0.dev6.dist-info/entry_points.txt,sha256=-jmCqcPPOqamUodczh91vTv1zMG_kQyDUOQmt3eO5MI,47
+ledgerdata-0.1.0.dev6.dist-info/licenses/LICENSE,sha256=vFovm9NfuoM4HokZBt6sYh7tTXwUSRNCYp_ugpqGzk0,1071
+ledgerdata-0.1.0.dev6.dist-info/RECORD,,

ledgerdata-0.1.0.dev6.dist-info/WHEEL

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

ledgerdata-0.1.0.dev6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ledgerdata = ledgerdata:main

ledgerdata-0.1.0.dev6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LEDGER-project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.