API

AddSkillDetails.py

@@ -1,71 +0,0 @@
-
-from psycopg2 import sql
-import pymysql
-import pandas as pd
-from DbConnection import DbConnection
-class AddSkill:
-    def AddSkillDetails(skills):
-        returnMsg=''
-        details = skills.split(',')
-        skill_details = details[0]
-        skill_type = details [1]
-        skill_score1 = details[2]
-        weightage = -2
-        is_active = True
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        print("Adding Skill " + skill_details)
-        query = "SELECT skillid FROM skillmaster WHERE upper(skillDetails) IN (%s)"
-        params = (skill_details.upper(),)  # Replace 'Test' with your actual variable or user input
-        cursor.execute(query, params)
-        if cursor.rowcount == 0:    
-
-            insert_query = ("""INSERT INTO skillmaster (SkillDetails, SkillType, Weightage, IsActive, skill_score) 
-                        VALUES (%s, %s, %s, %s, %s)""")
-            cursor.execute(insert_query, (skill_details, skill_type, weightage, is_active, skill_score1))
-            conn.commit()
-            returnMsg = 'Skill Added successfully'
-        else:            
-            returnMsg = 'Skill Already in DB'
-             
-        # Close the cursor and connection
-        cursor.close()
-        # Close the connection
-        conn.close()
-        print(returnMsg)   
-        return returnMsg
-    def UpdateSkillDetails(skills):
-        returnMsg=''
-        details = skills.split(',')
-        skill_details = details[0]
-        weightage = details [1]
-        is_active = True
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        print("Updating Skill " + skill_details)
-        query = "SELECT skillid FROM skillmaster WHERE upper(skillDetails) IN (%s)"
-        params = (skill_details.upper(),)  # Replace 'Test' with your actual variable or user input
-        cursor.execute(query, params)
-        if cursor.rowcount == 0:    
-            returnMsg = 'Skill Not in DB'
-        else:            
-            update_query = ("""UPDATE skillmaster set weightage = %s where upper(skilldetails) = %s""")
-            cursor.execute(update_query, (weightage, skill_details.upper()))
-            conn.commit()
-            returnMsg = 'Skill Updated successfully'
-             
-        # Close the cursor and connection
-        cursor.close()
-        # Close the connection
-        conn.close()
-        print(returnMsg)   
-        return returnMsg
-    def GetSkillDetails():
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        cursor.execute("SELECT * FROM skillmaster")
-        cursor.close()
-        # Close the connection
-        conn.close()
-        return cursor.fetchall()
-        

ClassModals.py

@@ -1,22 +0,0 @@
-from pydantic import BaseModel
-class Modals:
-    class AddSkillDetails(BaseModel):    
-        SkillName: str = 'SkillName'
-        SkillType: str = 'Soft Skill'
-        SkillScore: int = 10   
-
-    class FileDetails(BaseModel):
-        filecontents: str
-        IsJobDescription: bool
-        filename: str
-        fileid: str
-        message: str
-    class SkillDetails(BaseModel):
-        skillid: int 
-        requiredSkills: str
-        softSkills: str
-        goodToHaveSkills: str          
-
-    class UpdateSkillDetails(BaseModel):    
-        SkillName: str = 'SkillName'
-        SkillWeightage: int = -2  

Database/SkillMaster.csv

@@ -1,62 +0,0 @@
-"skillid";"skilldetails";"skilltype";"weightage";"isactive";"skill_score"
-17;"Office Automation";"Hard Skill";0.0;1;"100"
-18;"Biography";"Hard Skill";0.0;1;"100"
-19;"X Window System";"Hard Skill";0.0;1;"57"
-21;"Hospitality Management";"Hard Skill";0.0;1;"200"
-25;"Computer Booking Systems";"Hard Skill";0.0;1;"57"
-27;"Online Communication";"Hard Skill";0.0;1;"200"
-28;"Credit Control";"Hard Skill";0.0;1;"200"
-112;"Hindi Language";"Hard Skill";0.0;1;"100"
-130;"French Language";"Soft Skill";0.0;1;"100"
-194;"SkillName";"Soft Skill";0.0;1;"10"
-5269;"Project Proposals";"Hard Skill";0.0;1;"100"
-5332;"E";"Hard Skill";0.0;1;"100"
-5334;"Activism";"Hard Skill";0.0;1;"59"
-5348;"Disabilities";"Hard Skill";0.0;1;"92"
-5417;"Job Descriptions";"Hard Skill";0.0;1;"100"
-5418;"English Language";"Soft Skill";0.0;1;"100"
-5459;"Industrialization";"Hard Skill";0.0;1;"71"
-5464;"Levelling";"Hard Skill";0.0;1;"67"
-5488;"Consumables";"Hard Skill";0.0;1;"69"
-5535;"Management Process";"Hard Skill";0.0;1;"200"
-5583;"Containerization";"Hard Skill";0.0;1;"100"
-5628;"Interactivity";"Hard Skill";0.0;1;"91"
-5692;"Naturalization";"Hard Skill";0.0;1;"73"
-6021;"Custom Backend";"Hard Skill";0.0;1;"100"
-6027;"B";"Hard Skill";0.0;1;"100"
-6310;"Commenting";"Hard Skill";0.0;1;"81"
-6436;"Drawing";"Hard Skill";0.0;1;"100"
-6508;"Building Management";"Hard Skill";0.0;1;"200"
-6702;"Building Automation";"Hard Skill";0.0;1;"200"
-6855;"Gardening";"Hard Skill";0.0;1;"70"
-7040;"Good Agricultural Practices";"Hard Skill";0.0;1;"60"
-7117;"Nice";"Hard Skill";0.0;1;"100"
-7239;"Probation";"Hard Skill";0.0;1;"100"
-7282;"Oracle";"Hard Skill";-2.0;1;"100"
-7295;"System.net.mail";"Hard Skill";0.0;1;"60"
-7297;"WPF";"Hard Skill";-2.0;1;"100"
-7299;"Spring";"Hard Skill";-2.0;1;"100"
-7300;"EJB";"Hard Skill";-2.0;1;"100"
-7301;"Struts";"Hard Skill";-2.0;1;"100"
-7302;"J2EE";"Hard Skill";-2.0;1;"100"
-7311;"SharePoint";"Hard Skill";-2.0;1;"100"
-7312;"SSIS";"Hard Skill";-2.0;1;"100"
-7314;"Nodejs";"Hard Skill";-2.0;1;"100"
-7329;"Ddd Service";"Hard Skill";0.0;1;"100"
-7330;"OOPS";"Hard Skill";-2.0;1;"90"
-7331;"Lambda";"Hard Skill";-2.0;1;"90"
-7335;"Cloud";"Hard Skill";-2.0;1;"90"
-7342;"Toolchain";"Hard Skill";0.0;1;"100"
-7350;"User Feedback";"Hard Skill";0.0;1;"100"
-7373;"Excel";"Hard Skill";-2.0;1;"90"
-7374;"Word";"Hard Skill";-2.0;1;"90"
-7375;"Tally";"Hard Skill";-2.0;1;"100"
-7376;"GST";"Hard Skill";-2.0;1;"90"
-7377;"Income Tax";"Hard Skill";0.0;1;"100"
-7387;"International Taxation";"Hard Skill";0.0;1;"200"
-7388;"Internal Auditing";"Hard Skill";0.0;1;"200"
-7389;"DOT";"Hard Skill";0.0;1;"100"
-7390;"Apache Wicket";"Hard Skill";0.0;1;"100"
-7391;"Accounts Payable";"Hard Skill";0.0;1;"100"
-7392;"Computer Literacy";"Soft Skill";0.0;1;"100"
-7393;"test";"Har Skill";0.0;1;"50"

