├── .gitattributes ├── .gitignore ├── LICENSE ├── README.md ├── docs ├── Makefile ├── make.bat └── source │ ├── _static │ └── custom.css │ ├── abstract.rst │ ├── categories.rst │ ├── conf.py │ ├── ec3_wrapper_logo.svg │ ├── epds.rst │ ├── getting-started.rst │ ├── index.rst │ ├── materials.rst │ ├── projects.rst │ └── utilities.rst ├── ec3 ├── __init__.py ├── ec3_api.py ├── ec3_categories.py ├── ec3_epds.py ├── ec3_materials.py ├── ec3_projects.py ├── ec3_urls.py ├── ec3_utils.py └── py.typed ├── ec3_materials_plot.ipynb ├── ec3_overview.ipynb ├── examples └── ec3_concrete_epd_study.ipynb ├── pyproject.toml ├── readthedocs.yaml ├── requirements-dev.txt ├── requirements.txt ├── setup.cfg └── setup.py /.gitattributes: -------------------------------------------------------------------------------- 1 | *.ipynb linguist-detectable=false -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .env 2 | .env.* 3 | .vscode 4 | .venv 5 | 6 | build/ 7 | dist/ 8 | tests/ 9 | docs/build 10 | ec3_tests.ipynb 11 | .python-version 12 | *__pycache__ 13 | *.egg 14 | *egg-info 15 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 Jared Friedman 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # EC3 Python Wrapper 2 |

