regulatory_comments_api.py

# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import requests
import datasets

_DESCRIPTION = """\
United States governmental agencies often make proposed regulations open to the public for comment. 
Proposed regulations are organized into "dockets". This dataset will use Regulation.gov public API 
to aggregate and clean public comments for dockets that mention opioid use. 

Each example will consist of one docket, and include metadata such as docket id, docket title, etc. 
Each docket entry will also include information about the top 10 comments, including comment metadata
and comment text. 
"""

# Homepage URL of the dataset
_HOMEPAGE = "https://www.regulations.gov/"

# URL to download the dataset
_URLS = {"url": "https://huggingface.co/datasets/ro-h/regulatory_comments/raw/main/docket_comments_all.json"}

class RegulationsDataFetcher:
    API_KEY = "IsH1c1CAB0CR8spovnnx2INbLz8gQlVkbmXYII2z" #'4T29l93SvmnyNCVFZUFzSfUqTq6k7S0Wqn93sLcH'
    BASE_COMMENT_URL = 'https://api.regulations.gov/v4/comments'
    BASE_DOCKET_URL = 'https://api.regulations.gov/v4/dockets/'
    HEADERS = {
        'X-Api-Key': API_KEY,
        'Content-Type': 'application/json'
    }

    def __init__(self, docket_id):
        self.docket_id = docket_id
        self.docket_url = self.BASE_DOCKET_URL + docket_id
        self.dataset = []

    def fetch_comments(self):
        """Fetch a single page of 25 comments."""
        url = f'{self.BASE_COMMENT_URL}?filter[docketId]={self.docket_id}&page[number]=1&page[size]=25'
        response = requests.get(url, headers=self.HEADERS)
        
        if response.status_code == 200:
            return response.json()
        else:
            print(f'Failed to retrieve comments: {response.status_code}')
            return None

    def get_docket_info(self):
        """Get docket information."""
        response = requests.get(self.docket_url, headers=self.HEADERS)
        
        if response.status_code == 200:
            docket_data = response.json()
            return (docket_data['data']['attributes']['agencyId'],
                    docket_data['data']['attributes']['title'],
                    docket_data['data']['attributes']['modifyDate'], 
                    docket_data['data']['attributes']['docketType'], 
                    docket_data['data']['attributes']['keywords'])
        else:
            print(f'Failed to retrieve docket info: {response.status_code}')
            return None

    def fetch_comment_details(self, comment_url):
        """Fetch detailed information of a comment."""
        response = requests.get(comment_url, headers=self.HEADERS)
        if response.status_code == 200:
            return response.json()
        else:
            print(f'Failed to retrieve comment details: {response.status_code}')
            return None

    def collect_data(self):
        """Collect data and reshape into nested dictionary format."""
        data = self.fetch_comments()
        docket_info = self.get_docket_info()

        # Initialize the nested dictionary structure
        nested_data = {
            "id": self.docket_id,
            "title": docket_info[1] if docket_info else "Unknown Title",
            "context": docket_info[2] if docket_info else "Unknown Context",
            "purpose": docket_info[3],
            "keywords": docket_info[4],
            "comments": []
        }

        if data and 'data' in data:
            for comment in data['data']:
                comment_details = self.fetch_comment_details(comment['links']['self'])
                
                if comment_details and 'data' in comment_details and 'attributes' in comment_details['data']:
                    comment_data = comment_details['data']['attributes']
                    nested_comment = {
                        "text": comment_data.get('comment', ''),
                        "comment_id": comment['id'],
                        "comment_url": comment['links']['self'],
                        "comment_date": comment['attributes']['postedDate'],
                        "comment_title": comment['attributes']['title'],
                        "commenter_fname": comment_data.get('firstName', ''),
                        "commenter_lname": comment_data.get('lastName', ''),
                        "comment_length": len(comment_data.get('comment', '')) if comment_data.get('comment') is not None else 0
                    }
                    nested_data["comments"].append(nested_comment)

                if len(nested_data["comments"]) >= 10:
                    break

        return nested_data

class RegComments(datasets.GeneratorBasedBuilder):
    VERSION = datasets.Version("1.1.0")

    # Method to define the structure of the dataset
    def _info(self):
        # Defining the structure of the dataset
        features = datasets.Features({
            "id": datasets.Value("string"),
            "title": datasets.Value("string"),
            "context": datasets.Value("string"),
            "purpose": datasets.Value("string"),
            "keywords": datasets.Sequence(datasets.Value("string")),
            "comments": datasets.Sequence({
                "text": datasets.Value("string"),
                "comment_id": datasets.Value("string"),
                "comment_url": datasets.Value("string"),
                "comment_date": datasets.Value("string"),
                "comment_title": datasets.Value("string"),
                "commenter_fname": datasets.Value("string"),
                "commenter_lname": datasets.Value("string"),
                "comment_length": datasets.Value("int32")
            })
        })

        # Returning the dataset structure
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE
        )
    
    def _split_generators(self, dl_manager):
        # Expect an API key to be passed as a parameter
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "search_terms": opioid_related_terms,
                    "api_key": self.config.api_key,  # Use the API key provided by the user
                },
            ),
        ]

    def _generate_examples(self, search_terms, api_key):
        # Iterate over each search term to fetch relevant dockets
        for term in search_terms:
            docket_ids = get_docket_ids(term, api_key)  # Pass the API key here
            for docket_id in docket_ids:
                fetcher = RegulationsDataFetcher(docket_id, api_key)  # Initialize with the API key
                docket_data = fetcher.collect_data()
                if len(docket_data["comments"]) != 0:
                    yield docket_id, docket_data

# Modify the get_docket_ids function to accept an API key
def get_docket_ids(search_term, api_key):
    url = f"https://api.regulations.gov/v4/dockets"
    params = {
        'filter[searchTerm]': search_term,
        'api_key': api_key
    }
    response = requests.get(url, params=params)
    if response.status_code == 200:
        data = response.json()
        dockets = data['data']
        docket_ids = [docket['id'] for docket in dockets]
        return docket_ids
    else:
        return f"Error: {response.status_code}"
    
opioid_related_terms = [
    # Types of Opioids
    "opioids",
    "heroin", 
    "morphine", 
    "fentanyl", 
    "methadone", 
    "oxycodone", 
    "hydrocodone", 
    "codeine", 
    "tramadol", 
    "prescription opioids", 
    # Withdrawal Support
    "lofexidine", 
    "buprenorphine", 
    "naloxone", 
    # Related Phrases
    "opioid epidemic", 
    "opioid abuse", 
    "opioid crisis", 
    "opioid overdose"
    "opioid tolerance", 
    "opioid treatment program", 
    "medication assisted treatment", 
]