Upload 5 files

Clauses_Extractor.py

@@ -0,0 +1,48 @@
+import openai
+import os
+
+
+# Define the Clauses class
+class Clauses:
+    def __init__(self):
+        """
+        Initialize the Extractor class.
+        """
+
+        # Set OpenAI API key
+        # os.environ["OPENAI_API_KEY"] = ""
+
+    def get_extracted_clauses(extracted_summary):
+        """
+        Gets extracted clauses using GPT-3 based on the provided PDF.
+
+        Args:
+            max_tokens (int, optional): Maximum number of tokens for GPT-3 response.
+
+        Returns:
+            str: Extracted clauses from GPT-3 response.
+        """
+        try:
+            # Prepare a prompt for GPT-3 that includes the extracted PDF text and instructions
+            prompt = f"""
+            Extract clauses and sub-clauses from the provided contract PDF:
+
+            {extracted_summary}
+
+            Instructions: Organize the extracted clauses and sub clauses in a readable format.
+            """
+            # Use GPT-3 to process the prompt and generate clauses
+            response = openai.Completion.create(
+                engine="text-davinci-003",
+                prompt=prompt,
+                max_tokens=1000
+            )
+
+            # Extract the generated text from the GPT-3 response
+            result = response['choices'][0]['text'].strip()
+            return result
+
+        except Exception as e:
+            # If an error occurs during GPT-3 processing, log the error and raise an exception
+            print(f"Error occurred while processing PDF with GPT-3. Error message: {str(e)}")
+            raise

Tags_Extractor.py

@@ -0,0 +1,39 @@
+import openai
+import os
+
+
+class Tags:
+    def __init__(self):
+        """
+        Initialize the Extractor class.
+        """
+
+        # Set OpenAI API key
+
+        
+        # openai.api_key = ""
+
+
+    def extract_tags(extracted_summary):
+        """
+        Extract tags from the refined summary using OpenAI API.
+
+        Returns:
+            str: Extracted tags.
+        """
+        try:
+            
+            # Use OpenAI's Completion API to analyze the text and extract tags
+            response = openai.Completion.create(
+                engine="text-davinci-003",
+                temperature=0,
+                prompt=f"analyze the given contract to extract tags for following contract in triple backticks. tags should be bullet points.contract :```{extracted_summary}```.",
+                max_tokens=1000
+            )
+
+            # Extract and return the chatbot's reply
+            result = response['choices'][0]['text'].strip()
+            return result
+
+        except Exception as e:
+            print(f"Error occurred while extracting tags: {str(e)}")

key_value_extractor.py

@@ -0,0 +1,37 @@
+import openai
+import os
+
+
+# Define the KeyValue class
+class KeyValue:
+    def __init__(self):
+        """
+        Initialize the Extractor class.
+        """
+
+        # Set OpenAI API key
+        # os.environ["OPENAI_API_KEY"] = ""
+
+    def extract_key_value_pair(extracted_summary):
+        """
+        Extract key-value pairs from the refined summary.
+
+        Prints the extracted key-value pairs.
+        """
+        try:
+
+
+            # Use OpenAI's Completion API to analyze the text and extract key-value pairs
+            response = openai.Completion.create(
+                engine="text-davinci-003",
+                temperature=0,
+                prompt=f"analyze the given contract and get meaningful key value pairs in given content.contract in backticks.```{extracted_summary}```.",
+                max_tokens=1000
+            )
+
+            # Extract and return the chatbot's reply
+            result = response['choices'][0]['text'].strip()
+            return result
+        except Exception as e:
+            # If an error occurs during the key-value extraction process, log the error
+            print(f"Error occurred while extracting key-value pairs: {str(e)}")

pdftojson.py