Database/SkillMasterTableScript.txt

@@ -1,9 +0,0 @@
-CREATE TABLE "skillmaster" (
-  "skillid" int NOT NULL AUTO_INCREMENT,
-  "skilldetails" varchar(255) NOT NULL,
-  "skilltype" varchar(50) DEFAULT NULL,
-  "weightage" decimal(10,2) DEFAULT NULL,
-  "isactive" tinyint(1) DEFAULT '1',
-  "skill_score" varchar(20) DEFAULT NULL,
-  PRIMARY KEY ("skillid")
-);

DbConnection.py

@@ -1,21 +0,0 @@
-
-import pymysql
-
-timeout = 10
-class DbConnection:  
-    def GetMySQLDbConnection():
-        connection = pymysql.connect(
-        charset="utf8mb4",
-        connect_timeout=timeout,
-        cursorclass=pymysql.cursors.DictCursor,
-        db="defaultdb",
-        host="mysql-anu-xboxgames1900-aebf.a.aivencloud.com",
-        password="AVNS_TGfs_uHRKteMjB9pFnq",
-        read_timeout=timeout,
-        port=25227,
-        user="avnadmin",
-        write_timeout=timeout,
-        )
-        return connection
-
-    

ExtractContentsFromFile.py

@@ -1,32 +0,0 @@
-import io 
-import PyPDF2
-import docx2txt 
-import numpy as np
-from psycopg2.extensions import register_adapter, AsIs
-register_adapter(np.int64, AsIs)
-import warnings
-warnings.filterwarnings('ignore')
-class ExtractContentFromFile:
-    def ExtractDataFromFile(FileName,file):
-        text =''
-        try:
-            #print(text)
-            if FileName.endswith("pdf"):
-                reserve_pdf_on_memory = io.BytesIO(file)
-                load_pdf = PyPDF2.PdfReader(reserve_pdf_on_memory)
-                for page in load_pdf.pages:
-                    text += page.extract_text()
-            
-            elif FileName.endswith("doc") or FileName.endswith("docx"):
-                text = docx2txt.process(file)
-                text = text.read()
-            
-            else:
-                text = file.decode('utf-8')
-        except:
-            print("Error reading file")    
-        finally:
-            # Close the resources to free up memory
-            del reserve_pdf_on_memory
-            del load_pdf
-        return text    

RemoveSkills.py

@@ -1,40 +0,0 @@
-import psycopg2
-import pymysql
-from DbConnection import DbConnection
-class RemoveSkill:
-    def RemoveSkillDetails(SkillName):
-        returnMsg=''
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        
-        query = "SELECT skillid FROM skillmaster WHERE upper(skillDetails) IN (%s)"
-        params = (SkillName.upper(),)  # Replace 'Test' with your actual variable or user input
-        cursor.execute(query, params)
-        if cursor.rowcount == 0:  
-            print("New Archived Entry")
-            skill_type = "Hard Skill"
-            skill_score1 = 0
-            weightage = 0
-            is_active = True  
-            returnMsg = 'Skill Not in DB'
-            insert_query = ("""INSERT INTO skillmaster (SkillDetails, SkillType, Weightage, IsActive, skill_score) 
-                        VALUES (%s, %s, %s, %s, %s)""")
-            cursor.execute(insert_query, (SkillName, skill_type, weightage, is_active, skill_score1))
-            conn.commit()
-            returnMsg = 'Skill Added successfully'
-        else:            
-            print("Update Archived Entry")
-            query = "update skillmaster set weightage = 0 where upper(skilldetails) = (%s)"        
-            params = (SkillName.upper(),)  
-            cursor.execute(query, params)
-            conn.commit()
-            returnMsg = 'Skill Updated successfully'
-             
-        # Close the cursor and connection
-        cursor.close()
-        # Close the connection
-        conn.close()
-        print(returnMsg)   
-   
-
-

SampleCode/PHP/UpdateSkill.php

@@ -1,39 +0,0 @@
-<?php
-// API endpoint URL
-$url = 'https://vaibhav84-resumeapi.hf.space/UpdateSkillDetails/';
-
-// Define the input data
-$data = array(
-    "SkillName" => "Test4",
-    "SkillWeightage" => -3 // Example weightage
-);
-
-// Initialize cURL
-$curl = curl_init();
-
-// Set cURL options
-curl_setopt_array($curl, array(
-    CURLOPT_URL => $url,
-    CURLOPT_RETURNTRANSFER => true,
-    CURLOPT_CUSTOMREQUEST => "PUT",
-    CURLOPT_POSTFIELDS => json_encode($data),
-    CURLOPT_HTTPHEADER => array(
-        "Content-Type: application/json"
-    ),
-));
-
-// Execute the cURL request
-$response = curl_exec($curl);
-
-// Check for errors
-if (curl_errno($curl)) {
-    echo 'Error: ' . curl_error($curl);
-} else {
-    // Print response
-    echo "Skill details updated successfully.\n";
-    echo "Response: " . $response . "\n";
-}
-
-// Close cURL
-curl_close($curl);
-?>

SampleCode/PHP/UploadJD.php

@@ -1,45 +0,0 @@
-<?php
-// API endpoint URL
-$url = "https://vaibhav84-resumeapi.hf.space/UploadJobDescription/";
-// Path to the file you want to upload
-$file_path = "data/Java1.pdf";
-
-// Extract the filename from the file path
-$file_name = basename($file_path);
-
-// Initialize cURL
-$curl = curl_init();
-
-// Set cURL options
-curl_setopt_array($curl, array(
-    CURLOPT_URL => $url,
-    CURLOPT_RETURNTRANSFER => true,
-    CURLOPT_POST => true,
-    CURLOPT_POSTFIELDS => array(
-        'file' => new CURLFile($file_path), // Attach the file
-        'FileName' => $file_name // Pass the filename parameter
-    ),
-));
-$start_time = microtime(true);
-// Execute the cURL request
-$response = curl_exec($curl);
-// Measure the end time
-$end_time = microtime(true);
-
-// Calculate the total time taken
-$total_time = $end_time - $start_time;
-
-// Check for errors
-if (curl_errno($curl)) {
-    echo 'Error: ' . curl_error($curl);
-} else {
-    // Print response
-    echo $response . " \n";
-    echo "Total time: " . $total_time . " seconds\n";
-}
-
-// Close cURL
-//php samplephpcall.php
-curl_close($curl);
-?>
-

SampleCode/SampleAddSkill.py

