Skanska GenAI Hackathon

import os
from openai import AzureOpenAI
from dotenv import load_dotenv

# Load environment variables from a .env file
load_dotenv()

# Constants
API_VERSION = "2024-02-01"
MODEL_NAME = os.getenv("MODEL_NAME")
AZURE_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
API_KEY = os.getenv("AZURE_OPENAI_API_KEY")

if not all([MODEL_NAME, AZURE_ENDPOINT, API_KEY]):
print("Missing required environment variables.")
exit(1)

# Setup Azure OpenAI client
try:
client = AzureOpenAI(
    azure_endpoint=AZURE_ENDPOINT,
    api_key=API_KEY,
    api_version=API_VERSION
)
except Exception as e:
print(f"Failed to initialize Azure OpenAI Client: {e}")
exit(1)

print("Azure OpenAI Client initialized successfully!")

# Continuously interact with the user until they decide to exit
while True:
user_question = input("Enter your question (type 'exit' to quit): ").strip()
if user_question.lower() in ["exit", "quit"]:
    print("Exiting the program.")
    break

try:
    # Requesting a response from the Azure OpenAI model
    response = client.chat.completions.create(
        model=MODEL_NAME,
        messages=[
            {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
            {"role": "user", "content": user_question}
        ]
    )
    print(response.choices[0].message.content)
except Exception as e:
    print(f"Error fetching response from OpenAI: {e}")                    
              

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient
from dotenv import load_dotenv

# Load environment variables from a .env file
load_dotenv()

# Constants for the Azure Document Analysis API
ENDPOINT = os.getenv("AZURE_DI_ENDPOINT")
API_KEY = os.getenv("AZURE_DI_API_KEY")

if not all([ENDPOINT, API_KEY]):
    print("Missing required environment variables.")
    exit(1)

def analyze_read():
    """Read and analyze document content from a PDF file."""
    try:
        with open("TR010065_A46 Newark Bypass_3.1 draft Development Consent Order.pdf", "rb") as f:
            pdf_data = f.read()
    except FileNotFoundError:
        print("The file 'test.pdf' was not found.")
        return
    except Exception as e:
        print(f"An error occurred while reading the file: {e}")
        return

    try:
        client = DocumentAnalysisClient(endpoint=ENDPOINT, credential=AzureKeyCredential(API_KEY))
        poller = client.begin_analyze_document("prebuilt-layout", document=pdf_data)
        result = poller.result()
    except Exception as e:
        print(f"Failed to analyze document: {e}")
        return

    content_paragraphs = []
    for page in result.pages:
        page_content = [line.content for line in page.lines]
        content_paragraphs.append(" ".join(page_content))

    combined_content = "\n\n".join(content_paragraphs)
    print("Document content as paragraph:\n")
    print(combined_content)
    print("----------------------------------------")


analyze_read()
                                   
              

import os
from dotenv import load_dotenv
from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

# Load environment variables
load_dotenv()

# Constants
ENDPOINT = os.getenv("DFZ_AZURE_DI_ENDPOINT")
KEY = os.getenv("DFZ_AZURE_DI_API_KEY")
MODEL_ID = "MyCustomModel1"
FILE_PATH = r'.\scan.jpg'

# Read the file content
try:
    with open(FILE_PATH, "rb") as f:
        file_content = f.read()
except FileNotFoundError:
    print(f"Error: File not found at {FILE_PATH}")
    exit(1)
except Exception as e:
    print(f"An error occurred while reading the file: {e}")
    exit(1)

# Initialize DocumentAnalysisClient
try:
    document_analysis_client = DocumentAnalysisClient(
        endpoint=ENDPOINT,
        credential=AzureKeyCredential(KEY)
    )
except Exception as e:
    print(f"Failed to initialize DocumentAnalysisClient: {e}")
    exit(1)

# Analyze the document
try:
    poller = document_analysis_client.begin_analyze_document(model_id=MODEL_ID, document=file_content)
    result = poller.result()
except Exception as e:
    print(f"An error occurred during document analysis: {e}")
    exit(1)

# Mapping of template field names to created field names
template_to_field = {
    "Signed name": "sign",
    "Print name(Contractor name)": "contractor",
    "Company": "company",
    "Date of Sign": "date",
    "Establishment and area where work is to be carried out": "area",
    "Contractor Name & Address": "address",
    "Person(s) carrying out work": "person",
    "Exact location of work": "location",
    "Start date": "start",
    "Finish date": "finish",
    "Order No": "order",
    "Type of work": "type",
    "Scope of work": "scope",
    "Does the area need to be fenced off or enclosed?": "fence",
    "Will this block a fire escape route?": "fire",
    "Do any utilities need to be disconnected to do the work? (e.g. water, electricity, gas etc)": "utilities",
    "Will there be excessive noise?": "noise",
    "Will there be excessive amounts of dust created?": "dust",
    "Will smoke/heat detectors be affected?": "detector",
    "Will any hazardous substances be used?": "hazard"
}

# Store extracted information
extracted_data = {"documents": []}

# Extract document-level information and map to template fields
for document in result.documents:
    doc_info = {
        "type": document.doc_type,
        "confidence": document.confidence,
        "model_id": result.model_id,
        "fields": {}
    }

    # Mapping fields based on the provided template
    for template_field, created_field in template_to_field.items():
        if created_field in document.fields:
            field = document.fields[created_field]
            field_value = field.value if field.value else field.content
            field_confidence = f"{field.confidence:.2f}%" if field.confidence is not None else "N/A"
            doc_info["fields"][template_field] = {
                "type": field.value_type,
                "value": field_value,
                "confidence": field_confidence
            }

    extracted_data["documents"].append(doc_info)

# Display the extracted data with template field names
for doc in extracted_data["documents"]:
    print(f"Document type: {doc['type']}, Confidence: {doc['confidence']}, Model ID: {doc['model_id']}")
    print("----------------------------")
    for field_name, field_info in doc["fields"].items():
        print(f"{field_name}: {field_info['value']} (Confidence: {field_info['confidence']})")
    print("----------------------------")
            
                               
          

import os
import uuid
import json
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
from azure.search.documents import SearchClient
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import SearchIndex, SimpleField, SearchableField
from openai import AzureOpenAI



# Set these environment variables or replace with your values
endpoint = "https://workshop-docs.cognitiveservices.azure.com/"
key = "afaa2d0bade14d46aed622597a3bfd6f"

# Create a client
client = DocumentAnalysisClient(endpoint=endpoint, credential=AzureKeyCredential(key))

pdf_path = "./manual.pdf"

# Read the PDF file
with open(pdf_path, "rb") as f:
    pdf_data = f.read()

# Analyze the PDF
poller = client.begin_analyze_document("prebuilt-layout", document=pdf_data)

# Wait for the analysis to complete
result = poller.result()


search_service_endpoint = "https://skanska-search.search.windows.net"
search_service_key = "pVU4xuS2ncxFjdlJGxlEZtIT1ZmmfzpCjpWTQgRGNqAzSeB90n4p"
index_name = "skanska-testing-document-index-4"

# Create the index schema
index_schema = SearchIndex(
    name=index_name,
    fields=[
        SimpleField(name="id", type="Edm.String", key=True),
        SearchableField(name="content", type="Edm.String"),
    ]
)

# Create the index
#index_client = SearchIndexClient(endpoint=search_service_endpoint, credential=AzureKeyCredential(search_service_key))
#index_client.create_index(index=index_schema)




# Initialize the SearchClient
search_client = SearchClient(endpoint=search_service_endpoint, index_name=index_name, credential=AzureKeyCredential(search_service_key))

"""
# Extracted data from the PDF
extracted_data = [
    {"id": str(uuid.uuid4()), "content": line.content}
    for page in result.pages
    for line in page.lines
]
"""



# Initialize an empty list to hold the extracted data
extracted_data = []

# Simulated loop over pages, replace this loop with your actual PDF processing code
for page in result.pages:  # Replace 'pdf_document' with your actual object holding PDF pages
    # Initialize an empty string to collect all lines in a page
    page_content = ""
    for line in page.lines:  # Replace 'page' with the method or attribute to access lines on a page
        page_content += line.content + " "  # Assuming each 'line' is a string of text, concatenate it with a space

    # Create a dictionary for the page with a unique ID and the collected content
    page_data = {
        "id": str(uuid.uuid4()),  # Generate a unique identifier
        "content": page_content.strip()  # Remove any trailing whitespace
    }
    # Append the dictionary to the list
    extracted_data.append(page_data)

# At this point, extracted_data contains all the page information with unique IDs




# Upload data to the index
#search_client.upload_documents(documents=extracted_data)


client = AzureOpenAI(
    api_key="f2ccda332a64455ea47d08d8e9290a78",
    api_version="2024-02-01",
    azure_endpoint = "https://skanska-open-ai.openai.azure.com/"
    )

deployment_name='skanska-gpt35-model'




def search_index(query, limit=1):
    results = search_client.search(query, top=limit)
    return [doc["content"] for doc in results]

# User question
user_question = "what is the maximum operating temperature"

# Search the index and get the response
search_results = search_index(user_question)
#print(search_results)

def generate_response(search_results, user_question):
    prompt = f"You are an AI assistant. Use the following information to answer the question.\n\nInformation:\n"
    for result in search_results:
        prompt += result + "\n"
    prompt += f"\nQuestion: {user_question}\nAnswer:"

    response = client.chat.completions.create(
      model = "skanska-gpt35-model",
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": prompt }
      ]
    )
    return response.choices[0].message.content



# Search the index and get the response
search_results = search_index(user_question)
answer = generate_response(search_results, user_question)

print(answer)