3 | 4 | This is a Python wrapper for working with the Building Transparency EC3 API. 5 | Documentation for the EC3 API can be found at [https://buildingtransparency.org/ec3/manage-apps/api-doc/api](https://buildingtransparency.org/ec3/manage-apps/api-doc/api) 6 | 7 | This project is still early in development. Further documentation and functionality will continue to evolve as the project progresses. 8 | 9 | ## Installing 10 | 11 | ``` 12 | pip install ec3-python-wrapper 13 | ``` 14 | 15 | ## Documentation 16 | 17 | For documentation on how to use the EC3 Python Wrapper visit: 18 | [https://ec3-python-wrapper.readthedocs.io/](https://ec3-python-wrapper.readthedocs.io/) 19 | 20 | ### Usage Examples 21 | 22 | Some Jupyter Notebook examples are provided here: 23 | 24 | * Overview of some available functions: [ec3_overview.ipynb](ec3_overview.ipynb) 25 | * Querying and plotting materials: [ec3_materials_plot.ipynb](ec3_materials_plot.ipynb) 26 | 27 | A Streamlit example app can be found here: 28 | * EC3 Concrete Carbon Comparison by postal Code: [![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://jbf1212-example-app-ec3-wrapper-ec3-app-bd2ea4.streamlit.app/) 29 | 30 | ## Credits 31 | 32 | * Obviously none of this would exist without the great efforts of the [Building Transparency](https://buildingtransparency.org/ec3) team and the EC3 database. 33 | * Much of how this library has been structured was modeled off of the amazing work done on the [pyAirtable module](https://github.com/gtalarico/pyairtable). 34 | 35 | ## License 36 | [MIT](https://opensource.org/licenses/MIT) 37 | -------------------------------------------------------------------------------- /docs/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line, and also 5 | # from the environment for the first two. 6 | SPHINXOPTS ?= 7 | SPHINXBUILD ?= sphinx-build 8 | SOURCEDIR = source 9 | BUILDDIR = build 10 | 11 | # Put it first so that "make" without argument is like "make help". 12 | help: 13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 14 | 15 | .PHONY: help Makefile 16 | 17 | # Catch-all target: route all unknown targets to Sphinx using the new 18 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 19 | %: Makefile 20 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 21 | -------------------------------------------------------------------------------- /docs/make.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | pushd %~dp0 4 | 5 | REM Command file for Sphinx documentation 6 | 7 | if "%SPHINXBUILD%" == "" ( 8 | set SPHINXBUILD=sphinx-build 9 | ) 10 | set SOURCEDIR=source 11 | set BUILDDIR=build 12 | 13 | %SPHINXBUILD% >NUL 2>NUL 14 | if errorlevel 9009 ( 15 | echo. 16 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx 17 | echo.installed, then set the SPHINXBUILD environment variable to point 18 | echo.to the full path of the 'sphinx-build' executable. Alternatively you 19 | echo.may add the Sphinx directory to PATH. 20 | echo. 21 | echo.If you don't have Sphinx installed, grab it from 22 | echo.https://www.sphinx-doc.org/ 23 | exit /b 1 24 | ) 25 | 26 | if "%1" == "" goto help 27 | 28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 29 | goto end 30 | 31 | :help 32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 33 | 34 | :end 35 | popd 36 | -------------------------------------------------------------------------------- /docs/source/_static/custom.css: -------------------------------------------------------------------------------- 1 | .wy-side-nav-search, .wy-nav-top { 2 | background: #EECD7A; 3 | } 4 | 5 | .wy-side-nav-search .wy-dropdown > a img.logo, .wy-side-nav-search > a img.logo { 6 | width: 275px; 7 | } -------------------------------------------------------------------------------- /docs/source/abstract.rst: -------------------------------------------------------------------------------- 1 | EC3 Abstract Class 2 | ================== 3 | The EC3Abstract class contains the base functionality of interacting with the EC3 API. 4 | This class gets inherited and extended upon by by other major classes in the wrapper. 5 | 6 | EC3Abstract 7 | ************ 8 | 9 | .. autoclass:: ec3.ec3_api.EC3Abstract 10 | :members: -------------------------------------------------------------------------------- /docs/source/categories.rst: -------------------------------------------------------------------------------- 1 | Categories Queries 2 | ================== 3 | 4 | The EC3Categories class can be used for retrieving Categories in the EC3 database. 5 | 6 | EC3 Categories represent the categories as EC3 has defined and organized them for their interface. 7 | These categories will not map 1:1 with other systems such as Masterformat. 8 | 9 | Current functionality provides the ability to get the entire category tree as well as categories by id. 10 | 11 | 12 | EC3Categories 13 | ************* 14 | 15 | .. autoclass:: ec3.ec3_categories.EC3Categories 16 | :members: -------------------------------------------------------------------------------- /docs/source/conf.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import os 3 | sys.path.insert(0, os.path.abspath('../..')) 4 | 5 | from ec3 import __version__ as version 6 | 7 | # -- Project information ----------------------------------------------------- 8 | # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information 9 | 10 | project = "EC3 Python Wrapper" 11 | copyright = "2024, Jared Friedman" 12 | author = "Jared Friedman" 13 | 14 | # -- General configuration --------------------------------------------------- 15 | # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration 16 | 17 | extensions = [ 18 | "sphinx.ext.duration", 19 | "sphinx.ext.doctest", 20 | "sphinx.ext.autodoc", 21 | "sphinx.ext.autosummary", 22 | "sphinx.ext.intersphinx", 23 | "sphinx.ext.napoleon", 24 | ] 25 | 26 | intersphinx_mapping = { 27 | "python": ("https://docs.python.org/3/", None), 28 | "sphinx": ("https://www.sphinx-doc.org/en/master/", None), 29 | } 30 | intersphinx_disabled_domains = ["std"] 31 | 32 | templates_path = ["_templates"] 33 | 34 | # Auto Create Api Reference 35 | autoapi_dirs = ["../ec3"] 36 | autoapi_add_toctree_entry = True 37 | autoapi_options = [ 38 | "members", 39 | "undoc-members", 40 | "private-members", 41 | "show-inheritance", 42 | "show-module-summary", 43 | "special-members", 44 | "imported-members", 45 | ] 46 | 47 | # -- Options for HTML output ------------------------------------------------- 48 | # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output 49 | 50 | html_theme = "sphinx_rtd_theme" 51 | html_static_path = ["_static"] 52 | html_logo = "ec3_wrapper_logo.svg" 53 | html_theme_options = { 54 | 'logo_only': True, 55 | 'display_version': False 56 | } 57 | 58 | html_css_files = ["custom.css"] 59 | 60 | # -- Options for EPUB output 61 | epub_show_urls = "footnote" 62 | 63 | 64 | ################################ 65 | # CUSTOM 66 | ################################ 67 | napoleon_google_docstring = True 68 | napoleon_include_init_with_doc = True 69 | napoleon_attr_annotations = True 70 | 71 | 72 | __version__ = version.split("-", 0) 73 | __release__ = version 74 | -------------------------------------------------------------------------------- /docs/source/ec3_wrapper_logo.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 10 | 11 | 12 | 16 | 19 | 23 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 36 | 40 | 45 | 46 | 50 | 52 | 55 | 58 | 62 | 64 | 65 | 67 | 69 | 74 | 78 | 82 | 86 | 88 | 89 | 90 | -------------------------------------------------------------------------------- /docs/source/epds.rst: -------------------------------------------------------------------------------- 1 | EPD Queries 2 | ================== 3 | 4 | The EC3epds class can be used for simplifying queries of EPDs in the EC3 database. 5 | 6 | The primary method currently setup for this class is the 'get_epds' method. 7 | When using this the user should pass a dictionary of parameters and values for querying. 8 | 9 | There are a large number of fields listed in the EC3 documentation that 10 | can be used to query EPDs. Users should refer to that documentation 11 | for the field names and values expected. 12 | 13 | A small number of commonly used fields have been built into the class. 14 | Refer to documentation below to see further details. 15 | 16 | EC3epds 17 | ******** 18 | 19 | .. autoclass:: ec3.ec3_epds.EC3epds 20 | :members: -------------------------------------------------------------------------------- /docs/source/getting-started.rst: -------------------------------------------------------------------------------- 1 | Getting Started 2 | ====================================== 3 | 4 | Installation 5 | ************ 6 | 7 | To use ec3-python-wrapper, first install it using pip: 8 | 9 | .. code-block:: console 10 | 11 | $ pip install ec3-python-wrapper 12 | 13 | 14 | Authentication 15 | ************** 16 | 17 | Usage of the EC3 Python Wrapper assumes you have obtained a bearer token from Building Transparency. 18 | To obtain your token `follow the instructions found here `_ 19 | 20 | Your token should be securely stored. 21 | A common way to do this, is to `store it as an environment variable `_, 22 | and load it using ``os.environ``: 23 | 24 | .. code-block:: python 25 | 26 | import os 27 | api_key = os.environ["EC3_KEY"] 28 | 29 | 30 | Quickstart 31 | ********** 32 | 33 | The following is a simple example of querying for a list of materials. 34 | Refer to the `Building Transparency API documentation `_ for valid fields to search. 35 | 36 | .. code-block:: python 37 | 38 | >>> import os 39 | >>> from ec3 import EC3Materials 40 | >>> token = os.environ['EC3_KEY'] 41 | >>> ec3_materials = EC3Materials(bearer_token=token, ssl_verify=False) 42 | >>> mat_param_dict = {"lightweight":True, "concrete_compressive_strength_at_28d__target":"5000 psi", "jurisdiction":"US"} 43 | >>> ec3_materials.return_fields = ["id", "concrete_compressive_strength_28d", "gwp"] 44 | >>> mat_records = ec3_materials.get_materials(return_all=True, params=mat_param_dict) 45 | 46 | 47 | Examples 48 | ********** 49 | 50 | Some Jupyter Notebook examples can be found over in the github repository: 51 | 52 | * Example 1: `Overview Notebook `_ 53 | * Example 2: `Material Plotting Notebook `_ -------------------------------------------------------------------------------- /docs/source/index.rst: -------------------------------------------------------------------------------- 1 | Welcome to EC3 Python Wrapper's documentation! 2 | ============================================== 3 | 4 | .. container:: .large 5 | 6 | This is a Python wrapper for working with the `Building Transparency EC3 API `_ 7 | 8 | Latest Release: |version| 9 | 10 | .. note:: 11 | 12 | This project is still in the early stages. 13 | 14 | .. toctree:: 15 | :maxdepth: 2 16 | :caption: Getting Started 17 | 18 | getting-started 19 | 20 | .. toctree:: 21 | :maxdepth: 1 22 | :caption: Contents 23 | 24 | abstract 25 | materials 26 | epds 27 | projects 28 | categories 29 | utilities 30 | 31 | _______________________________________________ 32 | 33 | Contribute 34 | ********** 35 | https://github.com/jbf1212/ec3-python-wrapper 36 | 37 | License 38 | ******* 39 | `MIT License `_ -------------------------------------------------------------------------------- /docs/source/materials.rst: -------------------------------------------------------------------------------- 1 | Material Queries 2 | ================== 3 | The EC3Materials class is meant to simplify the querying of materials from the EC3 database 4 | 5 | The primary method currently setup for this class is the 'get_materials' method. 6 | When using this the user should pass a dictionary of parameters and values for querying. 7 | 8 | There are a large number of fields listed in the EC3 documentation that 9 | can be used to query materials. Users should refer to that documentation 10 | for the field names and values expected. 11 | 12 | A small number of commonly used fields have been built into the class. 13 | Refer to documentation below to see further details. 14 | 15 | EC3Materials 16 | ************ 17 | 18 | .. autoclass:: ec3.ec3_materials.EC3Materials 19 | :members: -------------------------------------------------------------------------------- /docs/source/projects.rst: -------------------------------------------------------------------------------- 1 | Project Queries 2 | ================== 3 | 4 | The EC3Projects class can be used for retrieving project records in the EC3 database. 5 | 6 | Usage of this class assumes that you have projects setup already in your EC3 account. 7 | The simplest method for returning projects will likely be by using the get_project_by_name method. 8 | 9 | Users should refer to the EC3 documentation for the field names and values expected for projects. 10 | 11 | 12 | EC3Projects 13 | *********** 14 | 15 | .. autoclass:: ec3.ec3_projects.EC3Projects 16 | :members: -------------------------------------------------------------------------------- /docs/source/utilities.rst: -------------------------------------------------------------------------------- 1 | Utilities 2 | ================== 3 | 4 | Module for utilities that can be used throughout library 5 | 6 | .. automodule:: ec3.ec3_utils 7 | :members: -------------------------------------------------------------------------------- /ec3/__init__.py: -------------------------------------------------------------------------------- 1 | __version__ = "0.0.9" 2 | 3 | from .ec3_materials import EC3Materials 4 | from .ec3_epds import EC3epds 5 | from .ec3_urls import EC3URLs 6 | from .ec3_projects import EC3Projects 7 | from .ec3_categories import EC3Categories 8 | -------------------------------------------------------------------------------- /ec3/ec3_api.py: -------------------------------------------------------------------------------- 1 | import abc 2 | import requests 3 | 4 | 5 | class EC3Abstract(metaclass=abc.ABCMeta): 6 | """ 7 | Represents the abstract class for the Building Transparency Api 8 | 9 | This class get inherited by other major classes. 10 | 11 | :ivar int page_size: Specifies the page size to return. Max allowed by api is 250, defaults to 100 12 | :ivar int max_records: Specifies the maximum number of records to return, defaults to 100 13 | :ivar bool remove_nulls: Keep as True to remove fields with null values. Set to False to return all fields, defaults to True 14 | 15 | """ 16 | 17 | def __init__(self, bearer_token, response_format="json", ssl_verify=True): 18 | """ 19 | Args: 20 | bearer_token (str): EC3 bearer token for the user 21 | response_format (str, optional): Defaults to "json". 22 | ssl_verify (bool, optional): Defaults to True. 23 | """ 24 | 25 | session = requests.Session() 26 | self.bearer_token = bearer_token 27 | self.session = session 28 | self.session.headers.update({"Authorization": "Bearer {}".format(bearer_token)}) 29 | 30 | self.page_size = 100 31 | self.max_records = 100 32 | 33 | self.format = response_format 34 | self._ssl_verify = ssl_verify 35 | if not ssl_verify: 36 | # ignore any unresolved references 37 | requests.packages.urllib3.disable_warnings() 38 | 39 | self.remove_nulls = True 40 | 41 | def _process_response(self, response): 42 | """ 43 | Processes the response. Removes null values if set to do so. 44 | 45 | Args: 46 | response (requests.models.Response): response from Api 47 | 48 | Returns: 49 | json: Processed records as json 50 | """ 51 | try: 52 | response.raise_for_status() 53 | except requests.exceptions.HTTPError as exc: 54 | err_msg = str(exc) 55 | 56 | # Attempt to get Error message from response 57 | try: 58 | error_dict = response.json() 59 | except ValueError: 60 | pass 61 | else: 62 | if "error" in error_dict: 63 | err_msg += " [Error: {}]".format(error_dict["error"]) 64 | exc.args = (*exc.args, err_msg) 65 | raise exc 66 | else: 67 | # if user put in anything other than True or False, assume True 68 | if type(self.remove_nulls) != bool: 69 | self.remove_nulls = True 70 | 71 | if self.remove_nulls is True: 72 | ec3_response = response.json() 73 | if isinstance(ec3_response, dict): 74 | cleaned_response = self._remove_nulls(ec3_response) 75 | else: 76 | cleaned_response = [self._remove_nulls(d) for d in ec3_response] 77 | return cleaned_response 78 | else: 79 | return response.json() 80 | 81 | def _request(self, method, url, params=None): 82 | if params: 83 | response = self.session.request( 84 | method, url, verify=self._ssl_verify, params=params["params"] 85 | ) 86 | else: 87 | response = self.session.request(method, url, verify=self._ssl_verify) 88 | 89 | return self._process_response(response) 90 | 91 | def _get_records(self, url, **params): 92 | """ 93 | Returns the requested number of records. 94 | 95 | This will only return the first (or specified #) page when number of records exceeds page size. 96 | """ 97 | data = self._request("get", url, params=params) 98 | requested_records = data 99 | page_number = 1 100 | 101 | while len(data) == self.page_size and len(requested_records) < self.max_records: 102 | page_number += 1 103 | params["params"]["page_number"] = page_number 104 | 105 | try: 106 | data = self._request("get", url, params=params) 107 | except requests.exceptions.HTTPError: 108 | break 109 | 110 | if data: 111 | requested_records.extend(data) 112 | 113 | if len(requested_records) > self.max_records: 114 | return requested_records[0 : self.max_records] 115 | else: 116 | return requested_records 117 | 118 | def _get_all(self, url, **params): 119 | """ 120 | Returns all the records as a single list 121 | """ 122 | hold_val1 = self.max_records 123 | self.max_records = 10000000 # temp max value 124 | 125 | data = self._get_records(url, **params) 126 | all_records = data 127 | page_number = 1 128 | 129 | while len(data) == self.page_size: 130 | page_number += 1 131 | params["params"]["page_number"] = page_number 132 | 133 | try: 134 | data = self._get_records(url, **params) 135 | except requests.exceptions.HTTPError: 136 | break 137 | 138 | if data: 139 | all_records.extend(data) 140 | 141 | self.max_records = hold_val1 142 | 143 | return all_records 144 | 145 | def _remove_nulls(self, response_dict): 146 | """ 147 | Removes key/value pairs where value is None 148 | 149 | Args: 150 | response_dict (dict): Response dictionary 151 | 152 | Returns: 153 | dict: Cleaned version of input dictionary 154 | """ 155 | for key, value in list(response_dict.items()): 156 | if value is None: 157 | del response_dict[key] 158 | elif isinstance(value, dict): 159 | self._remove_nulls(value) 160 | return response_dict 161 | -------------------------------------------------------------------------------- /ec3/ec3_categories.py: -------------------------------------------------------------------------------- 1 | from .ec3_api import EC3Abstract 2 | from .ec3_urls import EC3URLs 3 | 4 | 5 | class EC3Categories(EC3Abstract): 6 | """ 7 | Wraps functionality of EC3 Categories 8 | 9 | Usage: 10 | >>> ec3_categories = EC3Categories(bearer_token=token, ssl_verify=False) 11 | >>> ec3_categories.get_all_categories() 12 | """ 13 | 14 | def __init__(self, bearer_token, response_format="json", ssl_verify=True): 15 | super().__init__( 16 | bearer_token, response_format=response_format, ssl_verify=ssl_verify 17 | ) 18 | 19 | self.url = EC3URLs(response_format=response_format) 20 | 21 | def get_all_categories(self): 22 | """ 23 | Gets the entire categories tree 24 | 25 | Returns: 26 | dict: Dictionary of entire category tree 27 | """ 28 | return super()._request("get", self.url.categories_tree_url()) 29 | 30 | def get_category_by_id(self, category_id): 31 | """ 32 | Returns the category from a category id 33 | 34 | Args: 35 | category_id (str): Category ID 36 | 37 | Returns: 38 | dict: Returns a category by ID with the whole sub-categories tree 39 | """ 40 | return super()._request( 41 | "get", self.url.categories_id_url().format(category_id=category_id) 42 | ) 43 | -------------------------------------------------------------------------------- /ec3/ec3_epds.py: -------------------------------------------------------------------------------- 1 | from datetime import datetime 2 | 3 | from .ec3_api import EC3Abstract 4 | from .ec3_urls import EC3URLs 5 | from .ec3_categories import EC3Categories 6 | from .ec3_utils import get_masterformat_category_dict, get_displayname_category_dict 7 | 8 | 9 | class EC3epds(EC3Abstract): 10 | """ 11 | Wraps functionality of EC3 EPDs 12 | 13 | :ivar list return_fields: List of the fields you would like returned (EC3 returns everything by default), defaults to [] 14 | :ivar str sort_by: Optional name of return field to sort results by, defaults to "" 15 | :ivar bool only_valid: If True will return only EPDs that are currently valid (set to False to also return expired EPDs), defaults to True 16 | :ivar list masterformat_filter: Optional list of Masterformat Category names to filter by (ex: ["03 21 00 Reinforcement Bars"]), defaults to [] 17 | :ivar list display_name_filter: Optional list of Display Name Categories to filter by (ex: ["Ready Mix"]), defaults to [] 18 | 19 | Usage: 20 | >>> ec3_epds = EC3epds(bearer_token=token, ssl_verify=False) 21 | >>> ec3_epd_list = ec3_epds.get_epds(params=epd_param_dict) 22 | """ 23 | 24 | def __init__(self, bearer_token, response_format="json", ssl_verify=True): 25 | super().__init__( 26 | bearer_token, response_format=response_format, ssl_verify=ssl_verify 27 | ) 28 | 29 | self.return_fields = [] 30 | self.sort_by = "" 31 | self.only_valid = True 32 | self.category_tree = None 33 | self.masterformat_filter = ( 34 | [] 35 | ) # Currently EC3 requires you to go through category class for this 36 | self.display_name_filter = [] 37 | 38 | self.url = EC3URLs(response_format=response_format) 39 | 40 | def _process_params(self, params): 41 | params["params"]["page_size"] = self.page_size 42 | 43 | if self.return_fields: 44 | fields_string = ",".join(self.return_fields) 45 | params["params"]["fields"] = fields_string 46 | 47 | # NOTE "sort_by" is not currently working as expected when passing multiple fields. 48 | # Setting up to expect a single string field temporarily. 49 | if self.sort_by: 50 | params["params"]["sort_by"] = self.sort_by 51 | 52 | if self.only_valid: 53 | params["params"]["date_validity_ends__gt"] = datetime.today().strftime( 54 | "%Y-%m-%d" 55 | ) 56 | 57 | if self.masterformat_filter or self.display_name_filter: 58 | ec3_categories = EC3Categories( 59 | bearer_token=self.bearer_token, ssl_verify=False 60 | ) 61 | self.category_tree = ec3_categories.get_all_categories() 62 | 63 | if self.masterformat_filter: 64 | masterformat_dict = get_masterformat_category_dict(self.category_tree) 65 | 66 | category_ids = [masterformat_dict[i] for i in self.masterformat_filter] 67 | params["params"]["category"] = category_ids 68 | 69 | if self.display_name_filter: 70 | display_name_dict = get_displayname_category_dict(self.category_tree) 71 | 72 | category_ids = [display_name_dict[i] for i in self.display_name_filter] 73 | category_ids = list(set(category_ids)) # Remove duplicates 74 | params["params"]["category"] = category_ids 75 | 76 | return params 77 | 78 | def get_epds(self, return_all=False, **params): 79 | """ 80 | Returns matching EPDs 81 | 82 | Args: 83 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in page_size. 84 | 85 | Returns: 86 | list: List of dictionaries of matching EPD records 87 | """ 88 | processed_params = self._process_params(params) 89 | 90 | if return_all: 91 | return super()._get_all(self.url.epds_url(), **processed_params) 92 | else: 93 | return super()._get_records(self.url.epds_url(), **processed_params) 94 | 95 | def get_epd_by_xpduuid(self, epd_xpd_uuid): 96 | """ 97 | Returns the epd from an Open xPD UUID 98 | 99 | Args: 100 | epd_xpd_uuid (str): Open xPD UUID (Example: EC300001) 101 | Returns: 102 | dict: Dictionary of the matching EPD record 103 | """ 104 | return super()._request( 105 | "get", self.url.epds_xpd_uuid_url().format(epd_xpd_uuid=epd_xpd_uuid) 106 | ) 107 | -------------------------------------------------------------------------------- /ec3/ec3_materials.py: -------------------------------------------------------------------------------- 1 | from datetime import datetime 2 | import json 3 | 4 | from .ec3_api import EC3Abstract 5 | from .ec3_urls import EC3URLs 6 | from .ec3_categories import EC3Categories 7 | from .ec3_utils import postal_to_latlong, get_masterformat_category_dict 8 | 9 | 10 | class EC3Materials(EC3Abstract): 11 | """ 12 | Wraps functionality of EC3 Materials 13 | 14 | :ivar list return_fields: List of the fields you would like returned (EC3 returns everything by default), defaults to [] 15 | :ivar str sort_by: Optional name of return field to sort results by, defaults to "" 16 | :ivar bool only_valid: If True will return only Materials with EPDs that are currently valid (set to False to also return materials with expired EPDs), defaults to True 17 | :ivar list masterformat_filter: Optional list of Masterformat Category names to filter by (ex: ["03 21 00 Reinforcement Bars"]), defaults to [] 18 | 19 | Usage: 20 | >>> ec3_materials = EC3Materials(bearer_token=token, ssl_verify=False) 21 | >>> ec3_mat_list = ec3_materials.get_materials(params=mat_param_dict) 22 | """ 23 | 24 | def __init__(self, bearer_token, response_format="json", ssl_verify=True): 25 | super().__init__( 26 | bearer_token, response_format=response_format, ssl_verify=ssl_verify 27 | ) 28 | 29 | self.return_fields = [] 30 | self.sort_by = "" 31 | self.only_valid = True 32 | self.masterformat_filter = ( 33 | [] 34 | ) # Currently EC3 requires you to go through category class for this 35 | 36 | self.url = EC3URLs(response_format=response_format) 37 | 38 | def _process_params(self, params): 39 | params["params"]["page_size"] = self.page_size 40 | 41 | if self.return_fields: 42 | fields_string = ",".join(self.return_fields) 43 | params["params"]["fields"] = fields_string 44 | 45 | # FIXME seems like this is not return full dictionaries for nested values 46 | 47 | # NOTE "sort_by" is not currently working as expected when passing multiple fields. 48 | # Setting up to expect a single string field temporarily. 49 | if self.sort_by: 50 | params["params"]["sort_by"] = self.sort_by 51 | 52 | if self.masterformat_filter: 53 | ec3_categories = EC3Categories( 54 | bearer_token=self.bearer_token, ssl_verify=False 55 | ) 56 | whole_tree = ec3_categories.get_all_categories() 57 | masterformat_dict = get_masterformat_category_dict(whole_tree) 58 | 59 | category_ids = [masterformat_dict[i] for i in self.masterformat_filter] 60 | params["params"]["category"] = category_ids 61 | 62 | return params 63 | 64 | def get_materials(self, return_all=False, **params): 65 | """ 66 | Returns matching materials 67 | 68 | Args: 69 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in max_records. 70 | 71 | Returns: 72 | list: List of dictionaries of matching material records 73 | """ 74 | if self.only_valid: 75 | params["params"]["epd__date_validity_ends__gt"] = datetime.today().strftime( 76 | "%Y-%m-%d" 77 | ) 78 | 79 | processed_params = self._process_params(params) 80 | 81 | if return_all: 82 | return super()._get_all(self.url.materials_url(), **processed_params) 83 | else: 84 | return super()._get_records(self.url.materials_url(), **processed_params) 85 | 86 | def convert_query_to_mf_string(self, category_name, field_dict_list, pragma=None): 87 | """ 88 | Converts a dictionary of material search parameters to a pragma string for use in the EC3 API 89 | This function includes a POST request that requires an API key with write access 90 | 91 | Args: 92 | category_name (str): EC3 category name (see https://docs.open-epd-forum.org/en/data-format/materials/ for list of valid category names) 93 | field_dict_list (list): List of dictionaries of search parameters (format: [{"field": "field_name", "op": "operator", "arg": "argument"}]) 94 | pragma (list, optional): List of dictionaries of pragma parameters. Defaults to eMF 2.0/1 and TRACI 2.1. 95 | 96 | Returns: 97 | str: string formatted to work with MaterialFilter pragma in EC3 API 98 | """ 99 | payload_dict = {} 100 | 101 | if pragma is None: 102 | pragma = [ 103 | {"name": "eMF", "args": ["2.0/1"]}, 104 | {"name": "lcia", "args": ["TRACI 2.1"]}, 105 | ] 106 | 107 | payload_dict["pragma"] = pragma 108 | payload_dict["category"] = category_name 109 | payload_dict["filter"] = field_dict_list 110 | 111 | payload = json.dumps(payload_dict) 112 | 113 | mf_url = ( 114 | self.url.materials_convert_matfilter_url() 115 | + "?output=string&output_style=compact" 116 | ) 117 | 118 | headers = { 119 | "Content-Type": "application/json", 120 | "Authorization": f"Bearer {self.bearer_token}", 121 | } 122 | response = self.session.request( 123 | "post", mf_url, verify=self._ssl_verify, data=payload, headers=headers 124 | ) 125 | 126 | return response 127 | 128 | def get_materials_mf(self, category_name, mf_list, return_all=False, **params): 129 | """ 130 | Returns matching materials using filters 131 | 132 | Args: 133 | category_name (str): Open EPD category name (see https://docs.open-epd-forum.org/en/data-format/materials/ for list of valid category names) 134 | mf_list (list): List of dictionaries of search parameters (format: [{"field": "field_name", "op": "operator", "arg": "argument"}]) 135 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in max_records. 136 | 137 | Returns: 138 | list: List of dictionaries of matching material records 139 | """ 140 | if self.only_valid: 141 | mf_list.append( 142 | { 143 | "field": "epd__date_validity_ends", 144 | "op": "gt", 145 | "arg": datetime.today().strftime("%Y-%m-%d"), 146 | } 147 | ) 148 | 149 | mf_response = self.convert_query_to_mf_string(category_name, mf_list) 150 | mf_response_json = mf_response.json() 151 | mf_string = mf_response_json["material_filter_str"] 152 | 153 | params["params"] = {} 154 | params["params"]["mf"] = mf_string 155 | 156 | processed_params = self._process_params(params) 157 | 158 | if return_all: 159 | return super()._get_all(self.url.materials_url(), **processed_params) 160 | else: 161 | return super()._get_records(self.url.materials_url(), **processed_params) 162 | 163 | def get_materials_within_region( 164 | self, 165 | postal_code, 166 | country_code="US", 167 | plant_distance="100 mi", 168 | return_all=False, 169 | **params, 170 | ): 171 | """ 172 | Returns only materials from plants within provided distance of postal code. 173 | This adds the "latitude", "longitude", and "plant_distance_lt" keys to your parameter dictionary. 174 | 175 | Args: 176 | postal_code (int): postal code 177 | country_code (str, optional): Two letter country code.. Defaults to 'US'. 178 | plant_distance (str, optional): Distance to plant with units in string ('mi' or 'km'). Defaults to "100 mi". 179 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in max_records. 180 | 181 | Returns: 182 | list: List of dictionaries of matching material records within distance provided from postal code 183 | """ 184 | lat, long = postal_to_latlong(postal_code, country_code) 185 | params["params"]["latitude"] = lat 186 | params["params"]["longitude"] = long 187 | params["params"]["plant__distance__lt"] = plant_distance 188 | 189 | return self.get_materials(return_all=return_all, **params) 190 | 191 | def get_materials_within_region_mf( 192 | self, 193 | category_name, 194 | mf_list, 195 | postal_code, 196 | country_code="US", 197 | plant_distance="100 mi", 198 | return_all=False, 199 | **params, 200 | ): 201 | """ 202 | Returns only materials from plants within provided distance of postal code. 203 | This adds the "latitude", "longitude", and "plant_distance_lt" keys to your parameter dictionary. 204 | 205 | Args: 206 | category_name (str): Open EPD category name (see https://docs.open-epd-forum.org/en/data-format/materials/ for list of valid category names) 207 | mf_list (list): List of dictionaries of search parameters (format: [{"field": "field_name", "op": "operator", "arg": "argument"}]) 208 | postal_code (int): postal code 209 | country_code (str, optional): Two letter country code.. Defaults to 'US'. 210 | plant_distance (str, optional): Distance to plant with units in string ('mi' or 'km'). Defaults to "100 mi". 211 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in max_records. 212 | 213 | Returns: 214 | list: List of dictionaries of matching material records within distance provided from postal code 215 | """ 216 | lat, long = postal_to_latlong(postal_code, country_code) 217 | 218 | mf_list.extend( 219 | [ 220 | {"field": "latitude", "op": "exact", "arg": lat}, 221 | {"field": "longitude", "op": "exact", "arg": long}, 222 | {"field": "plant__distance", "op": "lt", "arg": plant_distance}, 223 | ] 224 | ) 225 | 226 | return self.get_materials_mf( 227 | category_name, mf_list, return_all=return_all, **params 228 | ) 229 | 230 | # NOTE Querying materials by "open_xpd_uuid" does not appear to currently work with the api 231 | # def get_material_by_xpduuid(self, epd_xpd_uuid): 232 | # """ 233 | # Returns the material from an Open xPD UUID of an EPD 234 | 235 | # Args: 236 | # epd_xpd_uuid (str): Open xPD UUID (Example: EC300001) 237 | 238 | # Returns: 239 | # list: List of dictionaries of matching material records 240 | # """ 241 | # return super()._request( 242 | # "get", self.url.materials_xpd_uuid_url().format(epd_xpd_uuid=epd_xpd_uuid) 243 | # ) 244 | -------------------------------------------------------------------------------- /ec3/ec3_projects.py: -------------------------------------------------------------------------------- 1 | from .ec3_api import EC3Abstract 2 | from .ec3_urls import EC3URLs 3 | 4 | 5 | class EC3Projects(EC3Abstract): 6 | """ 7 | Wraps functionality of EC3 Projects 8 | 9 | :ivar str sort_by: Optional name of return field to sort results by, defaults to "" 10 | 11 | Usage: 12 | >>> ec3_project_list = EC3Projects(bearer_token=token, ssl_verify=False) 13 | >>> ec3_project_list.get_projects(params=project_param_dict) 14 | """ 15 | 16 | def __init__(self, bearer_token, response_format="json", ssl_verify=True): 17 | super().__init__( 18 | bearer_token, response_format=response_format, ssl_verify=ssl_verify 19 | ) 20 | 21 | self.sort_by = "" 22 | 23 | self.url = EC3URLs(response_format=response_format) 24 | 25 | def _process_params(self, params): 26 | params["params"]["page_size"] = self.page_size 27 | 28 | # NOTE "sort_by" is not currently working as expected when passing multiple fields. 29 | # Setting up to expect a single string field temporarily. 30 | if self.sort_by: 31 | params["params"]["sort_by"] = self.sort_by 32 | 33 | return params 34 | 35 | def get_projects(self, return_all=False, **params): 36 | """ 37 | Returns matching Projects in your EC3 account 38 | 39 | Args: 40 | return_all (bool, optional): Set to True to return all matches. Defaults to False, which will return the quantity specified in page_size. 41 | 42 | Returns: 43 | list: List of dictionaries of matching Project records 44 | """ 45 | processed_params = self._process_params(params) 46 | 47 | if return_all: 48 | return super()._get_all(self.url.projects_url(), **processed_params) 49 | else: 50 | return super()._get_records(self.url.projects_url(), **processed_params) 51 | 52 | def get_project_by_id(self, project_id): 53 | """ 54 | Returns the project from a project id 55 | 56 | Args: 57 | project_id (str): Entity ID 58 | 59 | Returns: 60 | list: List of dictionaries of matching Project records 61 | """ 62 | return super()._request( 63 | "get", self.url.projects_id_url().format(project_id=project_id) 64 | ) 65 | 66 | def get_projects_by_name(self, project_name): 67 | """ 68 | Returns a list of projects with a name equivalent to the input 69 | If your exact project name is put here you should get a list with one item. 70 | 71 | Args: 72 | project_name (str): Search term for your EC3 project name 73 | 74 | Returns: 75 | list: List of dictionaries of matching Project records 76 | """ 77 | return super()._request( 78 | "get", self.url.projects_name_url().format(project_name=project_name) 79 | ) 80 | -------------------------------------------------------------------------------- /ec3/ec3_urls.py: -------------------------------------------------------------------------------- 1 | class EC3URLs: 2 | """ 3 | This class is intended to store commonly used EC3 URLs. 4 | Should EC3 URLs change in the future they can be updated here 5 | """ 6 | 7 | def __init__(self, response_format="json"): 8 | self.format = response_format 9 | 10 | self.base_url = "https://buildingtransparency.org/api/" 11 | 12 | # materials 13 | self.materials = "materials" 14 | self.material_statistics = "materials/statistics.{format}".format( 15 | format=self.format 16 | ) 17 | self.material_statistics_cached = "materials/statistics/cached.{format}".format( 18 | format=self.format 19 | ) 20 | self.material_epds_xpd_uuid = "materials?open_xpd_uuid={epd_xpd_uuid}".format( 21 | epd_xpd_uuid="{epd_xpd_uuid}" 22 | ) 23 | 24 | self.materials_convert_matfilter = "materials/convert-query".format( 25 | format=self.format 26 | ) 27 | 28 | # epds 29 | self.epds = "epds" 30 | self.epds_xpd_uuid = "epds/{epd_xpd_uuid}".format( 31 | format=self.format, epd_xpd_uuid="{epd_xpd_uuid}" 32 | ) 33 | self.epds_id = "epds/{id}.{format}".format(format=self.format, id="{id}") 34 | 35 | # projects 36 | self.projects = "projects" 37 | self.projects_id = "projects?id={project_id}".format( 38 | format=self.format, project_id="{project_id}" 39 | ) 40 | self.projects_name = "projects?name__like={project_name}".format( 41 | format=self.format, project_name="{project_name}" 42 | ) 43 | 44 | # categories 45 | self.categories_tree = "categories/root" 46 | self.categories_id = "categories/{category_id}".format( 47 | format=self.format, category_id="{category_id}" 48 | ) 49 | 50 | def base_url(self): 51 | """ 52 | Returns the base url 53 | """ 54 | return self.base_url 55 | 56 | ### MATERIALS ### 57 | def materials_url(self): 58 | """ 59 | Combines the base URL and materials API URL 60 | """ 61 | return self.base_url + self.materials 62 | 63 | def material_statistics_url(self): 64 | """ 65 | Combines the base URL and materials statistics API URL 66 | """ 67 | return self.base_url + self.material_statistics 68 | 69 | def material_statistics_cached_url(self): 70 | """ 71 | Combines the base URL and materials statistics cached API URL 72 | """ 73 | return self.base_url + self.material_statistics_cached 74 | 75 | def materials_xpd_uuid_url(self): 76 | """ 77 | Combines the base URL and epds_xpd_uuid API URL 78 | """ 79 | return self.base_url + self.material_epds_xpd_uuid 80 | 81 | def materials_convert_matfilter_url(self): 82 | """ 83 | Combines the base URL and materials convert filter API URL 84 | """ 85 | return self.base_url + self.materials_convert_matfilter 86 | 87 | ### EPDs ### 88 | def epds_url(self): 89 | """ 90 | Combines the base URL and epds API URL 91 | """ 92 | return self.base_url + self.epds 93 | 94 | def epds_xpd_uuid_url(self): 95 | """ 96 | Combines the base URL and epds_xpd_uuid API URL 97 | """ 98 | return self.base_url + self.epds_xpd_uuid 99 | 100 | def epds_id_url(self): 101 | """ 102 | Combines the base URL and epds_id API URL 103 | """ 104 | return self.base_url + self.epds_id 105 | 106 | def epds_product_classes_url(self): 107 | """ 108 | Combines the base URL and epds_id API URL 109 | """ 110 | return self.base_url + self.product_classes 111 | 112 | ### PROJECTS ### 113 | def projects_url(self): 114 | """ 115 | Combines the base URL and projects API URL 116 | """ 117 | return self.base_url + self.projects 118 | 119 | def projects_id_url(self): 120 | """ 121 | Combines the base URL and projects ID API URL 122 | """ 123 | return self.base_url + self.projects_id 124 | 125 | def projects_name_url(self): 126 | """ 127 | Combines the base URL and projects ID API URL 128 | """ 129 | return self.base_url + self.projects_name 130 | 131 | ### CATEGORIES ### 132 | def categories_tree_url(self): 133 | """ 134 | Combines the base URL and categories url for the whole categories tree 135 | """ 136 | return self.base_url + self.categories_tree 137 | 138 | def categories_id_url(self): 139 | """ 140 | Combines the base URL and projects ID API URL 141 | """ 142 | return self.base_url + self.categories_id 143 | -------------------------------------------------------------------------------- /ec3/ec3_utils.py: -------------------------------------------------------------------------------- 1 | import pgeocode 2 | 3 | 4 | def postal_to_latlong(postal_code, country_code="US"): 5 | """ 6 | Converts postal code to latitude and longitude returned as array. 7 | Refer to pgeocode documentation for supported country codes. 8 | If not found, then coordinates for Null Island are returned (0,0). 9 | 10 | Args: 11 | postal_code (int): postal code 12 | country_code (str, optional): Two letter country code. Defaults to 'US'. 13 | 14 | Returns: 15 | A tuple containing a float (latitude) and a float (longitude) 16 | """ 17 | lat = 0 18 | long = 0 19 | nomi = pgeocode.Nominatim(country_code) 20 | if nomi: 21 | df = nomi.query_postal_code(str(postal_code)) 22 | lat = df["latitude"].item() 23 | long = df["longitude"].item() 24 | return (lat, long) 25 | 26 | 27 | def recursive_dict_list_return(dict_item, key_name, out_keys, outlist=[]): 28 | """ 29 | Recursively loops through a nested json/dictionary based on the key name 30 | 31 | This is intended for where the key_name may occur at multiple levels of nesting. 32 | For example, the "subcategories" key occurs at multiple levels of the EC3 categories tree. 33 | Using this function allows you to return a flattened list of dictionaries with the 34 | desired keys defined in the "out_keys" argument. 35 | 36 | Args: 37 | dict_item (dict): Dictionary with nested data to crawl through 38 | key_name (str): Name of key to crawl through nested dictionary 39 | out_keys (list[str]): List of key names to return 40 | outlist (list, optional): List to return (can be left empty if starting a new list) 41 | 42 | Returns: 43 | list: List of dictionaries with keys provided in out_keys 44 | """ 45 | if (key_name in dict_item.keys()) and dict_item[key_name]: 46 | new_dict = {k: dict_item[k] for k in out_keys} 47 | outlist.append(new_dict) 48 | 49 | for d in dict_item[key_name]: 50 | recursive_dict_list_return(d, key_name, out_keys, outlist=outlist) 51 | 52 | elif key_name in dict_item: 53 | new_dict = {k: dict_item[k] for k in out_keys} 54 | outlist.append(new_dict) 55 | 56 | return outlist 57 | 58 | 59 | def get_masterformat_category_dict(category_tree): 60 | """ 61 | Get a dictionary with masterformat codes as the keys and ids as the values 62 | 63 | Args: 64 | category_tree (dict): This should be a nested dictionary of all or part of the category tree 65 | 66 | Returns: 67 | dict: Dictionary with masterformat codes as keys (ex: {'03 00 00 Concrete': '484df282d43f4b0e855fad6b351ce006'}) 68 | """ 69 | category_dict_list = recursive_dict_list_return( 70 | category_tree, "subcategories", ["masterformat", "id"] 71 | ) 72 | 73 | masterformat_dict = { 74 | i.get("masterformat"): i.get("id") 75 | for i in category_dict_list 76 | if i.get("masterformat") and i.get("id") 77 | } 78 | return masterformat_dict 79 | 80 | 81 | def get_displayname_category_dict(category_tree): 82 | """ 83 | Get a dictionary with display names as the keys and ids as the values 84 | 85 | Args: 86 | category_tree (dict): This should be a nested dictionary of all or part of the category tree 87 | 88 | Returns: 89 | dict: Dictionary with display names as keys (ex: {'Ready Mix': '6991a61b52b24e59b1244fe9dee59e9b'}) 90 | """ 91 | category_dict_list = recursive_dict_list_return( 92 | category_tree, "subcategories", ["display_name", "id"] 93 | ) 94 | display_name_dict = { 95 | i.get("display_name"): i.get("id") 96 | for i in category_dict_list 97 | if i.get("display_name") and i.get("id") 98 | } 99 | return display_name_dict 100 | -------------------------------------------------------------------------------- /ec3/py.typed: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jbf1212/ec3-python-wrapper/0bd738db18744c8d2cf2df049ef65665db644e52/ec3/py.typed -------------------------------------------------------------------------------- /ec3_materials_plot.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# Example: Query and Plot Materials" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### Imports and Token Assignment" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 2, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import os\n", 26 | "import pandas as pd\n", 27 | "import seaborn as sns\n", 28 | "\n", 29 | "token = os.environ['EC3_KEY']" 30 | ] 31 | }, 32 | { 33 | "attachments": {}, 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "### Import EC3Materials and Setup Query" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 3, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "from ec3 import EC3Materials\n", 47 | "ec3_materials = EC3Materials(bearer_token=token, ssl_verify=False)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "### Querying Materials Within Region" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 6, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "#Conduct a search of normal weights concrete mixes between 2000 psi and 8000 psi within a radius of a given postal code\n", 64 | "mat_filters = [\n", 65 | " {\n", 66 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 67 | " \"op\": \"gt\",\n", 68 | " \"arg\": \"2000 psi\"\n", 69 | " },\n", 70 | " {\n", 71 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 72 | " \"op\": \"lt\",\n", 73 | " \"arg\": \"8000 psi\"\n", 74 | " },\n", 75 | " {\n", 76 | " \"field\": \"lightweight\",\n", 77 | " \"op\": \"exact\",\n", 78 | " \"arg\": False\n", 79 | " }\n", 80 | "]\n", 81 | "\n", 82 | "ec3_materials.return_fields = [\"id\", \"concrete_compressive_strength_28d\", \"gwp\"]\n", 83 | "ec3_materials.sort_by = \"concrete_compressive_strength_28d\" #This will sort the responses based on the field assiged to the 'sort_by' property\n", 84 | "ec3_materials.only_valid = True\n", 85 | "postal_code = 11232\n", 86 | "\n", 87 | "#NOTE The following query may take a few minutes to return all responses\n", 88 | "mat_records = ec3_materials.get_materials_within_region_mf(\"ReadyMix\", mat_filters, postal_code, plant_distance=\"10 mi\", return_all=True)\n" 89 | ] 90 | }, 91 | { 92 | "attachments": {}, 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "### Clean the Data" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 8, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "#The following code will convert all the compressive strengths to the same units and round to the nearest 500 psi\n", 106 | "\n", 107 | "mpa_to_psi = 145.03773773 #conversion for megapascal\n", 108 | "\n", 109 | "converted_records = []\n", 110 | "for rec in mat_records:\n", 111 | " new_dict = {}\n", 112 | " split_strength = rec[\"concrete_compressive_strength_28d\"].split()\n", 113 | " if split_strength[1] == \"MPa\":\n", 114 | " conc_strength = float(split_strength[0]) * mpa_to_psi\n", 115 | " elif split_strength[1] == \"psi\":\n", 116 | " conc_strength = float(split_strength[0])\n", 117 | " elif split_strength[1] == \"ksi\":\n", 118 | " conc_strength = float(split_strength[0]) * 1000\n", 119 | " else:\n", 120 | " continue #unknown unit\n", 121 | "\n", 122 | " rounded_strength = int(round(conc_strength/ 500.0) * 500.0)\n", 123 | "\n", 124 | " new_dict[\"Compressive_Strength\"] = rounded_strength\n", 125 | " new_dict[\"GWP\"] = float(rec[\"gwp\"].split()[0])\n", 126 | " converted_records.append(new_dict)" 127 | ] 128 | }, 129 | { 130 | "attachments": {}, 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "### Create Pandas Dataframe and Plot with Seaborn" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 9, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "data": { 144 | "text/html": [ 145 | "

\n", 146 | "\n", 159 | "\n", 160 | " \n", 161 | " \n", 162 | " \n", 163 | " \n", 164 | " \n", 165 | " \n", 166 | " \n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | "
Compressive_StrengthGWP
02000275.00
12000327.70
22000275.10
32000273.70
42000318.87
\n", 195 | "
" 196 | ], 197 | "text/plain": [ 198 | " Compressive_Strength GWP\n", 199 | "0 2000 275.00\n", 200 | "1 2000 327.70\n", 201 | "2 2000 275.10\n", 202 | "3 2000 273.70\n", 203 | "4 2000 318.87" 204 | ] 205 | }, 206 | "execution_count": 9, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "df = pd.DataFrame(converted_records)\n", 213 | "df.head()" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 10, 219 | "metadata": {}, 220 | "outputs": [], 221 | "source": [ 222 | "#Filter out materials if less than 10 instances of that strength\n", 223 | "vc = df.Compressive_Strength.value_counts()\n", 224 | "filtered_df = df[df.Compressive_Strength.isin(vc.index[vc.gt(10)])]" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 11, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "data": { 234 | "text/plain": [ 235 | "Text(0, 0.5, 'GWP [kgCO2e]')" 236 | ] 237 | }, 238 | "execution_count": 11, 239 | "metadata": {}, 240 | "output_type": "execute_result" 241 | }, 242 | { 243 | "data": { 244 | "image/png": "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", 245 | "text/plain": [ 246 | "
" 247 | ] 248 | }, 249 | "metadata": {}, 250 | "output_type": "display_data" 251 | } 252 | ], 253 | "source": [ 254 | "### Create plot with Seaborn ###\n", 255 | "sns.set_style(\"whitegrid\") #set style\n", 256 | "sns.set(rc={\"figure.figsize\":(8, 4)}) #set figure size\n", 257 | "\n", 258 | "#Add dots using stripplot\n", 259 | "bp = sns.stripplot(data=filtered_df, x='Compressive_Strength', y='GWP',\n", 260 | " color=\"dimgrey\", linewidth = 1, alpha=0.1)\n", 261 | "\n", 262 | "#Add boxplot\n", 263 | "bp = sns.boxplot(data=filtered_df, x='Compressive_Strength', y='GWP',\n", 264 | " linewidth = 2, palette=\"YlGnBu\", showfliers = False)\n", 265 | "\n", 266 | "#set axis titles and fonts\n", 267 | "bp.set_title(\"GWP of Concrete Mixes within 10 miles of Zip Code {}\".format(postal_code), fontsize = 14, fontweight='bold')\n", 268 | "bp.set_xlabel(\"Compressive Strength [psi]\", fontsize = 12, fontweight='bold')\n", 269 | "bp.set_ylabel(\"GWP [kgCO2e]\", fontsize = 12, fontweight='bold')" 270 | ] 271 | } 272 | ], 273 | "metadata": { 274 | "kernelspec": { 275 | "display_name": "ec3_wrapper", 276 | "language": "python", 277 | "name": "python3" 278 | }, 279 | "language_info": { 280 | "codemirror_mode": { 281 | "name": "ipython", 282 | "version": 3 283 | }, 284 | "file_extension": ".py", 285 | "mimetype": "text/x-python", 286 | "name": "python", 287 | "nbconvert_exporter": "python", 288 | "pygments_lexer": "ipython3", 289 | "version": "3.10.10" 290 | }, 291 | "orig_nbformat": 4, 292 | "vscode": { 293 | "interpreter": { 294 | "hash": "fdbf00880556660fdc4fac131905148da79afaec9153c0f17986ad660a5222a4" 295 | } 296 | } 297 | }, 298 | "nbformat": 4, 299 | "nbformat_minor": 2 300 | } 301 | -------------------------------------------------------------------------------- /ec3_overview.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "attachments": {}, 5 | "cell_type": "markdown", 6 | "metadata": {}, 7 | "source": [ 8 | "# Example: Overview of Primary Query Functionality" 9 | ] 10 | }, 11 | { 12 | "attachments": {}, 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "### Imports and Token Assignment" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import os\n", 26 | "from pprint import pprint\n", 27 | "\n", 28 | "token = os.environ['EC3_KEY']" 29 | ] 30 | }, 31 | { 32 | "attachments": {}, 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "### Querying EPDs" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "from ec3 import EC3epds\n", 46 | "ec3_epds = EC3epds(bearer_token=token, ssl_verify=False)\n", 47 | "print(ec3_epds)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 3, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "#Getting EPD records example\n", 57 | "from ec3 import EC3epds\n", 58 | "ec3_epds = EC3epds(bearer_token=token, ssl_verify=False)\n", 59 | "\n", 60 | "epd_param_dict = {\n", 61 | " \"concrete_compressive_strength_28d\":\"3000 psi\",\n", 62 | " \"lightweight\":True,\n", 63 | " 'applicable_in': ['US', 'CA']\n", 64 | " }\n", 65 | "\n", 66 | "#The masterformat_filter can be used to filter out categories\n", 67 | "ec3_epds.masterformat_filter = [\"03 30 00 Cast-in-Place Concrete\"]\n", 68 | "\n", 69 | "ec3_epds.max_records = 10 #default max records is 100\n", 70 | "ec3_epds.only_valid = False #Default is True. You can set this to False if you want to also return expired EPDs\n", 71 | "epd_records = ec3_epds.get_epds(params=epd_param_dict)" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "#Get EPDs while using masterformat filter (A similar approach using the 'masterformat_filter' property will work with the EC3Materials class)\n", 81 | "#(In this example we return all rebar EPDs)\n", 82 | "from ec3 import EC3epds\n", 83 | "ec3_epds2 = EC3epds(bearer_token=token, ssl_verify=False)\n", 84 | "ec3_epds2.only_valid = True\n", 85 | "ec3_epds2.masterformat_filter = [\"03 21 00 Reinforcement Bars\"]\n", 86 | "epd_param_dict2 = {}\n", 87 | "\n", 88 | "epd_records2 = ec3_epds2.get_epds(params=epd_param_dict2)\n", 89 | "\n", 90 | "pprint(epd_records2[0])" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "#Get an epd by xpd uuid\n", 100 | "epd_xpd_uuid = \"ec3c0h02\"\n", 101 | "\n", 102 | "epd_record = ec3_epds.get_epd_by_xpduuid(epd_xpd_uuid)\n", 103 | "pprint(epd_record)" 104 | ] 105 | }, 106 | { 107 | "attachments": {}, 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "### Querying Materials (Soon to be Deprecated)" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [ 120 | "#Getting material records example\n", 121 | "from ec3 import EC3Materials\n", 122 | "ec3_materials = EC3Materials(bearer_token=token, ssl_verify=False)\n", 123 | "\n", 124 | "#Dictonary of params and values. See EC3 Api documentation for options.\n", 125 | "mat_param_dict = {\"lightweight\":False, \"concrete_compressive_strength_at_28d__target\":\"3000 psi\", \"jurisdiction\":\"US-NY\"}\n", 126 | "\n", 127 | "ec3_materials.return_fields = [\"id\", \"concrete_compressive_strength_28d\", \"gwp\"] #This can be used to limit the fields beings returned\n", 128 | "ec3_materials.sort_by = \"concrete_compressive_strength_28d\" #This will sort the responses based on the field assiged to the 'sort_by' property\n", 129 | "\n", 130 | "#NOTE The following query may take a few minutes to return all responses depending on parameters passed\n", 131 | "#Setting return_all to True will ignore the max_records number and attempt to return all matches\n", 132 | "mat_records = ec3_materials.get_materials(return_all=True, params=mat_param_dict)\n", 133 | "\n", 134 | "pprint(mat_records[0])" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "#Get materials within a given distance of a postal code\n", 144 | "#Conduct a search of normal weights concrete mixes between 2000 psi and 8000 psi within a radius of a given postal code\n", 145 | "mat_param_dict = {\n", 146 | " \"product_classes\":{\"EC3\":\"Concrete >> ReadyMix\"},\n", 147 | " \"lightweight\":False,\n", 148 | " \"concrete_compressive_strength_at_28d__gt\":\"2000 psi\",\n", 149 | " \"concrete_compressive_strength_at_28d__lt\":\"8000 psi\",\n", 150 | " }\n", 151 | "\n", 152 | "ec3_materials.return_fields = [\"id\", \"concrete_compressive_strength_28d\", \"gwp\", \"plant_or_group\"]\n", 153 | "ec3_materials.sort_by = \"concrete_compressive_strength_28d\" #This will sort the responses based on the field assiged to the 'sort_by' property\n", 154 | "ec3_materials.only_valid = True\n", 155 | "ec3_materials.max_records = 50\n", 156 | "postal_code = 11232\n", 157 | "\n", 158 | "mat_records = ec3_materials.get_materials_within_region(postal_code, plant_distance=\"10 mi\", return_all=False, params=mat_param_dict)\n", 159 | "pprint(mat_records[0])" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "### Querying Materials with MaterialFilter (New Approach)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "#Getting material records example\n", 176 | "from ec3 import EC3Materials\n", 177 | "ec3_materials = EC3Materials(bearer_token=token, ssl_verify=False)\n", 178 | "\n", 179 | "#List of filters to apply to the material search\n", 180 | "mat_filters = [\n", 181 | " {\n", 182 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 183 | " \"op\": \"gt\",\n", 184 | " \"arg\": \"2000 psi\"\n", 185 | " },\n", 186 | " {\n", 187 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 188 | " \"op\": \"lt\",\n", 189 | " \"arg\": \"8000 psi\"\n", 190 | " },\n", 191 | " {\n", 192 | " \"field\": \"lightweight\",\n", 193 | " \"op\": \"exact\",\n", 194 | " \"arg\": False\n", 195 | " },\n", 196 | " {\"field\": \"jurisdiction\",\n", 197 | " \"op\": \"in\",\n", 198 | " \"arg\": [\"US-NY\"]\n", 199 | " }\n", 200 | " ]\n", 201 | "\n", 202 | "ec3_materials.return_fields = [\"id\", \"concrete_compressive_strength_28d\", \"gwp\"] #This can be used to limit the fields beings returned\n", 203 | "ec3_materials.sort_by = \"concrete_compressive_strength_28d\" #This will sort the responses based on the field assiged to the 'sort_by' property\n", 204 | "ec3_materials.only_valid = True\n", 205 | "ec3_materials.max_records = 50\n", 206 | "\n", 207 | "#NOTE The following query may take a few minutes to return all responses depending on parameters passed\n", 208 | "#Setting return_all to True will ignore the max_records number and attempt to return all matches\n", 209 | "mat_records = ec3_materials.get_materials_mf(\"ReadyMix\", mat_filters, return_all=False)\n", 210 | "\n", 211 | "pprint(mat_records[0])" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [ 220 | "#Get materials within a given distance of a postal code\n", 221 | "mat_filters = [\n", 222 | " {\n", 223 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 224 | " \"op\": \"gt\",\n", 225 | " \"arg\": \"2000 psi\"\n", 226 | " },\n", 227 | " {\n", 228 | " \"field\": \"concrete_compressive_strength_at_28d\",\n", 229 | " \"op\": \"lt\",\n", 230 | " \"arg\": \"8000 psi\"\n", 231 | " },\n", 232 | " {\n", 233 | " \"field\": \"lightweight\",\n", 234 | " \"op\": \"exact\",\n", 235 | " \"arg\": False\n", 236 | " }\n", 237 | "]\n", 238 | "\n", 239 | "ec3_materials.return_fields = [\"id\", \"concrete_compressive_strength_28d\", \"gwp\", \"plant_or_group\"]\n", 240 | "ec3_materials.sort_by = \"concrete_compressive_strength_28d\" #This will sort the responses based on the field assiged to the 'sort_by' property\n", 241 | "ec3_materials.only_valid = True\n", 242 | "ec3_materials.max_records = 50\n", 243 | "postal_code = 11232\n", 244 | "\n", 245 | "mat_records = ec3_materials.get_materials_within_region_mf(\"ReadyMix\", mat_filters, postal_code, plant_distance=\"20 mi\", return_all=False)\n", 246 | "pprint(mat_records[0])" 247 | ] 248 | }, 249 | { 250 | "attachments": {}, 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "### Retrieving Projects" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": {}, 261 | "outputs": [], 262 | "source": [ 263 | "#Retrieve a project examples.\n", 264 | "#You will need projects setup in your EC3 account or be looking at publicly available projects for this to work\n", 265 | "from ec3 import EC3Projects\n", 266 | "ec3_projects = EC3Projects(bearer_token=token, ssl_verify=False)\n", 267 | "\n", 268 | "#Search by name\n", 269 | "project_name = \"[PROJECT NAME TO SEARCH]\"\n", 270 | "proj_by_name = ec3_projects.get_projects_by_name(project_name)\n", 271 | "\n", 272 | "#Search by project id\n", 273 | "project_id = \"fd0e951748f44dceb9d51c3c6a298ea2\"\n", 274 | "proj_by_id = ec3_projects.get_project_by_id(project_id)\n", 275 | "\n", 276 | "pprint(proj_by_id[0])" 277 | ] 278 | }, 279 | { 280 | "attachments": {}, 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "### Retrieving Categories" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": {}, 291 | "outputs": [], 292 | "source": [ 293 | "#Get category by id\n", 294 | "from ec3 import EC3Categories\n", 295 | "ec3_categories = EC3Categories(bearer_token=token, ssl_verify=False)\n", 296 | "\n", 297 | "cat_by_id = ec3_categories.get_category_by_id('05d49f750eed4648b7f72e3bbfc8b8e4')\n", 298 | "pprint(cat_by_id)" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | "#Get root category with the entire tree\n", 308 | "whole_tree = ec3_categories.get_all_categories()\n", 309 | "\n", 310 | "#Once you have the entire tree you can use some of the functions in utils for crawlingthrough the tree\n", 311 | "#The following function will create a dictionary with masterformat codes as keys and ids as values\n", 312 | "from ec3 import ec3_utils\n", 313 | "masterformat_dict = ec3_utils.get_masterformat_category_dict(whole_tree)\n", 314 | "pprint(masterformat_dict)" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": null, 320 | "metadata": {}, 321 | "outputs": [], 322 | "source": [ 323 | "#The following function will create a dictionary with display names as keys and ids as values\n", 324 | "displayname_dict = ec3_utils.get_displayname_category_dict(whole_tree)\n", 325 | "pprint(displayname_dict)" 326 | ] 327 | } 328 | ], 329 | "metadata": { 330 | "kernelspec": { 331 | "display_name": "ec3_wrapper", 332 | "language": "python", 333 | "name": "python3" 334 | }, 335 | "language_info": { 336 | "codemirror_mode": { 337 | "name": "ipython", 338 | "version": 3 339 | }, 340 | "file_extension": ".py", 341 | "mimetype": "text/x-python", 342 | "name": "python", 343 | "nbconvert_exporter": "python", 344 | "pygments_lexer": "ipython3", 345 | "version": "3.10.10" 346 | }, 347 | "orig_nbformat": 4, 348 | "vscode": { 349 | "interpreter": { 350 | "hash": "fdbf00880556660fdc4fac131905148da79afaec9153c0f17986ad660a5222a4" 351 | } 352 | } 353 | }, 354 | "nbformat": 4, 355 | "nbformat_minor": 2 356 | } 357 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools>=61.0"] 3 | build-backend = "setuptools.build_meta" 4 | 5 | [project] 6 | name = "ec3-python-wrapper" 7 | authors = [ 8 | { name="Jared Friedman"}, 9 | ] 10 | description = "A python wrapper around the EC3 api by Building Transparency" 11 | readme = "README.md" 12 | classifiers = [ 13 | "Programming Language :: Python :: 3", 14 | "License :: OSI Approved :: MIT License", 15 | "Operating System :: OS Independent", 16 | ] 17 | 18 | dynamic = [ 19 | "version", 20 | "keywords", 21 | "license" 22 | ] 23 | 24 | [project.urls] 25 | "Homepage" = "https://github.com/jbf1212/ec3-python-wrapper" 26 | "Bug Tracker" = "https://github.com/jbf1212/ec3-python-wrapper/issues" 27 | 28 | [tool.black] 29 | line-length = 88 30 | target-version = ['py38'] -------------------------------------------------------------------------------- /readthedocs.yaml: -------------------------------------------------------------------------------- 1 | # See https://docs.readthedocs.io/en/stable/config-file/v2.html 2 | version: 2 3 | 4 | build: 5 | os: ubuntu-22.04 6 | tools: 7 | python: "3.9" 8 | 9 | sphinx: 10 | configuration: docs/source/conf.py 11 | 12 | python: 13 | install: 14 | - method: pip 15 | path: . 16 | - requirements: requirements-dev.txt 17 | -------------------------------------------------------------------------------- /requirements-dev.txt: -------------------------------------------------------------------------------- 1 | # Docs 2 | Sphinx==5.3.0 3 | sphinx-rtd-theme==1.1.1 4 | sphinx-autoapi==2.0.0 5 | sphinxext-opengraph==0.7.5 6 | sphinx-autodoc-typehints==1.21.1 7 | 8 | # Packaging 9 | wheel==0.38.4 10 | twine==4.0.2 11 | build==0.10.0 12 | 13 | # Formatting 14 | black ; python_version >="3.6" 15 | 16 | # Utilities 17 | pgeocode==0.3.0 -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | # Utilities 2 | pgeocode==0.3.0 -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [bdist_wheel] 2 | universal=1 3 | 4 | [metadata] 5 | name = ec3-python-wrapper 6 | version = attr: ec3.__version__ 7 | 8 | description = Python Wrapper for Building Transparency EC3 API 9 | long_description = file: README.md 10 | long_description_content_type = text/markdown 11 | author = Jared Friedman 12 | url = https://github.com/jbf1212/ec3-python-wrapper 13 | license = The MIT License (MIT) 14 | copyright = Copyright 2024 Jared Friedman 15 | keywords = ec3, api 16 | classifiers = 17 | Intended Audience :: Developers 18 | Programming Language :: Python 19 | Topic :: Software Development 20 | Programming Language :: Python 21 | Programming Language :: Python :: 3.6 22 | Programming Language :: Python :: 3.7 23 | Programming Language :: Python :: 3.8 24 | Programming Language :: Python :: 3.9 25 | Programming Language :: Python :: 3.10 26 | Programming Language :: Python :: Implementation :: CPython 27 | 28 | [options] 29 | packages = find: 30 | install_requires = 31 | requests >= 2 32 | pgeocode >= 0.3.0 33 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | import setuptools 2 | 3 | setuptools.setup( 4 | package_data={ 5 | "ec3": ["py.typed"], 6 | }, 7 | ) 8 | --------------------------------------------------------------------------------