@@ -1,32 +0,0 @@
-import requests
-from pydantic import BaseModel
-class UserAddNewSkill:
-# Define the class for the input data
-    class AddSkillDetails(BaseModel):
-        SkillName: str = 'SkillName'
-        SkillType: str = 'Soft Skill'
-        SkillScore: int = 10
-
-    # Define the data to be sent to the API
-        
-    def AddNewSkill(API, skillName1,SkillType1,SkillScore1):    
-        data = UserAddNewSkill.AddSkillDetails(
-            SkillName=skillName1,
-            SkillType=SkillType1,
-            SkillScore=SkillScore1  # Example score
-        )
-
-        # URL of the API endpoint
-        #url = "https://vaibhav84-resumeapi.hf.space/AddSkillDetails/"
-
-        # Make the POST request
-        response = requests.post(API, json=data.dict())
-
-        # Check the response
-        if response.status_code == 200:
-            print("Skill details added successfully.")
-            print("Response:", response.json())
-        else:
-            print("Failed to add skill details.")
-            print("Status code:", response.status_code)
-            print("Response:", response.text)

SampleCode/SampleCall.py

@@ -1,46 +0,0 @@
-import requests
-import os
-import time
-# URL of the API endpoint
-url = "https://vaibhav84-resumeapi.hf.space/UploadJobDescription/"
-
-def CallAPI(file_path):
-# Open the file in binary mode
-    with open(file_path, "rb") as file:
-        # Prepare the file to be sent in the request
-        files = {"file": (file_path, file)}
-
-        # Additional parameters for the request
-        params = {"FileName": file_name}  # Adjust FileName if necessary
-        start_time = time.time()
-        # Make the POST request
-        response = requests.post(url, files=files, params=params)
-        end_time = time.time()
-        total_time = end_time - start_time
-    # Check if the request was successful (status code 200)
-    if response.status_code == 200:
-        print("_____________________________________________________")
-        print("Job description uploaded successfully.", file_name)
-        print("")
-        # Print the response from the API
-        print(response.text)
-        print("")
-        print("Total time:", total_time, "seconds")
-        print("_____________________________________________________")
-    else:
-        print("Failed to upload job description.")
-        print("Status code:", response.status_code)
-        print("Response:", response.text)
-
-folderPath = "Data"
-files = os.listdir(folderPath)
-for file in files:
-        
-    filePath = os.path.join(folderPath, file)        
-    file_name = os.path.basename(filePath)
-    CallAPI(filePath)
-# Path to the file you want to upload
-#file_path = "data/python_developer.pdf"
-    
-
-

SampleCode/SampleCallAdmin.py

@@ -1,116 +0,0 @@
-import requests
-import os
-import time
-from pydantic import BaseModel
-
-from SampleAddSkill import UserAddNewSkill
-# URL of the API endpoint
-url = "https://vaibhav84-resumeapi.hf.space/"
-class AddSkillDetails(BaseModel):
-    SkillName: str = 'SkillName'
-    SkillType: str = 'Soft Skill'
-    SkillScore: int = 10
-
-class UpdateSkillDetails(BaseModel):    
-    SkillName: str = 'SkillName'
-    SkillWeightage: int = -2  
-
-def CallAPI(API):
-     
-    
-        # Make the POST request
-    response = requests.get(url + API)
-
-    # Check if the request was successful (status code 200)
-    if response.status_code == 200:
-        print("_____________________________________________________")
-        print("Skill Details")
-        print("")
-        # Print the response from the API
-        print(response.text)
-        print("")        
-        print("_____________________________________________________")
-    else:
-        print("Failed to get skill details.")
-        print("Status code:", response.status_code)
-        print("Response:", response.text)
-
-#RemoveSkillsByName
-def CallRemoveAPI(API, SkillName):
-     
-    params = {"SkillName": SkillName} 
-        # Make the POST request
-    response = requests.delete(url + API,params=params)
-
-    # Check if the request was successful (status code 200)
-    if response.status_code == 200:
-        print("_____________________________________________________")
-        print("Skill Deleted ")
-        print("")
-        # Print the response from the API
-        print(response.text)
-        print("")        
-        print("_____________________________________________________")
-    else:
-        print("Failed to delete skill details.")
-        print("Status code:", response.status_code)
-        print("Response:", response.text)
-
-def CallUpdateSkillAPI(API, SkillName1, weight):
-    data = UpdateSkillDetails(
-    SkillName=SkillName1,    
-    SkillWeightage=weight
-    )
-    print(data)
-        # Make the POST request
-    response = requests.put(url + API,json=data.dict())
-
-    # Check if the request was successful (status code 200)
-    if response.status_code == 200:
-        print("_____________________________________________________")
-        print("Skill Updated ")
-        print("")
-        # Print the response from the API
-        print(response.text)
-        print("")        
-        print("_____________________________________________________")
-    else:
-        print("Failed to update skill details.")
-        print("Status code:", response.status_code)
-        print("Response:", response.text)        
-
-def CallAddSkillAPI(API, SkillName1,skilltype, score):
-    UserAddNewSkill.AddNewSkill(url + API,SkillName1,skilltype,score)
-    
-
-print("Enter API number to call:")
-print("1. GetAll Skill")
-print("2. Remove Skill")
-print("3. Update Skill")
-print("4. Add Skill")
-userinput = input()
-if(userinput == "1"):
-    CallAPI('GetAllSkillDetails/')
-elif(userinput == "2"):
-    print("Enter skill which you want to delete")    
-    userinputskill = input()    
-    CallRemoveAPI('RemoveSkillsByName',userinputskill)
-elif(userinput == "3"):
-    print("Enter skill which you want to update")    
-    userupdateskill = input() 
-    print("Enter skill weightage you want to update")    
-    userwskill = input()     
-    CallUpdateSkillAPI('UpdateSkillDetails/',userupdateskill,userwskill) 
-elif(userinput == "4"):
-    print("Enter skill which you want to add")    
-    uskill = input() 
-    print("Enter skill type")    
-    userskilltype = input()   
-    print("Enter skill score")    
-    userskillscore = input()     
-    CallAddSkillAPI('AddSkillDetails/',uskill,userskilltype,userskillscore)           
-
-
-    #UpdateSkillDetails
-
-

SampleCode/SampleDbConnection.py

@@ -1,23 +0,0 @@
-import pymysql
-
-timeout = 10
-db_params = {}
-connection = pymysql.connect(
-  charset="utf8mb4",
-  connect_timeout=timeout,
-  cursorclass=pymysql.cursors.DictCursor,
-  db="defaultdb",
-  host="mysql-anu-xboxgames1900-aebf.a.aivencloud.com",
-  password="AVNS_TGfs_uHRKteMjB9pFnq",
-  read_timeout=timeout,
-  port=25227,
-  user="avnadmin",
-  write_timeout=timeout,
-)
-  
-try:
-  cursor = connection.cursor()
-  cursor.execute("SELECT * FROM skillmaster")
-  print(cursor.fetchall())
-finally:
-  connection.close()

SampleCode/ca.pem

