I have been working in and around Product Carbon Footprint software and the PACT Network/Methodology for close to 2 years now and since I became consumed by this space, I have searched for a way to both interact with and show off the core building blocks of the PACT ecosystem.
I’ve had a personal belief that as a developer and ecosystem participant, it would be heaps of fun to be able to play around with Product Carbon Footprints, hack on some apps and generally be able to demonstrate the capabilities of the PACT Methodology to various interested parties in a more hands-on way. To be able to explain with code and apps, what the methodology is, what it can offer in terms of efficiency benefits in the standardisation of carbon accounting, and how stakeholders can more efficiently reason about product carbon footprints would be powerful illustrative tools in the development of interest and understanding of product carbon footprints.
In the urgent race to decarbonise, organisations are recognising the critical importance of accurate carbon accounting and product carbon footprinting. The PACT Methodology, an innovative approach to calculating and reporting product carbon footprints, has emerged as a powerful tool in this endeavor.
I am very proud to announce that after a number of months of hard work, a new way to demonstrate the strengths of the PACT Methodology now exists in the release of the ZeroTwentyFifty PACT Methodology Python library. I believe that this represents a significant step forward in making product carbon footprinting more accessible and efficient.
In this article, I will be introducing ZeroTwentyFifty’s new library. This work represents another stage in the evolution of ZeroTwentyFifty’s namesake ambitions to help enable accelerated adoption of carbon accounting and the use of product carbon footprints.
The power and potential of Open Source
Open-source software development has revolutionised countless industries, and the application of open source methodologies to carbon accounting will yield similar results. By making the ZeroTwentyFifty PACT Methodology library open source, I am inviting collaboration, innovation, and scrutiny from a global community of developers, environmental experts, and businesses. This transparency not only enhances the library's quality and reliability but also fosters trust in the data it generates.
When assessing the positive impacts of OSS from the perspective of the financial, environmental and innovation functions of organisations, they are large:
- Financial:
A recently released working paper from Harvard Business School analysed the impact of Open Source Software (OSS) on businesses and estimated that organisations would have to increase their current day software spend by 350% if OSS did not exist. The paper goes on to estimate that the supply-side value of OSS is $4.15b, with a B, whilst the demand-side value of OSS is $8.8T, with a T. Where else can such multiples of value be derived?
- Environmental:
In terms of environmental benefits, there are a range of organisations finding that OSS is starting to provide acceleratory benefits on measures of sustainability innovation. However, I believe that one of the core environmental benefits of an OSS approach is in the reduction of duplicative development efforts and the ability to coalesce and utilise a shared Open Core for common functionality within the Carbon Accounting and Product Carbon Footprint space.
- Innovation:
The impacts of OSS on innovation are extensive, with a fairly thought provoking insight being gleaned from an excerpt here, which summises that innovation in larger organisations is fundamentally different in its structure and make up from smaller organisations. When you assess this statement through the historical lens of an organisation like Bell Labs, you realise the impossibility of a single smaller organisation creating such sweeping innovations. Bell Labs was only able to spend enormous amounts of capital over a sustained period of time on free-wheeling innovation attempts, due to its dominant position in the telephone market. Given that most organisations are not the size of Bell Labs, perhaps a more open approach to innovation might work?
ZeroTwentyFiffty’s ambitions and vision for the future of Open Source and Carbon Accounting
I have a vision for the future of ZeroTwentyFifty that allows us to help drive technology on carbon accounting and product carbon footprinting forward by using a combination of open source technologies, libraries and tooling. I believe that by providing open source technologies that provide stable software access to various carbon accounting methodologies, standards and protocols, barriers to entry are reduced for organisations wishing to perform vital emissions calculations, whilst the negative impacts of double spending development resources on basic work is reduced to base minimum.
I wish for ZeroTwentyFifty to act accordingly with the name it operates under, providing technical support for the Carbon Accounting and Product Carbon Footprint fields to accelerate adoption of repeatable and reliable carbon accounting processes, enabling like-for-like comparisons on products and services and a more granular data lifecycle that can make emissions hotspots visible and systematically reducible over follow up product lifecycle generations.
This is a continuation of ZeroTwentyFifty’s strategy and belief to deliver value and innovation through Open Source software. I fundamentally believe that we cannot unlock further advancements without leveraging Open Source innovation to drive us closer to a unified vision of an Internet of Emissions Data.
The ZeroTwentyFifty PACT Methodology Python Library
The ZeroTwentyFifty PACT Methodology library is a Python SDK/Client library that models the PACT Methodology as defined by the PACT Network technical specification; it is currently compatible with Version 2.2 of the technical specification.
I have chosen Python as the language for the library, due to both personal and professional familiarity with the language and its ecosystem, as well as its close ties to the scientific community and its fairly heavy usage within the OSS movement for sustainability.
The project is currently on Python 3.11, and at 464 tests and 97% test coverage, I feel confident in saying that the library has been tested to a high level of certainty. CI/CD exists on every push to the codebase, running the tests and performing a currently limited suite of linting checks. Documentation coverage has also been a priority, with code level documentation being high quality and rendered to a hosted documentation provider. The documentation system works but needs a small amount of work in light of the recent rebranding from PACT Pathfinder Framework/Network to PACT Methodology/Network.
---------- coverage: platform linux, python 3.11.9-final-0 -----------
Name Stmts Miss Cover
---------------------------------------------------------------------------------------------------
pact_methodology/__init__.py 0 0 100%
pact_methodology/assurance/__init__.py 0 0 100%
pact_methodology/assurance/assurance.py 54 1 98%
pact_methodology/carbon_footprint/__init__.py 0 0 100%
pact_methodology/carbon_footprint/biogenic_accounting_methodology.py 6 0 100%
pact_methodology/carbon_footprint/carbon_footprint.py 111 3 97%
… # omitted for brevity
---------------------------------------------------------------------------------------------------
TOTAL 2012 56 97%
462 passed, 2 xfailed in 4.34s
It is available for public viewing on Github, where you can also download it, and there is also an installable version available via Pypi, which is accessible via:
pip install pact_methodology
poetry add pact_methodology
The library in its current state can be used by organisations to create objects and interact with the PACT Methodology in a hands-on way, an example of which would be for organisations that already have an application built, but perhaps no solid library for managing or working with the core building blocks of the library. When I am referring to core building blocks, I am talking about entities such as:
- Product Footprints
- Carbon Footprints
- Data Model Extensions
- Data Quality Indicators
- Assurances
The library includes solutions for all of the listed items, as well as basic/fundamental data types defined by the specification, basically, if it’s listed as a data type in the technical specification, it is in the library.
Key Features of the ZeroTwentyFifty PACT Methodology Library:
- Basic Representation: The library provides a robust framework to represent product carbon footprints with code.
- Interoperability: The library is designed to seamlessly integrate with other carbon accounting tools and systems, whilst also promoting use of the PACT Methodology and the data sharing benefits and collaboration of the PACT Network.
- Customisability: Users can adapt the library to their specific needs, tailoring it to their industry, product types, and reporting requirements.
- Well documented code: The library is documented to a high degree, making it easy to understand and interact with the code base within your own projects.
The ZeroTwentyFifty PACT Methodology in action
If you want to see examples of how the library is used, I have built a small application for generating Product Carbon Footprints. The project is a work in progress, written in Python and can be used to build PACT formatted Product Carbon Footprints, and output them into transmissible format that is acceptable for the PACT Network.
Over the coming months, there will also be further enhancements to our ZeroTwentyFifty Open Source application, which will utilise the ZeroTwentyFifty PACT Methodology Library internally, to provide better support for more advanced interactions with the PACT Methodology and better features for users of our Product Carbon Footprint Exchange software.
Our roadmap for the ZeroTwentyFifty PACT Methodology Library
What does the library not do?
When building this library, the focus and intention has always been on creating a useful domain library for use in larger and more fully featured user facing applications, it is unlikely that many of the end users of Product Carbon Footprints will ever go near or have a use for this library, it does not contain any code related to internet connectivity or more integrated use with 3rd party components.
Who was this built for:
- Developers
- Sustainability Professionals
- Scientists
- Consultants
- Researchers
If you are looking for a more integrated app approach complete with web interfaces and database interactions, perhaps I can direct you to our ZeroTwentyFifty application.
The ZeroTwentyFifty PACT Methodology Library exists to provide developers and the teams they support an easy way of interacting with the PACT Methodology in a programmatic way. It provides common abstractions for the core building blocks of the PACT Methodology. The library does not try to shepherd you into what to build, it is up to you what you do with it. However, if I was to make some friendly suggestions, you could build:
- Command Line Interfaces
- Data Pipelines
- Web Applications
- Small scripts
- Swap out internally developed PACT Methodology code for this new library.
- Anything else you can think of
Still to come:
Whilst the library is ready for release, it’s not perfect yet, and there are some opportunities for community engagement:
- Represents the core entities: The library currently covers the essential building blocks of the PACT Methodology, and you’ll find models for Product Footprints, Carbon Footprints, Data Quality Indicators and any other concept you’ll find in the Version 2.2 specification. However, some of the interactions between these entities are not quite fleshed out yet. This has been an intentional decision that boils down to two major reasons:
- Further consultation and understanding of how the library is to be used.
- The complexity of some of the interactions between the entities.
- Support current versions of the PACT Technical Specification: As mentioned, the library is currently up to date with Version 2.2 of the PACT Methodology/Network, I have plans to get the codebase to Version 2.3.
- API is still a work in progress: This blog is an announcement for version 0.0.2 for the time being and will be continuing to release as minor updates for the foreseeable future, as a result, the API will likely evolve through some large changes as we uncover further use cases.
- Documentation rework: The documentation is hosted but there is a need to improve it, put it on a new domain reflecting the most recent rebranding from “PACT Pathfinder Framework” to the “PACT Methodology”, as well as overall improvements to the quality of the documentation.
The Road Ahead:
The release of the ZeroTwentyFifty PACT Methodology Python library is just the beginning. We're committed to continuous improvement and expansion, working with the open-source community to refine the library, develop new features, and utilise it in our ZeroTwentyFifty Open Source tool for PACT Network data exchange. Our ultimate goal is to empower businesses worldwide to embrace carbon transparency and accelerate their journey towards a sustainable future.
Benefits for Businesses and the Environment:
By adopting the ZeroTwentyFifty PACT Methodology Library, organisations can:
- Check out the PACT Methodology Today: Get started using the PACT methodology in your software and applications right away. You can use it to test ideas or build more complex applications.
- Why bother reinventing the wheel? Don't waste time and resources developing your own implementation of a carbon accounting methodology. We've already done the work for you!
- Trust in the Code: Using a well-tested implementation of the PACT methodology will give you peace of mind knowing that your code is accurate and reliable.
How you can help
The ZeroTwentyFifty PACT Methodology Library is a powerful open-source tool that has the potential to significantly ease the transition into product carbon footprinting from a PACT Methodology entry point for developers, organisations and the industry, ultimately enabling the enhancement of primary data driven carbon accounting practices. By making it freely available, we're inviting collaboration and innovation to drive the transition to a low-carbon economy. Join us in this critical mission by exploring the library and contributing to its development. Together, we can build a more sustainable future.
Speaking of togetherness, I am looking for opportunities to increase the usage, spread and visibility of this project, and whilst any amount of interaction is greatly appreciated, here are a few ways you can help:
- Developers:
- Star the repository on Github
- Use the library to build something, and then ping me and let me know what you built!
- Share it with anyone you think might get some use out of it.
- Recommend your organisation builds projects with it.
- Contribute your ideas and development time to see it progress!
- Sustainability Professionals:
- Let us know how you’re currently using the PACT Methodology
- How is it currently helping your organisation?
- Are there any issues you’re having with your use?
- How would you like to see it improved?
- Let us know how you’re currently using the PACT Methodology
- Organisations:
- Use the software!
- Talk to ZeroTwentyFifty about how we can support your use of the software!
Here is summary of the applicable links from this article, to make it easier for you to access:
ZeroTwentyFifty PACT Methodology Library:
- Github: https://github.com/ZeroTwentyFifty/pact_methodology
- Pypi: https://pypi.org/project/pact-methodology/
- Documentation: https://pathfinder-framework.readthedocs.io/en/latest/
- Solution Page: https://www.zerotwentyfifty.com/solutions/pact-methodology
If you’ve resonated with this article, I’d really appreciate you sharing this article on whatever platforms you use. Alternatively, you can follow ZeroTwentyFifty or add me on Linkedin. I release all writing on our free newsletter. You can also book a 30 minute no-obligation call with me, to talk about our range of solutions and services.
