dev-subsets-pr (#4)

- Refactored get results for MCR Labs and SC Labs (2b99de3e861c8e392d89f9322699d61a48f56646)

.gitignore

@@ -0,0 +1,8 @@
+# Ignore environment variables.
+*.env
+
+# Ignore temporary files.
+*tmp
+
+# Ignore PDFs.
+*pdfs

LICENSE

@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -18,6 +18,10 @@ tags:
 
 # Cannabis Tests, Curated by Cannlytics
 
+<div style="margin-top:1rem; margin-bottom: 1rem;">
+  <img width="240px" alt="" src="https://firebasestorage.googleapis.com/v0/b/cannlytics.appspot.com/o/public%2Fimages%2Fdatasets%2Fcannabis_tests%2Fcannabis_tests_curated_by_cannlytics.png?alt=media&token=22e4d1da-6b30-4c3f-9ff7-1954ac2739b2">
+</div>
+
 ## Table of Contents
 - [Table of Contents](#table-of-contents)
 - [Dataset Description](#dataset-description)
@@ -29,6 +33,7 @@ tags:
 - [Dataset Creation](#dataset-creation)
   - [Curation Rationale](#curation-rationale)
   - [Source Data](#source-data)
+  - [Data Collection and Normalization](#data-collection-and-normalization)
   - [Personal and Sensitive Information](#personal-and-sensitive-information)
 - [Considerations for Using the Data](#considerations-for-using-the-data)
   - [Social Impact of Dataset](#social-impact-of-dataset)
@@ -48,18 +53,19 @@ tags:
 
 ### Dataset Summary
 
-This dataset is a collection of public cannabis lab test results parsed by `CoADoc`, a certificate of analysis (COA) parsing tool.
+This dataset is a collection of public cannabis lab test results parsed by [`CoADoc`](https://github.com/cannlytics/cannlytics/tree/main/cannlytics/data/coas), a certificate of analysis (COA) parsing tool.
 
 ## Dataset Structure
 
 The dataset is partitioned into the various sources of lab results.
 
-| Source | Observations |
-|--------|--------------|
-| Raw Gardens | 2,667 |
-| MCR Labs | Coming soon! |
-| PSI Labs | Coming soon! |
-| SC Labs | Coming soon! |
+| Subset | Source | Observations |
+|--------|--------|--------------|
+| `rawgarden` | Raw Gardens | 2,667 |
+| `mcrlabs` | MCR Labs | Coming soon! |
+| `psilabs` | PSI Labs | Coming soon! |
+| `sclabs` | SC Labs | Coming soon! |
+| `washington` | Washington State | Coming soon! |
 
 ### Data Instances
 
@@ -123,8 +129,10 @@ Below is a non-exhaustive list of fields, used to standardize the various data t
 | `total_thc` | 14.00 | The analytical total of THC and THCA. |
 | `total_cbd` | 0.20 | The analytical total of CBD and CBDA. |
 | `total_terpenes` | 0.42 | The sum of all terpenes measured. |
-| `sample_id` | "{sha256-hash}" | A generated ID to uniquely identify the `producer`, `product_name`, and `date_tested`. |
-| `strain_name` | "Blue Rhino" | A strain name, if specified. Otherwise, can be attempted to be parsed from the `product_name`. |
+| `results_hash` | "{sha256-hash}" | An HMAC of the sample's `results` JSON signed with Cannlytics' public key, `"cannlytics.eth"`. |
+| `sample_id` | "{sha256-hash}" | A generated ID to uniquely identify the `producer`, `product_name`, and `results`. |
+| `sample_hash` | "{sha256-hash}" | An HMAC of the entire sample JSON signed with Cannlytics' public key, `"cannlytics.eth"`. |
+<!-- | `strain_name` | "Blue Rhino" | A strain name, if specified. Otherwise, can be attempted to be parsed from the `product_name`. | -->
 
 Each result can contain the following fields.
 
@@ -148,15 +156,17 @@ The data is split into `details`, `results`, and `values` data. Configurations f
 ```py
 from cannlytics.data.coas import CoADoc
 from datasets import load_dataset
+import pandas as pd
 
 # Download Raw Garden lab result details.
-dataset = load_dataset('cannlytics/cannabis_tests', 'rawgarden')
+repo = 'cannlytics/cannabis_tests'
+dataset = load_dataset(repo, 'rawgarden')
 details = dataset['details']
 
 # Save the data locally with "Details", "Results", and "Values" worksheets.
 outfile = 'details.xlsx'
 parser = CoADoc()
-parser.save(details, outfile)
+parser.save(details.to_pandas(), outfile)
 
 # Read the values.
 values = pd.read_excel(outfile, sheet_name='Values')
@@ -181,15 +191,44 @@ Certificates of analysis (CoAs) are abundant for cannabis cultivators, processor
 | PSI Labs Test Results | <https://results.psilabs.org/test-results/> |
 | Raw Garden Test Results | <https://rawgarden.farm/lab-results/> |
 | SC Labs Test Results | <https://client.sclabs.com/> |
+| Washington State Lab Test Results | <https://lcb.app.box.com/s/e89t59s0yb558tjoncjsid710oirqbgd> |
+
+#### Data Collection and Normalization
+
+You can recreate the dataset using the open source algorithms in the repository. First clone the repository:
+
+```
+git clone https://huggingface.co/datasets/cannlytics/cannabis_tests
+```
+
+You can then install the algorithm Python (3.9+) requirements:
+
+```
+cd cannabis_tests
+pip install -r requirements.txt
+```
+
+Then you can run all of the data-collection algorithms:
+
+```
+python algorithms/main.py
+```
+
+Or you can run each algorithm individually. For example:
+
+```
+python algorithms/get_results_mcrlabs.py
+```
 
-#### Initial Data Collection and Normalization
+In the `algorithms` directory, you can find the data collection scripts described in the table below.
 
-| Algorithm | URL |
-|-----------|-----|
-| MCR Labs Data Collection Routine | <https://github.com/cannlytics/cannlytics/tree/main/ai/curation/get_mcr_labs_data> |
-| PSI Labs Data Collection Routine | <https://github.com/cannlytics/cannlytics/tree/main/ai/curation/get_psi_labs_data> |
-| SC Labs Data Collection Routine | <https://github.com/cannlytics/cannlytics/tree/main/ai/curation/get_sc_labs_data> |
-| Raw Garden Data Collection Routine | <https://github.com/cannlytics/cannlytics/tree/main/ai/curation/get_rawgarden_data> |
+| Algorithm |  Organization | Description | 
+|-----------|---------------|-------------|
+| `get_results_mcrlabs.py` | MCR Labs | Get lab results published by MCR Labs. |
+| `get_results_psilabs.py` | PSI Labs | Get historic lab results published by MCR Labs. |
+| `get_results_rawgarden.py` | Raw Garden | Get lab results Raw Garden publishes for their products. |
+| `get_results_sclabs.py` | SC Labs | Get lab results published by SC Labs. |
+| `get_results_washington.py` | Washington State | Get historic lab results obtained through a FOIA request in Washington State. |
 
 ### Personal and Sensitive Information
 
@@ -265,4 +304,4 @@ Please cite the following if you use the code examples in your research:
 
 ### Contributions
 
-Thanks to [🔥Cannlytics](https://cannlytics.com), [@candy-o](https://github.com/candy-o), [@keeganskeate](https://github.com/keeganskeate), [The CESC](https://thecesc.org), and the entire [Cannabis Data Science Team](https://meetup.com/cannabis-data-science/members) for their contributions.
+Thanks to [🔥Cannlytics](https://cannlytics.com), [@candy-o](https://github.com/candy-o), [@hcadeaux](https://huggingface.co/hcadeaux), [@keeganskeate](https://github.com/keeganskeate), [The CESC](https://thecesc.org), and the entire [Cannabis Data Science Team](https://meetup.com/cannabis-data-science/members) for their contributions.

algorithms/algorithm_constants.py

@@ -0,0 +1,903 @@
+"""
+Cannabis Tests | Algorithm Constants
+Copyright (c) 2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 1/18/2022
+Updated: 9/16/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+"""
+
+SC_LABS_PRODUCER_IDS = [
+    '6',
+    '23',
+    '214',
+    '257',
+    '325',
+    '365',
+    '546',
+    '936',
+    '971',
+    '1064',
+    '1212',
+    '1303',
+    '1360',
+    '1503',
+    '1523',
+    '1739',
+    '1811',
+    '1822',
+    '1995',
+    '2243',
+    '2411',
+    '2619',
+    '2728',
+    '2798',
+    '2821',
+    '2850',
+    '2884',
+    '3146',
+    '3153',
+    '3193',
+    '3430',
+    '3448',
+    '3506',
+    '3785',
+    '3798',
+    '3905',
+    '3926',
+    '4069',
+    '4085',
+    '4200',
+    '4252',
+    '4287',
+    '4446',
+    '4512',
+    '4614',
+    '4702',
+    '5029',
+    '5071',
+    '5096',
+    '5139',
+    '5164',
+    '5282',
+    '5505',
+    '5560',
+    '5615',
+    '5950',
+    '6071',
+    '6109',
+    '6112',
+    '6145',
+    '6272',
+    '6331',
+    '6340',
+    '6358',
+    '6399',
+    '6437',
+    '6756',
+    '6762',
+    '6771',
+    '6791',
+    '6815',
+    '6873',
+    '6882',
+    '6887',
+    '6900',
+    '6913',
+    '6933',
+    '7005',
+    '7034',
+    '7065',
+    '7066',
+    '7102',
+    '7112',
+    '7118',
+    '7131',
+    '7132',
+    '7134',
+    '7139',
+    '7147',
+    '7149',
+    '7159',
+    '7169',
+    '7172',
+    '7176',
+    '7195',
+    '7198',
+    '7218',
+    '7221',
+    '7228',
+    '7233',
+    '7249',
+    '7250',
+    '7253',
+    '7275',
+    '7277',
+    '7284',
+    '7303',
+    '7329',
+    '7337',
+    '7346',
+    '7349',
+    '7382',
+    '7393',
+    '7396',
+    '7406',
+    '7414',
+    '7428',
+    '7454',
+    '7472',
+    '7481',
+    '7486',
+    '7503',
+    '7509',
+    '7510',
+    '7524',
+    '7544',
+    '7569',
+    '7589',
+    '7675',
+    '7885',
+    '7939',
+    '7948',
+    '7955',
+    '7959',
+    '7984',
+    '8013',
+    '8027',
+    '8042',
+    '8079',
+    '8082',
+    '8099',
+    '8101',
+    '8104',
+    '8121',
+    '8143',
+    '8156',
+    '8168',
+    '8193',
+    '8269',
+    '8278',
+    '8285',
+    '8381',
+    '8490',
+    '8497',
+    '8516',
+    '8647',
+    '8661',
+    '8676',
+    '8710',
+    '8719',
+    '8724',
+    '8732',
+    '8776',
+    '8778',
+    '8782',
+    '8791',
+    '8809',
+    '8836',
+    '8838',
+    '8839',
+    '8856',
+    '8917',
+    '8923',
+    '8940',
+    '8954',
+    '8992',
+    '9002',
+    '9013',
+    '9071',
+    '9104',
+    '9115',
+    '9147',
+    '9176',
+    '9206',
+    '9216',
+    '9220',
+    '9281',
+    '9292',
+    '9325',
+    '9346',
+    '9370',
+    '9372',
+    '9393',
+    '9420',
+    '9431',
+    '9438',
+    '9460',
+    '9473',
+    '9476',
+    '9484',
+    '9515',
+    '9516',
+    '9536',
+    '9575',
+    '9583',
+    '9584',
+    '9589',
+    '9609',
+    '9647',
+    '9689',
+    '9709',
+    '9715',
+    '9716',
+    '9725',
+    '9726',
+    '9736',
+    '9742',
+    '9745',
+    '9746',
+    '9753',
+    '9787',
+    '9796',
+    '9802',
+    '9805',
+    '9811',
+    '9848',
+    '9856',
+    '9861',
+    '9863',
+    '9872',
+    '9895',
+    '9907',
+    '9912',
+    '9923',
+    '9940',
+    '9958',
+    '9959',
+    '9965',
+    '9982',
+    '9984',
+    '10006',
+    '10014',
+    '10019',
+    '10020',
+    '10022',
+    '10033',
+    '10074',
+    '10085',
+    '10140',
+    '10145',
+    '10164',
+    '10169',
+    '10180',
+    '10197',
+    '10221',
+    '10252',
+    '10254',
+    '10265',
+    '10276',
+    '10293',
+    '10300',
+    '10307',
+    '10316',
+    '10357',
+    '10366',
+    '10376',
+    '10382',
+    '10388',
+    '10394',
+    '10405',
+    '10415',
+    '10446',
+    '10447',
+    '10474',
+    '10477',
+    '10478',
+    '10481',
+    '10482',
+    '10487',
+    '10505',
+    '10513',
+    '10519',
+    '10543',
+    '10553',
+    '10570',
+    '10573',
+    '10590',
+    '10598',
+    '10639',
+    '10644',
+    '10651',
+    '10679',
+    '10683',
+    '10685',
+    '10727',
+    '10767',
+    '10773',
+    '10783',
+    '10793',
+    '10813',
+    '10815',
+    '10830',
+    '10833',
+    '10886',
+    '10905',
+    '10915',
+    '10922',
+    '10924',
+    '10934',
+    '10998',
+    '11006',
+    '11022',
+    '11031',
+    '11033',
+    '11043',
+    '11059',
+    '11067',
+    '11073',
+    '11078',
+    '11083',
+    '11084',
+    '11086',
+    '11088',
+    '11095',
+    '11098',
+    '11119',
+    '11167',
+    '11185',
+    '11195',
+    '11198',
+    '11226',
+    '11232',
+    '11236',
+    '11237',
+    '11248',
+    '11251',
+    '11256',
+    '11259',
+    '11260',
+    '11269',
+    '11273',
+    '11288',
+    '11297',
+    '11301',
+    '11327',
+    '11344',
+    '11368',
+    '11382',
+    '11387',
+    '11399',
+    '11409',
+    '11413',
+    '11424',
+    '11433',
+]
+
+#------------------------------------------------------------------------------
+# Lab result fields.
+#------------------------------------------------------------------------------
+
+lab_result_fields = {
+    'global_id': 'string',
+    'mme_id': 'string',
+    'intermediate_type': 'category',
+    'status': 'category',
+    'global_for_inventory_id': 'string',
+    'cannabinoid_status': 'category',
+    'cannabinoid_cbc_percent': 'float',
+    'cannabinoid_cbc_mg_g': 'float',
+    'cannabinoid_cbd_percent': 'float',
+    'cannabinoid_cbd_mg_g': 'float',
+    'cannabinoid_cbda_percent': 'float',
+    'cannabinoid_cbda_mg_g': 'float',
+    'cannabinoid_cbdv_percent': 'float',
+    'cannabinoid_cbdv_mg_g': 'float',
+    'cannabinoid_cbg_percent': 'float',
+    'cannabinoid_cbg_mg_g': 'float',
+    'cannabinoid_cbga_percent': 'float',
+    'cannabinoid_cbga_mg_g': 'float',
+    'cannabinoid_cbn_percent': 'float',
+    'cannabinoid_cbn_mg_g': 'float',
+    'cannabinoid_d8_thc_percent': 'float',
+    'cannabinoid_d8_thc_mg_g': 'float',
+    'cannabinoid_d9_thca_percent': 'float',
+    'cannabinoid_d9_thca_mg_g': 'float',
+    'cannabinoid_d9_thc_percent': 'float',
+    'cannabinoid_d9_thc_mg_g': 'float',
+    'cannabinoid_thcv_percent': 'float',
+    'cannabinoid_thcv_mg_g': 'float',
+    'solvent_status': 'category',
+    'solvent_acetone_ppm': 'float',
+    'solvent_benzene_ppm': 'float',
+    'solvent_butanes_ppm': 'float',
+    'solvent_chloroform_ppm': 'float',
+    'solvent_cyclohexane_ppm': 'float',
+    'solvent_dichloromethane_ppm': 'float',
+    'solvent_ethyl_acetate_ppm': 'float',
+    'solvent_heptane_ppm': 'float',
+    'solvent_hexanes_ppm': 'float',
+    'solvent_isopropanol_ppm': 'float',
+    'solvent_methanol_ppm': 'float',
+    'solvent_pentanes_ppm': 'float',
+    'solvent_propane_ppm': 'float',
+    'solvent_toluene_ppm': 'float',
+    'solvent_xylene_ppm': 'float',
+    'foreign_matter': 'bool',
+    'foreign_matter_stems': 'float',
+    'foreign_matter_seeds': 'float',
+    'microbial_status': 'category',
+    'microbial_bile_tolerant_cfu_g': 'float',
+    'microbial_pathogenic_e_coli_cfu_g': 'float',
+    'microbial_salmonella_cfu_g': 'float',
+    'moisture_content_percent': 'float',
+    'moisture_content_water_activity_rate': 'float',
+    'mycotoxin_status': 'category',
+    'mycotoxin_aflatoxins_ppb': 'float',
+    'mycotoxin_ochratoxin_ppb': 'float',
+    'thc_percent': 'float',
+    'notes': 'string',
+    'testing_status': 'category',
+    'type': 'category',
+    'inventory_id': 'string',
+    'batch_id': 'string',
+    'parent_lab_result_id': 'string',
+    'og_parent_lab_result_id': 'string',
+    'copied_from_lab_id': 'string',
+    'external_id': 'string',
+    'lab_user_id': 'string',
+    'user_id': 'string',
+    'cannabinoid_editor': 'string',
+    'microbial_editor': 'string',
+    'mycotoxin_editor': 'string',
+    'solvent_editor': 'string',
+}
+
+lab_result_date_fields = [
+    'created_at',
+    'deleted_at',
+    'updated_at',
+    'received_at',
+]
+
+#------------------------------------------------------------------------------
+# Licensees fields.
+#------------------------------------------------------------------------------
+
+licensee_fields = {
+    'global_id': 'string',
+    'name': 'string',
+    'type': 'string',
+    'code': 'string',
+    'address1': 'string',
+    'address2': 'string',
+    'city': 'string',
+    'state_code': 'string',
+    'postal_code': 'string',
+    'country_code': 'string',
+    'phone': 'string',
+    'external_id': 'string',
+    'certificate_number': 'string',
+    'is_live': 'bool',
+    'suspended': 'bool',
+}
+
+licensee_date_fields = [
+    'created_at', # No records if issued before 2018-02-21.
+    'updated_at',
+    'deleted_at',
+    'expired_at',
+]
+
+#------------------------------------------------------------------------------
+# Inventories fields.
+#------------------------------------------------------------------------------
+
+inventory_fields = {
+    'global_id': 'string',
+    'strain_id': 'string',
+    'inventory_type_id': 'string',
+    'qty': 'float',
+    'uom': 'string',
+    'mme_id': 'string',
+    'user_id': 'string',
+    'external_id': 'string',
+    'area_id': 'string',
+    'batch_id': 'string',
+    'lab_result_id': 'string',
+    'lab_retest_id': 'string',
+    'is_initial_inventory': 'bool',
+    'created_by_mme_id': 'string',
+    'additives': 'string',
+    'serving_num': 'float',
+    'sent_for_testing': 'bool',
+    'medically_compliant': 'string',
+    'legacy_id': 'string',
+    'lab_results_attested': 'int',
+    'global_original_id': 'string',
+}
+
+inventory_date_fields = [
+    'created_at', # No records if issued before 2018-02-21.
+    'updated_at',
+    'deleted_at',
+    'inventory_created_at',
+    'inventory_packaged_at',
+    'lab_results_date',
+]
+
+#------------------------------------------------------------------------------
+# Inventory type fields.
+#------------------------------------------------------------------------------
+
+inventory_type_fields = {
+    'global_id': 'string',
+    'mme_id': 'string',
+    'user_id': 'string',
+    'external_id': 'string',
+    'uom': 'string',
+    'name': 'string',
+    'intermediate_type': 'string',
+}
+
+inventory_type_date_fields = [
+    'created_at',
+    'updated_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Strain fields.
+#------------------------------------------------------------------------------
+
+strain_fields = {
+    'mme_id': 'string',
+    'user_id': 'string',
+    'global_id': 'string',
+    'external_id': 'string',
+    'name': 'string',
+}
+strain_date_fields = [
+    'created_at',
+    'updated_at',
+    'deleted_at',
+]
+
+
+#------------------------------------------------------------------------------
+# Sales fields.
+# TODO: Parse Sales_0, Sales_1, Sales_2
+#------------------------------------------------------------------------------
+
+sales_fields = {
+    'global_id': 'string',
+    'external_id': 'string',
+    'type': 'string', # wholesale or retail_recrational
+    'price_total': 'float',
+    'status': 'string',
+    'mme_id': 'string',
+    'user_id': 'string',
+    'area_id': 'string',
+    'sold_by_user_id': 'string',
+}
+sales_date_fields = [
+    'created_at',
+    'updated_at',
+    'sold_at',
+    'deleted_at',
+]
+
+
+#------------------------------------------------------------------------------
+# Sales Items fields.
+# TODO: Parse SalesItems_0, SalesItems_1, SalesItems_2, SalesItems_3
+#------------------------------------------------------------------------------
+
+sales_items_fields = {
+    'global_id': 'string',
+    'mme_id': 'string',
+    'user_id': 'string',
+    'sale_id': 'string',
+    'batch_id': 'string',
+    'inventory_id': 'string',
+    'external_id': 'string',
+    'qty': 'float',
+    'uom': 'string',
+    'unit_price': 'float',
+    'price_total': 'float',
+    'name': 'string',
+}
+sales_items_date_fields = [
+    'created_at',
+    'updated_at',
+    'sold_at',
+    'use_by_date',
+]
+
+#------------------------------------------------------------------------------
+# Batches fields.
+# TODO: Parse Batches_0
+#------------------------------------------------------------------------------
+
+batches_fields = {
+    'external_id': 'string',
+    'num_plants': 'float',
+    'status': 'string',
+    'qty_harvest': 'float',
+    'uom': 'string',
+    'is_parent_batch': 'int',
+    'is_child_batch': 'int',
+    'type': 'string',
+    'harvest_stage': 'string',
+    'qty_accumulated_waste': 'float',
+    'qty_packaged_flower': 'float',
+    'qty_packaged_by_product': 'float',
+    'origin': 'string',
+    'source': 'string',
+    'qty_cure': 'float',
+    'plant_stage': 'string',
+    'flower_dry_weight': 'float',
+    'waste': 'float',
+    'other_waste': 'float',
+    'flower_waste': 'float',
+    'other_dry_weight': 'float',
+    'flower_wet_weight': 'float',
+    'other_wet_weight': 'float',
+    'global_id': 'string',
+    'global_area_id': 'string',
+    'area_name': 'string',
+    'global_mme_id': 'string',
+    'mme_name': 'string',
+    'mme_code': 'string',
+    'global_user_id': 'string',
+    'global_strain_id': 'string',
+    'strain_name': 'string',
+    'global_mother_plant_id': 'string',
+    'global_flower_area_id': 'string',
+    'global_other_area_id': 'string',
+}
+batches_date_fields = [
+    'created_at',
+    'updated_at',
+    'planted_at',
+    'harvested_at',
+    'batch_created_at',
+    'deleted_at',
+    'est_harvest_at',
+    'packaged_completed_at',
+    'harvested_end_at',
+]
+
+
+#------------------------------------------------------------------------------
+# Taxes fields.
+# TODO: Parse Taxes_0
+#------------------------------------------------------------------------------
+
+taxes_fields = {
+
+}
+taxes_date_fields = [
+
+]
+
+#------------------------------------------------------------------------------
+# Areas fields.
+#------------------------------------------------------------------------------
+
+areas_fields = {
+    'external_id': 'string',
+    'name': 'string',
+    'type': 'string',
+    'is_quarantine_area': 'bool',
+    'global_id': 'string',
+}
+areas_date_fields = [
+    'created_at',
+    'updated_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Inventory Transfer Items fields.
+# TODO: Parse InventoryTransferItems_0
+#------------------------------------------------------------------------------
+
+inventory_transfer_items_fields = {
+    'external_id': 'string',
+    'is_sample': 'int',
+    'sample_type': 'string',
+    'product_sample_type': 'string',
+    'description': 'string',
+    'qty': 'float',
+    'price': 'float',
+    'uom': 'string',
+    'received_qty': 'float',
+    'retest': 'int',
+    'global_id': 'string',
+    'is_for_extraction': 'int',
+    'propagation_source': 'string',
+    'inventory_name': 'string',
+    'intermediate_type': 'string',
+    'strain_name': 'string',
+    'global_mme_id': 'string',
+    'global_user_id': 'string',
+    'global_batch_id': 'string',
+    'global_plant_id': 'string',
+    'global_inventory_id': 'string',
+    'global_lab_result_id': 'string',
+    'global_received_area_id': 'string',
+    'global_received_strain_id': 'string',
+    'global_inventory_transfer_id': 'string',
+    'global_received_batch_id': 'string',
+    'global_received_inventory_id': 'string',
+    'global_received_plant_id': 'string',
+    'global_received_mme_id': 'string',
+    'global_received_mme_user_id': 'string',
+    'global_customer_id': 'string',
+    'global_inventory_type_id': 'string',
+    # Optional: Match with inventory type fields
+    # "created_at": "09/11/2018 07:39am",
+    # "updated_at": "09/12/2018 03:55am",
+    # "external_id": "123425",
+    # "name": "Charlotte's Web Pre-Packs - 3.5gm",
+    # "description": "",
+    # "storage_instructions": "",
+    # "ingredients": "",
+    # "type": "end_product",
+    # "allergens": "",
+    # "contains": "",
+    # "used_butane": 0,
+    # "net_weight": "2",
+    # "packed_qty": null,
+    # "cost": "0.00",
+    # "value": "0.00",
+    # "serving_num": 1,
+    # "serving_size": 0,
+    # "uom": "ea",
+    # "total_marijuana_in_grams": "0.000000",
+    # "total_marijuana_in_mcg": null,
+    # "deleted_at": null,
+    # "intermediate_type": "usable_marijuana",
+    # "global_id": "WAG12.TY3DE",
+    # "global_original_id": null,
+    # "weight_per_unit_in_grams": "0.00"
+    # "global_mme_id": "WASTATE1.MM30",
+    # "global_user_id": "WASTATE1.US1I",
+    # "global_strain_id": null
+}
+inventory_transfer_items_date_fields = [
+    'created_at',
+    'updated_at',
+    'received_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Inventory Transfers fields.
+# TODO: Parse InventoryTransfers_0
+#------------------------------------------------------------------------------
+
+inventory_transfers_fields = {
+    'number_of_edits': 'int',
+    'external_id': 'string',
+    'void': 'int',
+    'multi_stop': 'int',
+    'route': 'string',
+    'stops': 'string',
+    'vehicle_description': 'string',
+    'vehicle_year': 'string',
+    'vehicle_color': 'string',
+    'vehicle_vin': 'string',
+    'vehicle_license_plate': 'string',
+    'notes': 'string',
+    'transfer_manifest': 'string',
+    'manifest_type': 'string',
+    'status': 'string',
+    'type': 'string',
+    'transfer_type': 'string',
+    'global_id': 'string',
+    'test_for_terpenes': 'int',
+    'transporter_name1': 'string',
+    'transporter_name2': 'string',
+    'global_mme_id': 'string',
+    'global_user_id': 'string',
+    'global_from_mme_id': 'string',
+    'global_to_mme_id': 'string',
+    'global_from_user_id': 'string',
+    'global_to_user_id': 'string',
+    'global_from_customer_id': 'string',
+    'global_to_customer_id': 'string',
+    'global_transporter_user_id': 'string',
+}
+inventory_transfers_date_fields = [
+    'created_at',
+    'updated_at',
+    'hold_starts_at',
+    'hold_ends_at',
+    'transferred_at',
+    'est_departed_at',
+    'est_arrival_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Disposals fields.
+# Optional: Parse Disposals_0
+#------------------------------------------------------------------------------
+
+disposals_fields = {
+    'external_id': 'string',
+    'whole_plant': 'string',
+    'reason': 'string',
+    'method': 'string',
+    'phase': 'string',
+    'type': 'string',
+    'qty': 'float',
+    'uom': 'string',
+    'source': 'string',
+    'disposal_cert': 'string',
+    'global_id': 'string',
+    'global_mme_id': 'string',
+    'global_user_id': 'string',
+    'global_batch_id': 'string',
+    'global_area_id': 'string',
+    'global_plant_id': 'string',
+    'global_inventory_id': 'string',
+}
+disposals_date_fields = [
+    'created_at',
+    'updated_at',
+    'hold_starts_at',
+    'hold_ends_at',
+    'disposal_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Inventory Adjustments fields.
+# Optional: Parse InventoryAdjustments_0, InventoryAdjustments_1, InventoryAdjustments_2
+#------------------------------------------------------------------------------
+
+inventory_adjustments_fields = {
+    'external_id': 'string',
+    'qty': 'float',
+    'uom': 'string',
+    'reason': 'string',
+    'memo': 'string',
+    'global_id': 'string',
+    'global_mme_id': 'string',
+    'global_user_id': 'string',
+    'global_inventory_id': 'string',
+    'global_adjusted_by_user_id': 'string',
+}
+inventory_adjustments_date_fields = [
+    'created_at',
+    'updated_at',
+    'adjusted_at',
+    'deleted_at',
+]
+
+#------------------------------------------------------------------------------
+# Plants fields.
+#------------------------------------------------------------------------------
+
+plants_fields = {
+    'global_id': 'string',
+    'mme_id': 'string',
+    'user_id': 'string',
+    'external_id': 'string',
+    'inventory_id': 'string',
+    'batch_id': 'string',
+    'area_id': 'string',
+    'mother_plant_id': 'string',
+    'is_initial_inventory': 'string',
+    'origin': 'string',
+    'stage': 'string',
+    'strain_id': 'string',
+    'is_mother': 'string',
+    'last_moved_at': 'string',
+    'plant_harvested_end_at': 'string',
+    'legacy_id': 'string',
+}
+plants_date_fields = [
+    'created_at',
+    'deleted_at',
+    'updated_at',
+    'plant_created_at',
+    'plant_harvested_at',
+    'plant_harvested_end_at'
+]

algorithms/algorithm_utils.py

@@ -0,0 +1,240 @@
+"""
+Cannabis Tests | Utility Functions
+Copyright (c) 2021-2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 10/27/2021
+Updated: 9/16/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+"""
+# Standard imports.
+from datetime import datetime
+import re
+from typing import Any, List, Optional, Tuple
+
+# External imports.
+import pandas as pd
+from pandas import DataFrame, Series, to_datetime
+from pandas.tseries.offsets import MonthEnd
+
+
+def end_of_month(value: datetime) -> str:
+    """Format a datetime as an ISO formatted date at the end of the month.
+    Args:
+        value (datetime): A datetime value to transform into an ISO date.
+    Returns:
+        (str): An ISO formatted date.
+    """
+    month = value.month
+    if month < 10:
+        month = f'0{month}'
+    year = value.year
+    day = value + MonthEnd(0)
+    return f'{year}-{month}-{day.day}'
+
+
+def end_of_year(value: datetime) -> str:
+    """Format a datetime as an ISO formatted date at the end of the year.
+    Args:
+        value (datetime): A datetime value to transform into an ISO date.
+    Returns:
+        (str): An ISO formatted date.
+    """
+    return f'{value.year}-12-31'
+
+
+def end_of_period_timeseries(data: DataFrame, period: Optional[str] = 'M') -> DataFrame:
+    """Convert a DataFrame from beginning-of-the-period to
+    end-of-the-period timeseries.
+    Args:
+        data (DataFrame): The DataFrame to adjust timestamps.
+        period (str): The period of the time series, monthly "M" by default.
+    Returns:
+        (DataFrame): The adjusted DataFrame, with end-of-the-month timestamps.
+    """
+    data.index = data.index.to_period(period).to_timestamp(period)
+    return data
+
+
+# def forecast_arima(
+#         model: Any,
+#         forecast_horizon: Any,
+#         exogenous: Optional[Any] = None,
+# ) -> Tuple[Any]:
+#     """Format an auto-ARIMA model forecast as a time series.
+#     Args:
+#         model (ARIMA): An pmdarima auto-ARIMA model.
+#         forecast_horizon (DatetimeIndex): A series of dates.
+#         exogenous (DataFrame): Am optional DataFrame of exogenous variables.
+#     Returns:
+#         forecast (Series): The forecast series with forecast horizon index.
+#         conf (Array): A 2xN array of lower and upper confidence bounds.
+#     """
+#     periods = len(forecast_horizon)
+#     forecast, conf = model.predict(
+#         n_periods=periods,
+#         return_conf_int=True,
+#         X=exogenous,
+#     )
+#     forecast = Series(forecast)
+#     forecast.index = forecast_horizon
+#     return forecast, conf
+
+
+def format_billions(value: float, pos: Optional[int] = None) -> str: #pylint: disable=unused-argument
+    """The two args are the value and tick position."""
+    return '%1.1fB' % (value * 1e-9)
+
+
+def format_millions(value: float, pos: Optional[int] = None) -> str: #pylint: disable=unused-argument
+    """The two args are the value and tick position."""
+    return '%1.1fM' % (value * 1e-6)
+
+
+def format_thousands(value: float, pos: Optional[int] = None) -> str: #pylint: disable=unused-argument
+    """The two args are the value and tick position."""
+    return '%1.0fK' % (value * 1e-3)
+
+
+def get_blocks(files, size=65536):
+    """Get a block of a file by the given size."""
+    while True:
+        block = files.read(size)
+        if not block: break
+        yield block
+
+
+def get_number_of_lines(file_name, encoding='utf-16', errors='ignore'):
+    """
+    Read the number of lines in a large file.
+    Credit: glglgl, SU3 <https://stackoverflow.com/a/9631635/5021266>
+    License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
+    """
+    with open(file_name, 'r', encoding=encoding, errors=errors) as f:
+        count = sum(bl.count('\n') for bl in get_blocks(f))
+        print('Number of rows:', count)
+        return count
+
+
+def reverse_dataframe(data: DataFrame) -> DataFrame:
+    """Reverse the ordering of a DataFrame.
+    Args:
+        data (DataFrame): A DataFrame to re-order.
+    Returns:
+        (DataFrame): The re-ordered DataFrame.
+    """
+    return data[::-1].reset_index(drop=True)
+
+
+def set_training_period(series: Series, date_start: str, date_end: str) -> Series:
+    """Helper function to restrict a series to the desired
+    training time period.
+    Args:
+        series (Series): The series to clean.
+        date_start (str): An ISO date to mark the beginning of the training period.
+        date_end (str): An ISO date to mark the end of the training period.
+    Returns
+        (Series): The series restricted to the desired time period.
+    """
+    return series.loc[
+        (series.index >= to_datetime(date_start)) & \
+        (series.index < to_datetime(date_end))
+    ]
+
+
+def sorted_nicely(unsorted_list: List[str]) -> List[str]:
+    """Sort the given iterable in the way that humans expect.
+    Credit: Mark Byers <https://stackoverflow.com/a/2669120/5021266>
+    License: CC BY-SA 2.5 <https://creativecommons.org/licenses/by-sa/2.5/>
+    """
+    convert = lambda text: int(text) if text.isdigit() else text
+    alpha = lambda key: [convert(c) for c in re.split('([0-9]+)', key)]
+    return sorted(unsorted_list, key=alpha)
+
+
+def rmerge(left, right, **kwargs):
+    """Perform a merge using pandas with optional removal of overlapping
+    column names not associated with the join.
+
+    Though I suspect this does not adhere to the spirit of pandas merge 
+    command, I find it useful because re-executing IPython notebook cells 
+    containing a merge command does not result in the replacement of existing
+    columns if the name of the resulting DataFrame is the same as one of the
+    two merged DataFrames, i.e. data = pa.merge(data,new_dataframe). I prefer
+    this command over pandas df.combine_first() method because it has more
+    flexible join options.
+
+    The column removal is controlled by the 'replace' flag which is
+    'left' (default) or 'right' to remove overlapping columns in either the
+    left or right DataFrame. If 'replace' is set to None, the default
+    pandas behavior will be used. All other parameters are the same
+    as pandas merge command.
+
+    Author: Michelle Gill
+    Source: https://gist.github.com/mlgill/11334821
+
+    Examples
+    --------
+    >>> left       >>> right
+       a  b   c       a  c   d
+    0  1  4   9    0  1  7  13
+    1  2  5  10    1  2  8  14
+    2  3  6  11    2  3  9  15
+    3  4  7  12
+
+    >>> rmerge(left,right,on='a')
+       a  b  c   d
+    0  1  4  7  13
+    1  2  5  8  14
+    2  3  6  9  15
+
+    >>> rmerge(left,right,on='a',how='left')
+       a  b   c   d
+    0  1  4   7  13
+    1  2  5   8  14
+    2  3  6   9  15
+    3  4  7 NaN NaN
+
+    >>> rmerge(left,right,on='a',how='left',replace='right')
+       a  b   c   d
+    0  1  4   9  13
+    1  2  5  10  14
+    2  3  6  11  15
+    3  4  7  12 NaN
+
+    >>> rmerge(left,right,on='a',how='left',replace=None)
+       a  b  c_x  c_y   d
+    0  1  4    9    7  13
+    1  2  5   10    8  14
+    2  3  6   11    9  15
+    3  4  7   12  NaN NaN
+    """
+
+    # Function to flatten lists from http://rosettacode.org/wiki/Flatten_a_list#Python
+    def flatten(lst):
+        return sum(([x] if not isinstance(x, list) else flatten(x) for x in lst), [])
+
+    # Set default for removing overlapping columns in "left" to be true
+    myargs = {'replace':'left'}
+    myargs.update(kwargs)
+
+    # Remove the replace key from the argument dict to be sent to
+    # pandas merge command
+    kwargs = {k:v for k, v in myargs.items() if k != 'replace'}
+
+    if myargs['replace'] is not None:
+        # Generate a list of overlapping column names not associated with the join
+        skipcols = set(flatten([v for k, v in myargs.items() if k in ['on', 'left_on', 'right_on']]))
+        leftcols = set(left.columns)
+        rightcols = set(right.columns)
+        dropcols = list((leftcols & rightcols).difference(skipcols))
+
+        # Remove the overlapping column names from the appropriate DataFrame
+        if myargs['replace'].lower() == 'left':
+            left = left.copy().drop(dropcols, axis=1)
+        elif myargs['replace'].lower() == 'right':
+            right = right.copy().drop(dropcols, axis=1)
+
+    return pd.merge(left, right, **kwargs)

algorithms/get_results_mcrlabs.py

@@ -0,0 +1,63 @@
+"""
+Cannabis Tests | Get MCR Labs Test Result Data
+Copyright (c) 2022-2023 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 7/13/2022
+Updated: 2/6/2023
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+
+Description:
+
+    Collect all of MCR Labs' publicly published lab results.
+
+Data Points: See `cannlytics.data.coas.mcrlabs.py`.
+
+Data Sources:
+    
+    - MCR Labs Test Results
+    URL: <https://reports.mcrlabs.com>
+
+"""
+# Standard imports.
+from datetime import datetime
+import os
+
+# External imports.
+import pandas as pd
+
+# Internal imports.
+from cannlytics.data.coas.mcrlabs import get_mcr_labs_test_results
+from cannlytics.firebase import initialize_firebase, update_documents
+from cannlytics.utils.utils import to_excel_with_style
+
+
+# Specify where your data lives.
+DATA_DIR = '.datasets/lab_results/mcr_labs'
+
+# Get all of the results!
+all_results = get_mcr_labs_test_results(
+    starting_page=1,
+    pause=3,
+)
+
+# Save the results to Excel.
+data = pd.DataFrame(all_results)
+timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+if not os.path.exists(DATA_DIR): os.makedirs(DATA_DIR)
+datafile = f'{DATA_DIR}/mcr-lab-results-{timestamp}.xlsx'
+to_excel_with_style(data, datafile)
+
+# Prepare the data to upload to Firestore.
+refs, updates = [], []
+for index, obs in data.iterrows():
+    sample_id = obs['sample_id']
+    refs.append(f'public/data/lab_results/{sample_id}')
+    updates.append(obs.to_dict())
+
+# Initialize Firebase and upload the data to Firestore!
+database = initialize_firebase()
+update_documents(refs, updates, database=database)
+print('Added %i lab results to Firestore!' % len(refs))

algorithms/get_results_psilabs.py

@@ -0,0 +1,714 @@
+"""
+Cannabis Tests | Get PSI Labs Test Result Data
+Copyright (c) 2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: July 4th, 2022
+Updated: 9/16/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+
+Description:
+
+    1. Archive all of the PSI Labs test results.
+
+    2. Analyze all of the PSI Labs test results, separating
+    training and testing data to use for prediction models.
+
+    3. Create and use re-usable prediction models.
+
+Data Sources:
+
+    - PSI Labs Test Results
+    URL: <https://results.psilabs.org/test-results/>
+
+Resources:
+
+    - ChromeDriver
+    URL: <https://chromedriver.chromium.org/home>
+
+    - Automation Cartoon
+    URL: https://xkcd.com/1319/
+
+    - Efficiency Cartoon
+    URL: https://xkcd.com/1445/
+
+    - SHA in Python
+    URL: https://www.geeksforgeeks.org/sha-in-python/
+
+    - Split / Explode a column of dictionaries into separate columns with pandas
+    URL: https://stackoverflow.com/questions/38231591/split-explode-a-column-of-dictionaries-into-separate-columns-with-pandas
+
+    - Tidyverse: Wide and Long Data Tables
+    URL: https://rstudio-education.github.io/tidyverse-cookbook/tidy.html
+
+    - Web Scraping using Selenium and Python
+    URL: <https://www.scrapingbee.com/blog/selenium-python/>
+
+Setup:
+
+    1. Create a data folder `../../.datasets/lab_results/psi_labs/raw_data`.
+
+    2. Download ChromeDriver and put it in your `C:\Python39\Scripts` folder
+    or pass the `executable_path` to the `Service`.
+
+    3. Specify the `PAGES` that you want to collect.
+
+"""
+# Standard imports.
+from ast import literal_eval
+from datetime import datetime
+from hashlib import sha256
+import hmac
+from time import sleep
+
+# External imports.
+from cannlytics.utils.utils import snake_case
+import pandas as pd
+
+# Selenium imports.
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+from selenium.common.exceptions import ElementNotInteractableException, TimeoutException
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+
+
+# Setup.
+DATA_DIR = '../../.datasets/lab_results/raw_data/psi_labs'
+TRAINING_DATA = '../../../.datasets/lab_results/training_data'
+
+# API Constants
+BASE = 'https://results.psilabs.org/test-results/?page={}'
+PAGES = range(1, 10) # 4921 total!
+
+# Desired order for output columns.
+COLUMNS = [
+    'sample_id',
+    'date_tested',
+    'analyses',
+    'producer',
+    'product_name',
+    'product_type',
+    'results',
+    'coa_urls',
+    'images',
+    'lab_results_url',
+    'date_received',
+    'method',
+    'qr_code',
+    'sample_weight',
+]
+
+
+def create_sample_id(private_key, public_key, salt='') -> str:
+    """Create a hash to be used as a sample ID.
+    The standard is to use:
+        1. `private_key = producer`
+        2. `public_key = product_name`
+        3. `salt = date_tested`
+    Args:
+        private_key (str): A string to be used as the private key.
+        public_key (str): A string to be used as the public key.
+        salt (str): A string to be used as the salt, '' by default (optional).
+    Returns:
+        (str): A sample ID hash.
+    """
+    secret = bytes(private_key, 'UTF-8')
+    message = snake_case(public_key) + snake_case(salt)
+    sample_id = hmac.new(secret, message.encode(), sha256).hexdigest()
+    return sample_id
+
+
+#-----------------------------------------------------------------------
+# Getting ALL the data.
+#-----------------------------------------------------------------------
+
+def get_psi_labs_test_results(driver, max_delay=5, reverse=True) -> list:
+    """Get all test results for PSI labs.
+    Args:
+        driver (WebDriver): A Selenium Chrome WebDiver.
+        max_delay (float): The maximum number of seconds to wait for rendering (optional).
+        reverse (bool): Whether to collect in reverse order, True by default (optional).
+    Returns:
+        (list): A list of dictionaries of sample data.
+    """
+
+    # Get all the samples on the page.
+    samples = []
+    try:
+        detect = EC.presence_of_element_located((By.TAG_NAME, 'sample-card'))
+        WebDriverWait(driver, max_delay).until(detect)
+    except TimeoutException:
+        print('Failed to load page within %i seconds.' % max_delay)
+        return samples
+    cards = driver.find_elements(by=By.TAG_NAME, value='sample-card')
+    if reverse:
+        cards.reverse()
+    for card in cards:
+
+        # Begin getting sample details from the card.
+        details = card.find_element(by=By.TAG_NAME, value='md-card-title')
+
+        # Get images.
+        image_elements = details.find_elements(by=By.TAG_NAME, value='img')
+        images = []
+        for image in image_elements:
+            src = image.get_attribute('src')
+            filename = src.split('/')[-1]
+            images.append({'url': src, 'filename': filename})
+
+        # Get the product name.
+        product_name = details.find_element(by=By.CLASS_NAME, value='md-title').text
+
+        # Get the producer, date tested, and product type.
+        headers = details.find_elements(by=By.CLASS_NAME, value='md-subhead')
+        producer = headers[0].text
+        try:
+            mm, dd, yy = tuple(headers[1].text.split(': ')[-1].split('/'))
+            date_tested = f'20{yy}-{mm}-{dd}'
+        except ValueError:
+            date_tested = headers[1].text.split(': ')[-1]
+        product_type = headers[2].text.split(' ')[-1]
+
+        # Create a sample ID.
+        private_key = bytes(date_tested, 'UTF-8')
+        public_key = snake_case(product_name)
+        salt = snake_case(producer)
+        sample_id = hmac.new(private_key, (public_key + salt).encode(), sha256).hexdigest()
+
+        # Get the analyses.
+        analyses = []
+        container = details.find_element(by=By.CLASS_NAME, value='layout-row')
+        chips = container.find_elements(by=By.TAG_NAME, value='md-chip')
+        for chip in chips:
+            hidden = chip.get_attribute('aria-hidden')
+            if hidden == 'false':
+                analyses.append(chip.text)
+
+        # Get the lab results URL.
+        links = card.find_elements(by=By.TAG_NAME, value='a')
+        lab_results_url = links[0].get_attribute('href')
+
+        # Aggregate sample data.
+        sample = {
+            'analyses': analyses,
+            'date_tested': date_tested,
+            'images': images,
+            'lab_results_url': lab_results_url,
+            'producer': producer,
+            'product_name': product_name,
+            'product_type': product_type,
+            'sample_id': sample_id,
+        }
+        samples.append(sample)
+
+    return samples
+
+
+def get_psi_labs_test_result_details(driver, max_delay=5) -> dict:
+    """Get the test result details for a specific PSI lab result.
+    Args:
+        driver (WebDriver): A Selenium Chrome WebDiver.
+        max_delay (float): The maximum number of seconds to wait for rendering.
+    Returns:
+        (dict): A dictionary of sample details.
+    """
+
+    # Deemed optional:
+    # Wait for elements to load, after a maximum delay of X seconds.
+    qr_code, coa_urls = None, []
+    # try:
+
+    #     # Wait for the QR code to load.
+    #     detect = EC.presence_of_element_located((By.CLASS_NAME, 'qrcode-link'))
+    #     qr_code_link = WebDriverWait(driver, max_delay).until(detect)
+
+    #     # Get the QR code.
+    #     qr_code = qr_code_link.get_attribute('href')
+
+    #     # Get CoA URLs by finding all links with with `analytics-event="PDF View"`.
+    #     actions = driver.find_elements(by=By.TAG_NAME, value='a')
+    #     coa_urls = []
+    #     for action in actions:
+    #         event = action.get_attribute('analytics-event')
+    #         if event == 'PDF View':
+    #             href = action.get_attribute('href')
+    #             coa_urls.append({'filename': action.text, 'url': href})
+
+    # except TimeoutException:
+    #     print('QR Code not loaded within %i seconds.' % max_delay)
+
+
+    # Wait for the results to load.
+    try:
+        detect = EC.presence_of_element_located((By.TAG_NAME, 'ng-include'))
+        WebDriverWait(driver, max_delay).until(detect)
+    except TimeoutException:
+        print('Results not loaded within %i seconds.' % max_delay)
+
+    # Get results for each analysis.
+    results = []
+    date_received, sample_weight, method = None, None, None
+    values = ['name', 'value', 'margin_of_error']
+    analysis_cards = driver.find_elements(by=By.TAG_NAME, value='ng-include')
+    for analysis in analysis_cards:
+        try:
+            analysis.click()
+        except ElementNotInteractableException:
+            continue
+        rows = analysis.find_elements(by=By.TAG_NAME, value='tr')
+        if rows:
+            for row in rows:
+                result = {}
+                cells = row.find_elements(by=By.TAG_NAME, value='td')
+                for i, cell in enumerate(cells):
+                    key = values[i]
+                    result[key] = cell.text
+                if result:
+                    results.append(result)
+
+        # Get the last few sample details: method, sample_weight, and received_at
+        if analysis == 'potency':
+            extra = analysis.find_element(by=By.TAG_NAME, value='md-card-content')
+            headings = extra.find_elements(by=By.TAG_NAME, value='h3')
+            mm, dd, yy = tuple(headings[0].text.split('/'))
+            date_received = f'20{yy}-{mm}-{dd}'
+            sample_weight = headings[1].text
+            method = headings[-1].text
+
+    # Aggregate sample details.
+    details = {
+        'coa_urls': coa_urls,
+        'date_received': date_received,
+        'method': method,
+        'qr_code': qr_code,
+        'results': results,
+        'sample_weight': sample_weight,
+    }
+    return details
+
+
+# FIXME: This function doesn't work well.
+def get_all_psi_labs_test_results(service, pages, pause=0.125, verbose=True):
+    """Get ALL of PSI Labs test results.
+    Args:
+        service (ChromeDriver): A ChromeDriver service.
+        pages (iterable): A range of pages to get lab results from.
+        pause (float): A pause between requests to respect PSI Labs' server.
+        verbose (bool): Whether or not to print out progress, True by default (optional).
+    Returns:
+        (list): A list of collected lab results.
+    """
+
+    # Create a headless Chrome browser.
+    options = Options()
+    options.headless = True
+    options.add_argument('--window-size=1920,1200')
+    driver = webdriver.Chrome(options=options, service=service)
+
+    # Iterate over all of the pages to get all of the samples.
+    test_results = []
+    for page in pages:
+        if verbose:
+            print('Getting samples on page:', page)
+        driver.get(BASE.format(str(page)))
+        results = get_psi_labs_test_results(driver)
+        if results:
+            test_results += results
+        else:
+            print('Failed to find samples on page:', page)
+        sleep(pause)
+
+    # Get the details for each sample.
+    for i, test_result in enumerate(test_results):
+        if verbose:
+            print('Getting details for:', test_result['product_name'])
+        driver.get(test_result['lab_results_url'])
+        details = get_psi_labs_test_result_details(driver)
+        test_results[i] = {**test_result, **details}
+        sleep(pause)
+
+    # Close the browser and return the results.
+    driver.quit()
+    return test_results
+
+
+#-----------------------------------------------------------------------
+# Test: Data aggregation with `get_all_psi_labs_test_results`.
+#-----------------------------------------------------------------------
+
+# if __name__ == '__main__':
+
+#     # Specify the full-path to your chromedriver.
+#     # You can also put your chromedriver in `C:\Python39\Scripts`.
+#     # DRIVER_PATH = '../assets/tools/chromedriver_win32/chromedriver'
+#     # full_driver_path = os.path.abspath(DRIVER_PATH)
+#     start = datetime.now()
+#     service = Service()
+
+#     # Create a headless Chrome browser.
+#     options = Options()
+#     options.headless = True
+#     options.add_argument('--window-size=1920,1200')
+#     driver = webdriver.Chrome(options=options, service=service)
+
+#     # Iterate over all of the pages to get all of the samples.
+#     errors = []
+#     test_results = []
+#     pages = list(PAGES)
+#     pages.reverse()
+#     for page in pages:
+#         print('Getting samples on page:', page)
+#         driver.get(BASE.format(str(page)))
+#         results = get_psi_labs_test_results(driver)
+#         if results:
+#             test_results += results
+#         else:
+#             print('Failed to find samples on page:', page)
+#             errors.append(page)
+
+#     # Get the details for each sample.
+#     rows = []
+#     samples = pd.DataFrame(test_results)
+#     total = len(samples)
+#     for index, values in samples.iterrows():
+#         percent = round((index  + 1) / total * 100, 2)
+#         print('Collecting (%.2f%%) (%i/%i):' % (percent, index + 1, total), values['product_name'])
+#         driver.get(values['lab_results_url'])
+#         details = get_psi_labs_test_result_details(driver)
+#         rows.append({**values.to_dict(), **details})
+            
+#     # Save the results.
+#     data = pd.DataFrame(rows)
+#     timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+#     datafile = f'{DATA_DIR}/psi-lab-results-{timestamp}.xlsx'
+#     data.to_excel(datafile, index=False)
+#     end = datetime.now()
+#     print('Runtime took:', end - start)
+
+#     # Close the browser.
+#     driver.quit()
+
+
+#-----------------------------------------------------------------------
+# TODO: Preprocessing the Data
+#-----------------------------------------------------------------------
+
+ANALYSES = {
+    'cannabinoids': ['potency', 'POT'],
+    'terpenes': ['terpene', 'TERP'],
+    'residual_solvents': ['solvent', 'RST'],
+    'pesticides': ['pesticide', 'PEST'],
+    'microbes': ['microbial', 'MICRO'],
+    'heavy_metals': ['metal', 'MET'],
+}
+ANALYTES = {
+    # TODO: Define all of the known analytes from the Cannlytics library.
+}
+DECODINGS = {
+    '<LOQ': 0,
+    '<LOD': 0,
+    'ND': 0,
+}
+
+
+# Read in the saved results.
+datafile = f'{DATA_DIR}/aggregated-cannabis-test-results.xlsx'
+data = pd.read_excel(datafile, sheet_name='psi_labs_raw_data')
+
+# Optional: Drop rows with no analyses at this point.
+drop = ['coa_urls', 'date_received', 'method', 'qr_code', 'sample_weight']
+data.drop(drop, axis=1, inplace=True)
+
+# Isolate a training sample.
+sample = data.sample(100, random_state=420)
+
+
+# Create both wide and long data for ease of use.
+# See: https://rstudio-education.github.io/tidyverse-cookbook/tidy.html
+# Normalize and clean the data. In particular, flatten:
+# ✓ `analyses`
+# ✓ `results`
+# - `images`
+wide_data = pd.DataFrame()
+long_data = pd.DataFrame()
+for index, row in sample.iterrows():
+    series = row.copy()
+    analyses = literal_eval(series['analyses'])
+    images = literal_eval(series['images'])
+    results = literal_eval(series['results'])
+    series.drop(['analyses', 'images', 'results'], inplace=True)
+
+    # Code analyses.
+    if not analyses:
+        continue
+    for analysis in analyses:
+        series[analysis] = 1
+    
+    # Add to wide data.
+    wide_data = pd.concat([wide_data, pd.DataFrame([series])])
+
+    # Iterate over results, cleaning results and adding columns.
+    # Future work: Augment results with key, limit, and CAS.
+    for result in results:
+
+        # Clean the values.
+        analyte_name = result['name']
+        measurements = result['value'].split(' ')
+        try:
+            measurement = float(measurements[0])
+        except:
+            measurement = None
+        try:
+            units = measurements[1]
+        except:
+            units = None
+        key = snake_case(analyte_name)
+        try:
+            margin_of_error = float(result['margin_of_error'].split(' ')[-1])
+        except:
+            margin_of_error = None
+
+        # Format long data.
+        entry = series.copy()
+        entry['analyte'] = key
+        entry['analyte_name'] = analyte_name
+        entry['result'] = measurement
+        entry['units'] = units
+        entry['margin_of_error'] = margin_of_error
+
+        # Add to long data.
+        long_data = pd.concat([long_data, pd.DataFrame([entry])])
+
+
+# Fill null observations.
+wide_data = wide_data.fillna(0)
+
+# Rename columns
+analyses = {
+    'POT': 'cannabinoids',
+    'RST': 'residual_solvents',
+    'TERP': 'terpenes',
+    'PEST': 'pesticides',
+    'MICRO': 'micro',
+    'MET': 'heavy_metals',
+}
+wide_data.rename(columns=analyses, inplace=True)
+long_data.rename(columns=analyses, inplace=True)
+
+
+#------------------------------------------------------------------------------
+# Processing the data.
+#------------------------------------------------------------------------------
+
+# Calculate totals:
+# - `total_cbd`
+# - `total_thc`
+# - `total_terpenes`
+# - `total_cannabinoids`
+# - `total_cbg`
+# - `total_thcv`
+# - `total_cbc`
+# - `total_cbdv`
+
+
+# Optional: Add `status` variables for pass / fail tests.
+
+
+# TODO: Augment with:
+# - lab details: lab, lab_url, lab_license_number, etc.
+# - lab_latitude, lab_longitude
+
+# Future work: Calculate average results by state, county, and zip code.
+
+
+#------------------------------------------------------------------------------
+# Exploring the data.
+#------------------------------------------------------------------------------
+
+# Count the number of various tests.
+terpenes = wide_data.loc[wide_data['terpenes'] == 1]
+
+# Find all of the analytes.
+analytes = list(long_data.analyte.unique())
+
+# Find all of the product types.
+product_types = list(long_data.product_type.unique())
+
+# Look at cannabinoid distributions by type.
+flower = long_data.loc[long_data['product_type'] == 'Flower']
+flower.loc[flower['analyte'] == '9_thc']['result'].hist(bins=100)
+
+concentrates = long_data.loc[long_data['product_type'] == 'Concentrate']
+concentrates.loc[concentrates['analyte'] == '9_thc']['result'].hist(bins=100)
+
+
+# Look at terpene distributions by type!
+terpene = flower.loc[flower['analyte'] == 'dlimonene']
+terpene['result'].hist(bins=100)
+
+terpene = concentrates.loc[concentrates['analyte'] == 'dlimonene']
+terpene['result'].hist(bins=100)
+
+
+# Find the first occurrences of famous strains.
+gorilla_glue = flower.loc[
+    (flower['product_name'].str.contains('gorilla', case=False)) |
+    (flower['product_name'].str.contains('glu', case=False))    
+]
+
+# Create strain fingerprints: histograms of dominant terpenes.
+compound = gorilla_glue.loc[gorilla_glue['analyte'] == '9_thc']
+compound['result'].hist(bins=100)
+
+
+#------------------------------------------------------------------------------
+# Exploring the data.
+#------------------------------------------------------------------------------
+
+# Future work: Augment results with key, limit, and CAS.
+
+# TODO: Save the curated data, both wide and long data.
+
+
+# TODO: Standardize the `analyte` names! Ideally with a re-usable function.
+
+
+# TODO: Standardize `analyses`.
+
+
+# TODO: Standardize the `product_type`.
+
+
+# TODO: Standardize `strain_name`.
+
+
+# TODO: Add any new entries to the Cannlypedia:
+# - New `analyses`
+# - New `analytes`
+# - New `strains`
+# - New `product_types`
+
+
+# Optional: Create data / CoA NFTs for the lab results!!!
+
+
+#------------------------------------------------------------------------------
+# Exploring the data.
+#------------------------------------------------------------------------------
+
+# TODO: Count the number of lab results scraped!
+
+
+# TODO: Count the number of unique data points scraped!
+
+
+# TODO: Look at cannabinoid concentrations over time.
+
+
+# TODO: Look at cannabinoid distributions by type.
+
+
+# TODO: Look at terpene distributions by type!
+
+
+#-----------------------------------------------------------------------
+# Modeling the data.
+#-----------------------------------------------------------------------
+
+# TODO: Given a lab result, predict if it's in the Xth percentile.
+
+
+# TODO: Use in ARIMA model to approach the question:
+# Are terpene or cannabinoid concentrations increasing over time by sample type?
+# - total_terpenes
+# - D-limonene
+# - beta-pinene
+# - myrcene
+# - caryophyllene
+# - linalool
+# - cbg
+# - thcv
+# - total_thc
+# - total_cbd
+# - total_cannabinoids
+
+
+# Calculate THC to CBD ratio.
+
+
+# Calculate average terpene ratios by strain:
+# - beta-pinene to d-limonene ratio
+# - humulene to caryophyllene
+# - linalool and myrcene? (Research these!)
+
+
+# Future work: Add description of why the ratio is meaningful.
+
+
+# Future work: Calculator to determine the number of mg's of each
+# compound are in a given unit of weight.
+# E.g. How much total THC in mg is in an eighth given that it tests X%.
+# mg = percent * 10 * grams
+# mg_per_serving = percent * 10 * grams_per_serving (0.33 suggested?)
+
+
+# TODO: Find parents and crosses of particular strains.
+# E.g. Find all Jack crosses.
+
+
+#-----------------------------------------------------------------------
+# Training and testing the model.
+#-----------------------------------------------------------------------
+
+# TODO: Separate results after 2020 as test data.
+
+
+# TODO: Estimate a large number of ARIMA models on the training data,
+# use the models to predict the test data, and measure the accuracies.
+
+
+# TODO: Pick the model that predicts the test data the best.
+
+
+#-----------------------------------------------------------------------
+# Evaluating the model.
+#-----------------------------------------------------------------------
+
+# TODO: Re-estimate the model with the entire dataset.
+
+
+# TODO: Predict if cannabinoid and terpene concentrations are trending
+# up or down and to what degree if so.
+
+
+# TODO: Take away an insight: Is there statistical evidence that
+# cannabis cultivated in Michigan is successfully being bred to, on average,
+# have higher levels of cannabinoids or terpenes? If so, which compounds?
+
+
+# TODO: Forecast: If the trend continues, what would cannabis look like
+# in 10 years? What average cannabinoid and terpene concentration can
+# we expect to see in Michigan in 2025 and 2030?
+
+
+
+#-----------------------------------------------------------------------
+# Saving the data, statistics, and model.
+#-----------------------------------------------------------------------
+# Note: The data, statistics, and model are only useful if we can get
+# them # in front of people's eyeballs. Therefore, saving the data and
+# making them available to people is arguably the most important step.
+#-----------------------------------------------------------------------
+
+# TODO: Upload the data to Firestore.
+
+
+# TODO: Test getting the data and statistics through the Cannlytics API.
+
+
+# TODO: Test using the statistical model through the Cannlytics API.

algorithms/{get_all_rawgarden_data.py → get_results_rawgarden.py}

@@ -1,13 +1,13 @@
 """
-Get Raw Garden Test Result Data
+Cannabis Tests | Get Raw Garden Test Result Data
 Copyright (c) 2022 Cannlytics
 
 Authors:
     Keegan Skeate <https://github.com/keeganskeate>
     Candace O'Sullivan-Sutherland <https://github.com/candy-o>
 Created: 8/23/2022
-Updated: 9/13/2022
-License: <https://github.com/cannlytics/cannlytics/blob/main/LICENSE>
+Updated: 9/22/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
 
 Description:
 
@@ -56,13 +56,13 @@ from cannlytics.utils.constants import DEFAULT_HEADERS
 # Specify where your data lives.
 BUCKET_NAME = 'cannlytics-company.appspot.com'
 COLLECTION = 'public/data/lab_results'
-STORAGE_REF = 'data/lab_results/raw_garden'
+STORAGE_REF = 'data/lab_results/rawgarden'
 
 # Create directories if they don't already exist.
 # TODO: Edit `ENV_FILE` and `DATA_DIR` as needed for your desired setup.
 ENV_FILE = '../.env'
-DATA_DIR = '.././'
-COA_DATA_DIR = f'{DATA_DIR}/raw_garden'
+DATA_DIR = '../'
+COA_DATA_DIR = f'{DATA_DIR}/rawgarden'
 COA_PDF_DIR = f'{COA_DATA_DIR}/pdfs'
 TEMP_PATH = f'{COA_DATA_DIR}/tmp'
 if not os.path.exists(DATA_DIR): os.makedirs(DATA_DIR)
@@ -141,6 +141,7 @@ def get_rawgarden_products(
 def download_rawgarden_coas(
         items: pd.DataFrame,
         pause: Optional[float] = 0.24,
+        replace: Optional[bool] = False,
         verbose: Optional[bool] = True,
     ) -> None:
     """Download Raw Garden product COAs to `product_subtype` folders.
@@ -149,6 +150,8 @@ def download_rawgarden_coas(
             and `lab_results_url` to download.
         pause (float): A pause to respect the server serving the PDFs,
             `0.24` seconds by default (optional).
+        replace (bool): Whether or not to replace any existing PDFs,
+            `False` by default (optional).
         verbose (bool): Whether or not to print status, `True` by
             default (optional).
     """
@@ -172,6 +175,8 @@ def download_rawgarden_coas(
         filename = url.split('/')[-1]
         folder = kebab_case(subtype)
         outfile = os.path.join(COA_PDF_DIR, folder, filename)
+        if os.path.isfile(outfile):
+            continue
         response = requests.get(url, headers=DEFAULT_HEADERS)
         with open(outfile, 'wb') as pdf:
             pdf.write(response.content)
@@ -263,6 +268,8 @@ def parse_rawgarden_coas(
             if verbose:
                 print('Parsed:', filename)
 
+            # TODO: Save intermittently?
+
     return parsed, unidentified
 
 
@@ -311,7 +318,7 @@ def upload_lab_results(
 #
 #    1. Finding products and their COA URLS.
 #    2. Downloading COA PDFs from their URLs.
-#    3. Using CoADoc to parse the COA PDFs (with OCR).
+#    3. Using CoADoc to parse the COA PDFs (with OCR as needed).
 #    4. Saving the data to datafiles, Firebase Storage, and Firestore.
 #
 #-----------------------------------------------------------------------
@@ -331,7 +338,7 @@ if __name__ == '__main__':
         args = {}
 
     # Specify collection period.
-    DAYS_AGO = args.get('days_ago', 1)
+    DAYS_AGO = args.get('days_ago', 365)
     GET_ALL =  args.get('get_all', True)
 
     # === Data Collection ===
@@ -357,6 +364,7 @@ if __name__ == '__main__':
     )
 
     # Merge the `products`'s `product_subtype` with the COA data.
+    # FIXME: Keep the URL (`lab_results_url`)!
     coa_df = rmerge(
         pd.DataFrame(coa_data),
         products,
@@ -398,20 +406,20 @@ if __name__ == '__main__':
     # === Firebase Database and Storage ===
 
     # Optional: Initialize Firebase.
-    initialize_firebase(ENV_FILE)
+    # initialize_firebase(ENV_FILE)
 
-    # Optional: Upload the lab results to Firestore.
-    upload_lab_results(
-        coa_df.to_dict(orient='records'),
-        update=True,
-        verbose=True
-    )
+    # # Optional: Upload the lab results to Firestore.
+    # upload_lab_results(
+    #     coa_df.to_dict(orient='records'),
+    #     update=True,
+    #     verbose=True
+    # )
 
-    # Optional: Upload datafiles to Firebase Storage.
-    storage_datafile = '/'.join([STORAGE_REF, datafile.split('/')[-1]])
-    storage_error_file = '/'.join([STORAGE_REF, error_file.split('/')[-1]])
-    upload_file(storage_datafile, datafile, bucket_name=BUCKET_NAME)
-    upload_file(storage_error_file, error_file, bucket_name=BUCKET_NAME)
+    # # Optional: Upload datafiles to Firebase Storage.
+    # storage_datafile = '/'.join([STORAGE_REF, datafile.split('/')[-1]])
+    # storage_error_file = '/'.join([STORAGE_REF, error_file.split('/')[-1]])
+    # upload_file(storage_datafile, datafile, bucket_name=BUCKET_NAME)
+    # upload_file(storage_error_file, error_file, bucket_name=BUCKET_NAME)
 
     # == Data Aggregation ===
 
@@ -422,7 +430,6 @@ if __name__ == '__main__':
     # datafiles = [
     #     f'{COA_DATA_DIR}/d7815fd2a097d06b719aadcc00233026f86076a680db63c532a11b67d7c8bc70.xlsx',
     #     f'{COA_DATA_DIR}/01880e30f092cf5739f9f2b58de705fc4c245d6859c00b50505a3a802ff7c2b2.xlsx',
-    #     f'{COA_DATA_DIR}/154de9b1992a1bfd9a07d2e52c702e8437596923f34bee43f62f3e24f042b81c.xlsx',
     # ]
 
     # # Create custom column order.

algorithms/get_results_sclabs.py

@@ -0,0 +1,133 @@
+"""
+Cannabis Tests | Get SC Labs Test Result Data
+Copyright (c) 2022-2023 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 7/8/2022
+Updated: 2/6/2023
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+
+Description:
+
+    Collect all of SC Labs' publicly published lab results.
+
+Algorithm:
+
+    1. Discover all SC Labs public clients by scanning:
+
+      https://client.sclabs.com/client/{client}/
+
+    2. Iterate over pages for each client, collecting samples until
+    the 1st sample and active page are the same:
+
+        https://client.sclabs.com/client/{client}/?page={page}
+
+    3. (a) Get the sample details for each sample found.
+       (b) Save the sample details.
+
+Data Sources:
+    
+    - SC Labs Test Results
+    URL: <https://client.sclabs.com/>
+
+"""
+# Standard imports.
+from datetime import datetime
+import math
+import os
+from time import sleep
+
+# External imports.
+import pandas as pd
+
+# Internal imports.
+from cannlytics.data.coas.sclabs import (
+    get_sc_labs_sample_details,
+    get_sc_labs_test_results,
+)
+from cannlytics.firebase import initialize_firebase, update_documents
+
+# Specify where your data lives.
+RAW_DATA = '../../../.datasets/lab_results/raw_data/sc_labs'
+
+# Future work: Figure out a more efficient way to find all producer IDs.
+PAGES = range(1, 12_000)
+PRODUCER_IDS = list(PAGES)
+PRODUCER_IDS.reverse()
+
+# Alternatively, uncomment to read in the known producer IDs.
+# from algorithm_constants import SC_LABS_PRODUCER_IDS as PRODUCER_IDS
+
+# Iterate over potential client pages and client sample pages.
+start = datetime.now()
+clients = []
+errors = []
+test_results = []
+for _id in PRODUCER_IDS:
+    results = get_sc_labs_test_results(_id)
+    if results:
+        test_results += results
+        print('Found all samples for producer:', _id)
+        clients.append(_id)
+    sleep(3)
+
+# Save the results, just in case.
+data = pd.DataFrame(test_results)
+timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+if not os.path.exists(RAW_DATA): os.makedirs(RAW_DATA)
+datafile = f'{RAW_DATA}/sc-lab-results-{timestamp}.xlsx'
+data.to_excel(datafile, index=False)
+end = datetime.now()
+print('Sample collection took:', end - start)
+
+# Read in the saved test results (useful for debugging).
+start = datetime.now()
+data = pd.read_excel(datafile)
+
+# Get the sample details for each sample found.
+errors = []
+rows = []
+subset = data.loc[data['results'].isnull()]
+total = len(subset)
+for index, values in subset.iterrows():
+    if not math.isnan(values['results']):
+        continue
+    percent = round((index  + 1) * 100 / total, 2)
+    sample = values['lab_results_url'].split('/')[-2]
+    details = get_sc_labs_sample_details(sample)
+    rows.append({**values.to_dict(), **details})
+    if details['results']:
+        print('Results found (%.2f%%) (%i/%i):' % (percent, index + 1, total), sample)
+    else:
+        print('No results found (%.2f%%) (%i/%i):' % (percent, index + 1, total), sample)
+    sleep(3)
+
+    # Save every 500 samples just in case.
+    if index % 500 == 0 and index != 0:
+        data = pd.DataFrame(rows)
+        timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+        datafile = f'{RAW_DATA}/sc-lab-results-{timestamp}.xlsx'
+        data.to_excel(datafile, index=False)
+        print('Saved data:', datafile)
+
+# Save the final results.
+data = pd.DataFrame(rows)
+timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+datafile = f'{RAW_DATA}/sc-lab-results-{timestamp}.xlsx'
+data.to_excel(datafile, index=False)
+end = datetime.now()
+print('Detail collection took:', end - start)
+
+# Prepare the data to upload to Firestore.
+refs, updates = [], []
+for index, obs in data.iterrows():
+    sample_id = obs['sample_id']
+    refs.append(f'public/data/lab_results/{sample_id}')
+    updates.append(obs.to_dict())
+
+# Initialize Firebase and upload the data to Firestore!
+database = initialize_firebase()
+update_documents(refs, updates, database=database)
+print('Added %i lab results to Firestore!' % len(refs))

algorithms/get_results_sdpharmlabs.py

@@ -0,0 +1,28 @@
+"""
+Cannabis Tests | Get SDPharmLabs Test Result Data
+Copyright (c) 2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 8/23/2022
+Updated: 9/20/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+
+Description:
+
+    Curate SDPharmLabs' publicly published lab results by:
+
+        1. Finding products and their COA URLS on SDPharmLabs' website.
+        2. Downloading COA PDFs from their URLs.
+        3. Using CoADoc to parse the COA PDFs (with OCR if needed).
+        4. Archiving the COA data in Firestore.
+
+Data Source:
+
+    - SDPharmLabs
+    URL: <https://sandiego.pharmlabscannabistesting.com/>
+
+"""
+
+base = 'https://sandiego.pharmlabscannabistesting.com/results'

algorithms/get_results_washington_ccrs.py

@@ -0,0 +1,471 @@
+"""
+Cannabis Tests | Washington State
+Copyright (c) 2022 Cannlytics
+
+Authors: Keegan Skeate <https://github.com/keeganskeate>
+Created: 9/23/2022
+Updated: 9/27/2022
+License: <https://github.com/cannlytics/cannlytics/blob/main/LICENSE>
+
+Description: This script augments lab result data with pertinent 
+licensee, inventory, inventory type, product, and strain data.
+
+Data sources:
+
+    - WA State Traceability Data Dec. 2021 to Aug. 2022
+    URL: <https://lcb.app.box.com/s/gosuk65m5iinuaqxx2ef7uis9ccnzb20/folder/170118338288>
+
+"""
+# Standard imports.
+import gc
+import json
+import os
+
+# External imports.
+from dotenv import dotenv_values
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# Internal imports.
+# from cannlytics.data.ccrs.utils import get_number_of_lines
+from cannlytics.data.ccrs import CCRS
+from cannlytics.data.ccrs.utils import unzip_files
+from cannlytics.utils import (
+    camel_to_snake,
+    get_number_of_lines,
+    snake_case,
+    sorted_nicely,
+)
+
+
+DATA_DIR = 'D:\\data\\washington\\ccrs-2022-08-18'
+SUB_DIR = 'CCRS PRR (8-18-22)'
+ENV_FILE = '.env'
+
+
+#-----------------------------------------------------------------------
+# Get the data.
+#-----------------------------------------------------------------------
+
+# Extract all files.
+unzip_files(DATA_DIR, extension='.zip')
+
+
+#-----------------------------------------------------------------------
+# Curate the data.
+#-----------------------------------------------------------------------
+
+# Get all of the datafiles.
+subsets = {}
+datafiles = []
+for path, _, files in os.walk(DATA_DIR):
+    for f in files:
+        abs_path = os.path.join(path, f)
+        if f.endswith('.csv'):
+            datafiles.append(abs_path)
+
+# Count the number of observations in each file.
+print('| Subset | Observations |')
+print('|--------|--------------|')
+for f in sorted_nicely(datafiles):
+    datafile = f.split('\\')[-1]
+    name = datafile.replace('.csv', '').split('_')[0]
+    subset = subsets.get(name, {
+        'observations': 0,
+        'datafiles': [],
+    })
+    abs_path = os.path.join(DATA_DIR, f)
+    file_name = os.path.abspath(abs_path)
+    number = get_number_of_lines(file_name)
+    subset['observations'] += number
+    subset['datafiles'].append(datafile)
+    print(f'| `{datafile}` | `{number:,}` |')
+    subsets[name] = subset
+
+# Print the total number of observations.
+for key, values in subsets.items():
+    print(f'{key}: {values["observations"]:,}', 'observations.')
+
+# Get the columns for each subset.
+for key, values in subsets.items():
+    datafile = values['datafiles'][0]
+    name = datafile.replace('.csv', '').split('_')[0]
+    folder = datafile.replace('.csv', '')
+    abs_path = os.path.join(DATA_DIR, SUB_DIR, folder, datafile)
+    file_name = os.path.abspath(abs_path)
+    df = pd.read_csv(
+        file_name,
+        sep='\t',
+        encoding='utf-16',
+        nrows=2,
+        index_col=False,
+        low_memory=False,
+    )
+    subsets[name]['columns'] = list(df.columns)
+
+# Count the number of data points for each subset.
+for key, values in subsets.items():
+    number_of_cols = len(values['columns'])
+    data_points = values['observations'] * number_of_cols
+    print(f'{key}: {data_points:,}', 'data points.')
+
+
+#-----------------------------------------------------------------------
+# Augment license data.
+#-----------------------------------------------------------------------
+
+# Read licensee data.
+# licensees = ccrs.read_licensees()
+licensees = pd.read_csv(
+    f'{DATA_DIR}/{SUB_DIR}/Licensee_0/Licensee_0.csv',
+    sep='\t',
+    encoding='utf-16',
+    index_col=False,
+    low_memory=False,
+)
+licensees.columns = [camel_to_snake(x) for x in licensees.columns]
+
+# Restrict to active licensees.
+licensees = licensees.loc[licensees['license_status'] == 'Active']
+
+# TODO: Geocode licensees.
+
+# TODO: Figure out `license_type`.
+
+# TODO: Save augmented licensees.
+
+
+#-----------------------------------------------------------------------
+# Augment strain data.
+#-----------------------------------------------------------------------
+
+# Read strain data.
+strains = pd.read_csv(
+    f'{DATA_DIR}/{SUB_DIR}/Strains_0/Strains_0.csv',
+    sep='\t',
+    # sep=',',
+    encoding='utf-16',
+    index_col=False,
+    # skiprows=range(2, 901),
+    engine='python',
+    quotechar='"',
+    nrows=2000,
+    error_bad_lines=False,
+)
+strains.columns = [camel_to_snake(x) for x in strains.columns]
+
+# FIXME: First 899 rows are misaligned.
+strains = strains.iloc[900:]
+
+
+#------------------------------------------------------------------------------
+# Manage lab result data.
+#------------------------------------------------------------------------------
+
+# # Read lab results.
+# lab_results = ccrs.read_lab_results()
+
+# # Note: Sometimes "Not Tested" is a `test_value`.
+# lab_results['test_value'] = pd.to_numeric(lab_results['test_value'], errors='coerce')
+
+# # Remove lab results with `created_date` in the past.
+# lab_results = lab_results.loc[lab_results['created_date'] >= pd.to_datetime(START)]
+
+# # Identify all of the labs.
+# lab_ids = list(lab_results['lab_licensee_id'].unique())
+
+# # Trend analytes by day by lab.
+# group = [pd.Grouper(key='created_date', freq='M'), 'test_name', 'lab_licensee_id']
+# trending = lab_results.groupby(group, as_index=True)['test_value'].mean()
+
+# # Visualize all analytes!!!
+# tested_analytes = list(trending.index.get_level_values(1).unique())
+# for analyte in tested_analytes:
+#     fig, ax = plt.subplots(figsize=(8, 5))
+#     idx = pd.IndexSlice
+#     for lab_id in lab_ids:
+#         try:
+#             lab_samples = trending.loc[idx[:, analyte, lab_id]]
+#             if len(lab_samples) > 0:
+#                 lab_samples.plot(
+#                     ax=ax,
+#                     label=lab_id,
+#                 )
+#         except KeyError:
+#             pass
+#     plt.legend(title='Lab ID', loc='upper right')
+#     plt.title(f'Average {analyte} by Lab in Washington')
+#     plt.show()
+
+# # TODO: Save trending!
+
+# # Calculate failure rate by lab.
+
+# # TODO: Calculate failure rate by licensee.
+# # fail = lab_results.loc[lab_results['LabTestStatus'] == 'Fail']
+
+# # Get lab prices.
+
+# # Estimate laboratory revenue.
+
+# # Estimate laboratory market share.
+
+# # TODO: Estimate amount spent on lab testing by licensee.
+
+
+#-----------------------------------------------------------------------
+# CCRS data exploration.
+#-----------------------------------------------------------------------
+
+# # Initialize a CCRS client.
+# config = dotenv_values(ENV_FILE)
+# os.environ['CANNLYTICS_API_KEY'] = config['CANNLYTICS_API_KEY']
+# os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = config['GOOGLE_APPLICATION_CREDENTIALS']
+# ccrs = CCRS(data_dir=DATA_DIR)
+
+# # Read licensee data.
+# licensees = ccrs.read_licensees()
+
+# # Read areas data.
+# areas = ccrs.read_areas()
+
+# # Read inventory data.
+# inventory = ccrs.read_inventory(limit=100_000)
+
+# # Wishlist: Augment with licensee data with licensee_id
+
+# # Wishlist: Augment with strain data with strain_id
+
+# # Wishlist Augment product data with product_id
+
+# # Optional: Explore interesting fields:
+# # - quantity_on_hand
+# # - total_cost
+# # - created_date
+
+# # Optional: Count inventory items by date for each licensee?
+
+# # Estimate Cost of Goods Sold (CoGS) (Poor data for this metric). 
+# cogs = (inventory.initial_quantity - inventory.quantity_on_hand) * inventory.total_cost
+
+# # Read inventory adjustment data.
+# adjustments = ccrs.read_inventory_adjustments()
+
+# # Wishlist: Merge inventory details
+# # inventory_adjustments = pd.merge()
+
+# # Highlight imperfect system.
+# lost = adjustments.loc[adjustments.inventory_adjustment_reason == 'Lost']
+# theft = adjustments.loc[adjustments.inventory_adjustment_reason == 'Theft']
+# seized = adjustments.loc[adjustments.inventory_adjustment_reason == 'Seizure']
+# other = adjustments.loc[adjustments.inventory_adjustment_reason == 'Other']
+# not_found = lost.loc[lost['adjustment_detail'].astype(str).str.contains('not found', case=False)]
+
+# # Read plant data.
+# plants = ccrs.read_plants()
+
+# # Wishlist: Augment with strain data.
+# # StrainId is missing from strain data! And all plant StrainIds are 1...
+# strains = ccrs.read_strains()
+
+# # Wishlist: Augment with area data.
+# # Area data is missing AreaId.
+
+# # Wishlist: Augment with licensee data.
+# # Licensee data is missing LicenseeId
+
+# # TODO: Calculate number of plants by type by day, week, month, year
+# # for each licensee.
+# # This may have to be done by looking at created_date and harvest_date.
+
+# # TODO: Estimate wholesale sales by licensee_id
+
+# # Estimate growing period.
+# final_states = ['Harvested', 'Drying', 'Sold']
+# harvested = plants.loc[plants.plant_state.isin(final_states)]
+# grow_days = (harvested.harvest_date - harvested.created_date).dt.days
+# grow_days = grow_days.loc[(grow_days > 30) & (grow_days < 365)]
+# grow_days.describe()
+# grow_days.hist(bins=100)
+# plt.show()
+
+# # TODO: Estimate a production function (yield per plant).
+
+# # # Optional: See who is transferring plants to who.
+# # # InventoryPlantTransfer_0
+# # # FromLicenseeId, ToLicenseeId, FromInventoryId, ToInventoryId, TransferDate
+
+# # Read plant destruction data.
+# destructions = ccrs.read_plant_destructions()
+
+# # Look at the reasons for destruction.
+# destructions['destruction_reason'].value_counts().plot(kind='pie')
+
+# # Look at contaminants
+# mites = destructions.loc[destructions.destruction_reason == 'Mites']
+# contaminated = destructions.loc[destructions.destruction_reason == 'Contamination']
+
+# # Plot plants destroyed by mites per day.
+# mites_by_day = mites.groupby('destruction_date')['plant_id'].count()
+# mites_by_day.plot()
+# plt.title('Number of Plants Destroyed by Mites in Washington')
+# plt.show()
+
+# # Plot plants destroyed by contamination per day.
+# contaminated_by_day = contaminated.groupby('destruction_date')['plant_id'].count()
+# contaminated_by_day.plot()
+# plt.title('Number of Contaminated Plants in Washington')
+# plt.show()
+
+# # # TODO: Calculate daily risk of plant death.
+# # destructions_by_day = destructions.groupby('destruction_date')['plant_id'].count()
+# # # plants_by_day = 
+# # # plant_risk = 
+
+# # Saturday Morning Statistics teaser:
+# # Capital asset pricing model (CAPM) or...
+# # Plant liability asset net total model (PLANTM) ;)
+
+
+#------------------------------------------------------------------------------
+# Manage product data.
+#------------------------------------------------------------------------------
+
+# # Read product data.
+# products = ccrs.read_products(limit=100_000)
+
+# # Look at products by day by licensee.
+# products_by_day = products.groupby(['licensee_id', 'created_date'])['name'].count()
+
+# # Wishlist: There is a reference to InventoryTypeId but not inventory type data.
+
+# # Wishlist: Match with licensee data with licensee_id
+
+
+#------------------------------------------------------------------------------
+# Manage sales data.
+#------------------------------------------------------------------------------
+
+# # Read sale header data.
+# sale_headers = ccrs.read_sale_headers()
+
+# # Read sale detail data.
+# sale_details = ccrs.read_sale_details()
+
+# # Calculate total price and total tax.
+# sale_details['total_tax'] = sale_details['sales_tax'] + sale_details['other_tax']
+# sale_details['total_price'] = sale_details['unit_price'] - abs(sale_details['discount']) + sale_details['total_tax']
+
+# sale_details = pd.merge(
+#     sale_details,
+#     sale_headers,
+#     left_on='sale_header_id',
+#     right_on='sale_header_id',
+#     how='left',
+#     validate='m:1',
+#     suffixes=(None, '_header'),
+# )
+
+# # Calculate total transactions, average transaction, and total sales by retailer.
+# transactions = sale_details.groupby(['sale_header_id', 'licensee_id'], as_index=False)
+# transaction_amount = transactions['total_price'].sum()
+# avg_transaction_amount = transaction_amount.groupby('licensee_id')['total_price'].mean()
+
+# # Calculate transactions and sales by day.
+# daily = sale_details.groupby(['sale_date', 'licensee_id'], as_index=False)
+# daily_sales = daily['total_price'].sum()
+# daily_transactions = daily['total_price'].count()
+# group = ['sale_date', 'licensee_id', 'sale_header_id']
+# daily_avg_transaction_amount = sale_details.groupby(group, as_index=False)['total_price'].mean()
+
+# # TODO: Aggregate statistics by daily and licensee.
+
+# # TODO: Calculate year-to-date statistics for each licensee.
+
+# # FIXME: Figure out how to connect sale_headers.licensee_id with licensees.license_number?
+
+# # TODO: Break down by sale type:
+# # 'RecreationalRetail', 'RecreationalMedical', 'Wholesale'
+
+# # TODO: Try to match sale_items.inventory_id to other details?
+
+
+#------------------------------------------------------------------------------
+# Manage transfer data.
+#------------------------------------------------------------------------------
+
+# # Read transfer data.
+# transfers = ccrs.read_transfers()
+
+# # TODO: Get list of license numbers / addresses from transers.
+
+# # Future work: Look at number of items, etc. for each transfer.
+
+
+#------------------------------------------------------------------------------
+# Future work: Augment the data.
+#------------------------------------------------------------------------------
+
+# Get Fed FRED data pertinent to geographic area.
+
+# Get Census data pertinent to geographic area.
+
+
+#------------------------------------------------------------------------------
+# Future work: Estimate ARIMAX for every variable.
+#------------------------------------------------------------------------------
+
+# Estimate each variable by licensee in 2022 by day, month, week, and year-end:
+# - total sales
+# - number of transactions (Poisson model)
+# - average transaction amount
+# - Number of failures (Poisson model)
+
+
+#------------------------------------------------------------------------------
+# Save the data and statistics, making the data available for future use.
+#------------------------------------------------------------------------------
+
+# # Save all the statistics and forecasts to local data archive.
+# ccrs.save(lab_results, 'D:\\data\\washington\\stats\\daily_sales.xlsx')
+
+# # Upload all the statistics and forecasts to make available through the API.
+# # through the Cannlytics API and Cannlytics Website.
+# ccrs.upload(lab_results, 'lab_results', id_field='lab_result_id')
+
+# # Get all data and statistics from the API!
+# base = 'http://127.0.0.1:8000/api'
+# ccrs.get('lab_results', limit=100, base=base)
+
+
+#-----------------------------------------------------------------------
+# Read lab results data.
+#-----------------------------------------------------------------------
+
+# 1. Read Leaf lab results.
+# 2. Sort the data, removing null observations.
+# 3. Define a lab ID for each observation and remove attested lab results.
+
+#-----------------------------------------------------------------------
+# Augment lab result data with inventory data.
+#-----------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------
+# Augment lab result data with inventory type data.
+#-----------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------
+# Augment lab result data with strain data.
+#-----------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------
+# Augment lab result data with GIS data.
+#-----------------------------------------------------------------------
+
+
+#-----------------------------------------------------------------------
+# Augment lab result data with the labs' licensee data.
+#-----------------------------------------------------------------------

algorithms/get_results_washington_leaf.py

@@ -0,0 +1,490 @@
+"""
+Cannabis Tests | Get Washington Test Result Data
+Copyright (c) 2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+Created: 1/11/2022
+Updated: 9/16/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+
+Description: This script combines relevant fields from the licensees, inventories,
+inventory types, and strains datasets with the lab results data. Lab results are
+augmented with licensees, inventories, inventory types, and strains data.
+
+Data sources:
+
+    - WA State Traceability Data January 2018 - November 2021
+    https://lcb.app.box.com/s/e89t59s0yb558tjoncjsid710oirqbgd?page=1
+    https://lcb.app.box.com/s/e89t59s0yb558tjoncjsid710oirqbgd?page=2
+
+Data Guide:
+
+    - Washington State Leaf Data Systems Guide
+    https://lcb.wa.gov/sites/default/files/publications/Marijuana/traceability/WALeafDataSystems_UserManual_v1.37.5_AddendumC_LicenseeUser.pdf
+
+Data available at:
+
+    - https://cannlytics.com/data/market/augmented-washington-state-lab-results
+    - https://cannlytics.com/data/market/augmented-washington-state-licensees
+
+"""
+# Standard imports.
+import gc
+import json
+
+# External imports.
+import pandas as pd
+
+# Internal imports.
+from utils import get_number_of_lines
+
+#------------------------------------------------------------------------------
+# Read lab results data.
+#------------------------------------------------------------------------------
+
+def read_lab_results(
+        columns=None,
+        fields=None,
+        date_columns=None,
+        nrows=None,
+        data_dir='../.datasets',
+):
+    """
+    1. Read Leaf lab results.
+    2. Sort the data, removing null observations.
+    3. Define a lab ID for each observation and remove attested lab results.
+    """
+    shards = []
+    lab_datasets = ['LabResults_0', 'LabResults_1', 'LabResults_2']
+    for dataset in lab_datasets:
+        lab_data = pd.read_csv(
+            f'{data_dir}/{dataset}.csv',
+            sep='\t',
+            encoding='utf-16',
+            usecols=columns,
+            dtype=fields,
+            parse_dates=date_columns,
+            nrows=nrows,
+        )
+        shards.append(lab_data)
+        del lab_data
+        gc.collect()
+    data = pd.concat(shards)
+    del shards
+    gc.collect()
+    data.dropna(subset=['global_id'], inplace=True)
+    # data.set_index('global_id', inplace=True)
+    data.sort_index(inplace=True)
+    data['lab_id'] = data['global_id'].map(lambda x: x[x.find('WAL'):x.find('.')])
+    data = data.loc[data.lab_id != '']
+    return data
+
+
+#------------------------------------------------------------------------------
+# Combine lab result data with inventory data.
+#------------------------------------------------------------------------------
+
+# Define necessary lab result fields.
+lab_result_fields = {
+    'global_id' : 'string',
+    'global_for_inventory_id': 'string'
+}
+
+# Read lab result fields necessary to connect with inventory data.
+lab_results = read_lab_results(
+    columns=list(lab_result_fields.keys()),
+    fields=lab_result_fields,
+)
+
+# Save initial enhanced lab results.
+lab_results.to_csv('../.datasets/augmented_lab_results.csv')
+
+# Define inventory fields.
+inventory_fields = {
+    'global_id' : 'string',
+    'inventory_type_id': 'string',
+    'strain_id': 'string',
+}
+inventory_columns = list(inventory_fields.keys())
+
+# Define chunking parameters.
+# inventory_type_rows = get_number_of_lines('../.datasets/Inventories_0.csv')
+inventory_row_count = 129_920_072
+chunk_size = 30_000_000
+read_rows = 0
+skiprows = None
+datatypes = {
+    'global_id' : 'string',
+    'global_for_inventory_id': 'string',
+    'lab_id': 'string',
+    'inventory_type_id': 'string',
+    'strain_id': 'string',
+}
+
+# Read in a chunk at a time, match with lab results, and save the data.
+while read_rows < inventory_row_count:
+
+    # Define the chunk size.
+    if read_rows:
+        skiprows = [i for i in range(1, read_rows)]
+
+    # 1. Open enhanced lab results.
+    lab_results = pd.read_csv(
+        '../.datasets/lab_results_with_ids.csv',
+        # index_col='global_id',
+        dtype=datatypes
+    )
+
+    # 2. Read chunk of inventories.
+    inventories = pd.read_csv(
+        '../.datasets/Inventories_0.csv',
+        sep='\t',
+        encoding='utf-16',
+        usecols=inventory_columns,
+        dtype=inventory_fields,
+        skiprows=skiprows,
+        nrows=chunk_size,
+    )
+
+    # 3. Merge inventories with enhanced lab results.
+    inventories.rename(columns={'global_id': 'inventory_id'}, inplace=True)
+    lab_results = pd.merge(
+        left=lab_results,
+        right=inventories,
+        how='left',
+        left_on='global_for_inventory_id',
+        right_on='inventory_id',
+    )
+
+    # Remove overlapping columns
+    try:
+        new_entries = lab_results[['inventory_type_id_y', 'strain_id_x']]
+        lab_results = lab_results.combine_first(new_entries)
+        lab_results.rename(columns={
+            'inventory_type_id_x': 'inventory_type_id',
+            'strain_id_x': 'strain_id',
+        }, inplace=True)
+    except KeyError:
+        pass
+    extra_columns = ['inventory_id', 'Unnamed: 0', 'inventory_type_id_y',
+                     'strain_id_y']
+    lab_results.drop(extra_columns, axis=1, inplace=True, errors='ignore')
+
+    # 4. Save lab results enhanced with IDs.
+    lab_results.to_csv('../.datasets/lab_results_with_ids.csv')
+    read_rows += chunk_size
+    print('Read:', read_rows)
+
+del new_entries
+del inventories
+gc.collect()
+
+
+#------------------------------------------------------------------------------
+# Combine lab result data with inventory type data.
+#------------------------------------------------------------------------------
+
+results_with_ids = pd.read_csv('../.datasets/lab_results_with_ids.csv')
+
+# Uncomment if you do not already have inventory_type_names.csv:
+
+# Get only the inventory names from the inventory types data.
+# from augment_inventory_types import augment_inventory_types
+# augment_inventory_types()
+
+# Get only the results with
+results_with_ids = results_with_ids[~results_with_ids['inventory_type_id'].isna()]
+
+# Read in inventory type names.
+inventory_type_names = pd.read_csv(
+    '../.datasets/inventory_type_names.csv',
+    # index_col='global_id',
+    dtype={
+        'global_id' : 'string',
+        'inventory_name': 'string',
+    }
+)
+
+# Merge enhanced lab results with inventory type names.
+results_with_ids = pd.merge(
+    left=results_with_ids,
+    right=inventory_type_names,
+    how='left',
+    left_on='inventory_type_id',
+    right_on='global_id',
+)
+results_with_ids.rename(columns={'global_id_x': 'global_id'}, inplace=True)
+results_with_ids.drop(['global_id_y'], axis=1, inplace=True, errors='ignore')
+
+# Save the lab results enhanced with inventory names.
+results_with_ids.to_csv('../.datasets/lab_results_with_inventory_names.csv')
+
+
+#------------------------------------------------------------------------------
+# Combine lab result data with strain data.
+#------------------------------------------------------------------------------
+
+# Define strain fields.
+strain_fields = {
+    'global_id': 'string',
+    'name': 'string',
+}
+strain_columns = list(strain_fields.keys())
+
+# Read in strain data.
+strains = pd.read_csv(
+    '../.datasets/Strains_0.csv',
+    sep='\t',
+    encoding='utf-16',
+    dtype=strain_fields,
+    usecols=strain_columns,
+)
+
+# Merge enhanced lab results with strain data.
+strains.rename(columns={
+    'global_id': 'strain_id',
+    'name': 'strain_name',
+}, inplace=True)
+results_with_ids = pd.merge(
+    left=results_with_ids,
+    right=strains,
+    how='left',
+    left_on='strain_id',
+    right_on='strain_id',
+)
+results_with_ids.rename(columns={'global_id_x': 'global_id'}, inplace=True)
+results_with_ids.drop(['global_id_y'], axis=1, inplace=True, errors='ignore')
+
+# Save the extra lab results fields.
+results_with_ids.to_csv('../.datasets/lab_results_with_strain_names.csv')
+
+#------------------------------------------------------------------------------
+# Combine lab result data with geocoded licensee data.
+#------------------------------------------------------------------------------
+
+# Add code variable to lab results with IDs.
+results_with_ids['code'] = results_with_ids['global_for_inventory_id'].map(
+    lambda x: x[x.find('WA'):x.find('.')]
+).str.replace('WA', '')
+
+# Specify the licensee fields.
+licensee_fields = {
+    'global_id' : 'string',
+    'code': 'string',
+    'name': 'string',
+    'type': 'string',
+    'address1': 'string',
+    'address2': 'string',
+    'city': 'string',
+    'state_code': 'string',
+    'postal_code': 'string',
+}
+licensee_date_fields = [
+    'created_at', # No records if issued before 2018-02-21.
+]
+licensee_columns = list(licensee_fields.keys()) + licensee_date_fields
+
+# # Read in the licensee data.
+licensees = pd.read_csv(
+    # '../.datasets/Licensees_0.csv',
+    '../.datasets/geocoded_licensee_data.csv',
+    # sep='\t',
+    # encoding='utf-16',
+    usecols=licensee_columns,
+    dtype=licensee_fields,
+    parse_dates=licensee_date_fields,
+)
+
+# Format the licensees data.
+licensees.rename(columns={
+    'global_id': 'mme_id',
+    'created_at': 'license_created_at',
+    'type': 'license_type',
+}, inplace=True)
+
+# Combine the data sets.
+results_with_ids = pd.merge(
+    left=results_with_ids,
+    right=licensees,
+    how='left',
+    left_on='code',
+    right_on='code'
+)
+results_with_ids.rename(columns={'global_id_x': 'global_id'}, inplace=True)
+results_with_ids.drop(['global_id_y'], axis=1, inplace=True, errors='ignore')
+
+# Save lab results enhanced with additional fields.
+results_with_ids.to_csv('../.datasets/lab_results_with_licensee_data.csv')
+
+
+#------------------------------------------------------------------------------
+# TODO: Combine lab result data with the labs' licensee data.
+#------------------------------------------------------------------------------
+
+# Read enhanced lab results.
+results_with_ids = pd.read_csv('../.datasets/lab_results_with_licensee_data.csv')
+
+# TODO: Combine each lab's licensee data.
+# lab_name
+# lab_address1
+# lab_address2
+# lab_ciy
+# lab_postal_code
+# lab_phone
+# lab_certificate_number
+# lab_global_id
+# lab_code
+# lab_created_at
+
+
+# TODO: Save the data enhanced with the lab's licensee data.
+
+#------------------------------------------------------------------------------
+# Combine lab result data with enhanced lab results data.
+#------------------------------------------------------------------------------
+
+# Read in results with IDs.
+results_with_ids = pd.read_csv(
+    '../.datasets/lab_results_with_licensee_data.csv',
+    dtype = {
+        'global_id': 'string',
+        'global_for_inventory_id': 'string',
+        'lab_result_id': 'string',
+        'inventory_type_id': 'string',
+        'lab_id': 'string',
+        'strain_id': 'string',
+        'inventory_name': 'string',
+        'strain_name': 'string',
+        'code': 'string',
+        'mme_id': 'string',
+        'license_created_at': 'string',
+        'name': 'string',
+        'address1': 'string',
+        'address2': 'string',
+        'city': 'string',
+        'state_code': 'string',
+        'postal_code': 'string',
+        'license_type': 'string',
+        # TODO: Re-run with latitude and longitude
+        'latitude': 'float',
+        'longitude': 'float',
+    },
+)
+
+# Read all lab results fields with any valuable data.
+lab_result_fields = {
+    'global_id' : 'string',
+    'intermediate_type' : 'category',
+    'status' : 'category',
+    'cannabinoid_status' : 'category',
+    'cannabinoid_cbc_percent' : 'float16',
+    'cannabinoid_cbc_mg_g' : 'float16',
+    'cannabinoid_cbd_percent' : 'float16',
+    'cannabinoid_cbd_mg_g' : 'float16',
+    'cannabinoid_cbda_percent' : 'float16',
+    'cannabinoid_cbda_mg_g' : 'float16',
+    'cannabinoid_cbdv_percent' : 'float16',
+    'cannabinoid_cbg_percent' : 'float16',
+    'cannabinoid_cbg_mg_g' : 'float16',
+    'cannabinoid_cbga_percent' : 'float16',
+    'cannabinoid_cbga_mg_g' : 'float16',
+    'cannabinoid_cbn_percent' : 'float16',
+    'cannabinoid_cbn_mg_g' : 'float16',
+    'cannabinoid_d8_thc_percent' : 'float16',
+    'cannabinoid_d8_thc_mg_g' : 'float16',
+    'cannabinoid_d9_thca_percent': 'float16',
+    'cannabinoid_d9_thca_mg_g' : 'float16',
+    'cannabinoid_d9_thc_percent' : 'float16',
+    'cannabinoid_d9_thc_mg_g' : 'float16',
+    'cannabinoid_thcv_percent' : 'float16',
+    'cannabinoid_thcv_mg_g' : 'float16',
+    'solvent_status' : 'category',
+    'solvent_acetone_ppm' : 'float16',
+    'solvent_benzene_ppm' : 'float16',
+    'solvent_butanes_ppm' : 'float16',
+    'solvent_chloroform_ppm' : 'float16',
+    'solvent_cyclohexane_ppm' : 'float16',
+    'solvent_dichloromethane_ppm' : 'float16',
+    'solvent_ethyl_acetate_ppm' : 'float16',
+    'solvent_heptane_ppm' : 'float16',
+    'solvent_hexanes_ppm' : 'float16',
+    'solvent_isopropanol_ppm' : 'float16',
+    'solvent_methanol_ppm' : 'float16',
+    'solvent_pentanes_ppm' : 'float16',
+    'solvent_propane_ppm' : 'float16',
+    'solvent_toluene_ppm' : 'float16',
+    'solvent_xylene_ppm' : 'float16',
+    'foreign_matter' : 'bool',
+    'foreign_matter_stems': 'float16',
+    'foreign_matter_seeds': 'float16',
+    'microbial_status' : 'category',
+    'microbial_bile_tolerant_cfu_g' : 'float16',
+    'microbial_pathogenic_e_coli_cfu_g' : 'float16',
+    'microbial_salmonella_cfu_g' : 'float16',
+    'moisture_content_percent' : 'float16',
+    'moisture_content_water_activity_rate' : 'float16',
+    'mycotoxin_status' : 'category',
+    'mycotoxin_aflatoxins_ppb' : 'float16',
+    'mycotoxin_ochratoxin_ppb' : 'float16',
+    'thc_percent' : 'float16',
+    'notes' : 'float32',
+    'testing_status' : 'category',
+    'type' : 'category',
+    'external_id' : 'string',
+}
+lab_result_date_columns = ['created_at', 'updated_at', 'received_at',]
+lab_result_columns = list(lab_result_fields.keys()) + lab_result_date_columns
+complete_lab_results = read_lab_results(
+    columns=lab_result_columns,
+    fields=lab_result_fields,
+    date_columns=None,
+)
+
+# Merge lab results with the complete lab results data.
+complete_lab_results.rename(columns={
+    'global_id': 'lab_result_id',
+    'type': 'sample_type',
+}, inplace=True)
+results_with_ids = pd.merge(
+    left=results_with_ids,
+    right=complete_lab_results,
+    how='left',
+    left_on='global_id',
+    right_on='lab_result_id',
+)
+results_with_ids.rename(columns={'lab_id_x': 'lab_id'}, inplace=True)
+results_with_ids.drop([
+    'Unnamed: 0',
+    'Unnamed: 0.1',
+    'global_id',
+    'lab_id_y',
+], axis=1, inplace=True, errors='ignore')
+
+# TODO: Fill missing cannabinoid percent or mg/g.
+
+# FIXME: Are missing values posing a problem?
+# Calculate total cannabinoids.
+cannabinoids_wa = [
+    'cannabinoid_d9_thca_percent',
+    'cannabinoid_d9_thc_percent',
+    'cannabinoid_d8_thc_percent',
+    'cannabinoid_thcv_percent',
+    'cannabinoid_cbd_percent',
+    'cannabinoid_cbda_percent',
+    'cannabinoid_cbdv_percent',
+    'cannabinoid_cbg_percent',
+    'cannabinoid_cbga_percent',
+    'cannabinoid_cbc_percent',
+    'cannabinoid_cbn_percent',
+]
+results_with_ids['total_cannabinoids'] = results_with_ids[cannabinoids_wa].sum(axis=1)
+
+# Save the complete lab results data to csv, xlsx, and json.
+results_with_ids.to_excel('../.datasets/lab_results_complete.xlsx')
+results_with_ids.to_csv('../.datasets/lab_results_complete.csv')
+# FIXME: NAType is not JSON serializable
+# with open('../.datasets/lab_results_complete.json', 'w') as outfile:
+#     data = results_with_ids.where(pd.notnull(results_with_ids), '')
+#     data = json.loads(json.dumps(list(data.T.to_dict().values())))
+#     json.dump(data, outfile)

algorithms/main.py

@@ -0,0 +1,370 @@
+"""
+Get Cannabis Tests Data
+Copyright (c) 2022 Cannlytics
+
+Authors:
+    Keegan Skeate <https://github.com/keeganskeate>
+    Candace O'Sullivan-Sutherland <https://github.com/candy-o>
+Created: 8/23/2022
+Updated: 9/15/2022
+License: MIT License <https://github.com/cannlytics/cannlytics/blob/main/LICENSE>
+
+Description:
+
+    Periodically curate publicly published lab results by:
+
+        1. Finding products and their COA URLS on the web.
+        2. Downloading COA PDFs from their URLs.
+        3. Using CoADoc to parse the COA PDFs (with OCR).
+        4. Archiving the COA data in Firebase Firestore and Storage.
+
+Data Sources:
+    
+    - Raw Garden Lab Results
+    URL: <https://rawgarden.farm/lab-results/>
+
+"""
+# # Standard imports.
+# import base64
+# from datetime import datetime, timedelta
+# import os
+# from time import sleep
+# from typing import Any, List, Optional, Tuple
+
+# # External imports.
+# from bs4 import BeautifulSoup
+# from firebase_admin import firestore, initialize_app
+# import pandas as pd
+# import requests
+
+# # Internal imports.
+# from cannlytics.data.coas import CoADoc
+# from cannlytics.firebase import (
+#     get_document,
+#     initialize_firebase,
+#     update_documents,
+#     upload_file,
+# )
+# from cannlytics.utils import kebab_case, rmerge
+# from cannlytics.utils.constants import DEFAULT_HEADERS
+
+# # Specify where your data lives.
+# BUCKET_NAME = 'cannlytics-company.appspot.com'
+# COLLECTION = 'public/data/lab_results'
+# STORAGE_REF = 'data/lab_results/raw_garden'
+
+# # Create temporary directories.
+# DATA_DIR = '/tmp'
+# COA_DATA_DIR = f'{DATA_DIR}/lab_results/raw_garden'
+# COA_PDF_DIR = f'{COA_DATA_DIR}/pdfs'
+# TEMP_PATH = f'{COA_DATA_DIR}/tmp'
+# if not os.path.exists(DATA_DIR): os.makedirs(DATA_DIR)
+# if not os.path.exists(COA_DATA_DIR): os.makedirs(COA_DATA_DIR)
+# if not os.path.exists(COA_PDF_DIR): os.makedirs(COA_PDF_DIR)
+# if not os.path.exists(TEMP_PATH): os.makedirs(TEMP_PATH)
+
+# # Define constants.
+# BASE = 'https://rawgarden.farm/lab-results/'
+
+
+# def get_rawgarden_products(
+#         start: Optional[Any] = None,
+#         end: Optional[Any] = None,
+#     ) -> pd.DataFrame:
+#     """Get Raw Garden's lab results page. Then get all of the product
+#     categories. Finally, get all product data, including: `coa_pdf`, 
+#     `lab_results_url`, `product_name`, `product_subtype`, `date_retail`.
+#     Args:
+#         start (str or datetime): A point in time to begin restricting
+#             the product list by `date_retail` (optional).
+#         end (str or datetime): A point in time to end restricting
+#             the product list by `date_retail` (optional).
+#     Returns:
+#         (DataFrame): Returns a DataFrame of product data.
+#     """
+
+#     # Get the website.
+#     response = requests.get(BASE, headers=DEFAULT_HEADERS)
+#     soup = BeautifulSoup(response.content, 'html.parser')
+
+#     # Get all product data listed on the website.
+#     observations = []
+#     categories = soup.find_all('div', attrs={'class': 'category-content'})
+#     for category in categories:
+#         subtype = category.find('h3').text
+#         dates = category.findAll('h5', attrs={'class': 'result-date'})
+#         names = category.findAll('h5')
+#         names = [div for div in names if div.get('class') is None]
+#         links = category.findAll('a')
+#         for i, link in enumerate(links):
+#             try:
+#                 href = link.get('href')
+#                 date = pd.to_datetime(dates[i].text)
+#                 name = names[i].text
+#                 if href.endswith('.pdf'):
+#                     observations.append({
+#                         'coa_pdf': href.split('/')[-1],
+#                         'lab_results_url': href,
+#                         'product_name': name,
+#                         'product_subtype': subtype,
+#                         'date_retail': date,
+#                     })
+#             except AttributeError:
+#                 continue
+    
+#     # Restrict the observations to the desired time frame.
+#     results = pd.DataFrame(observations)
+#     dates = results['date_retail']
+#     if start:
+#         if isinstance(start, str):
+#             latest = pd.to_datetime(start)
+#         else:
+#             latest = start
+#         results = results.loc[dates >= latest]
+#     if end:
+#         if isinstance(end, str):
+#             earliest = pd.to_datetime(end)
+#         else:
+#             earliest = end
+#         results = results.loc[dates <= earliest]
+#     results['date_retail'] = dates.apply(lambda x: x.isoformat()[:19])
+#     return results
+
+
+# def download_rawgarden_coas(
+#         items: pd.DataFrame,
+#         pause: Optional[float] = 0.24,
+#         verbose: Optional[bool] = True,
+#     ) -> None:
+#     """Download Raw Garden product COAs to `product_subtype` folders.
+#     Args:
+#         items: (DataFrame): A DataFrame of products with `product_subtype`
+#             and `lab_results_url` to download.
+#         pause (float): A pause to respect the server serving the PDFs,
+#             `0.24` seconds by default (optional).
+#         verbose (bool): Whether or not to print status, `True` by
+#             default (optional).
+#     """
+#     if verbose:
+#         total = len(items)
+#         print('Downloading %i PDFs, ETA > %.2fs' % (total, total * pause))
+
+#     # Create a folder of each of the subtypes.
+#     subtypes = list(items['product_subtype'].unique())
+#     for subtype in subtypes:
+#         folder = kebab_case(subtype)
+#         subtype_folder = f'{COA_PDF_DIR}/{folder}'
+#         if not os.path.exists(subtype_folder):
+#             os.makedirs(subtype_folder)
+
+#     # Download each COA PDF from its URL to a `product_subtype` folder.
+#     for i, row in enumerate(items.iterrows()):
+#         item = row[1]
+#         url = item['lab_results_url']
+#         subtype = item['product_subtype']
+#         filename = url.split('/')[-1]
+#         folder = kebab_case(subtype)
+#         outfile = os.path.join(COA_PDF_DIR, folder, filename)
+#         response = requests.get(url, headers=DEFAULT_HEADERS)
+#         with open(outfile, 'wb') as pdf:
+#             pdf.write(response.content)
+#         if verbose:
+#             message = 'Downloaded {}/{} | {}/{}'
+#             message = message.format(str(i +  1), str(total), folder, filename)
+#             print(message)
+#         sleep(pause)
+
+
+# def parse_rawgarden_coas(
+#         directory: str,
+#         filenames: Optional[list] = None,
+#         temp_path: Optional[str] = '/tmp',
+#         verbose: Optional[bool] = True,
+#         **kwargs,
+#     ) -> Tuple[list]:
+#     """Parse Raw Garden lab results with CoADoc.
+#     Args:
+#         directory (str): The directory of files to parse.
+#         filenames (list): A list of files to parse (optional).
+#         temp_path (str): A temporary directory to use for any OCR (optional).
+#         verbose (bool): Whether or not to print status, `True` by
+#             default (optional).
+#     Returns:
+#         (tuple): Returns both a list of parsed and unidentified COA data.
+#     """
+#     parser = CoADoc()
+#     parsed, unidentified = [], []
+#     started = False
+#     for path, _, files in os.walk(directory):
+#         if verbose and not started:
+#             started = True
+#             if filenames:
+#                 total = len(filenames)
+#             else:
+#                 total = len(files)
+#             print('Parsing %i COAs, ETA > %.2fm' % (total, total * 25 / 60))
+#         for filename in files:
+#             if not filename.endswith('.pdf'):
+#                 continue
+#             if filenames is not None:
+#                 if filename not in filenames:
+#                     continue
+#             doc = os.path.join(path, filename)
+#             try:
+#                 # FIXME: Make API request to Cannlytics? Tesseract, etc.
+#                 # are going to be too heavy for a cloud function.
+#                 coa  = parser.parse(doc, temp_path=temp_path, **kwargs)
+#                 subtype = path.split('\\')[-1]
+#                 coa[0]['product_subtype'] = subtype
+#                 parsed.extend(coa)
+#                 if verbose:
+#                     print('Parsed:', filename)
+#             except Exception as e:
+#                 unidentified.append({'coa_pdf': filename})
+#                 if verbose:
+#                     print('Error:', filename)
+#                     print(e)
+#                 pass
+#     return parsed, unidentified
+
+
+# def upload_lab_results(
+#         observations: List[dict],
+#         collection: Optional[str] = None,
+#         database: Optional[Any] = None,
+#         update: Optional[bool] = True,
+#         verbose: Optional[bool] = True,
+#     ) -> None:
+#     """Upload lab results to Firestore.
+#     Args:
+#         observations (list): A list of lab results to upload.
+#         collection (str): The Firestore collection where lab results live,
+#             `'public/data/lab_results'` by default (optional).
+#         database (Client): A Firestore database instance (optional).
+#         update (bool): Whether or not to update existing entries, `True`
+#             by default (optional).
+#         verbose (bool): Whether or not to print status, `True` by
+#             default (optional).
+#     """
+#     if collection is None:
+#         collection = COLLECTION
+#     if database is None:
+#         database = initialize_firebase()
+#     refs, updates = [], []
+#     for obs in observations:
+#         sample_id = obs['sample_id']
+#         ref = f'{collection}/{sample_id}'
+#         if not update:
+#             doc = get_document(ref)
+#             if doc is not None:
+#                 continue
+#         refs.append(ref)
+#         updates.append(obs)
+#     if updates:
+#         if verbose:
+#             print('Uploading %i lab results.' % len(refs))
+#         update_documents(refs, updates, database=database)
+#     if verbose:
+#         print('Uploaded %i lab results.' % len(refs))
+
+
+def main(event, context):
+    """Archive Raw Garden data on a periodic basis.
+    Triggered from a message on a Cloud Pub/Sub topic.
+    Args:
+        event (dict): Event payload.
+        context (google.cloud.functions.Context): Metadata for the event.
+    """
+    raise NotImplementedError
+
+    # # Check that the PubSub message is valid.
+    # pubsub_message = base64.b64decode(event['data']).decode('utf-8')
+    # if pubsub_message != 'success':
+    #     return
+
+    # # Get the most recent Raw Garden products.
+    # DAYS_AGO = 1
+    # start = datetime.now() - timedelta(days=DAYS_AGO)
+    # products = get_rawgarden_products(start=start)
+
+    # # Download Raw Garden product COAs to `product_subtype` folders.
+    # download_rawgarden_coas(products, pause=0.24, verbose=True)
+
+    # # Parse COA PDFs with CoADoc.
+    # coa_data, unidentified_coas = parse_rawgarden_coas(
+    #     COA_PDF_DIR,
+    #     filenames=products['coa_pdf'].to_list(),
+    #     temp_path=TEMP_PATH,
+    #     verbose=True,
+    # )
+
+    # # Merge the `products`'s `product_subtype` with the COA data.
+    # coa_dataframe = rmerge(
+    #     pd.DataFrame(coa_data),
+    #     products,
+    #     on='coa_pdf',
+    #     how='left',
+    #     replace='right',
+    # )
+
+    # # Optional: Save the COA data to a workbook.
+    # parser = CoADoc()
+    # timestamp = datetime.now().isoformat()[:19].replace(':', '-')
+    # datafile = f'{COA_DATA_DIR}/rawgarden-coa-data-{timestamp}.xlsx'
+    # parser.save(coa_dataframe, datafile)
+
+    # # Optional: Save the unidentified COA data.
+    # errors = [x['coa_pdf'] for x in unidentified_coas]
+    # error_file = f'{COA_DATA_DIR}/rawgarden-unidentified-coas-{timestamp}.xlsx'
+    # products.loc[products['coa_pdf'].isin(errors)].to_excel(error_file)
+
+    # # Initialize Firebase.
+    # # FIXME: Ideally use the internal initialization.
+    # try:
+    #     initialize_app()
+    # except ValueError:
+    #     pass
+    # database = firestore.client()
+
+    # # Optional: Upload the lab results to Firestore.
+    # upload_lab_results(
+    #     coa_dataframe.to_dict(orient='records'),
+    #     database=database,
+    #     update=False,
+    #     verbose=False
+    # )
+
+    # # Optional: Upload datafiles to Firebase Storage.
+    # storage_error_file = '/'.join([STORAGE_REF, error_file.split('/')[-1]])
+    # upload_file(storage_error_file, error_file, bucket_name=BUCKET_NAME)
+
+
+# === Test ===
+if __name__ == '__main__':
+
+    from cannlytics.utils import encode_pdf
+    from cannlytics.utils.constants import DEFAULT_HEADERS
+    import requests
+
+    # [✓] TEST: Mock the Google Cloud Function scheduled routine.
+    # event = {'data': base64.b64encode('success'.encode())}
+    # get_rawgarden_data(event, context={})
+
+    # # [ ] Test: Post a PDF to the Cannlytics API for parsing.
+    # # FIXME:
+    # coa_doc_api = 'https://cannlytics.com/api/data/coas'
+    # folder = 'tests/assets/coas/'
+    # filename = f'{folder}/210000525-Citrus-Slurm-Diamonds.pdf'
+    # # files = {'upload_file': open(filename, 'rb')}
+    # # values = {'lims': 'Cannalysis'}
+    # # response = requests.post(base, files=files, data=values)
+    # with open(filename, 'rb') as f:
+    #     response = requests.post(
+    #         coa_doc_api,
+    #         headers=DEFAULT_HEADERS,
+    #         files={'file': f}
+    #     )
+    #     print(response.status_code)
+
+    # # Optional: Also allow for encoding of PDFs.
+    # encoded_pdf = encode_pdf(filename)

cannabis_tests.py

@@ -6,7 +6,7 @@ Authors:
     Keegan Skeate <https://github.com/keeganskeate>
     Candace O'Sullivan-Sutherland <https://github.com/candy-o>
 Created: 9/10/2022
-Updated: 9/14/2022
+Updated: 9/16/2022
 License: <https://github.com/cannlytics/cannlytics/blob/main/LICENSE>
 """
 import datasets
@@ -15,11 +15,11 @@ import pandas as pd
 
 # === Constants. ===
 
-_VERSION = '1.0.1'
+_VERSION = '1.0.2'
 _HOMEPAGE = 'https://huggingface.co/datasets/cannlytics/cannabis_tests'
 _LICENSE = "https://opendatacommons.org/licenses/by/4-0/"
 _DESCRIPTION = """\
-Cannabis lab test results (https://cannlytics.com/data/tests) is a
+Cannabis lab test results (https://cannlytics.com/data/results) is a
 dataset of curated cannabis lab test results.
 """
 _CITATION = """\

requirements.txt

@@ -0,0 +1,7 @@
+# Cannabis Tests | Python Requirements
+# Created: 9/15/2022
+# Updated: 9/15/2022
+beautifulsoup4==4.11.1
+cannlytics==0.0.12
+firebase_admin==5.3.0
+pandas==1.4.4

test.py

@@ -0,0 +1,28 @@
+"""
+Test Cannabis Tests Dataset
+Copyright (c) 2022 Cannlytics
+
+Authors: Keegan Skeate <https://github.com/keeganskeate>
+Created: 9/16/2022
+Updated: 9/16/2022
+License: CC-BY 4.0 <https://huggingface.co/datasets/cannlytics/cannabis_tests/blob/main/LICENSE>
+"""
+from cannlytics.data.coas import CoADoc
+from datasets import load_dataset
+import pandas as pd
+
+# Download Raw Garden lab result details.
+repo = 'cannlytics/cannabis_tests'
+dataset = load_dataset(repo, 'rawgarden')
+details = dataset['details']
+
+# Save the data locally with "Details", "Results", and "Values" worksheets.
+outfile = 'rawgarden.xlsx'
+parser = CoADoc()
+parser.save(details.to_pandas(), outfile)
+
+# Read the values.
+values = pd.read_excel(outfile, sheet_name='Values')
+
+# Read the results.
+results = pd.read_excel(outfile, sheet_name='Results')