@@ -1,25 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEQTCCAqmgAwIBAgIUeOk/j5D8tDsrzwYSvjqXMEdi79UwDQYJKoZIhvcNAQEM
-BQAwOjE4MDYGA1UEAwwvNjllMTExOTQtNjRmNy00YjYxLTgzMDctYTQyMjU2NGU5
-NTNhIFByb2plY3QgQ0EwHhcNMjQwMzI0MDYyMzMzWhcNMzQwMzIyMDYyMzMzWjA6
-MTgwNgYDVQQDDC82OWUxMTE5NC02NGY3LTRiNjEtODMwNy1hNDIyNTY0ZTk1M2Eg
-UHJvamVjdCBDQTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAMqtfbv+
-233UB6p29LijiBLmVMAT91c6MXQJ13HCeghcjgBACLabARu2SMohGMEdJOVhdbZK
-aNU5YEPZayWQri2Xqrf7AFF/0/M+W7nAvFebs7RJ0k0AY80sih5F4LxgKy6CYhVE
-Ir+TNfO5hrB/qFc2BR8rAq2zm+qHK4NgJQ9s36+8JOphv4BRCt8xc/kkX2jnGFw5
-pWZV7/CXbymaMjk8WnSyRvYoMxk4FBewZshbVJXww/A3V2XC3J+k1HsU7ZZD3p+5
-HcAh0MgPLn0+LNnKfkqwRGst1ANI2WF5SpvkqS+2iF52Yq0O4LAoxKtithvMdwsR
-b5LmtGoPag44vgaxJmJSMwMLqK5Uz+fkGytPrznu9ALYjP/i6LlApKEsxltwcPaq
-tm2nWpEXxaUkIzrWqJOPCFL1XN2pZ2V6KodSSd9RxE7qKl+no+YQSLwPIT8C5rkO
-kIizu7Bmb8hrtCHk9XoEu0wRrRRNnOOTNb8mQpflzKwO3VNpwZn7MtM32QIDAQAB
-oz8wPTAdBgNVHQ4EFgQU2UjrAgDlISlFeGeZSNc7y0v3gegwDwYDVR0TBAgwBgEB
-/wIBADALBgNVHQ8EBAMCAQYwDQYJKoZIhvcNAQEMBQADggGBADFIiIw8v6AP3C2N
-0oJX+9yMJ7+qd9BEqHISk0mji/VKO9p8bsz3WnncQfPhOvkCIDR+IEXKKhji5jg5
-N0VqoXExy7VG9D7I+1FMva4OLQVyQDSt/MirFrXOpuE9Gb4m1pwZFPLclyLYFHV0
-pH4WR57KUK0M+wfUzBitV7pingAkXKzSqL/CEKo9scR3vH6n2ZYu/53PAVx+neNB
-3ZSkF/LB+cBOdOj3kt2DhaLSpnC1hltcviToqDZX1tmVBwD/XwmXMOJtxz5yzvRA
-yQBkMxTVfwPC+3mque00jl/tcrk3grhI9cPqB5PF01GqUNCPXn9XnMh0FPowou6v
-Z6g2FGTLbUDMM40oI4K3CLEtqsZ+UvJPIDbKj+NSJ7fRyksmBzc2S3YsDF1JHQ/e
-aMW92T1NZDx+wwI5D8V+qZ0PG5CQe0U4KD2Ecvs1Gg1z2JBsOkJ+BpOKBXT6VuI/
-Qmeyx2P+NoExuWF6bHbaI0/0h/XWvuz5LeCPJES+jA7JZVgpxg==
------END CERTIFICATE-----

SampleCode/index.php

@@ -1,21 +0,0 @@
-<?php
-
-$uri = "mysql://avnadmin:AVNS_TGfs_uHRKteMjB9pFnq@mysql-anu-xboxgames1900-aebf.a.aivencloud.com:25227/defaultdb?ssl-mode=REQUIRED";
-
-$fields = parse_url($uri);
-
-// build the DSN including SSL settings
-$conn = "mysql:";
-$conn .= "host=" . $fields["host"];
-$conn .= ";port=" . $fields["port"];;
-$conn .= ";dbname=defaultdb";
-$conn .= ";sslmode=verify-ca;sslrootcert=ca.pem";
-
-try {
-  $db = new PDO($conn, $fields["user"], $fields["pass"]);
-
-  $stmt = $db->query("SELECT VERSION()");
-  print($stmt->fetch()[0]);
-} catch (Exception $e) {
-  echo "Error: " . $e->getMessage();
-}

SkillExtract.py