@@ -0,0 +1,84 @@
+import os
+import PyPDF2
+from langchain import PromptTemplate, LLMChain
+from langchain.llms import OpenAI
+
+class PdftoJson:
+
+    def __init__(self):
+        """
+        Initialize the PdftoJson class with OpenAI API key.
+        """
+        # OPENAI_API_KEY =  ""
+        # os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+
+    def _get_json(self, input_text: str) -> str:
+        """
+        Generate JSON result by analyzing and splitting input text into topics and content.
+
+        Args:
+            input_text (str): Text to be analyzed.
+
+        Returns:
+            str: JSON result containing topics and content.
+        """
+        try:
+
+            # Initialize the OpenAI language model with specified settings
+            llm = OpenAI(temperature=0, max_tokens=1000)
+
+            # Define a template that instructs the model to split input text into topics and content
+            template = """
+            Your task is Get the text and analyse and split it into Topics and Content in json format.Give Proper Name to Topic dont give any Numbers and Dont Give any empty Contents.The Output Format Should Be very good.
+
+            {text}
+            """
+            prompt = PromptTemplate(template=template, input_variables=["text"])
+
+            # Create an LLMChain instance to chain the prompt and language model together
+            llm_chain = LLMChain(prompt=prompt, llm=llm)
+
+            # Use the provided input text to generate JSON result using the model
+            text = input_text
+            json_result = llm_chain.run(text)
+
+            return json_result
+
+        except Exception as e:
+            print(f"Error occurred while generating JSON result: {str(e)}")
+
+
+    def extract_text_from_pdf(self, pdf_path: str):
+        """
+        Extract text from a PDF file, generate JSON result, and save it to a file.
+
+        Args:
+            pdf_path (str): Path to the PDF file.
+        """
+        try:
+
+
+            # Open the PDF file in binary read mode
+            with open(pdf_path, "rb") as pdf_file:
+                # Create a PDF reader object
+                pdf_reader = PyPDF2.PdfReader(pdf_file)
+
+                # Iterate through each page in the PDF
+                for page_number in range(len(pdf_reader.pages)):
+                    # Extract text from the current page
+                    page = pdf_reader.pages[page_number]
+                    text = page.extract_text()
+
+                    # Generate JSON result for the extracted text
+                    json_result = self._get_json(text)
+
+                    # # Clear Extra Spaces
+                    # clear_json_result = self._remove_empty_lines(json_result)
+
+                    # # Save the JSON result to a file
+                    # self._save_json(clear_json_result)
+                    return json_result
+
+
+        except Exception as e:
+            print(f"Error occurred during extraction and processing: {str(e)}")

summary_extractor.py

@@ -0,0 +1,121 @@
+import openai
+import json
+from typing import Dict
+import os
+from typing import List
+from langchain.chat_models import ChatOpenAI
+from langchain.document_loaders import PyPDFLoader
+from langchain.chains.mapreduce import MapReduceChain
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.chains.summarize import load_summarize_chain
+from langchain.prompts import PromptTemplate
+
+
+class Extractor:
+
+    """
+    This class handles the extraction of tags from a PDF document.
+
+    Attributes:
+        config (dict): Configuration settings loaded from a JSON file.
+        pdf_file_path (str): Path to the input PDF file.
+    """
+    def __init__(self):
+        """
+        Initialize the Extractor class.
+        """
+
+        # Set OpenAI API key
+        # os.environ["OPENAI_API_KEY"] = ""
+
+    def _document_loader(self,pdf_file_path) -> List[str]:
+        """
+        Load and split the PDF document into individual pages.
+
+        Returns:
+            List[str]: List of text content from each page.
+        """
+        try:
+            loader = PyPDFLoader(pdf_file_path.name)
+            pages = loader.load_and_split()
+            return pages
+
+        except Exception as e:
+            print(f"Error while loading and splitting the document: {str(e)}")
+
+
+    def _document_text_spilliter(self,pdf_file_path) -> List[str]:
+        """
+        Split the document text into smaller chunks.
+
+        Returns:
+            List[str]: List of smaller text chunks.
+        """
+        try:
+            # Load the document texts
+            docs = self._document_loader(pdf_file_path)
+
+            # Initialize the text splitter with specified chunk size and overlap
+            text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
+                chunk_size=1000, chunk_overlap=200
+            )
+
+            # Split the documents into chunks
+            split_docs = text_splitter.split_documents(docs)
+
+            # Return the list of split document chunks
+            return split_docs
+
+        except Exception as e:
+            print(f"Error while splitting document text: {str(e)}")
+
+
+    def _refine_summary(self,pdf_file_path) -> str:
+        """
+        Generate a refined summary of the document using language models.
+
+        Returns:
+            str: Refined summary text.
+        """
+        try:
+            # Split documents into chunks for efficient processing
+            split_docs = self._document_text_spilliter(pdf_file_path)
+
+            # Prepare the prompt template for summarization
+            prompt_template = """Write a concise summary of the following:
+            {text}
+            CONCISE SUMMARY:"""
+            prompt = PromptTemplate.from_template(prompt_template)
+
+            # Prepare the template for refining the summary with additional context
+            refine_template = (
+                "Your job is to produce a final summary\n"
+                "We have provided an existing summary up to a certain point: {existing_answer}\n"
+                "We have the opportunity to refine the existing summary"
+                "(only if needed) with some more context below.\n"
+                "------------\n"
+                "{text}\n"
+                "------------\n"
+                "Given the new context, refine the original summary"
+                "If the context isn't useful, return the original summary."
+            )
+            refine_prompt = PromptTemplate.from_template(refine_template)
+
+            # Load the summarization chain using the ChatOpenAI language model
+            chain = load_summarize_chain(
+                llm = ChatOpenAI(temperature=0),
+                chain_type="refine",
+                question_prompt=prompt,
+                refine_prompt=refine_prompt,
+                return_intermediate_steps=True,
+                input_key="input_documents",
+                output_key="output_text",
+            )
+
+            # Generate the refined summary using the loaded summarization chain
+            result = chain({"input_documents": split_docs}, return_only_outputs=True)
+
+            return result["output_text"]
+
+        except Exception as e:
+            print(f"Error while generating refined summary: {str(e)}")