policymap/sponsored_add.py

109 lines
5.0 KiB
Python
Raw Normal View History

2025-03-06 14:29:01 -08:00
import requests
from neo4j import GraphDatabase
from dotenv import load_dotenv
import os
# Load environment variables from .env file
load_dotenv()
# Retrieve Neo4j connection details and API key
NEO4J_URI = os.getenv('NEO4J_URI')
NEO4J_USER = os.getenv('NEO4J_USER')
NEO4J_PASSWORD = os.getenv('NEO4J_PASSWORD')
CONGRESS_API_KEY = os.getenv('CONGRESS_API_KEY')
if not NEO4J_URI or not NEO4J_USER or not NEO4J_PASSWORD:
raise ValueError("Neo4j connection details not found in .env file")
if not CONGRESS_API_KEY:
raise ValueError("Congress API key not found in .env file")
# Initialize Neo4j driver
driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
# Function to get all person nodes and their bioguideIds
def get_person_bioguide_ids(driver):
with driver.session() as session:
result = session.run("MATCH (p:Person) RETURN p.bioguideId")
return [record['p.bioguideId'] for record in result]
# Get list of person bioguideIds
person_bioguide_ids = get_person_bioguide_ids(driver)
print("List of Person Bioguide IDs:", person_bioguide_ids)
# Function to fetch sponsored legislation for a given bioguideId from Congress API
def fetch_sponsored_legislation(bioguide_id, api_key):
url = f"https://api.congress.gov/v3/member/{bioguide_id}/sponsored-legislation"
headers = {
'X-API-Key': api_key,
'Content-Type': 'application/json'
}
params = {
'limit': 250 # Maximum limit allowed is 250
}
response = requests.get(url, headers=headers, params=params)
if response.status_code == 200:
return response.json()
else:
print(f"Failed to retrieve sponsored legislation for bioguideId {bioguide_id}: {response.status_code}")
print("Response Content:", response.content.decode('utf-8'))
return None
# Fetch and process sponsored legislation for each person
legislation_dict = {}
for bioguide_id in person_bioguide_ids:
if bioguide_id is not None: # Check if the bioguideId is not None
print(f"Fetching sponsored legislation for member with bioguideId {bioguide_id}")
json_response = fetch_sponsored_legislation(bioguide_id, CONGRESS_API_KEY)
if json_response and 'legislations' in json_response:
for legislation in json_response['legislations']:
legislation_dict[legislation.get('id')] = legislation
# Create legislation nodes and sponsored relationships
with driver.session() as session:
for legislation_id, legislation in legislation_dict.items():
properties_str = ', '.join([f"'{key}': '{value}'" for key, value in legislation.items() if value is not None and value != ''])
# Check if the legislation node already exists
query_check = f"MATCH (l:Legislation {{id: '{legislation_id}'}}) RETURN l"
result_check = session.run(query_check)
legislation_exists = bool(result_check.data())
# Create or update the legislation node
query_create_update = f"MATCH (p:Person {{bioguideId: '{bioguide_id}'}}) MERGE (l:Legislation {{id: '{legislation_id}'}}) SET l = {{{properties_str}}} RETURN l"
result_create_update = session.run(query_create_update)
# Print the creation or update status
if legislation_exists:
print(f"Updated Legislation Node for member {bioguide_id}: {result_create_update.single()}")
else:
print(f"Created Legislation Node for member {bioguide_id}: {result_create_update.single()}")
# Create the sponsored relationship
query_relationship = f"MATCH (p:Person {{bioguideId: '{bioguide_id}'}}), (l:Legislation {{id: '{legislation_id}'}}) MERGE (p)-[:SPONSORED]->(l)"
session.run(query_relationship)
print(f"Created Sponsored Relationship for Person {bioguide_id} and Legislation {legislation_id}")
# Test that nodes and relationships were created properly
with driver.session() as session:
for bioguide_id, legislation in legislation_dict.items():
legislation_id = legislation['id']
# Check if the legislation node exists
query_check_legislation = f"MATCH (l:Legislation {{id: '{legislation_id}'}}) RETURN l"
result_check_legislation = session.run(query_check_legislation)
if not result_check_legislation.data():
print(f"Error: Legislation Node with ID {legislation_id} does not exist.")
# Check if the sponsored relationship exists
query_check_relationship = f"MATCH (p:Person {{bioguideId: '{bioguide_id}'}})-[:SPONSORED]->(l:Legislation {{id: '{legislation_id}'}}) RETURN p, l"
result_check_relationship = session.run(query_check_relationship)
if not result_check_relationship.data():
print(f"Error: Sponsored Relationship for Person {bioguide_id} and Legislation {legislation_id} does not exist.")
# Print success message
print(f"Success: Node and Relationship for Person {bioguide_id} and Legislation {legislation_id} are created properly.")
# Close the Neo4j driver connection
driver.close()