@@ -1,220 +0,0 @@
-import psycopg2
-from psycopg2 import sql
-import pandas as pd
-import re
-class SkillExtractorDetails:
-
-    def GetSkillId(skillname,jdmasterid,db_params):    
-        #Fetching skill id from skillmaster
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        query = "select skillid from skillmaster where upper(skilldetails) = (%s)"
-        params = (skillname.upper(),)  
-        cursor.execute(query, params)
-        generated_skill_id = cursor.fetchone()[0]
-        #jdmasterid = 912
-        #print(generated_skill_id)
-        #checking if skill id already in skilldetails
-        query = "SELECT skillid FROM jdSkilldetails WHERE skillid IN (%s) and jdMasterid in (%s)"
-        params = (generated_skill_id,jdmasterid,)  
-        cursor.execute(query, params)
-        if cursor.rowcount > 0: 
-            #print("Already")
-            query =''
-        else:
-            #print("Updating in DB")
-            insert_query = sql.SQL("""INSERT INTO jdSkilldetails (Skillid, jdMasterid) VALUES (%s, %s)""")
-            cursor.execute(insert_query, (generated_skill_id, jdmasterid))
-            conn.commit()
-
-        cursor.close()
-        # Close the connection
-        conn.close()   
-        return generated_skill_id
-    def skill_Validate(df, skill):
-        skill = skill.upper()
-        if (len(skill.split()) < 2 and len(skill) < 3) or len(skill.split())==1:
-            df['skill_present'] = df['skilldetails'].apply(lambda x: re.match(rf'^{skill}$', x))
-            if any(df['skill_present']):
-                #print("Valid Skill")
-                return 1
-            else:
-                #print("Not a Skill")
-                return 0
-        elif df['skilldetails'].str.contains(skill.upper()).any():
-            #print("Valid Skill")
-            return 1
-        else:
-            # print("Not a Skill")
-            return 0 
-    def getNewSkills(db_params):
-        query = "select skillid,skilldetails,skilltype,skill_score from skillmaster where weightage = -2"
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        df_skill_master = pd.read_sql_query(query, conn)
-        df_skill_master['skilldetails'] = df_skill_master['skilldetails'].str.upper()
-        cursor.close()
-        # Close the connection
-        conn.close()
-
-        #print(df_skill_master)
-        return df_skill_master
-    def extractWords(job_description,JdMasterid,db_params):
-        job_roles = []
-        job_description = job_description.replace(')',' ')
-        delimiters = ",", " ", " , ", ";","\n","/","\\"
-        regex_pattern = '|'.join(map(re.escape, delimiters))
-        df = SkillExtractorDetails.getNewSkills(db_params)
-        data = re.split(regex_pattern, job_description)
-        #data = job_description.split(',')
-        for ds in data:
-            #print(ds)
-            try:
-                if(SkillExtractorDetails.skill_Validate(df,ds.strip())):                
-                    job_roles.append(ds) 
-                    SkillExtractorDetails.GetSkillId(ds.strip(),JdMasterid,db_params)
-                    print("Skills Identified* : " + ds)   
-            except Exception as error:
-                test = 1
-        return job_roles 
-    def SkillExtract(db_params,skill_extractor,JdID, IsJD):
-        print("Extracting Skills for the JD...")
-        # Connect to the PostgreSQL database
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-
-        jd_id = str(JdID)
-        # Retrieve "id" and "description" columns from the table
-        #query = sql.SQL("select jdmasterid,jobdescription from JDMaster where isskillsextracted in (0)")
-        query = "select jdmasterid,jobdescription,filename from JDMaster where isskillsextracted = 0 and jdmasterid ="+ jd_id 
-        CVquery = "select masterid,description,filename from CourseMaster where isskillsextracted = 0 and masterid ="+ jd_id
-        # Use Pandas to read the data into a DataFrame
-        if(IsJD):
-            df = pd.read_sql_query(query, conn)
-        else:
-            df = pd.read_sql_query(CVquery, conn)    
-
-        # Print the DataFrame (for demonstration purposes)
-        #print(df)
-        
-        skill_details = ''
-        skill_type = ''
-        weightage = -1.0
-        is_active = True
-        Skillid = 0
-        jdMasterid = 0
-        OldSkillCount = 0
-        NewSkillCount = 0
-        if(len(df.index) > 0):
-            print("Total IDs for Extractraction : " + str(len(df.index)))
-        for index, row in df.iterrows():
-            # Access individual columns using column names
-            if(IsJD):
-                id_value = row['jdmasterid']
-                description_value = row['jobdescription']
-            else:
-                id_value = row['masterid']
-                description_value = row['description']
-
-            filename_jd = row['filename']
-            OldSkillCount = 0
-            NewSkillCount = 0
-            skill_score = 0.0
-            print("Extracting Skills For ", filename_jd + " , Id : " + str(id_value) + " , Index " + str(index + 1))
-
-            
-            annotations = skill_extractor.annotate(description_value)
-            matches = annotations['results']['full_matches']+annotations['results']['ngram_scored']
-            skills_list = []
-            for result in matches:
-                if(1==1):
-                    
-                    isOld = "Yes"
-                    skill_id = result['skill_id']
-                    skill_name1 = skill_extractor.skills_db[skill_id]['skill_name']
-                    skill_name = skill_name1.split("(")[0].strip()
-                    skill_type = skill_extractor.skills_db[skill_id]['skill_type']
-                    skill_score = round(result['score'],2)
-                    
-
-                    if( skill_name in skills_list):
-                        continue
-                    skills_list.append(skill_name)
-                    #print("Skill Identified : ", j['doc_node_value'])
-                    query = "SELECT skillid FROM skillmaster WHERE skillDetails IN (%s)"
-                    params = (skill_name,)  # Replace 'Test' with your actual variable or user input
-                    cursor.execute(query, params)
-                    if cursor.rowcount > 0:    
-                        print('Skill in DB')
-                    else:    
-                        NewSkillCount = NewSkillCount + 1
-                        isOld = "No"
-                        skill_details = skill_name              
-                        weightage = -1.0
-                        skill_score = skill_score * 100               
-                        skill_score1 = str(skill_score)
-                        #skill_score = skill_score.astype(float)   
-                        #print(skill_score)         
-                        insert_query = sql.SQL("""INSERT INTO SkillMaster (SkillDetails, SkillType, Weightage, IsActive, skill_score) 
-                        VALUES (%s, %s, %s, %s, %s) RETURNING SkillID""")
-                        cursor.execute(insert_query, (skill_details, skill_type, weightage, is_active, skill_score1))
-                        conn.commit()
-                           
-                        print("Skill Identified : ", skill_name)
-                        #print("Skill inserted in SkillMaster and Inserted in JDSkillDetails")
-
-            
-     
-            print("Skills Updated for Skills Extraction for file ", filename_jd)
-            print("Total Skills : ", len(skills_list))
-            return SkillExtractorDetails.latestSkillDetails(id_value,db_params,IsJD)
-    def latestSkillDetails(jid,db_params,IsJD):
-        data = ""
-        data = SkillExtractorDetails.display_skills(jid,db_params,IsJD)
-        #    jid = df.iat[0,0]
-        return data
-    def tuple_to_int(tup):
-        if len(tup) == 1:
-            return tup[0]
-        else:
-            return tup[0] * (10 ** (len(tup) - 1)) + SkillExtractorDetails.tuple_to_int(tup[1:])
-
-
-    def skill_check(dbQuery,db_params,IsJD):
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        df = pd.read_sql_query(dbQuery, conn)
-        Required_Skills=''
-        for index, row in df.iterrows():   
-        
-            skillname = row['skillname']
-            Required_Skills = Required_Skills + ', '+ skillname
-        
-        Required_Skills = Required_Skills[2:] 
-        return Required_Skills
-    def display_skills(id, db_params,IsJD):
-        jd=str(id)
-        tableName = 'CVSkillDetails'
-        if(IsJD):
-            tableName = 'SkillDetails'
-        
-
-        query = "select skillname from " + tableName +"  where id = "+ jd +" and skillscore > 99 and skilltype = 'Hard Skill'"    
-        RequiredSkills_Hard  = SkillExtractorDetails.skill_check(query,db_params,IsJD)
-
-        query = "select skillname from " + tableName +"  where id = "+ jd +" and skillscore > 50 and skilltype = 'Soft Skill'"  
-        RequiredSkills_Soft  = SkillExtractorDetails.skill_check(query,db_params,IsJD)
-
-        query = "select skillname from " + tableName +"  where id = "+ jd +" and skillscore < 50 and skilltype = 'Soft Skill'"  
-        RequiredSkills_G1  = SkillExtractorDetails.skill_check(query,db_params,IsJD)
-
-        query = "select skillname from " + tableName +"  where id = "+ jd +" and skillscore < 99 and skilltype = 'Hard Skill'"  
-        RequiredSkills_G2  = SkillExtractorDetails.skill_check(query,db_params,IsJD)
-
-        print('')
-        print("Required Skills      : " + RequiredSkills_Hard)
-        print('')
-        print("Required Soft Skills : " + RequiredSkills_Soft)
-        print('')
-        print("Good to have Skills  : " + RequiredSkills_G1 +  " " + RequiredSkills_G2)
-        return RequiredSkills_Hard + "@" + RequiredSkills_Soft + "@" + RequiredSkills_G1 + " " + RequiredSkills_G2

SkillExtractV1.py

@@ -1,164 +0,0 @@
-import re
-from datetime import datetime
-import psycopg2
-import pandas as pd
-from DbConnection import DbConnection
-class SkillExtractorDetailsV1:
-
-
-    def GetSkillData(skill_extractor, inputData):
-        getdbskills = SkillExtractorDetailsV1.getSkills1()
-        print(getdbskills)
-        skills_list = []
-        annotations = skill_extractor.annotate(inputData)
-        matches = annotations['results']['full_matches']+annotations['results']['ngram_scored']
-        skill_Typelst = []
-        skill_Scorelst = []
-        reuiredSkilllst = []
-        softskillslst = []
-        goodtohavelst = []
-        ArchivedSkill=0
-        for result in matches:
-            ArchivedSkill=0
-            skill_id = result['skill_id']
-            skill_name1 = skill_extractor.skills_db[skill_id]['skill_name']
-            skill_name = skill_name1.split("(")[0].strip()
-            skill_type = skill_extractor.skills_db[skill_id]['skill_type']
-            skill_score = round(result['score'],2) * 100
-            #result = getdbskills[getdbskills['skilldetails'] == skill_name.upper()]
-            #print('Result1 -'+ result)
-            print('Skill - ' + skill_name.upper())
-            for row in getdbskills:
-                 if(row['skills'].upper() == skill_name.upper()):
-                    ArchivedSkill=1
-                    break
-                 
-            if(ArchivedSkill == 0 and skill_name not in skills_list):
-                print('Weightage non skill-'+ skill_name)  
-                print(skill_name)  
-                print(skill_score)  
-                print(skill_type)  
-                skills_list.append(skill_name)    
-                if(skill_score > 99 and skill_type != 'Soft Skill'):
-                    reuiredSkilllst.append(skill_name)
-                elif(skill_score > 50 and skill_type == 'Soft Skill'):
-                    softskillslst.append(skill_name)
-                elif(skill_score <= 50 and skill_type == 'Soft Skill'):
-                    goodtohavelst.append(skill_name)
-                elif(skill_score <= 99 and skill_type != 'Soft Skill'):
-                    goodtohavelst.append(skill_name)
-
-                # skills_list.append(skill_name)
-                # skill_Typelst.append(skill_type)
-                # skill_Scorelst.append(skill_score)
-            else:
-                print('Weightage zero skill-'+ skill_name)    
-        # list_of_tuples = list(zip(skills_list, skill_Typelst,skill_Scorelst))        
-        # df = pd.DataFrame(list_of_tuples,
-        #           columns=['Skill_Name', 'Skill_Type','Skill_Score'])
-        newSkilllst = SkillExtractorDetailsV1.extractWordsNew(inputData)
-        reqSkill = ''
-        if(len(newSkilllst)>0):
-            reqSkill = ','.join(reuiredSkilllst) + ','  + ','.join(newSkilllst)
-        else:
-            reqSkill = ','.join(reuiredSkilllst)    
-
-        data = {'Data':['Required Skills', 'Soft Skills', 'Good to have Skills'], 'Values':[reqSkill, ','.join(softskillslst), ','.join(goodtohavelst)]}
-        df = pd.DataFrame(data)
-        
-        return df        
-
-    def GetSkillDatafromDB():
-        conn = DbConnection.GetMySQLDbConnection()
-        
-        query = "select skilldetails from skillmaster where weightage = 0"
-        df = pd.read_sql_query(query, conn)
-        return df
-    
-    def extractWords(job_description):
-        job_roles = []
-        job_description = job_description.replace(')',' ')
-        delimiters = ",", " ", " , ", ";","\n","/","\\"
-        regex_pattern = '|'.join(map(re.escape, delimiters))
-        df = SkillExtractorDetailsV1.getNewSkills()
-        data = re.split(regex_pattern, job_description)
-        #data = job_description.split(',')
-        for ds in data:
-            #print(ds)
-            try:
-                
-                if(SkillExtractorDetailsV1.skill_Validate(df,ds.strip())):                
-                    job_roles.append(ds) 
-                    #SkillExtractorDetails.GetSkillId(ds.strip(),JdMasterid,db_params)
-                    print("Additional Skills : " + ds)   
-            except Exception as error:
-                test = 1
-        return job_roles 
-    def extractWordsNew(job_description):
-        job_roles = []
-        job_description = job_description.replace(')',' ')
-        delimiters = ",", " ", " , ", ";","\n","/","\\"
-        regex_pattern = '|'.join(map(re.escape, delimiters))
-        df = SkillExtractorDetailsV1.getNewSkills1()
-        data = re.split(regex_pattern, job_description)
-        #data = job_description.split(',')
-        for ds in data:
-            #print(ds)
-            try:
-                for row in df:                 
-                 if(row['skills'].upper() == ds.strip().upper()):
-                    if(ds.strip() not in job_roles):                        
-                        job_roles.append(ds.strip()) 
-                        print("Additional Skills : " + ds)   
-                
-            except Exception as error:
-                test = 1
-        return job_roles
-
-    def getNewSkills():
-        query = "select skillid,skilldetails,skilltype,skill_score from skillmaster where weightage = -2"
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        df_skill_master = pd.read_sql_query(query, conn)
-        df_skill_master['skilldetails'] = df_skill_master['skilldetails'].str.upper()
-        cursor.close()
-        # Close the connection
-        conn.close()
-
-        #print(df_skill_master)
-        return df_skill_master
-    def getSkills1():
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        cursor.execute("SELECT upper(skilldetails) skills FROM skillmaster where weightage = 0")
-        cursor.close()
-        # Close the connection
-        conn.close()
-        return cursor.fetchall()
-        #print(df_skill_master)
-    def getNewSkills1():
-        conn = DbConnection.GetMySQLDbConnection()
-        cursor = conn.cursor()
-        cursor.execute("SELECT upper(skilldetails) skills FROM skillmaster where weightage = -2")
-        cursor.close()
-        # Close the connection
-        conn.close()
-        return cursor.fetchall()
-        #print(df_skill_master)    
-        
-    def skill_Validate(df, skill):
-        skill = skill.upper()
-        if (len(skill.split()) < 2 and len(skill) < 3) or len(skill.split())==1:
-            df['skill_present'] = df['skilldetails'].apply(lambda x: re.match(rf'^{skill}$', x))
-            if any(df['skill_present']):
-                #print("Valid Skill")
-                return 1
-            else:
-                #print("Not a Skill")
-                return 0
-        elif df['skilldetails'].str.contains(skill.upper()).any():
-            #print("Valid Skill")
-            return 1
-        else:
-            # print("Not a Skill")
-            return 0 

SkillExtract_Backup.py

@@ -1,236 +0,0 @@
-import psycopg2
-from psycopg2 import sql
-import pandas as pd
-import re
-class SkillExtractorDetails:
-
-    def GetSkillId(skillname,jdmasterid,db_params):    
-        #Fetching skill id from skillmaster
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        query = "select skillid from skillmaster where upper(skilldetails) = (%s)"
-        params = (skillname.upper(),)  
-        cursor.execute(query, params)
-        generated_skill_id = cursor.fetchone()[0]
-        #jdmasterid = 912
-        #print(generated_skill_id)
-        #checking if skill id already in skilldetails
-        query = "SELECT skillid FROM jdSkilldetails WHERE skillid IN (%s) and jdMasterid in (%s)"
-        params = (generated_skill_id,jdmasterid,)  
-        cursor.execute(query, params)
-        if cursor.rowcount > 0: 
-            #print("Already")
-            query =''
-        else:
-            #print("Updating in DB")
-            insert_query = sql.SQL("""INSERT INTO jdSkilldetails (Skillid, jdMasterid) VALUES (%s, %s)""")
-            cursor.execute(insert_query, (generated_skill_id, jdmasterid))
-            conn.commit()
-
-        cursor.close()
-        # Close the connection
-        conn.close()   
-        return generated_skill_id
-    def skill_Validate(df, skill):
-        skill = skill.upper()
-        if (len(skill.split()) < 2 and len(skill) < 3) or len(skill.split())==1:
-            df['skill_present'] = df['skilldetails'].apply(lambda x: re.match(rf'^{skill}$', x))
-            if any(df['skill_present']):
-                #print("Valid Skill")
-                return 1
-            else:
-                #print("Not a Skill")
-                return 0
-        elif df['skilldetails'].str.contains(skill.upper()).any():
-            #print("Valid Skill")
-            return 1
-        else:
-            # print("Not a Skill")
-            return 0 
-    def getNewSkills(db_params):
-        query = "select skillid,skilldetails,skilltype,skill_score from skillmaster where weightage = -2"
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        df_skill_master = pd.read_sql_query(query, conn)
-        df_skill_master['skilldetails'] = df_skill_master['skilldetails'].str.upper()
-        cursor.close()
-        # Close the connection
-        conn.close()
-
-        #print(df_skill_master)
-        return df_skill_master
-    def extractWords(job_description,JdMasterid,db_params):
-        job_roles = []
-        job_description = job_description.replace(')',' ')
-        delimiters = ",", " ", " , ", ";","\n","/","\\"
-        regex_pattern = '|'.join(map(re.escape, delimiters))
-        df = SkillExtractorDetails.getNewSkills(db_params)
-        data = re.split(regex_pattern, job_description)
-        #data = job_description.split(',')
-        for ds in data:
-            #print(ds)
-            try:
-                if(SkillExtractorDetails.skill_Validate(df,ds.strip())):                
-                    job_roles.append(ds) 
-                    SkillExtractorDetails.GetSkillId(ds.strip(),JdMasterid,db_params)
-                    print("Skills Identified* : " + ds)   
-            except Exception as error:
-                test = 1
-        return job_roles 
-    def SkillExtract(db_params,skill_extractor,JdID):
-        print("Extracting Skills for the JD...")
-        # Connect to the PostgreSQL database
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-
-        jd_id = str(JdID)
-        # Retrieve "id" and "description" columns from the table
-        #query = sql.SQL("select jdmasterid,jobdescription from JDMaster where isskillsextracted in (0)")
-        query = "select jdmasterid,jobdescription,filename from JDMaster where isskillsextracted = 0 and jdmasterid ="+ jd_id 
-
-        # Use Pandas to read the data into a DataFrame
-        df = pd.read_sql_query(query, conn)
-
-        # Print the DataFrame (for demonstration purposes)
-        #print(df)
-        
-        skill_details = ''
-        skill_type = ''
-        weightage = -1.0
-        is_active = True
-        Skillid = 0
-        jdMasterid = 0
-        OldSkillCount = 0
-        NewSkillCount = 0
-        if(len(df.index) > 0):
-            print("Total JDs for Extractraction : " + str(len(df.index)))
-        for index, row in df.iterrows():
-            # Access individual columns using column names
-            id_value = row['jdmasterid']
-            filename_jd = row['filename']
-            OldSkillCount = 0
-            NewSkillCount = 0
-            skill_score = 0.0
-            print("Extracting Skills For ", filename_jd + " , Id : " + str(id_value) + " , Index " + str(index + 1))
-
-            description_value = row['jobdescription']
-            #print(description_value)
-            
-            annotations = skill_extractor.annotate(description_value)
-            matches = annotations['results']['full_matches']+annotations['results']['ngram_scored']
-            skills_list = []
-            for result in matches:
-                if(1==1):
-                    
-                    isOld = "Yes"
-                    skill_id = result['skill_id']
-                    skill_name1 = skill_extractor.skills_db[skill_id]['skill_name']
-                    skill_name = skill_name1.split("(")[0].strip()
-                    skill_type = skill_extractor.skills_db[skill_id]['skill_type']
-                    skill_score = round(result['score'],2)
-                    
-
-                    if( skill_name in skills_list):
-                        continue
-                    skills_list.append(skill_name)
-                    #print("Skill Identified : ", j['doc_node_value'])
-                    query = "SELECT skillid FROM skillmaster WHERE skillDetails IN (%s)"
-                    params = (skill_name,)  # Replace 'Test' with your actual variable or user input
-                    cursor.execute(query, params)
-                    if cursor.rowcount > 0:    
-                        print("Skill Identified : ", skill_name)                
-                        result = cursor.fetchall()                
-                        for row in result:
-                            row_as_int = [int(element) for element in row]
-                            #print("Skill Already in SkillMaster")
-                            OldSkillCount = OldSkillCount + 1
-                            isOld = "Yes"
-                            query = "SELECT skillid FROM jdSkilldetails WHERE skillid IN (%s) and jdMasterid in (%s)"
-                            params = (row_as_int[0],id_value,)  
-                            cursor.execute(query, params)
-                            if cursor.rowcount > 0: 
-                                weightage = -1.0  
-                                #print("Skill Already in SkillMaster and JDSkillDetails")
-                            else:  
-                                Skillid = row_as_int[0]
-                                jdMasterid = id_value   
-                                insert_query = sql.SQL("""INSERT INTO jdSkilldetails (Skillid, jdMasterid) VALUES (%s, %s)""")
-                                cursor.execute(insert_query, (Skillid, jdMasterid))
-                                conn.commit()
-                                #print("Skill Already in SkillMaster and Inserted in JDSkillDetails")	
-                                #print(row_as_int)
-                    else:    
-                        NewSkillCount = NewSkillCount + 1
-                        isOld = "No"
-                        skill_details = skill_name              
-                        weightage = -1.0
-                        skill_score = skill_score * 100               
-                        skill_score1 = str(skill_score)
-                        #skill_score = skill_score.astype(float)   
-                        #print(skill_score)         
-                        insert_query = sql.SQL("""INSERT INTO SkillMaster (SkillDetails, SkillType, Weightage, IsActive, skill_score) 
-                        VALUES (%s, %s, %s, %s, %s) RETURNING SkillID""")
-                        cursor.execute(insert_query, (skill_details, skill_type, weightage, is_active, skill_score1))
-                        conn.commit()
-                        generated_skill_id = cursor.fetchone()[0]
-                        Skillid = generated_skill_id
-                        jdMasterid = id_value
-                        insert_query = sql.SQL("""INSERT INTO jdSkilldetails (Skillid, jdMasterid) VALUES (%s, %s)""")
-                        cursor.execute(insert_query, (Skillid, jdMasterid))
-                        conn.commit()
-                        print("Skill Identified : ", skill_name)
-                        #print("Skill inserted in SkillMaster and Inserted in JDSkillDetails")
-            SkillExtractorDetails.extractWords(description_value,id_value,db_params)
-            query = "update public.jdmaster set isskillsextracted = 1 where jdmasterid = (%s)"
-            
-            params = (id_value,)  
-            cursor.execute(query, params)
-            conn.commit()
-            print("Skills Updated for Skills Extraction for file ", filename_jd)
-            print("Total Skills : ", len(skills_list))
-            return SkillExtractorDetails.latestSkillDetails(id_value,db_params)
-    def latestSkillDetails(jid,db_params):
-        data = ""
-        data = SkillExtractorDetails.display_skills(jid,db_params)
-        #    jid = df.iat[0,0]
-        return data
-    def tuple_to_int(tup):
-        if len(tup) == 1:
-            return tup[0]
-        else:
-            return tup[0] * (10 ** (len(tup) - 1)) + SkillExtractorDetails.tuple_to_int(tup[1:])
-
-
-    def skill_check(dbQuery,db_params):
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()
-        df = pd.read_sql_query(dbQuery, conn)
-        Required_Skills=''
-        for index, row in df.iterrows():   
-        
-            skillname = row['skillname']
-            Required_Skills = Required_Skills + ', '+ skillname
-        
-        Required_Skills = Required_Skills[2:] 
-        return Required_Skills
-    def display_skills(id, db_params):
-        jd=str(id)
-        query = "select skillname from SkillDetails  where id = "+ jd +" and skillscore > 99 and skilltype = 'Hard Skill'"
-        RequiredSkills_Hard  = SkillExtractorDetails.skill_check(query,db_params)
-
-        query = "select skillname from SkillDetails  where id = "+ jd +" and skillscore > 50 and skilltype = 'Soft Skill'"  
-        RequiredSkills_Soft  = SkillExtractorDetails.skill_check(query,db_params)
-
-        query = "select skillname from SkillDetails  where id = "+ jd +" and skillscore < 50 and skilltype = 'Soft Skill'"  
-        RequiredSkills_G1  = SkillExtractorDetails.skill_check(query,db_params)
-
-        query = "select skillname from SkillDetails  where id = "+ jd +" and skillscore < 99 and skilltype = 'Hard Skill'"  
-        RequiredSkills_G2  = SkillExtractorDetails.skill_check(query,db_params)
-
-        print('')
-        print("Required Skills      : " + RequiredSkills_Hard)
-        print('')
-        print("Required Soft Skills : " + RequiredSkills_Soft)
-        print('')
-        print("Good to have Skills  : " + RequiredSkills_G1 +  " " + RequiredSkills_G2)
-        return RequiredSkills_Hard + "@" + RequiredSkills_Soft + "@" + RequiredSkills_G1 + " " + RequiredSkills_G2

SkillMatcher.py

@@ -1,110 +0,0 @@
-import psycopg2
-import pandas as pd
-from sentence_transformers import SentenceTransformer, util
-class SkillMatch:
-    def SkillMatcher(model,db_params,jdID):
-        print("Checking Best Course for the JD...")  
-        conn = psycopg2.connect(**db_params)
-        cursor_obj = conn.cursor()
-
-        query = "select * from JDDetailsAllSkill where jdmasterid = (%s)"
-        params = (jdID,)
-        cursor_obj.execute(query,params)
-        jd_data = cursor_obj.fetchall()
-        #connection_obj.commit()
-        print(jd_data)
-        query = "select * from CourseDetailsForMatching"
-        cursor_obj.execute(query)
-        cv_data = cursor_obj.fetchall()
-        print(cv_data)
-        #connection_obj.commit()
-        query = "select jdmasterid || '-' || courseid from courseskillmatch"
-        cursor_obj.execute(query)
-        match_data = cursor_obj.fetchall()
-
-        jd_skills = {}
-        for obj in jd_data:
-            if obj[0] not in jd_skills:
-                jd_skills[obj[0]] = []
-
-            jd_skills[obj[0]].append(obj[1])
-
-        cv_skills = {}
-        for obj in cv_data:
-            if obj[0] not in cv_skills:
-                cv_skills[obj[0]] = []
-            
-            cv_skills[obj[0]].append(obj[1])
-
-        
-        count = 0
-        MatchSkillsId = 0
-        isAlreadyInDb = False
-        TopScore = 0
-        CourseId = 0
-        MatchId =''
-        for jd in jd_skills:
-            for cv in cv_skills:
-            #if(cv in match_data[1] and jd in match_data[0]):
-            #print("Already record : " + str(cv) + " , "  + str(jd))
-                isAlreadyInDb = False
-                match_details = str(jd) + "-" + str(cv)
-                print("Checking for existing Profile")
-                for i in match_data:
-                    if(i[0] == match_details):
-                        print( "Already in Database -----------"  + i[0])
-                        isAlreadyInDb = True
-                        break
-                
-                if(isAlreadyInDb == True):
-                    continue
-                #print(match_details)  
-                print("Running Matching Algo")
-                count += 1
-                sentence1 = " ".join(cv_skills[cv])
-                sentence2 = " ".join(jd_skills[jd])
-                embedding1 = model.encode(sentence1, convert_to_tensor=True)
-                embedding2 = model.encode(sentence2, convert_to_tensor=True)
-
-                # Compute cosine similarity between the two sentence embeddings
-                cosine_similarit = util.cos_sim(embedding1, embedding2)
-                if(TopScore < cosine_similarit * 100):
-                    TopScore = cosine_similarit * 100
-                    CourseId = cv
-                
-                print("DB Entry for Matching Results")  
-                #common = set(cv_skills[cv]) & set(jd_skills[jd])
-                if(1==1):
-                    if(MatchSkillsId == 0):
-                        query = "select coalesce(max(skillmatchid),0) + 1 from courseskillmatch"
-                        cursor_obj.execute(query)
-                        MatchId = cursor_obj.fetchall()
-                        MatchSkillsId = SkillMatch.tuple_to_int( MatchId[0])
-                
-
-                
-                if(1==1):  
-                    record = (MatchSkillsId, cv, jd, cosine_similarit[0][0].item(),1)
-                    query = """INSERT INTO public.courseskillmatch(SkillMatchID, courseid, JDMasterID, MatchScore,isactive) VALUES (%s,%s,%s,%s,%s)"""
-                    cursor_obj.execute(query, record)
-                    conn.commit()
-                    MatchSkillsId = MatchSkillsId + 1
-                print( str( MatchSkillsId)  + " "+"Updating in DB - JD {} CV {} ".format(jd, cv), cosine_similarit[0][0].item())
-                #print(TopScore)
-            print(CourseId)
-            query = "select filename from coursemaster where masterid = " + str(CourseId)
-            df = pd.read_sql_query(query, conn)
-            try:
-                MatchId = df.iat[0,0]
-            except:
-                print(CourseId)    
-        print("------------------------Beta Results  - " + MatchId)
-        cursor_obj.close()
-        conn.close()  
-        return str(MatchId) + ";" + str(TopScore[0][0].item()) + ";" + str(CourseId)
-        
-    def tuple_to_int(tup):
-        if len(tup) == 1:
-            return tup[0]
-        else:
-            return tup[0] * (10 ** (len(tup) - 1)) + SkillMatch.tuple_to_int(tup[1:])

UploadFile.py

@@ -1,32 +0,0 @@
-from datetime import date
-import psycopg2
-from psycopg2 import sql
-import pandas as pd
-
-class UploadOpenFile:
-
-    def uploadFile(text,filePath,db_params,isJD):
-
-        conn = psycopg2.connect(**db_params)
-        cursor = conn.cursor()    
-        if(isJD):             
-            df = pd.read_sql_query("Select max(jdmasterid) from JdMaster", conn)
-        else:
-            df = pd.read_sql_query("Select max(masterid) from CourseMaster", conn)    
-        try:
-            MasterId = df.iat[0,0] + 1
-        except:
-            MasterId =1
-
-        print(MasterId)
-        if(isJD): 
-            query =sql.SQL("""INSERT INTO  JDMaster (jdmasterid,jobdescription, filename, UploadedDate, IsDetailsExtracted,IsSkillsExtracted,source) VALUES (%s,%s,%s,%s,%s,%s,%s)""")
-        else:
-            query =sql.SQL("""INSERT INTO  CourseMaster (masterid,description, filename, UploadedDate, IsDetailsExtracted,IsSkillsExtracted,source) VALUES (%s,%s,%s,%s,%s,%s,%s)""")    
-        cursor.execute(query, (MasterId,text,filePath, date.today(),0,0,"JD")) 
-        conn.commit()
-        cursor.close()
-        conn.close()
-        print("File Uploaded...")
-        return MasterId
-