Add logging configuration and update similarity score display (#245)

* Add logging configuration and update similarity score display

* Refactor import statements and clean up code formatting

Demo/DemoData.py

@@ -1,6 +1,33 @@
-jobs = [{'job_desc': 'Job Description Product Manager 10+ Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nTech Solutions is a global leader in the technology industry specializing in the development of cuttingedge\nsoftware products We’re currently looking for a seasoned Product Manager with over 10 years of experience\nto join our dynamic team\nJob Description\nThe Product Manager will be responsible for guiding the success of a product and leading the crossfunctional\nteam that is responsible for improving it This is an important organizational role that sets the strategy\nroadmap and feature definition for a product or product line\nResponsibilities\n•Define the product strategy and roadmap\n•Deliver MRDs and PRDs with prioritized features and corresponding justification\n•Work with external third parties to assess partnerships and licensing opportunities\n•Run beta and pilot programs with earlystage products and samples\n•Be an expert with respect to the competition\n•Act as a leader within the company\n•Develop the core positioning and messaging for the product\n•Perform product demos to customers\n•Set pricing to meet revenue and profitability goals\nRequirements\n•10+ years of experience in product management\n•Demonstrated success defining and launching excellent products\n•Excellent written and verbal communication skills\n•Technical background with experience in software development\n•Excellent teamwork skills\n•Proven ability to influence crossfunctional teams without formal authority\n•Must be able to travel 20\n•Bachelor’s degree MBA preferred\n1 Benefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is an equal opportunity employer We celebrate diversity and are committed to creating\nan inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2'}, {'job_desc': 'Job Description Senior Full Stack Engineer 5+ Years of\nExperience\nTech Solutions San Francisco CA USA\nAbout Us\nTech Solutions is a leading technology company that creates innovative solutions across a variety of industries\nOur mission is to improve lives through advanced technology We’re currently seeking a Senior Full Stack\nEngineer to join our dynamic team\nJob Description\nWe’re looking for a Senior Full Stack Engineer with 5+ years of experience in developing web applications\nThe successful candidate will have experience working with both frontend and backend technologies and\nwill be capable of overseeing projects from conception to production deployment\nResponsibilities\n•Developing front end website architecture\n•Designing user interactions on web pages\n•Developing back end website applications\n•Creating servers and databases for functionality\n•Ensuring crossplatform optimization for mobile phones\n•Seeing through a project from conception to finished product\n•Designing and developing APIs\n•Meeting both technical and consumer needs\n•Staying abreast of developments in web applications and programming languages\nRequirements\n•Degree in Computer Science or similar field\n•5+ years of experience in web development\n•Strong organizational and project management skills\n•Proficiency with fundamental front end languages such as HTML CSS and JavaScript\n•Proficiency with serverside languages such as Python Ruby Java PHP and Net\n•Familiarity with database technology such as MySQL Oracle and MongoDB\n1 •Excellent verbal communication skills\n•Good problemsolving skills\n•Attention to detail\nBenefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is an equal opportunity employer and we value diversity at our company\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2'},
-        {'job_desc': 'Job Description Front End Engineer 2 Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nAt Tech Solutions we are on a mission to build products that solve complex problems and improve people’s\nlives We are seeking a talented Front End Engineer to join our dynamic team in San Francisco\nJob Description\nWe are looking for a Front End Engineer with at least 2 years of experience in developing scalable and\nuserfriendly web applications The successful candidate will be proficient in modern JavaScript frameworks\nand libraries HTML CSS and responsive design principles This role will contribute significantly to the\ncreation and implementation of user interfaces for our web applications\nResponsibilities\n•Develop new userfacing features using modern JavaScript frameworks like Reactjs Vuejs or Angu\nlarjs\n•Build reusable code and libraries for future use\n•Ensure the technical feasibility of UI/UX designs\n•Optimize application for maximum speed and scalability\n•Assure that all user input is validated before submitting to backend services\n•Collaborate with other team members and stakeholders\nRequirements\n•2 years of experience as a Front End Developer or similar role\n•Proficiency in web markup including HTML5 CSS3\n•Knowledge of modern JavaScript programming and experience with libraries like jQuery\n•Familiarity with modern frontend build pipelines and tools\n•Experience with popular frontend frameworks such as React Vue or Angular\n•Familiarity with code versioning tools such as Git\n•Degree in Computer Science Engineering or a related field\n1 Benefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is proud to be an equal opportunity employer We celebrate diversity and are committed\nto creating an inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2'}, {'job_desc': 'Job Description Java Developer 3 Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nAt Tech Solutions we believe in the power of technology to solve complex problems We are a dynamic\nforwardthinking tech company specializing in custom software solutions for various industries We are\nseeking a talented and experienced Java Developer to join our team\nJob Description\nWe are seeking a skilled Java Developer with at least 3 years of experience in building highperforming scal\nable enterprisegrade applications You will be part of a talented software team that works on missioncritical\napplications Your roles and responsibilities will include managing Java/Java EE application development\nwhile providing expertise in the full software development lifecycle\nResponsibilities\n•Designing implementing and maintaining Java applications that are often highvolume and low\nlatency required for missioncritical systems\n•Delivering high availability and performance\n•Contributing to all phases of the development lifecycle\n•Writing welldesigned efficient and testable code\n•Conducting software analysis programming testing and debugging\n•Ensuring designs comply with specifications\n•Preparing and producing releases of software components\n•Supporting continuous improvement by investigating alternatives and technologies and presenting these\nfor architectural review\nRequirements\n•BS/MS degree in Computer Science Engineering or a related subject\n•Proven handson Software Development experience\n•Proven working experience in Java development\n•Handson experience in designing and developing applications using Java EE platforms\n•ObjectOriented Analysis and design using common design patterns\n•Profound insight of Java and JEE internals Classloading Memory Management Transaction man\nagement etc\n1 •Excellent knowledge of Relational Databases SQL and ORM technologies JPA2 Hibernate\n•Experience in developing web applications using at least one popular web framework JSF Wicket\nGWT Spring MVC\n•Experience with testdriven development\nBenefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is proud to be an equal opportunity employer We celebrate diversity and are committed\nto creating an inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2'}]
+jobs = [
+    {
+        "job_desc": "Job Description Product Manager 10+ Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nTech Solutions is a global leader in the technology industry specializing in the development of cuttingedge\nsoftware products We’re currently looking for a seasoned Product Manager with over 10 years of experience\nto join our dynamic team\nJob Description\nThe Product Manager will be responsible for guiding the success of a product and leading the crossfunctional\nteam that is responsible for improving it This is an important organizational role that sets the strategy\nroadmap and feature definition for a product or product line\nResponsibilities\n•Define the product strategy and roadmap\n•Deliver MRDs and PRDs with prioritized features and corresponding justification\n•Work with external third parties to assess partnerships and licensing opportunities\n•Run beta and pilot programs with earlystage products and samples\n•Be an expert with respect to the competition\n•Act as a leader within the company\n•Develop the core positioning and messaging for the product\n•Perform product demos to customers\n•Set pricing to meet revenue and profitability goals\nRequirements\n•10+ years of experience in product management\n•Demonstrated success defining and launching excellent products\n•Excellent written and verbal communication skills\n•Technical background with experience in software development\n•Excellent teamwork skills\n•Proven ability to influence crossfunctional teams without formal authority\n•Must be able to travel 20\n•Bachelor’s degree MBA preferred\n1 Benefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is an equal opportunity employer We celebrate diversity and are committed to creating\nan inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2"
+    },
+    {
+        "job_desc": "Job Description Senior Full Stack Engineer 5+ Years of\nExperience\nTech Solutions San Francisco CA USA\nAbout Us\nTech Solutions is a leading technology company that creates innovative solutions across a variety of industries\nOur mission is to improve lives through advanced technology We’re currently seeking a Senior Full Stack\nEngineer to join our dynamic team\nJob Description\nWe’re looking for a Senior Full Stack Engineer with 5+ years of experience in developing web applications\nThe successful candidate will have experience working with both frontend and backend technologies and\nwill be capable of overseeing projects from conception to production deployment\nResponsibilities\n•Developing front end website architecture\n•Designing user interactions on web pages\n•Developing back end website applications\n•Creating servers and databases for functionality\n•Ensuring crossplatform optimization for mobile phones\n•Seeing through a project from conception to finished product\n•Designing and developing APIs\n•Meeting both technical and consumer needs\n•Staying abreast of developments in web applications and programming languages\nRequirements\n•Degree in Computer Science or similar field\n•5+ years of experience in web development\n•Strong organizational and project management skills\n•Proficiency with fundamental front end languages such as HTML CSS and JavaScript\n•Proficiency with serverside languages such as Python Ruby Java PHP and Net\n•Familiarity with database technology such as MySQL Oracle and MongoDB\n1 •Excellent verbal communication skills\n•Good problemsolving skills\n•Attention to detail\nBenefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is an equal opportunity employer and we value diversity at our company\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2"
+    },
+    {
+        "job_desc": "Job Description Front End Engineer 2 Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nAt Tech Solutions we are on a mission to build products that solve complex problems and improve people’s\nlives We are seeking a talented Front End Engineer to join our dynamic team in San Francisco\nJob Description\nWe are looking for a Front End Engineer with at least 2 years of experience in developing scalable and\nuserfriendly web applications The successful candidate will be proficient in modern JavaScript frameworks\nand libraries HTML CSS and responsive design principles This role will contribute significantly to the\ncreation and implementation of user interfaces for our web applications\nResponsibilities\n•Develop new userfacing features using modern JavaScript frameworks like Reactjs Vuejs or Angu\nlarjs\n•Build reusable code and libraries for future use\n•Ensure the technical feasibility of UI/UX designs\n•Optimize application for maximum speed and scalability\n•Assure that all user input is validated before submitting to backend services\n•Collaborate with other team members and stakeholders\nRequirements\n•2 years of experience as a Front End Developer or similar role\n•Proficiency in web markup including HTML5 CSS3\n•Knowledge of modern JavaScript programming and experience with libraries like jQuery\n•Familiarity with modern frontend build pipelines and tools\n•Experience with popular frontend frameworks such as React Vue or Angular\n•Familiarity with code versioning tools such as Git\n•Degree in Computer Science Engineering or a related field\n1 Benefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is proud to be an equal opportunity employer We celebrate diversity and are committed\nto creating an inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2"
+    },
+    {
+        "job_desc": "Job Description Java Developer 3 Years of Experience\nTech Solutions San Francisco CA USA\nAbout Us\nAt Tech Solutions we believe in the power of technology to solve complex problems We are a dynamic\nforwardthinking tech company specializing in custom software solutions for various industries We are\nseeking a talented and experienced Java Developer to join our team\nJob Description\nWe are seeking a skilled Java Developer with at least 3 years of experience in building highperforming scal\nable enterprisegrade applications You will be part of a talented software team that works on missioncritical\napplications Your roles and responsibilities will include managing Java/Java EE application development\nwhile providing expertise in the full software development lifecycle\nResponsibilities\n•Designing implementing and maintaining Java applications that are often highvolume and low\nlatency required for missioncritical systems\n•Delivering high availability and performance\n•Contributing to all phases of the development lifecycle\n•Writing welldesigned efficient and testable code\n•Conducting software analysis programming testing and debugging\n•Ensuring designs comply with specifications\n•Preparing and producing releases of software components\n•Supporting continuous improvement by investigating alternatives and technologies and presenting these\nfor architectural review\nRequirements\n•BS/MS degree in Computer Science Engineering or a related subject\n•Proven handson Software Development experience\n•Proven working experience in Java development\n•Handson experience in designing and developing applications using Java EE platforms\n•ObjectOriented Analysis and design using common design patterns\n•Profound insight of Java and JEE internals Classloading Memory Management Transaction man\nagement etc\n1 •Excellent knowledge of Relational Databases SQL and ORM technologies JPA2 Hibernate\n•Experience in developing web applications using at least one popular web framework JSF Wicket\nGWT Spring MVC\n•Experience with testdriven development\nBenefits\n•Competitive salary package\n•Health dental and vision insurance\n•Retirement savings plan\n•Professional development opportunities\n•Flexible work hours\nTech Solutions is proud to be an equal opportunity employer We celebrate diversity and are committed\nto creating an inclusive environment for all employees\nHow to Apply\nTo apply please submit your resume and a brief explanation of your relevant experience to  \n2"
+    },
+]
 
 
-resumes = [{'resume': 'JOHN DOE\n123 Main St Anywhere USA    \nLinkedIn linkedincom/in/johndoe  GitHub githubcom/johndoe\nPROFESSIONAL SUMMARY\nHighly skilled Full Stack Developer with over 5 years of experience in Java and Angular development\nspecializing in designing building testing and maintaining web applications Proficient in an assortment\nof technologies including Java Spring Boot Angular HTML5 CSS3 and SQL Exceptional ability to\nwork in a team and selfdirect Committed to providing highquality results with little supervision\nSKILLS\n•Java and J2EE\n•Spring Boot Spring MVC and Hibernate\n•Angular versions 2+\n•JavaScript TypeScript HTML5 CSS3 and Bootstrap\n•RESTful APIs\n•SQL and NoSQL databases MySQL MongoDB\n•Agile and Scrum\n•Git and GitHub\n•Junit and Mockito\n•Docker\nWORK EXPERIENCE\nFull Stack Java Developer  ABC Company Inc Anywhere USA June 2018  Present\n•Developed scalable robust and maintainable enterpriselevel applications using Java and Spring\nBoot\n•Used Angular for developing dynamic and responsive web frontends improving user experience\nby 30\n•Integrated applications with MySQL and MongoDB databases to store and retrieve data efficiently\n•Collaborated in an Agile development team to deliver highquality software every sprint\n•Created RESTful services and APIs for frontend and thirdparty applications\n•Wrote unit tests using Junit and Mockito for robust testing of application components\nSoftware Developer  XYZ Solutions Anywhere USA July 2016  June 2018\n•Participated in the complete software development life cycle from requirement analysis to deploy\nment\n•Implemented business logic using Java and enhanced user interface using Angular\n•Developed and maintained SQL and NoSQL databases implementing complex queries for business\nneeds\n•Utilized Git for version control and collaborated with team members via GitHub\n•Assisted in troubleshooting software debugging and system enhancements\n1 EDUCATION\nBachelor of Science in Computer Science  State University Anywhere USA May 2016\nCERTIFICATIONS\n•Oracle Certified Professional Java SE 8 Programmer\n•Certified Angular Developer\n2'}, {'resume': 'Alfred Pennyworth\nProduct ManagerSilicon Valley CA USA\n♂¶obilealt\n/envel⌢\n/linkedininapennyworth\n\nProfessional Summary\nSeasoned Product Manager with over 20 years of experience in software development and product\nmanagement having worked at all FAANG companies Exceptional leadership skills strategic\nthinking and a track record of managing products from conception to market success\nSkills\nProduct management Agile methodologies Leadership Communication Project\nmanagement User Experience Design Market Research Data Analysis Java\nPython JavaScript HTML/CSS SQL AWS\nExperience\n2017 \nPresentProduct Manager Google  Mountain View CA USA\nLeading crossfunctional teams to design develop and launch innovative products Devel\noping product strategies and making datadriven decisions to improve user experience and\nmeet business goals\n2012  2017 Software Development Engineer III Amazon  Seattle WA USA\nLed a team of developers in building scalable and highperforming ecommerce applications\nSuccessfully delivered multiple projects within the stipulated time and budget\n2007  2012 Software Development Engineer II Apple  Cupertino CA USA\nDesigned and implemented software components for various Apple services Optimized the\nperformance of applications and improved code quality through thorough testing\n2002  2007 Software Development Engineer I Netflix  Los Gatos CA USA\nDeveloped and maintained the user interface for the Netflix web application Worked closely\nwith product managers and designers to create an optimal user experience\n1999  2002 Software Development Engineer I Facebook  Menlo Park CA USA\nPlayed a key role in the development of early Facebook features Implemented scalable\nbackend services using Java and SQL\nEducation\n2016  2018 Master of Business Administration Stanford University  Stanford CA USA\n1997  1999 Master of Science in Computer Science Massachusetts Institute of Technology \nCambridge MA USA\n1994  1997 Bachelor of Science in Computer Science University of California Berkeley \nBerkeley CA USA\nProjects\n1/2 2020 \nPresentPersonal Project Home Automation System\nDeveloped a smart home automation system using Raspberry Pi and Python The system\nautomates various home appliances based on user behavior and preferences contributing to\nenergy saving and improved user convenience\n2/2'},
-           {'resume': 'Harvey Dent\nMachine Learning Engineer321 Gotham St\nGotham USA\n♂¶obilealt\n/envel⌢\n/linkedininhdent\n/githubhdent\nProfessional Summary\nMachine Learning Engineer with 5 years of experience in designing building and deploying predictive\nmodels and deep learning systems Proficient in Python TensorFlow PyTorch and Scikitlearn\nCurrently leading a team of AI engineers at OpenAI\nSkills\nPython R TensorFlow PyTorch Scikitlearn Keras SQL NoSQL Git Docker\nKubernetes Agile and Scrum Statistics Data visualization Deep Learning Natural\nLanguage Processing\nExperience\n2021 \nPresentMachine Learning Engineer OpenAI  San Francisco USA\nLeading a team of AI engineers Designed and implemented deep learning models for natural\nlanguage processing tasks Improved the efficiency of model training and data processing\npipelines Published several research papers in toptier AI conferences\n2018  2021 Data Scientist Uber  San Francisco USA\nDeveloped and deployed machine learning models to improve the efficiency of ride allocation\nalgorithms Utilized TensorFlow and PyTorch for developing predictive models Analyzed\nand visualized large data sets to drive business strategies\n2016  2018 Junior Data Analyst Facebook  Menlo Park USA\nAnalyzed and visualized large datasets using Python and R Assisted in the development of\nmachine learning models for user behavior prediction Conducted A/B testing and provided\ninsights to the product team\nEducation\n2014  2016 Master of Science in Computer Science Specialization in AI MIT Cambridge\nUSA\n2010  2014 Bachelor of Science in Computer Science UC San Diego  San Diego USA\nProjects\n2021 \nPresentPersonal Project Predictive Stock Trading Model\nDeveloped a predictive stock trading model using deep learning and time series analysis\nUsed PyTorch for model development and Docker for deployment The model predicts stock\nprices with a high degree of accuracy and automates trading decisions'}, {'resume': 'Bruce Wayne\nMERN Stack Developer123 Gotham St\nGotham USA\n♂¶obilealt\n/envel⌢\n/linkedininbwayne\n\nProfessional Summary\nHighly skilled MERN Stack Developer with over 10 years of experience specializing in designing\nbuilding and maintaining complex web applications Proficient in MongoDB Expressjs React and\nNodejs Currently contributing to the development of AI technologies at OpenAI with a primary\nfocus on the ChatGPT project\nSkills\nJavaScript and TypeScript MongoDB Expressjs React Nodejs MERN stack\nRESTful APIs Git and GitHub Docker and Kubernetes Agile and Scrum Python\nand Machine Learning basics\nExperience\nJune 2020 \nPresentMERN Stack Developer OpenAI  San Francisco USA\nWorking on the development of the ChatGPT project using Nodejs Expressjs and React\nImplementing RESTful services for communication between frontend and backend Utilizing\nDocker and Kubernetes for deployment and management of applications Working in an\nAgile environment delivering highquality software every sprint Contributing to the design\nand implementation of machine learning algorithms for natural language processing tasks\nJuly 2015 \nMay 2020Full Stack Developer Uber  San Francisco USA\nDeveloped and maintained scalable web applications using MERN stack Ensured the\nperformance quality and responsiveness of applications Successfully deployed solutions\nusing Docker and Kubernetes Collaborated with a team of engineers product managers\nand UX designers Led a team of junior developers conducted code reviews and ensured\nadherence to best coding practices Worked closely with the data science team to optimize\nrecommendation algorithms and enhance user experience\nJune 2012 \nJune 2015Software Developer Facebook  Menlo Park USA\nDeveloped features for the Facebook web application using React Ensured the performance\nof the MongoDB databases Utilized RESTful APIs for communication between different\nparts of the application Worked in a fastpaced testdriven development environment\nAssisted in migrating the legacy system to a modern MERN stack architecture\nEducation\n2009  2012 PhD in Computer Science CalTech  Pasadena USA\n2007  2009 Master of Science in Computer Science MIT Cambridge USA\n2003  2007 Bachelor of Science in Computer Science UC San Diego  San Diego USA\n1/2 Projects\n2019 \nPresentPersonal Project Gotham Event Planner\nCreated a fullfeatured web application to plan and organize events in Gotham city Used\nMERN stack for development and Docker for deployment The application allows users to\ncreate manage and share events and integrates with Google Maps API to display event\nlocations\n2/2'}, {'resume': 'Barry Allen\nFrontEnd DeveloperGoogle HQ Mountain View CA USA\n♂¶obilealt\n/envel⌢\n/linkedininbwayne\n\nObjective\nSeeking a challenging role as a FrontEnd Developer where I can leverage my knowledge of UI/UX\ndesign and modern web technologies to create intuitive and engaging user interfaces\nEducation\n2018  2022 BTech Computer Science and Engineering Indian Institute of Technology\nDelhi  New Delhi India\nOverall GPA 95/10\nSkills\nJavaScript ES6+ TypeScript HTML5 CSS3 Python React Redux Angular\nVuejs Nodejs Expressjs D3js Git Docker Webpack Babel Google Cloud\nPlatform Firebase RESTful APIs GraphQL Agile Development TestDriven\nDevelopment Responsive Design UI/UX\nExperience\nJune 2022 \nPresentSoftware Engineer FrontEnd Google  Mountain View CA USA\nDeveloping intuitive and engaging user interfaces using React and Redux Working closely\nwith UX designers to implement responsive and accessible web design Participating in\nagile development processes including sprint planning and code reviews Collaborating with\nbackend developers to integrate RESTful APIs and ensure seamless data flow\nProjects\n2022 Personal Expense Tracker\nDeveloped a personal expense tracker application using React Redux and Firebase Imple\nmented user authentication using Firebase Auth and data storage using Firestore Utilized\nD3js for data visualization to provide users with insights into their spending patterns'}]
+resumes = [
+    {
+        "resume": "JOHN DOE\n123 Main St Anywhere USA    \nLinkedIn linkedincom/in/johndoe  GitHub githubcom/johndoe\nPROFESSIONAL SUMMARY\nHighly skilled Full Stack Developer with over 5 years of experience in Java and Angular development\nspecializing in designing building testing and maintaining web applications Proficient in an assortment\nof technologies including Java Spring Boot Angular HTML5 CSS3 and SQL Exceptional ability to\nwork in a team and selfdirect Committed to providing highquality results with little supervision\nSKILLS\n•Java and J2EE\n•Spring Boot Spring MVC and Hibernate\n•Angular versions 2+\n•JavaScript TypeScript HTML5 CSS3 and Bootstrap\n•RESTful APIs\n•SQL and NoSQL databases MySQL MongoDB\n•Agile and Scrum\n•Git and GitHub\n•Junit and Mockito\n•Docker\nWORK EXPERIENCE\nFull Stack Java Developer  ABC Company Inc Anywhere USA June 2018  Present\n•Developed scalable robust and maintainable enterpriselevel applications using Java and Spring\nBoot\n•Used Angular for developing dynamic and responsive web frontends improving user experience\nby 30\n•Integrated applications with MySQL and MongoDB databases to store and retrieve data efficiently\n•Collaborated in an Agile development team to deliver highquality software every sprint\n•Created RESTful services and APIs for frontend and thirdparty applications\n•Wrote unit tests using Junit and Mockito for robust testing of application components\nSoftware Developer  XYZ Solutions Anywhere USA July 2016  June 2018\n•Participated in the complete software development life cycle from requirement analysis to deploy\nment\n•Implemented business logic using Java and enhanced user interface using Angular\n•Developed and maintained SQL and NoSQL databases implementing complex queries for business\nneeds\n•Utilized Git for version control and collaborated with team members via GitHub\n•Assisted in troubleshooting software debugging and system enhancements\n1 EDUCATION\nBachelor of Science in Computer Science  State University Anywhere USA May 2016\nCERTIFICATIONS\n•Oracle Certified Professional Java SE 8 Programmer\n•Certified Angular Developer\n2"
+    },
+    {
+        "resume": "Alfred Pennyworth\nProduct ManagerSilicon Valley CA USA\n♂¶obilealt\n/envel⌢\n/linkedininapennyworth\n\nProfessional Summary\nSeasoned Product Manager with over 20 years of experience in software development and product\nmanagement having worked at all FAANG companies Exceptional leadership skills strategic\nthinking and a track record of managing products from conception to market success\nSkills\nProduct management Agile methodologies Leadership Communication Project\nmanagement User Experience Design Market Research Data Analysis Java\nPython JavaScript HTML/CSS SQL AWS\nExperience\n2017 \nPresentProduct Manager Google  Mountain View CA USA\nLeading crossfunctional teams to design develop and launch innovative products Devel\noping product strategies and making datadriven decisions to improve user experience and\nmeet business goals\n2012  2017 Software Development Engineer III Amazon  Seattle WA USA\nLed a team of developers in building scalable and highperforming ecommerce applications\nSuccessfully delivered multiple projects within the stipulated time and budget\n2007  2012 Software Development Engineer II Apple  Cupertino CA USA\nDesigned and implemented software components for various Apple services Optimized the\nperformance of applications and improved code quality through thorough testing\n2002  2007 Software Development Engineer I Netflix  Los Gatos CA USA\nDeveloped and maintained the user interface for the Netflix web application Worked closely\nwith product managers and designers to create an optimal user experience\n1999  2002 Software Development Engineer I Facebook  Menlo Park CA USA\nPlayed a key role in the development of early Facebook features Implemented scalable\nbackend services using Java and SQL\nEducation\n2016  2018 Master of Business Administration Stanford University  Stanford CA USA\n1997  1999 Master of Science in Computer Science Massachusetts Institute of Technology \nCambridge MA USA\n1994  1997 Bachelor of Science in Computer Science University of California Berkeley \nBerkeley CA USA\nProjects\n1/2 2020 \nPresentPersonal Project Home Automation System\nDeveloped a smart home automation system using Raspberry Pi and Python The system\nautomates various home appliances based on user behavior and preferences contributing to\nenergy saving and improved user convenience\n2/2"
+    },
+    {
+        "resume": "Harvey Dent\nMachine Learning Engineer321 Gotham St\nGotham USA\n♂¶obilealt\n/envel⌢\n/linkedininhdent\n/githubhdent\nProfessional Summary\nMachine Learning Engineer with 5 years of experience in designing building and deploying predictive\nmodels and deep learning systems Proficient in Python TensorFlow PyTorch and Scikitlearn\nCurrently leading a team of AI engineers at OpenAI\nSkills\nPython R TensorFlow PyTorch Scikitlearn Keras SQL NoSQL Git Docker\nKubernetes Agile and Scrum Statistics Data visualization Deep Learning Natural\nLanguage Processing\nExperience\n2021 \nPresentMachine Learning Engineer OpenAI  San Francisco USA\nLeading a team of AI engineers Designed and implemented deep learning models for natural\nlanguage processing tasks Improved the efficiency of model training and data processing\npipelines Published several research papers in toptier AI conferences\n2018  2021 Data Scientist Uber  San Francisco USA\nDeveloped and deployed machine learning models to improve the efficiency of ride allocation\nalgorithms Utilized TensorFlow and PyTorch for developing predictive models Analyzed\nand visualized large data sets to drive business strategies\n2016  2018 Junior Data Analyst Facebook  Menlo Park USA\nAnalyzed and visualized large datasets using Python and R Assisted in the development of\nmachine learning models for user behavior prediction Conducted A/B testing and provided\ninsights to the product team\nEducation\n2014  2016 Master of Science in Computer Science Specialization in AI MIT Cambridge\nUSA\n2010  2014 Bachelor of Science in Computer Science UC San Diego  San Diego USA\nProjects\n2021 \nPresentPersonal Project Predictive Stock Trading Model\nDeveloped a predictive stock trading model using deep learning and time series analysis\nUsed PyTorch for model development and Docker for deployment The model predicts stock\nprices with a high degree of accuracy and automates trading decisions"
+    },
+    {
+        "resume": "Bruce Wayne\nMERN Stack Developer123 Gotham St\nGotham USA\n♂¶obilealt\n/envel⌢\n/linkedininbwayne\n\nProfessional Summary\nHighly skilled MERN Stack Developer with over 10 years of experience specializing in designing\nbuilding and maintaining complex web applications Proficient in MongoDB Expressjs React and\nNodejs Currently contributing to the development of AI technologies at OpenAI with a primary\nfocus on the ChatGPT project\nSkills\nJavaScript and TypeScript MongoDB Expressjs React Nodejs MERN stack\nRESTful APIs Git and GitHub Docker and Kubernetes Agile and Scrum Python\nand Machine Learning basics\nExperience\nJune 2020 \nPresentMERN Stack Developer OpenAI  San Francisco USA\nWorking on the development of the ChatGPT project using Nodejs Expressjs and React\nImplementing RESTful services for communication between frontend and backend Utilizing\nDocker and Kubernetes for deployment and management of applications Working in an\nAgile environment delivering highquality software every sprint Contributing to the design\nand implementation of machine learning algorithms for natural language processing tasks\nJuly 2015 \nMay 2020Full Stack Developer Uber  San Francisco USA\nDeveloped and maintained scalable web applications using MERN stack Ensured the\nperformance quality and responsiveness of applications Successfully deployed solutions\nusing Docker and Kubernetes Collaborated with a team of engineers product managers\nand UX designers Led a team of junior developers conducted code reviews and ensured\nadherence to best coding practices Worked closely with the data science team to optimize\nrecommendation algorithms and enhance user experience\nJune 2012 \nJune 2015Software Developer Facebook  Menlo Park USA\nDeveloped features for the Facebook web application using React Ensured the performance\nof the MongoDB databases Utilized RESTful APIs for communication between different\nparts of the application Worked in a fastpaced testdriven development environment\nAssisted in migrating the legacy system to a modern MERN stack architecture\nEducation\n2009  2012 PhD in Computer Science CalTech  Pasadena USA\n2007  2009 Master of Science in Computer Science MIT Cambridge USA\n2003  2007 Bachelor of Science in Computer Science UC San Diego  San Diego USA\n1/2 Projects\n2019 \nPresentPersonal Project Gotham Event Planner\nCreated a fullfeatured web application to plan and organize events in Gotham city Used\nMERN stack for development and Docker for deployment The application allows users to\ncreate manage and share events and integrates with Google Maps API to display event\nlocations\n2/2"
+    },
+    {
+        "resume": "Barry Allen\nFrontEnd DeveloperGoogle HQ Mountain View CA USA\n♂¶obilealt\n/envel⌢\n/linkedininbwayne\n\nObjective\nSeeking a challenging role as a FrontEnd Developer where I can leverage my knowledge of UI/UX\ndesign and modern web technologies to create intuitive and engaging user interfaces\nEducation\n2018  2022 BTech Computer Science and Engineering Indian Institute of Technology\nDelhi  New Delhi India\nOverall GPA 95/10\nSkills\nJavaScript ES6+ TypeScript HTML5 CSS3 Python React Redux Angular\nVuejs Nodejs Expressjs D3js Git Docker Webpack Babel Google Cloud\nPlatform Firebase RESTful APIs GraphQL Agile Development TestDriven\nDevelopment Responsive Design UI/UX\nExperience\nJune 2022 \nPresentSoftware Engineer FrontEnd Google  Mountain View CA USA\nDeveloping intuitive and engaging user interfaces using React and Redux Working closely\nwith UX designers to implement responsive and accessible web design Participating in\nagile development processes including sprint planning and code reviews Collaborating with\nbackend developers to integrate RESTful APIs and ensure seamless data flow\nProjects\n2022 Personal Expense Tracker\nDeveloped a personal expense tracker application using React Redux and Firebase Imple\nmented user authentication using Firebase Auth and data storage using Firestore Utilized\nD3js for data visualization to provide users with insights into their spending patterns"
+    },
+]

archive/Data.py

@@ -1,4 +1,5 @@
 import json
+
 from scripts.utils.ReadFiles import get_filenames_from_dir
 
 resume_path = "Data/Processed/Resumes"
@@ -14,20 +15,16 @@ def read_json(filename):
 def build_resume_list(resume_names, path):
     resumes = []
     for resume in resume_names:
-        selected_file = read_json(path + '/' + resume)
-        resumes.append({
-            "resume": selected_file["clean_data"]
-        })
+        selected_file = read_json(path + "/" + resume)
+        resumes.append({"resume": selected_file["clean_data"]})
     return resumes
 
 
 def build_jobdesc_list(jobdesc_names, path):
     resumes = []
     for resume in resume_names:
-        selected_file = read_json(path + '/' + resume)
-        resumes.append({
-            "resume": selected_file["clean_data"]
-        })
+        selected_file = read_json(path + "/" + resume)
+        resumes.append({"resume": selected_file["clean_data"]})
     return resumes
 
 

archive/ExtraScripts.py

@@ -11,10 +11,10 @@ def list_to_matrix(list_to_convert, num_columns):
 
     matrix = []
     for i in range(len(list_to_convert) // num_columns):
-        matrix.append(list_to_convert[i * num_columns:(i + 1) * num_columns])
+        matrix.append(list_to_convert[i * num_columns : (i + 1) * num_columns])
 
     if len(list_to_convert) % num_columns > 0:
-        matrix.append(list_to_convert[-(len(list_to_convert) % num_columns):])
+        matrix.append(list_to_convert[-(len(list_to_convert) % num_columns) :])
 
     for i in range(len(matrix)):
         for j in range(len(matrix[i])):
@@ -40,10 +40,10 @@ def split_list(list_to_split, chunk_size):
 
     chunks = []
     for i in range(num_chunks):
-        chunks.append(list_to_split[i * chunk_size:(i + 1) * chunk_size])
+        chunks.append(list_to_split[i * chunk_size : (i + 1) * chunk_size])
 
     if remainder > 0:
-        chunks.append(list_to_split[num_chunks * chunk_size:])
+        chunks.append(list_to_split[num_chunks * chunk_size :])
 
     return chunks
 
@@ -53,10 +53,17 @@ def dirty_intersection(list1, list2):
     remainder_1 = [x for x in list1 if x not in intersection]
     remainder_2 = [x for x in list2 if x not in intersection]
 
-    output = pd.DataFrame({
-        'elements': ["Common words", "Words unique to Resume", "Words unique to Job Description"],
-        'values': [len(intersection), len(remainder_1), len(remainder_2)]
-    }, index=[1, 2, 3])
+    output = pd.DataFrame(
+        {
+            "elements": [
+                "Common words",
+                "Words unique to Resume",
+                "Words unique to Job Description",
+            ],
+            "values": [len(intersection), len(remainder_1), len(remainder_2)],
+        },
+        index=[1, 2, 3],
+    )
 
     return output
 
@@ -82,26 +89,27 @@ def find_intersection_of_lists(list1, list2):
         return max_value
 
     def fill_by_complements(num: int, list_to_fill: list):
-        if (num > len(list_to_fill)):
-            for i in range(num-len(list_to_fill)):
+        if num > len(list_to_fill):
+            for i in range(num - len(list_to_fill)):
                 list_to_fill.append(" ")
 
     intersection = list(set(list1) & set(list2))
     remainder_1 = [x for x in list1 if x not in intersection]
     remainder_2 = [x for x in list2 if x not in intersection]
 
-    max_count = max_of_three(
-        len(intersection), len(remainder_1), len(remainder_2))
+    max_count = max_of_three(len(intersection), len(remainder_1), len(remainder_2))
 
     fill_by_complements(max_count, intersection)
     fill_by_complements(max_count, remainder_1)
     fill_by_complements(max_count, remainder_2)
 
-    df = pd.DataFrame({
-        'intersection': intersection,
-        'remainder_1': remainder_1,
-        'remainder_2': remainder_2
-    })
+    df = pd.DataFrame(
+        {
+            "intersection": intersection,
+            "remainder_1": remainder_1,
+            "remainder_2": remainder_2,
+        }
+    )
 
     return df
 

archive/run.py

@@ -1,17 +1,17 @@
-from scripts.parsers.ParseResumeToJson import ParseResume
-from scripts.parsers.ParseJobDescToJson import ParseJobDesc
-from scripts.ReadPdf import read_single_pdf
+import json
 import os.path
 import pathlib
-import json
 
+from scripts.parsers.ParseJobDescToJson import ParseJobDesc
+from scripts.parsers.ParseResumeToJson import ParseResume
+from scripts.ReadPdf import read_single_pdf
 
-READ_DATA_FROM = 'Data/Raw/'
-SAVE_DIRECTORY = 'Data/Processed/'
+READ_DATA_FROM = "Data/Raw/"
+SAVE_DIRECTORY = "Data/Processed/"
 
 
 def read_resumes(input_file: str) -> dict:
-    input_file_name = os.path.join(READ_DATA_FROM+input_file)
+    input_file_name = os.path.join(READ_DATA_FROM + input_file)
     data = read_single_pdf(input_file_name)
     output = ParseResume(data).get_JSON()
     return output

archive/streamlit_app.py

@@ -1,17 +1,18 @@
+import json
 import string
-import spacy
-import pywaffle
-import streamlit as st
+
+import matplotlib.pyplot as plt
 import pandas as pd
-import json
 import plotly.express as px
 import plotly.graph_objects as go
-import matplotlib.pyplot as plt
+import pywaffle
+import spacy
 import squarify
+import streamlit as st
 
-st.title('Resume :blue[Matcher]')
-st.image('Assets/img/header_image.jpg')
-st.subheader('_AI Based Resume Analyzer & Ranker_')
+st.title("Resume :blue[Matcher]")
+st.image("Assets/img/header_image.jpg")
+st.subheader("_AI Based Resume Analyzer & Ranker_")
 
 
 def read_json(filename):
@@ -21,38 +22,49 @@ def read_json(filename):
 
 
 # read the json file
-resume = read_json(
-    'Data/Processed/Resume-d531571e-e4fa-45eb-ab6a-267cdeb6647e.json')
+resume = read_json("Data/Processed/Resume-d531571e-e4fa-45eb-ab6a-267cdeb6647e.json")
 job_desc = read_json(
-    'Data/Processed/Job-Desc-a4f06ccb-8d5a-4d0b-9f02-3ba6d686472e.json')
+    "Data/Processed/Job-Desc-a4f06ccb-8d5a-4d0b-9f02-3ba6d686472e.json"
+)
 
 st.write("### Reading Resume's POS")
-df = pd.DataFrame(resume['pos_frequencies'], index=[0])
-fig = go.Figure(data=go.Bar(y=list(resume['pos_frequencies'].values()), x=list(resume['pos_frequencies'].keys())),
-                layout_title_text="Resume's POS")
+df = pd.DataFrame(resume["pos_frequencies"], index=[0])
+fig = go.Figure(
+    data=go.Bar(
+        y=list(resume["pos_frequencies"].values()),
+        x=list(resume["pos_frequencies"].keys()),
+    ),
+    layout_title_text="Resume's POS",
+)
 st.write(fig)
 
-df2 = pd.DataFrame(resume['keyterms'], columns=["keyword", "value"])
+df2 = pd.DataFrame(resume["keyterms"], columns=["keyword", "value"])
 st.dataframe(df2)
 
 # Create the dictionary
 keyword_dict = {}
-for keyword, value in resume['keyterms']:
+for keyword, value in resume["keyterms"]:
     keyword_dict[keyword] = value
 
-fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                           font=dict(size=12),
-                                           fill_color='#070A52'),
-                               cells=dict(values=[list(keyword_dict.keys()),
-                                                  list(keyword_dict.values())],
-                                          line_color='darkslategray',
-                                          fill_color='#6DA9E4'))
-                      ])
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Keyword", "Value"], font=dict(size=12), fill_color="#070A52"
+            ),
+            cells=dict(
+                values=[list(keyword_dict.keys()), list(keyword_dict.values())],
+                line_color="darkslategray",
+                fill_color="#6DA9E4",
+            ),
+        )
+    ]
+)
 st.plotly_chart(fig)
 
 st.divider()
 
-for keyword, value in resume['keyterms']:
+for keyword, value in resume["keyterms"]:
     pass
 
 
@@ -62,7 +74,8 @@ figure = plt.figure(
     rows=20,
     columns=20,
     values=keyword_dict,
-    legend={'loc': 'upper left', 'bbox_to_anchor': (1, 1)})
+    legend={"loc": "upper left", "bbox_to_anchor": (1, 1)},
+)
 
 
 # Display the dictionary
@@ -70,32 +83,48 @@ figure = plt.figure(
 st.pyplot(fig=figure)
 # st.write(dict)
 
-fig = px.treemap(df2, path=['keyword'], values='value',
-                 color_continuous_scale='RdBu',
-                 title='Resume POS')
+fig = px.treemap(
+    df2,
+    path=["keyword"],
+    values="value",
+    color_continuous_scale="RdBu",
+    title="Resume POS",
+)
 st.write(fig)
 
 
 st.plotly_chart(figure_or_data=fig)
 
-fig = go.Figure(data=[go.Table(
-    header=dict(values=["Tri Grams"],
-                fill_color='#1D267D',
-                align='center', font=dict(color='white', size=16)),
-    cells=dict(values=[resume['tri_grams']],
-               fill_color='#19A7CE',
-               align='left'))])
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Tri Grams"],
+                fill_color="#1D267D",
+                align="center",
+                font=dict(color="white", size=16),
+            ),
+            cells=dict(
+                values=[resume["tri_grams"]], fill_color="#19A7CE", align="left"
+            ),
+        )
+    ]
+)
 
 st.plotly_chart(figure_or_data=fig)
 
-fig = go.Figure(data=[go.Table(
-    header=dict(values=["Bi Grams"],
-                fill_color='#1D267D',
-                align='center', font=dict(color='white', size=16)),
-    cells=dict(values=[resume['bi_grams']],
-               fill_color='#19A7CE',
-               align='left'))])
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Bi Grams"],
+                fill_color="#1D267D",
+                align="center",
+                font=dict(color="white", size=16),
+            ),
+            cells=dict(values=[resume["bi_grams"]], fill_color="#19A7CE", align="left"),
+        )
+    ]
+)
 
 st.plotly_chart(figure_or_data=fig)
-
-

run_first.py

@@ -1,19 +1,22 @@
 import json
-from scripts import ResumeProcessor, JobDescriptionProcessor
-from scripts.utils import init_logging_config, get_filenames_from_dir
 import logging
 import os
 
+from scripts import JobDescriptionProcessor, ResumeProcessor
+from scripts.utils import get_filenames_from_dir, init_logging_config
+
 init_logging_config()
 
 PROCESSED_RESUMES_PATH = "Data/Processed/Resumes"
 PROCESSED_JOB_DESCRIPTIONS_PATH = "Data/Processed/JobDescription"
 
+
 def read_json(filename):
     with open(filename) as f:
         data = json.load(f)
     return data
 
+
 def remove_old_files(files_path):
 
     for filename in os.listdir(files_path):
@@ -22,56 +25,53 @@ def remove_old_files(files_path):
 
             if os.path.isfile(file_path):
                 os.remove(file_path)
-        except Exception as e:  
+        except Exception as e:
             logging.error(f"Error deleting {file_path}:\n{e}")
 
-    logging.info("Deleted old files from "+files_path)
+    logging.info("Deleted old files from " + files_path)
 
 
-logging.info('Started to read from Data/Resumes')
+logging.info("Started to read from Data/Resumes")
 try:
     # Check if there are resumes present or not.
     # If present then parse it.
     remove_old_files(PROCESSED_RESUMES_PATH)
 
     file_names = get_filenames_from_dir("Data/Resumes")
-    logging.info('Reading from Data/Resumes is now complete.')
+    logging.info("Reading from Data/Resumes is now complete.")
 except:
     # Exit the program if there are no resumes.
-    logging.error('There are no resumes present in the specified folder.')
-    logging.error('Exiting from the program.')
-    logging.error(
-        'Please add resumes in the Data/Resumes folder and try again.')
+    logging.error("There are no resumes present in the specified folder.")
+    logging.error("Exiting from the program.")
+    logging.error("Please add resumes in the Data/Resumes folder and try again.")
     exit(1)
 
 # Now after getting the file_names parse the resumes into a JSON Format.
-logging.info('Started parsing the resumes.')
+logging.info("Started parsing the resumes.")
 for file in file_names:
     processor = ResumeProcessor(file)
     success = processor.process()
-logging.info('Parsing of the resumes is now complete.')
+logging.info("Parsing of the resumes is now complete.")
 
-logging.info('Started to read from Data/JobDescription')
+logging.info("Started to read from Data/JobDescription")
 try:
     # Check if there are resumes present or not.
     # If present then parse it.
     remove_old_files(PROCESSED_JOB_DESCRIPTIONS_PATH)
 
     file_names = get_filenames_from_dir("Data/JobDescription")
-    logging.info('Reading from Data/JobDescription is now complete.')
+    logging.info("Reading from Data/JobDescription is now complete.")
 except:
     # Exit the program if there are no resumes.
-    logging.error(
-        'There are no job-description present in the specified folder.')
-    logging.error('Exiting from the program.')
-    logging.error(
-        'Please add resumes in the Data/JobDescription folder and try again.')
+    logging.error("There are no job-description present in the specified folder.")
+    logging.error("Exiting from the program.")
+    logging.error("Please add resumes in the Data/JobDescription folder and try again.")
     exit(1)
 
 # Now after getting the file_names parse the resumes into a JSON Format.
-logging.info('Started parsing the Job Descriptions.')
+logging.info("Started parsing the Job Descriptions.")
 for file in file_names:
     processor = JobDescriptionProcessor(file)
     success = processor.process()
-logging.info('Parsing of the Job Descriptions is now complete.')
-logging.info('Success now run `streamlit run streamlit_second.py`')
+logging.info("Parsing of the Job Descriptions is now complete.")
+logging.info("Success now run `streamlit run streamlit_second.py`")

scripts/Extractor.py

@@ -1,43 +1,44 @@
 import re
 import urllib.request
+
 import spacy
-from .utils import TextCleaner
 
+from .utils import TextCleaner
 
 # Load the English model
-nlp = spacy.load('en_core_web_sm')
+nlp = spacy.load("en_core_web_sm")
 
 
 RESUME_SECTIONS = [
-    'Contact Information',
-    'Objective',
-    'Summary',
-    'Education',
-    'Experience',
-    'Skills',
-    'Projects',
-    'Certifications',
-    'Licenses',
-    'Awards',
-    'Honors',
-    'Publications',
-    'References',
-    'Technical Skills',
-    'Computer Skills',
-    'Programming Languages',
-    'Software Skills',
-    'Soft Skills',
-    'Language Skills',
-    'Professional Skills',
-    'Transferable Skills',
-    'Work Experience',
-    'Professional Experience',
-    'Employment History',
-    'Internship Experience',
-    'Volunteer Experience',
-    'Leadership Experience',
-    'Research Experience',
-    'Teaching Experience'
+    "Contact Information",
+    "Objective",
+    "Summary",
+    "Education",
+    "Experience",
+    "Skills",
+    "Projects",
+    "Certifications",
+    "Licenses",
+    "Awards",
+    "Honors",
+    "Publications",
+    "References",
+    "Technical Skills",
+    "Computer Skills",
+    "Programming Languages",
+    "Software Skills",
+    "Soft Skills",
+    "Language Skills",
+    "Professional Skills",
+    "Transferable Skills",
+    "Work Experience",
+    "Professional Experience",
+    "Employment History",
+    "Internship Experience",
+    "Volunteer Experience",
+    "Leadership Experience",
+    "Research Experience",
+    "Teaching Experience",
 ]
 
 
@@ -68,7 +69,7 @@ class DataExtractor:
         Returns:
             list: A list containing all the found links.
         """
-        link_pattern = r'\b(?:https?://|www\.)\S+\b'
+        link_pattern = r"\b(?:https?://|www\.)\S+\b"
         links = re.findall(link_pattern, self.text)
         return links
 
@@ -86,19 +87,28 @@ class DataExtractor:
         links = []
         try:
             response = urllib.request.urlopen(self.text)
-            html_content = response.read().decode('utf-8')
+            html_content = response.read().decode("utf-8")
             pattern = r'href=[\'"]?([^\'" >]+)'
             raw_links = re.findall(pattern, html_content)
             for link in raw_links:
-                if link.startswith(('http://', 'https://', 'ftp://', 'mailto:',
-                                    'www.linkedin.com', 'github.com/', 'twitter.com')):
+                if link.startswith(
+                    (
+                        "http://",
+                        "https://",
+                        "ftp://",
+                        "mailto:",
+                        "www.linkedin.com",
+                        "github.com/",
+                        "twitter.com",
+                    )
+                ):
                     links.append(link)
         except Exception as e:
             print(f"Error extracting links: {str(e)}")
         return links
 
     def extract_names(self):
-        """Extracts and returns a list of names from the given 
+        """Extracts and returns a list of names from the given
         text using spaCy's named entity recognition.
 
         Args:
@@ -107,7 +117,7 @@ class DataExtractor:
         Returns:
             list: A list of strings representing the names extracted from the text.
         """
-        names = [ent.text for ent in self.doc.ents if ent.label_ == 'PERSON']
+        names = [ent.text for ent in self.doc.ents if ent.label_ == "PERSON"]
         return names
 
     def extract_emails(self):
@@ -120,7 +130,7 @@ class DataExtractor:
         Returns:
             list: A list containing all the extracted email addresses.
         """
-        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b'
+        email_pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"
         emails = re.findall(email_pattern, self.text)
         return emails
 
@@ -134,7 +144,9 @@ class DataExtractor:
         Returns:
             list: A list containing all the extracted phone numbers.
         """
-        phone_number_pattern = r'^(\+\d{1,3})?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$'
+        phone_number_pattern = (
+            r"^(\+\d{1,3})?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$"
+        )
         phone_numbers = re.findall(phone_number_pattern, self.text)
         return phone_numbers
 
@@ -153,7 +165,7 @@ class DataExtractor:
 
         for token in self.doc:
             if token.text in RESUME_SECTIONS:
-                if token.text == 'Experience' or 'EXPERIENCE' or 'experience':
+                if token.text == "Experience" or "EXPERIENCE" or "experience":
                     in_experience_section = True
                 else:
                     in_experience_section = False
@@ -161,21 +173,22 @@ class DataExtractor:
             if in_experience_section:
                 experience_section.append(token.text)
 
-        return ' '.join(experience_section)
+        return " ".join(experience_section)
 
     def extract_position_year(self):
         """
-            Extract position and year from a given string.
+        Extract position and year from a given string.
 
-            Args:
-                text (str): The string from which to extract position and year.
+        Args:
+            text (str): The string from which to extract position and year.
 
-            Returns:
-                list: A list containing the extracted position and year.
+        Returns:
+            list: A list containing the extracted position and year.
         """
-        position_year_search_pattern = r"(\b\w+\b\s+\b\w+\b),\s+(\d{4})\s*-\s*(\d{4}|\bpresent\b)"
-        position_year = re.findall(
-            position_year_search_pattern, self.text)
+        position_year_search_pattern = (
+            r"(\b\w+\b\s+\b\w+\b),\s+(\d{4})\s*-\s*(\d{4}|\bpresent\b)"
+        )
+        position_year = re.findall(position_year_search_pattern, self.text)
         return position_year
 
     def extract_particular_words(self):
@@ -188,7 +201,7 @@ class DataExtractor:
         Returns:
             list: A list of extracted nouns.
         """
-        pos_tags = ['NOUN', 'PROPN']
+        pos_tags = ["NOUN", "PROPN"]
         nouns = [token.text for token in self.doc if token.pos_ in pos_tags]
         return nouns
 
@@ -202,7 +215,8 @@ class DataExtractor:
         Returns:
             list: A list of extracted entities.
         """
-        entity_labels = ['GPE', 'ORG']
+        entity_labels = ["GPE", "ORG"]
         entities = [
-            token.text for token in self.doc.ents if token.label_ in entity_labels]
+            token.text for token in self.doc.ents if token.label_ in entity_labels
+        ]
         return list(set(entities))

scripts/JobDescriptionProcessor.py

@@ -1,19 +1,18 @@
-from .parsers import ParseResume
-from .parsers import ParseJobDesc
-from .ReadPdf import read_single_pdf
+import json
 import os.path
 import pathlib
-import json
 
-READ_JOB_DESCRIPTION_FROM = 'Data/JobDescription/'
-SAVE_DIRECTORY = 'Data/Processed/JobDescription'
+from .parsers import ParseJobDesc, ParseResume
+from .ReadPdf import read_single_pdf
+
+READ_JOB_DESCRIPTION_FROM = "Data/JobDescription/"
+SAVE_DIRECTORY = "Data/Processed/JobDescription"
 
 
 class JobDescriptionProcessor:
     def __init__(self, input_file):
         self.input_file = input_file
-        self.input_file_name = os.path.join(
-            READ_JOB_DESCRIPTION_FROM + self.input_file)
+        self.input_file_name = os.path.join(READ_JOB_DESCRIPTION_FROM + self.input_file)
 
     def process(self) -> bool:
         try:
@@ -35,8 +34,12 @@ class JobDescriptionProcessor:
         return output
 
     def _write_json_file(self, resume_dictionary: dict):
-        file_name = str("JobDescription-" + self.input_file +
-                        resume_dictionary["unique_id"] + ".json")
+        file_name = str(
+            "JobDescription-"
+            + self.input_file
+            + resume_dictionary["unique_id"]
+            + ".json"
+        )
         save_directory_name = pathlib.Path(SAVE_DIRECTORY) / file_name
         json_object = json.dumps(resume_dictionary, sort_keys=True, indent=14)
         with open(save_directory_name, "w+") as outfile:

scripts/KeytermsExtraction.py

@@ -16,8 +16,7 @@ class KeytermExtractor:
             top_n_values (int): The number of top keyterms to extract.
         """
         self.raw_text = raw_text
-        self.text_doc = textacy.make_spacy_doc(
-            self.raw_text, lang="en_core_web_md")
+        self.text_doc = textacy.make_spacy_doc(self.raw_text, lang="en_core_web_md")
         self.top_n_values = top_n_values
 
     def get_keyterms_based_on_textrank(self):
@@ -27,8 +26,11 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of top keyterms based on TextRank.
         """
-        return list(extract.keyterms.textrank(self.text_doc, normalize="lemma",
-                                              topn=self.top_n_values))
+        return list(
+            extract.keyterms.textrank(
+                self.text_doc, normalize="lemma", topn=self.top_n_values
+            )
+        )
 
     def get_keyterms_based_on_sgrank(self):
         """
@@ -37,8 +39,11 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of top keyterms based on SGRank.
         """
-        return list(extract.keyterms.sgrank(self.text_doc, normalize="lemma",
-                                            topn=self.top_n_values))
+        return list(
+            extract.keyterms.sgrank(
+                self.text_doc, normalize="lemma", topn=self.top_n_values
+            )
+        )
 
     def get_keyterms_based_on_scake(self):
         """
@@ -47,8 +52,11 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of top keyterms based on sCAKE.
         """
-        return list(extract.keyterms.scake(self.text_doc, normalize="lemma",
-                                           topn=self.top_n_values))
+        return list(
+            extract.keyterms.scake(
+                self.text_doc, normalize="lemma", topn=self.top_n_values
+            )
+        )
 
     def get_keyterms_based_on_yake(self):
         """
@@ -57,8 +65,11 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of top keyterms based on YAKE.
         """
-        return list(extract.keyterms.yake(self.text_doc, normalize="lemma",
-                                          topn=self.top_n_values))
+        return list(
+            extract.keyterms.yake(
+                self.text_doc, normalize="lemma", topn=self.top_n_values
+            )
+        )
 
     def bi_gramchunker(self):
         """
@@ -67,8 +78,15 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of bigrams.
         """
-        return list(textacy.extract.basics.ngrams(self.text_doc, n=2, filter_stops=True,
-                                                  filter_nums=True, filter_punct=True))
+        return list(
+            textacy.extract.basics.ngrams(
+                self.text_doc,
+                n=2,
+                filter_stops=True,
+                filter_nums=True,
+                filter_punct=True,
+            )
+        )
 
     def tri_gramchunker(self):
         """
@@ -77,5 +95,12 @@ class KeytermExtractor:
         Returns:
             List[str]: A list of trigrams.
         """
-        return list(textacy.extract.basics.ngrams(self.text_doc, n=3, filter_stops=True,
-                                                  filter_nums=True, filter_punct=True))
+        return list(
+            textacy.extract.basics.ngrams(
+                self.text_doc,
+                n=3,
+                filter_stops=True,
+                filter_nums=True,
+                filter_punct=True,
+            )
+        )

scripts/LinkedinJobToPDF.py

@@ -8,7 +8,7 @@ from bs4 import BeautifulSoup
 from pathvalidate import sanitize_filename
 from xhtml2pdf import pisa
 
-'''
+"""
 This script takes a LinkedIn job posting URL
 and converts the description to a PDF file.
 The PDF file is saved in the Data/JobDescription folder.
@@ -16,7 +16,7 @@ The name will be OrgName__Job Title_X.pdf, where X is the number of files in the
 
 IMPORTANT: Make sure the URL is to the actual job description,
 and not the job search page.
-'''
+"""
 
 
 def linkedin_to_pdf(job_url: str):
@@ -29,26 +29,30 @@ def linkedin_to_pdf(job_url: str):
         page = requests.get(job_url)
 
         if page.status_code != 200:
-            print(f"Failed to retrieve the job posting at {job_url}. Status code: {page.status_code}")
+            print(
+                f"Failed to retrieve the job posting at {job_url}. Status code: {page.status_code}"
+            )
             return
 
         # Parse the HTML content of the job posting using BeautifulSoup
-        soup = BeautifulSoup(page.text, 'html.parser')
+        soup = BeautifulSoup(page.text, "html.parser")
 
         # Find the job title element and get the text
-        job_title = soup.find('h1', {'class': 'topcard__title'}).text.strip()
+        job_title = soup.find("h1", {"class": "topcard__title"}).text.strip()
 
         # Find the organization name element (try both selectors)
-        organization_element = soup.find('span', {'class': 'topcard__flavor'})
+        organization_element = soup.find("span", {"class": "topcard__flavor"})
 
         if not organization_element:
-            organization_element = soup.find('a', {'class': 'topcard__org-name-link'})
+            organization_element = soup.find("a", {"class": "topcard__org-name-link"})
 
         # Extract the organization name
         organization = organization_element.text.strip()
 
         # Find the job description element
-        job_description_element = soup.find('div', {'class': 'show-more-less-html__markup'})
+        job_description_element = soup.find(
+            "div", {"class": "show-more-less-html__markup"}
+        )
 
         # Extract the job description and concatenate its elements
         if job_description_element:
@@ -59,8 +63,8 @@ def linkedin_to_pdf(job_url: str):
         file_path = f"{job_path}{sanitize_filename(organization + '__' + job_title)}_{files_number}.pdf"
 
         # Create a PDF file and write the job description to it
-        with open(file_path, 'wb') as pdf_file:
-            pisa.CreatePDF(job_description, dest=pdf_file, encoding='utf-8')
+        with open(file_path, "wb") as pdf_file:
+            pisa.CreatePDF(job_description, dest=pdf_file, encoding="utf-8")
 
         logging.info("PDF saved to " + file_path)
 
@@ -72,4 +76,4 @@ def linkedin_to_pdf(job_url: str):
 
 if __name__ == "__main__":
     url = easygui.enterbox("Enter the URL of the LinkedIn Job Posting:").strip()
-    linkedin_to_pdf(url)
+    linkedin_to_pdf(url)

scripts/ReadPdf.py

@@ -1,5 +1,6 @@
-import os
 import glob
+import os
+
 from pypdf import PdfReader
 
 
@@ -14,7 +15,7 @@ def get_pdf_files(file_path):
         list: A list containing the paths of all the PDF files in the directory.
     """
     if os.path.exists(file_path):
-        return glob.glob(os.path.join(file_path, '*.pdf'))
+        return glob.glob(os.path.join(file_path, "*.pdf"))
     else:
         return []
 
@@ -33,7 +34,7 @@ def read_multiple_pdf(file_path: str) -> list:
     output = []
     for file in pdf_files:
         try:
-            with open(file, 'rb') as f:
+            with open(file, "rb") as f:
                 pdf_reader = PdfReader(f)
                 count = pdf_reader.getNumPages()
                 for i in range(count):
@@ -56,7 +57,7 @@ def read_single_pdf(file_path: str) -> str:
     """
     output = []
     try:
-        with open(file_path, 'rb') as f:
+        with open(file_path, "rb") as f:
             pdf_reader = PdfReader(f)
             count = len(pdf_reader.pages)
             for i in range(count):
@@ -79,7 +80,7 @@ def get_pdf_files(file_path: str) -> list:
     """
     pdf_files = []
     try:
-        pdf_files = glob.glob(os.path.join(file_path, '*.pdf'))
+        pdf_files = glob.glob(os.path.join(file_path, "*.pdf"))
     except Exception as e:
         print(f"Error getting PDF files from '{file_path}': {str(e)}")
     return pdf_files

scripts/ResumeProcessor.py

@@ -1,12 +1,12 @@
-from .parsers import ParseResume
-from .parsers import ParseJobDesc
-from .ReadPdf import read_single_pdf
+import json
 import os.path
 import pathlib
-import json
 
-READ_RESUME_FROM = 'Data/Resumes/'
-SAVE_DIRECTORY = 'Data/Processed/Resumes'
+from .parsers import ParseJobDesc, ParseResume
+from .ReadPdf import read_single_pdf
+
+READ_RESUME_FROM = "Data/Resumes/"
+SAVE_DIRECTORY = "Data/Processed/Resumes"
 
 
 class ResumeProcessor:
@@ -34,8 +34,9 @@ class ResumeProcessor:
         return output
 
     def _write_json_file(self, resume_dictionary: dict):
-        file_name = str("Resume-" + self.input_file +
-                        resume_dictionary["unique_id"] + ".json")
+        file_name = str(
+            "Resume-" + self.input_file + resume_dictionary["unique_id"] + ".json"
+        )
         save_directory_name = pathlib.Path(SAVE_DIRECTORY) / file_name
         json_object = json.dumps(resume_dictionary, sort_keys=True, indent=14)
         with open(save_directory_name, "w+") as outfile:

scripts/TextCleaner.py

@@ -1,15 +1,15 @@
+import string
+
 import nltk
 from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize
 from nltk.stem import WordNetLemmatizer
-import string
+from nltk.tokenize import word_tokenize
 
 
 class TextCleaner:
 
     def __init__(self, raw_text):
-        self.stopwords_set = set(stopwords.words(
-            'english') + list(string.punctuation))
+        self.stopwords_set = set(stopwords.words("english") + list(string.punctuation))
         self.lemmatizer = WordNetLemmatizer()
         self.raw_input_text = raw_text
 
@@ -17,5 +17,5 @@ class TextCleaner:
         tokens = word_tokenize(self.raw_input_text.lower())
         tokens = [token for token in tokens if token not in self.stopwords_set]
         tokens = [self.lemmatizer.lemmatize(token) for token in tokens]
-        cleaned_text = ' '.join(tokens)
+        cleaned_text = " ".join(tokens)
         return cleaned_text

scripts/__init__.py

@@ -1,3 +1,3 @@
 from . import ReadPdf
 from .JobDescriptionProcessor import JobDescriptionProcessor
-from .ResumeProcessor import ResumeProcessor
+from .ResumeProcessor import ResumeProcessor

scripts/parsers/ParseJobDescToJson.py

@@ -1,9 +1,10 @@
 import json
+import os
 import pathlib
+
 from scripts.Extractor import DataExtractor
-from scripts.utils.Utils import TextCleaner, CountFrequency, generate_unique_id
 from scripts.KeytermsExtraction import KeytermExtractor
-import os
+from scripts.utils.Utils import CountFrequency, TextCleaner, generate_unique_id
 
 SAVE_DIRECTORY = "../../Data/Processed/JobDescription"
 
@@ -12,15 +13,11 @@ class ParseJobDesc:
 
     def __init__(self, job_desc: str):
         self.job_desc_data = job_desc
-        self.clean_data = TextCleaner.clean_text(
-            self.job_desc_data)
+        self.clean_data = TextCleaner.clean_text(self.job_desc_data)
         self.entities = DataExtractor(self.clean_data).extract_entities()
-        self.key_words = DataExtractor(
-            self.clean_data).extract_particular_words()
-        self.pos_frequencies = CountFrequency(
-            self.clean_data).count_frequency()
-        self.keyterms = KeytermExtractor(
-            self.clean_data).get_keyterms_based_on_sgrank()
+        self.key_words = DataExtractor(self.clean_data).extract_particular_words()
+        self.pos_frequencies = CountFrequency(self.clean_data).count_frequency()
+        self.keyterms = KeytermExtractor(self.clean_data).get_keyterms_based_on_sgrank()
         self.bi_grams = KeytermExtractor(self.clean_data).bi_gramchunker()
         self.tri_grams = KeytermExtractor(self.clean_data).tri_gramchunker()
 
@@ -37,7 +34,7 @@ class ParseJobDesc:
             "keyterms": self.keyterms,
             "bi_grams": str(self.bi_grams),
             "tri_grams": str(self.tri_grams),
-            "pos_frequencies": self.pos_frequencies
+            "pos_frequencies": self.pos_frequencies,
         }
 
         return job_desc_dictionary

scripts/parsers/ParseResumeToJson.py

@@ -1,32 +1,29 @@
 import json
-from scripts.Extractor import DataExtractor
-from scripts.utils.Utils import TextCleaner, CountFrequency, generate_unique_id
-from scripts.KeytermsExtraction import KeytermExtractor
-import os.path
 import os
+import os.path
 import pathlib
 
-SAVE_DIRECTORY = '../../Data/Processed/Resumes'
+from scripts.Extractor import DataExtractor
+from scripts.KeytermsExtraction import KeytermExtractor
+from scripts.utils.Utils import CountFrequency, TextCleaner, generate_unique_id
+
+SAVE_DIRECTORY = "../../Data/Processed/Resumes"
 
 
 class ParseResume:
 
     def __init__(self, resume: str):
         self.resume_data = resume
-        self.clean_data = TextCleaner.clean_text(
-            self.resume_data)
+        self.clean_data = TextCleaner.clean_text(self.resume_data)
         self.entities = DataExtractor(self.clean_data).extract_entities()
         self.name = DataExtractor(self.clean_data[:30]).extract_names()
         self.experience = DataExtractor(self.clean_data).extract_experience()
         self.emails = DataExtractor(self.resume_data).extract_emails()
         self.phones = DataExtractor(self.resume_data).extract_phone_numbers()
         self.years = DataExtractor(self.clean_data).extract_position_year()
-        self.key_words = DataExtractor(
-            self.clean_data).extract_particular_words()
-        self.pos_frequencies = CountFrequency(
-            self.clean_data).count_frequency()
-        self.keyterms = KeytermExtractor(
-            self.clean_data).get_keyterms_based_on_sgrank()
+        self.key_words = DataExtractor(self.clean_data).extract_particular_words()
+        self.pos_frequencies = CountFrequency(self.clean_data).count_frequency()
+        self.keyterms = KeytermExtractor(self.clean_data).get_keyterms_based_on_sgrank()
         self.bi_grams = KeytermExtractor(self.clean_data).bi_gramchunker()
         self.tri_grams = KeytermExtractor(self.clean_data).tri_gramchunker()
 
@@ -48,7 +45,7 @@ class ParseResume:
             "years": self.years,
             "bi_grams": str(self.bi_grams),
             "tri_grams": str(self.tri_grams),
-            "pos_frequencies": self.pos_frequencies
+            "pos_frequencies": self.pos_frequencies,
         }
 
         return resume_dictionary

scripts/parsers/__init__.py

@@ -1,2 +1,2 @@
 from .ParseJobDescToJson import ParseJobDesc
-from .ParseResumeToJson import ParseResume
+from .ParseResumeToJson import ParseResume

scripts/similarity/__init__.py

@@ -1 +1 @@
-from .get_similarity_score import get_similarity_score, find_path, read_config
+from .get_similarity_score import find_path, get_similarity_score, read_config

scripts/similarity/get_score.py

@@ -6,49 +6,65 @@ from typing import List
 import yaml
 from qdrant_client import QdrantClient
 
-logging.basicConfig(
-    filename='app_similarity_score.log',
-    filemode='w',
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
+from scripts.utils.logger import init_logging_config
 
+init_logging_config(basic_log_level=logging.INFO)
+# Get the logger
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
-console_handler = logging.StreamHandler()
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-console_handler.setFormatter(formatter)
-console_handler.setLevel(logging.DEBUG)
-
-file_handler = logging.FileHandler("app_similarity_score.log")
-file_handler.setLevel(logging.DEBUG)
-file_handler.setFormatter(formatter)
-
-logger.addHandler(file_handler)
-logger.addHandler(console_handler)
+# Set the logging level
+logger.setLevel(logging.INFO)
 
 
 def find_path(folder_name):
+    """
+    The function `find_path` searches for a folder by name starting from the current directory and
+    traversing up the directory tree until the folder is found or the root directory is reached.
+
+    Args:
+      folder_name: The `find_path` function you provided is designed to search for a folder by name
+    starting from the current working directory and moving up the directory tree until it finds the
+    folder or reaches the root directory.
+
+    Returns:
+      The `find_path` function is designed to search for a folder with the given `folder_name` starting
+    from the current working directory (`os.getcwd()`). It iterates through the directory structure,
+    checking if the folder exists in the current directory or any of its parent directories. If the
+    folder is found, it returns the full path to that folder using `os.path.join(curr_dir, folder_name)`
+    """
     curr_dir = os.getcwd()
     while True:
         if folder_name in os.listdir(curr_dir):
             return os.path.join(curr_dir, folder_name)
         else:
             parent_dir = os.path.dirname(curr_dir)
-            if parent_dir == '/':
+            if parent_dir == "/":
                 break
             curr_dir = parent_dir
     raise ValueError(f"Folder '{folder_name}' not found.")
 
 
-cwd = find_path('Resume-Matcher')
-READ_RESUME_FROM = os.path.join(cwd, 'Data', 'Processed', 'Resumes')
-READ_JOB_DESCRIPTION_FROM = os.path.join(cwd, 'Data', 'Processed', 'JobDescription')
+cwd = find_path("Resume-Matcher")
+READ_RESUME_FROM = os.path.join(cwd, "Data", "Processed", "Resumes")
+READ_JOB_DESCRIPTION_FROM = os.path.join(cwd, "Data", "Processed", "JobDescription")
 config_path = os.path.join(cwd, "scripts", "similarity")
 
 
 def read_config(filepath):
+    """
+    The `read_config` function reads a configuration file in YAML format and handles exceptions related
+    to file not found or parsing errors.
+
+    Args:
+      filepath: The `filepath` parameter in the `read_config` function is a string that represents the
+    path to the configuration file that you want to read and parse. This function attempts to open the
+    file specified by `filepath`, load its contents as YAML, and return the parsed configuration. If any
+    errors occur during
+
+    Returns:
+      The function `read_config` will return the configuration loaded from the file if successful, or
+    `None` if there was an error during the process.
+    """
     try:
         with open(filepath) as f:
             config = yaml.safe_load(f)
@@ -56,23 +72,55 @@ def read_config(filepath):
     except FileNotFoundError as e:
         logger.error(f"Configuration file {filepath} not found: {e}")
     except yaml.YAMLError as e:
-        logger.error(f"Error parsing YAML in configuration file {filepath}: {e}", exc_info=True)
+        logger.error(
+            f"Error parsing YAML in configuration file {filepath}: {e}", exc_info=True
+        )
     except Exception as e:
         logger.error(f"Error reading configuration file {filepath}: {e}")
     return None
 
 
 def read_doc(path):
+    """
+    The `read_doc` function reads a JSON file from the specified path and returns its contents, handling
+    any exceptions that may occur during the process.
+
+    Args:
+      path: The `path` parameter in the `read_doc` function is a string that represents the file path to
+    the JSON document that you want to read and load. This function reads the JSON data from the file
+    located at the specified path.
+
+    Returns:
+      The function `read_doc(path)` reads a JSON file located at the specified `path`, and returns the
+    data loaded from the file. If there is an error reading the JSON file, it logs the error message and
+    returns an empty dictionary `{}`.
+    """
     with open(path) as f:
         try:
             data = json.load(f)
         except Exception as e:
-            logger.error(f'Error reading JSON file: {e}')
+            logger.error(f"Error reading JSON file: {e}")
             data = {}
     return data
 
 
 def get_score(resume_string, job_description_string):
+    """
+    The function `get_score` uses QdrantClient to calculate the similarity score between a resume and a
+    job description.
+
+    Args:
+      resume_string: The `resume_string` parameter is a string containing the text of a resume. It
+    represents the content of a resume that you want to compare with a job description.
+      job_description_string: The `get_score` function you provided seems to be using a QdrantClient to
+    calculate the similarity score between a resume and a job description. The function takes in two
+    parameters: `resume_string` and `job_description_string`, where `resume_string` is the text content
+    of the resume and
+
+    Returns:
+      The function `get_score` returns the search result obtained by querying a QdrantClient with the
+    job description string against the resume string provided.
+    """
     logger.info("Started getting similarity score")
 
     documents: List[str] = [resume_string]
@@ -85,8 +133,7 @@ def get_score(resume_string, job_description_string):
     )
 
     search_result = client.query(
-        collection_name="demo_collection",
-        query_text=job_description_string
+        collection_name="demo_collection", query_text=job_description_string
     )
     logger.info("Finished getting similarity score")
     return search_result
@@ -95,14 +142,18 @@ def get_score(resume_string, job_description_string):
 if __name__ == "__main__":
     # To give your custom resume use this code
     resume_dict = read_config(
-        READ_RESUME_FROM + "/Resume-alfred_pennyworth_pm.pdf83632b66-5cce-4322-a3c6-895ff7e3dd96.json")
+        READ_RESUME_FROM
+        + "/Resume-alfred_pennyworth_pm.pdf83632b66-5cce-4322-a3c6-895ff7e3dd96.json"
+    )
     job_dict = read_config(
-        READ_JOB_DESCRIPTION_FROM + "/JobDescription-job_desc_product_manager.pdf6763dc68-12ff-4b32-b652-ccee195de071.json")
+        READ_JOB_DESCRIPTION_FROM
+        + "/JobDescription-job_desc_product_manager.pdf6763dc68-12ff-4b32-b652-ccee195de071.json"
+    )
     resume_keywords = resume_dict["extracted_keywords"]
     job_description_keywords = job_dict["extracted_keywords"]
 
-    resume_string = ' '.join(resume_keywords)
-    jd_string = ' '.join(job_description_keywords)
+    resume_string = " ".join(resume_keywords)
+    jd_string = " ".join(job_description_keywords)
     final_result = get_score(resume_string, jd_string)
     for r in final_result:
         print(r.score)

scripts/similarity/get_similarity_score.py

@@ -7,49 +7,65 @@ import yaml
 from qdrant_client import QdrantClient, models
 from qdrant_client.http.models import Batch
 
-logging.basicConfig(
-    filename='app_similarity_score.log',
-    filemode='w',
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
+from scripts.utils.logger import get_handlers, init_logging_config
 
+init_logging_config(basic_log_level=logging.INFO)
+# Get the logger
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
-console_handler = logging.StreamHandler()
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-console_handler.setFormatter(formatter)
-console_handler.setLevel(logging.DEBUG)
+# Set the logging level
+logger.setLevel(logging.INFO)
 
-file_handler = logging.FileHandler("app_similarity_score.log")
-file_handler.setLevel(logging.DEBUG)
-file_handler.setFormatter(formatter)
-
-logger.addHandler(file_handler)
-logger.addHandler(console_handler)
+stderr_handler, file_handler = get_handlers()
 
 
 def find_path(folder_name):
+    """
+    Find the path of a folder with the given name in the current directory or its parent directories.
+
+    Args:
+        folder_name (str): The name of the folder to search for.
+
+    Returns:
+        str: The path of the folder if found.
+
+    Raises:
+        ValueError: If the folder with the given name is not found in the current directory or its parent directories.
+    """
     curr_dir = os.getcwd()
     while True:
         if folder_name in os.listdir(curr_dir):
             return os.path.join(curr_dir, folder_name)
         else:
             parent_dir = os.path.dirname(curr_dir)
-            if parent_dir == '/':
+            if parent_dir == "/":
                 break
             curr_dir = parent_dir
     raise ValueError(f"Folder '{folder_name}' not found.")
 
 
-cwd = find_path('Resume-Matcher')
-READ_RESUME_FROM = os.path.join(cwd, 'Data', 'Processed', 'Resumes')
-READ_JOB_DESCRIPTION_FROM = os.path.join(cwd, 'Data', 'Processed', 'JobDescription')
+cwd = find_path("Resume-Matcher")
+READ_RESUME_FROM = os.path.join(cwd, "Data", "Processed", "Resumes")
+READ_JOB_DESCRIPTION_FROM = os.path.join(cwd, "Data", "Processed", "JobDescription")
 config_path = os.path.join(cwd, "scripts", "similarity")
 
 
 def read_config(filepath):
+    """
+    Reads a configuration file in YAML format and returns the parsed configuration.
+
+    Args:
+        filepath (str): The path to the configuration file.
+
+    Returns:
+        dict: The parsed configuration as a dictionary.
+
+    Raises:
+        FileNotFoundError: If the configuration file is not found.
+        yaml.YAMLError: If there is an error parsing the YAML in the configuration file.
+        Exception: If there is an error reading the configuration file.
+
+    """
     try:
         with open(filepath) as f:
             config = yaml.safe_load(f)
@@ -57,28 +73,56 @@ def read_config(filepath):
     except FileNotFoundError as e:
         logger.error(f"Configuration file {filepath} not found: {e}")
     except yaml.YAMLError as e:
-        logger.error(f"Error parsing YAML in configuration file {filepath}: {e}", exc_info=True)
+        logger.error(
+            f"Error parsing YAML in configuration file {filepath}: {e}", exc_info=True
+        )
     except Exception as e:
         logger.error(f"Error reading configuration file {filepath}: {e}")
     return None
 
 
 def read_doc(path):
+    """
+    Read a JSON file and return its contents as a dictionary.
+
+    Args:
+        path (str): The path to the JSON file.
+
+    Returns:
+        dict: The contents of the JSON file as a dictionary.
+
+    Raises:
+        Exception: If there is an error reading the JSON file.
+    """
     with open(path) as f:
         try:
             data = json.load(f)
         except Exception as e:
-            logger.error(f'Error reading JSON file: {e}')
+            logger.error(f"Error reading JSON file: {e}")
             data = {}
     return data
 
 
+# This class likely performs searches based on quadrants.
 class QdrantSearch:
     def __init__(self, resumes, jd):
+        """
+        The function initializes various parameters and clients for processing resumes and job
+        descriptions.
+
+        Args:
+          resumes: The `resumes` parameter in the `__init__` method seems to be a list of resumes that
+        is passed to the class constructor. It is likely used within the class for some processing or
+        analysis related to resumes. If you have any specific questions or need further assistance with
+        this parameter or any
+          jd: The `jd` parameter in the `__init__` method seems to represent a job description. It is
+        likely used as input to compare against the resumes provided in the `resumes` parameter. The job
+        description is probably used for matching and analyzing against the resumes in the system.
+        """
         config = read_config(config_path + "/config.yml")
-        self.cohere_key = config['cohere']['api_key']
-        self.qdrant_key = config['qdrant']['api_key']
-        self.qdrant_url = config['qdrant']['url']
+        self.cohere_key = config["cohere"]["api_key"]
+        self.qdrant_key = config["qdrant"]["api_key"]
+        self.qdrant_url = config["qdrant"]["url"]
         self.resumes = resumes
         self.jd = jd
         self.cohere = cohere.Client(self.cohere_key)
@@ -93,17 +137,30 @@ class QdrantSearch:
         self.qdrant.recreate_collection(
             collection_name=self.collection_name,
             vectors_config=models.VectorParams(
-                size=vector_size,
-                distance=models.Distance.COSINE
-            )
+                size=vector_size, distance=models.Distance.COSINE
+            ),
         )
 
         self.logger = logging.getLogger(self.__class__.__name__)
 
-        self.logger.addHandler(console_handler)
+        self.logger.addHandler(stderr_handler)
         self.logger.addHandler(file_handler)
 
     def get_embedding(self, text):
+        """
+        The function `get_embedding` takes a text input, generates embeddings using the Cohere API, and
+        returns the embeddings as a list of floats along with the length of the embeddings.
+
+        Args:
+          text: The `text` parameter in the `get_embedding` function is a string that represents the
+        text for which you want to generate embeddings. This text will be passed to the Cohere API to
+        retrieve the embeddings for further processing.
+
+        Returns:
+          The `get_embedding` function returns a tuple containing two elements:
+        1. A list of floating-point numbers representing the embeddings of the input text.
+        2. The length of the embeddings list.
+        """
         try:
             embeddings = self.cohere.embed([text], "large").embeddings
             return list(map(float, embeddings[0])), len(embeddings[0])
@@ -111,6 +168,10 @@ class QdrantSearch:
             self.logger.error(f"Error getting embeddings: {e}", exc_info=True)
 
     def update_qdrant(self):
+        """
+        This Python function updates vectors and corresponding metadata in a Qdrant collection based on
+        resumes.
+        """
         vectors = []
         ids = []
         for i, resume in enumerate(self.resumes):
@@ -123,33 +184,55 @@ class QdrantSearch:
                 points=Batch(
                     ids=ids,
                     vectors=vectors,
-                    payloads=[{"text": resume} for resume in self.resumes]
-
-                )
+                    payloads=[{"text": resume} for resume in self.resumes],
+                ),
             )
         except Exception as e:
-            self.logger.error(f"Error upserting the vectors to the qdrant collection: {e}", exc_info=True)
+            self.logger.error(
+                f"Error upserting the vectors to the qdrant collection: {e}",
+                exc_info=True,
+            )
 
     def search(self):
+        """
+        The `search` function retrieves search results based on a query vector using a specified
+        collection in a search engine.
+
+        Returns:
+          A list of dictionaries containing the text and score of the search results.
+        """
         vector, _ = self.get_embedding(self.jd)
 
         hits = self.qdrant.search(
-            collection_name=self.collection_name,
-            query_vector=vector,
-            limit=30
+            collection_name=self.collection_name, query_vector=vector, limit=30
         )
         results = []
         for hit in hits:
-            result = {
-                'text': str(hit.payload)[:30],
-                'score': hit.score
-            }
+            result = {"text": str(hit.payload)[:30], "score": hit.score}
             results.append(result)
 
         return results
 
 
 def get_similarity_score(resume_string, job_description_string):
+    """
+    This Python function `get_similarity_score` calculates the similarity score between a resume and a
+    job description using QdrantSearch.
+
+    Args:
+      resume_string: The `get_similarity_score` function seems to be using a `QdrantSearch` class to
+    calculate the similarity score between a resume and a job description. The `resume_string` parameter
+    likely contains the text content of a resume, while the `job_description_string` parameter contains
+    the text content of
+      job_description_string: The `job_description_string` parameter is a string containing the job
+    description for which you want to calculate the similarity score with a given resume. This
+    description typically includes details about the job requirements, responsibilities, qualifications,
+    and skills needed for the position. The function `get_similarity_score` takes this job description
+
+    Returns:
+      The function `get_similarity_score` returns the search result obtained from comparing a resume
+    string with a job description string using a QdrantSearch object.
+    """
     logger.info("Started getting similarity score")
     qdrant_search = QdrantSearch([resume_string], job_description_string)
     qdrant_search.update_qdrant()
@@ -161,15 +244,19 @@ def get_similarity_score(resume_string, job_description_string):
 if __name__ == "__main__":
     # To give your custom resume use this code
     resume_dict = read_config(
-        READ_RESUME_FROM + "/Resume-bruce_wayne_fullstack.pdf4783d115-e6fc-462e-ae4d-479152884b28.json")
+        READ_RESUME_FROM
+        + "/Resume-bruce_wayne_fullstack.pdf4783d115-e6fc-462e-ae4d-479152884b28.json"
+    )
     job_dict = read_config(
-        READ_JOB_DESCRIPTION_FROM + "/JobDescription-job_desc_full_stack_engineer_pdf4de00846-a4fe-4fe5-a4d7"
-                                    "-2a8a1b9ad020.json")
+        READ_JOB_DESCRIPTION_FROM
+        + "/JobDescription-job_desc_full_stack_engineer_pdf4de00846-a4fe-4fe5-a4d7"
+        "-2a8a1b9ad020.json"
+    )
     resume_keywords = resume_dict["extracted_keywords"]
     job_description_keywords = job_dict["extracted_keywords"]
 
-    resume_string = ' '.join(resume_keywords)
-    jd_string = ' '.join(job_description_keywords)
+    resume_string = " ".join(resume_keywords)
+    jd_string = " ".join(job_description_keywords)
     final_result = get_similarity_score(resume_string, jd_string)
     for r in final_result:
         print(r)

scripts/utils/ReadFiles.py

@@ -1,5 +1,10 @@
 import os
 
+
 def get_filenames_from_dir(directory_path: str) -> list:
-    filenames = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f)) and f != '.DS_Store']
+    filenames = [
+        f
+        for f in os.listdir(directory_path)
+        if os.path.isfile(os.path.join(directory_path, f)) and f != ".DS_Store"
+    ]
     return filenames

scripts/utils/Similar.py

@@ -6,6 +6,6 @@ def match(resume, job_des):
     s = td.sorensen_dice.similarity(resume, job_des)
     c = td.cosine.similarity(resume, job_des)
     o = td.overlap.normalized_similarity(resume, job_des)
-    total = (j+s+c+o)/4
+    total = (j + s + c + o) / 4
     # total = (s+o)/2
-    return total*100
+    return total * 100

scripts/utils/Utils.py

@@ -1,14 +1,15 @@
-from uuid import uuid4
 import re
+from uuid import uuid4
+
 import spacy
 
 # Load the English model
-nlp = spacy.load('en_core_web_md')
+nlp = spacy.load("en_core_web_md")
 
 REGEX_PATTERNS = {
-    'email_pattern': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b',
-    'phone_pattern': r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}",
-    'link_pattern': r'\b(?:https?://|www\.)\S+\b'
+    "email_pattern": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b",
+    "phone_pattern": r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}",
+    "link_pattern": r"\b(?:https?://|www\.)\S+\b",
 }
 
 
@@ -38,7 +39,7 @@ class TextCleaner:
             str: The cleaned text.
         """
         for pattern in REGEX_PATTERNS:
-            text = re.sub(REGEX_PATTERNS[pattern], '', text)
+            text = re.sub(REGEX_PATTERNS[pattern], "", text)
         return text
 
     def clean_text(text):
@@ -54,8 +55,8 @@ class TextCleaner:
         text = TextCleaner.remove_emails_links(text)
         doc = nlp(text)
         for token in doc:
-            if token.pos_ == 'PUNCT':
-                text = text.replace(token.text, '')
+            if token.pos_ == "PUNCT":
+                text = text.replace(token.text, "")
         return str(text)
 
     def remove_stopwords(text):
@@ -71,7 +72,7 @@ class TextCleaner:
         doc = nlp(text)
         for token in doc:
             if token.is_stop:
-                text = text.replace(token.text, '')
+                text = text.replace(token.text, "")
         return text
 
 

scripts/utils/__init__.py

@@ -1,3 +1,3 @@
 from .logger import init_logging_config
+from .ReadFiles import get_filenames_from_dir
 from .Utils import TextCleaner
-from .ReadFiles import get_filenames_from_dir

scripts/utils/logger.py

@@ -1,41 +1,145 @@
 import logging
 
 
-def init_logging_config():
-    class CustomFormatter(logging.Formatter):
-        def __init__(self, file=False):
-            super().__init__()
-            yellow = "\x1b[36;10m" if not file else ""
-            blue = "\x1b[35;10m" if not file else ""
-            green = "\x1b[32;10m" if not file else ""
-            red = "\x1b[31;10m" if not file else ""
-            bold_red = "\x1b[31;1m" if not file else ""
-            reset = "\x1b[0m" if not file else ""
-            log = "%(asctime)s (%(filename)s:%(lineno)d) - %(levelname)s: "
-            msg = reset + "%(message)s"
-
-            self.FORMATS = {
-                logging.DEBUG: blue + log + msg,
-                logging.INFO: green + log + msg,
-                logging.WARNING: yellow + log + msg,
-                logging.ERROR: red + log + msg,
-                logging.CRITICAL: bold_red + log + msg,
-            }
-
-        def format(self, record):
-            log_fmt = self.FORMATS.get(record.levelno)
-            formatter = logging.Formatter(log_fmt)
-            return formatter.format(record)
+def get_handlers(
+    filename="app.log", mode="w", file_level=logging.DEBUG, stderr_level=logging.DEBUG
+):
+    """
+    The function `get_handlers` returns a stream handler and a file handler with specified logging
+    levels and formatters.
 
-    logger = logging.getLogger()
-    logger.setLevel(logging.DEBUG)
+    Args:
+      filename: The `filename` parameter is the name of the log file where the log messages will be
+    written. In this case, the default filename is "app.log". Defaults to app.log
+      mode: The `mode` parameter in the `get_handlers` function specifies the mode in which the file
+    should be opened. In this case, the default mode is set to "w", which stands for write mode. This
+    means that if the file already exists, it will be truncated (i.e., its. Defaults to w
+      file_level: The `file_level` parameter in the `get_handlers` function is used to specify the
+    logging level for the file handler. In this case, it is set to `logging.DEBUG`, which means that the
+    file handler will log all messages at the DEBUG level and above.
+      stderr_level: The `stderr_level` parameter in the `get_handlers` function is used to specify the
+    logging level for the StreamHandler that outputs log messages to the standard error stream (stderr).
+    This level determines which log messages will be processed and output by the StreamHandler.
 
+    Returns:
+      The `get_handlers` function returns two logging handlers: `stderr_handler` which is a
+    StreamHandler for logging to stderr, and `file_handler` which is a FileHandler for logging to a file
+    specified by the `filename` parameter.
+    """
+    # Stream handler
     stderr_handler = logging.StreamHandler()
-    stderr_handler.setLevel(logging.DEBUG)
+    stderr_handler.setLevel(stderr_level)
     stderr_handler.setFormatter(CustomFormatter())
-    logger.addHandler(stderr_handler)
 
-    file_handler = logging.FileHandler("app.log",  mode="w")
-    file_handler.setLevel(logging.DEBUG)
+    # File handler
+    file_handler = logging.FileHandler(filename, mode=mode)
+    file_handler.setLevel(file_level)
     file_handler.setFormatter(CustomFormatter(True))
+
+    # TODO: Add RotatingFileHandler
+
+    return stderr_handler, file_handler
+
+
+class CustomFormatter(logging.Formatter):
+    """
+    A custom log formatter that adds color to log messages based on the log level.
+
+    Args:
+        file (bool): Indicates whether the log is being written to a file. Default is False.
+
+    Attributes:
+        FORMATS (dict): A dictionary mapping log levels to colorized log message formats.
+
+    Methods:
+        format(record): Formats the log record with the appropriate colorized log message format.
+
+    """
+
+    def __init__(self, file=False):
+        """
+        This function initializes logging formats with different colors and styles based on the log
+        level.
+
+        Args:
+          file: The `file` parameter in the `__init__` method is a boolean flag that determines whether
+        the logging output should be colored or not. If `file` is `True`, the colors will not be applied
+        to the log messages. Defaults to False
+        """
+        super().__init__()
+        yellow = "\x1b[36;10m" if not file else ""
+        blue = "\x1b[35;10m" if not file else ""
+        green = "\x1b[32;10m" if not file else ""
+        red = "\x1b[31;10m" if not file else ""
+        bold_red = "\x1b[31;1m" if not file else ""
+        reset = "\x1b[0m" if not file else ""
+        log = "%(asctime)s (%(filename)s:%(lineno)d) - %(levelname)s: "
+        msg = reset + "%(message)s"
+
+        self.FORMATS = {
+            logging.DEBUG: blue + log + msg,
+            logging.INFO: green + log + msg,
+            logging.WARNING: yellow + log + msg,
+            logging.ERROR: red + log + msg,
+            logging.CRITICAL: bold_red + log + msg,
+        }
+
+    def format(self, record):
+        """
+        Formats the log record with the appropriate colorized log message format.
+
+        Args:
+            record (LogRecord): The log record to be formatted.
+
+        Returns:
+            str: The formatted log message.
+
+        """
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+def init_logging_config(
+    basic_log_level=logging.INFO,
+    filename="app.log",
+    mode="w",
+    file_level=logging.DEBUG,
+    stderr_level=logging.DEBUG,
+):
+    """
+    The function `init_logging_config` initializes logging configuration in Python by setting basic log
+    level, configuring handlers, and adding them to the logger.
+
+    Args:
+      basic_log_level: The `basic_log_level` parameter is used to set the logging level for the root
+    logger. In this function, it is set to `logging.INFO` by default, which means that log messages with
+    severity level INFO or higher will be processed.
+      filename: The `filename` parameter is a string that specifies the name of the log file where the
+    logs will be written. In the `init_logging_config` function you provided, the default value for
+    `filename` is "app.log". This means that if no filename is provided when calling the function, logs.
+    Defaults to app.log
+      mode: The `mode` parameter in the `init_logging_config` function specifies the mode in which the
+    log file will be opened. In this case, the default value is "w" which stands for write mode. This
+    means that the log file will be opened for writing, and if the file already exists. Defaults to w
+      file_level: The `file_level` parameter in the `init_logging_config` function is used to specify
+    the logging level for the file handler. This determines the severity level of log messages that will
+    be written to the log file specified by the `filename` parameter. In this case, the default value
+    for `file
+      stderr_level: The `stderr_level` parameter in the `init_logging_config` function is used to
+    specify the logging level for the stderr (standard error) handler. This handler is responsible for
+    directing log messages to the standard error stream. The logging level determines which severity of
+    log messages will be output to the stderr.
+    """
+
+    logger = logging.getLogger()
+    logger.setLevel(basic_log_level)
+
+    # Get the handlers
+    stderr_handler, file_handler = get_handlers(
+        file_level=file_level, stderr_level=stderr_level, filename=filename, mode=mode
+    )
+
+    # Add the handlers
+    logger.addHandler(stderr_handler)
     logger.addHandler(file_handler)

streamlit_app.py

@@ -12,18 +12,25 @@ from annotated_text import annotated_text, parameters
 from streamlit_extras import add_vertical_space as avs
 from streamlit_extras.badges import badge
 
-from scripts.utils import get_filenames_from_dir
 from scripts.similarity.get_score import *
-# Set page configuration
-st.set_page_config(page_title='Resume Matcher', page_icon="Assets/img/favicon.ico", initial_sidebar_state='auto')
+from scripts.utils import get_filenames_from_dir
+from scripts.utils.logger import init_logging_config
 
-cwd = find_path('Resume-Matcher')
+# Set page configuration
+st.set_page_config(
+    page_title="Resume Matcher",
+    page_icon="Assets/img/favicon.ico",
+    initial_sidebar_state="auto",
+)
+
+init_logging_config()
+cwd = find_path("Resume-Matcher")
 config_path = os.path.join(cwd, "scripts", "similarity")
 
 try:
-    nltk.data.find('tokenizers/punkt')
+    nltk.data.find("tokenizers/punkt")
 except LookupError:
-    nltk.download('punkt')
+    nltk.download("punkt")
 
 parameters.SHOW_LABEL_SEPARATOR = False
 parameters.BORDER_RADIUS = 3
@@ -55,8 +62,13 @@ def create_star_graph(nodes_and_weights, title):
         edge_x.extend([x0, x1, None])
         edge_y.extend([y0, y1, None])
 
-    edge_trace = go.Scatter(x=edge_x, y=edge_y, line=dict(
-        width=0.5, color='#888'), hoverinfo='none', mode='lines')
+    edge_trace = go.Scatter(
+        x=edge_x,
+        y=edge_y,
+        line=dict(width=0.5, color="#888"),
+        hoverinfo="none",
+        mode="lines",
+    )
 
     # Create node trace
     node_x = []
@@ -66,10 +78,26 @@ def create_star_graph(nodes_and_weights, title):
         node_x.append(x)
         node_y.append(y)
 
-    node_trace = go.Scatter(x=node_x, y=node_y, mode='markers', hoverinfo='text',
-                            marker=dict(showscale=True, colorscale='Rainbow', reversescale=True, color=[], size=10,
-                                        colorbar=dict(thickness=15, title='Node Connections', xanchor='left',
-                                                      titleside='right'), line_width=2))
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode="markers",
+        hoverinfo="text",
+        marker=dict(
+            showscale=True,
+            colorscale="Rainbow",
+            reversescale=True,
+            color=[],
+            size=10,
+            colorbar=dict(
+                thickness=15,
+                title="Node Connections",
+                xanchor="left",
+                titleside="right",
+            ),
+            line_width=2,
+        ),
+    )
 
     # Color node points by number of connections
     node_adjacencies = []
@@ -77,24 +105,32 @@ def create_star_graph(nodes_and_weights, title):
     for node in G.nodes():
         adjacencies = list(G.adj[node])  # changes here
         node_adjacencies.append(len(adjacencies))
-        node_text.append(f'{node}<br># of connections: {len(adjacencies)}')
+        node_text.append(f"{node}<br># of connections: {len(adjacencies)}")
 
     node_trace.marker.color = node_adjacencies
     node_trace.text = node_text
 
     # Create the figure
-    fig = go.Figure(data=[edge_trace, node_trace],
-                    layout=go.Layout(title=title, titlefont_size=16, showlegend=False,
-                                     hovermode='closest', margin=dict(b=20, l=5, r=5, t=40),
-                                     xaxis=dict(
-                                         showgrid=False, zeroline=False, showticklabels=False),
-                                     yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+    fig = go.Figure(
+        data=[edge_trace, node_trace],
+        layout=go.Layout(
+            title=title,
+            titlefont_size=16,
+            showlegend=False,
+            hovermode="closest",
+            margin=dict(b=20, l=5, r=5, t=40),
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        ),
+    )
 
     # Show the figure
     st.plotly_chart(fig)
 
 
-def create_annotated_text(input_string: str, word_list: List[str], annotation: str, color_code: str):
+def create_annotated_text(
+    input_string: str, word_list: List[str], annotation: str, color_code: str
+):
     # Tokenize the input string
     tokens = nltk.word_tokenize(input_string)
 
@@ -128,18 +164,26 @@ def tokenize_string(input_string):
 
 
 # Display the main title and subheaders
-st.title(':blue[Resume Matcher]')
+st.title(":blue[Resume Matcher]")
 with st.sidebar:
-    st.image('Assets/img/header_image.png')
-    st.subheader('Free and Open Source ATS to help your resume pass the screening stage.')
-    st.markdown('Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)')
-
-    st.markdown('Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)')
+    st.image("Assets/img/header_image.png")
+    st.subheader(
+        "Free and Open Source ATS to help your resume pass the screening stage."
+    )
+    st.markdown(
+        "Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)"
+    )
+
+    st.markdown(
+        "Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)"
+    )
 
     badge(type="github", name="srbhr/Resume-Matcher")
-    st.markdown('For updates follow me on Twitter.')
+    st.markdown("For updates follow me on Twitter.")
     badge(type="twitter", name="_srbhr_")
-    st.markdown('If you like the project and would like to further help in development please consider 👇')
+    st.markdown(
+        "If you like the project and would like to further help in development please consider 👇"
+    )
     badge(type="buymeacoffee", name="srbhr")
 
 st.divider()
@@ -148,9 +192,10 @@ avs.add_vertical_space(1)
 resume_names = get_filenames_from_dir("Data/Processed/Resumes")
 
 
-st.markdown(f"##### There are {len(resume_names)} resumes present. Please select one from the menu below:")
-output  = st.selectbox(f"", resume_names)
-    
+st.markdown(
+    f"##### There are {len(resume_names)} resumes present. Please select one from the menu below:"
+)
+output = st.selectbox(f"", resume_names)
 
 
 avs.add_vertical_space(5)
@@ -161,7 +206,8 @@ selected_file = read_json("Data/Processed/Resumes/" + output)
 avs.add_vertical_space(2)
 st.markdown("#### Parsed Resume Data")
 st.caption(
-    "This text is parsed from your resume. This is how it'll look like after getting parsed by an ATS.")
+    "This text is parsed from your resume. This is how it'll look like after getting parsed by an ATS."
+)
 st.caption("Utilize this to understand how to make your resume ATS friendly.")
 avs.add_vertical_space(3)
 # st.json(selected_file)
@@ -170,38 +216,53 @@ st.write(selected_file["clean_data"])
 avs.add_vertical_space(3)
 st.write("Now let's take a look at the extracted keywords from the resume.")
 
-annotated_text(create_annotated_text(
-    selected_file["clean_data"], selected_file["extracted_keywords"],
-    "KW", "#0B666A"))
+annotated_text(
+    create_annotated_text(
+        selected_file["clean_data"],
+        selected_file["extracted_keywords"],
+        "KW",
+        "#0B666A",
+    )
+)
 
 avs.add_vertical_space(5)
 st.write("Now let's take a look at the extracted entities from the resume.")
 
 # Call the function with your data
-create_star_graph(selected_file['keyterms'], "Entities from Resume")
+create_star_graph(selected_file["keyterms"], "Entities from Resume")
 
-df2 = pd.DataFrame(selected_file['keyterms'], columns=["keyword", "value"])
+df2 = pd.DataFrame(selected_file["keyterms"], columns=["keyword", "value"])
 
 # Create the dictionary
 keyword_dict = {}
-for keyword, value in selected_file['keyterms']:
+for keyword, value in selected_file["keyterms"]:
     keyword_dict[keyword] = value * 100
 
-fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                           font=dict(size=12),
-                                           fill_color='#070A52'),
-                               cells=dict(values=[list(keyword_dict.keys()),
-                                                  list(keyword_dict.values())],
-                                          line_color='darkslategray',
-                                          fill_color='#6DA9E4'))
-                      ])
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Keyword", "Value"], font=dict(size=12), fill_color="#070A52"
+            ),
+            cells=dict(
+                values=[list(keyword_dict.keys()), list(keyword_dict.values())],
+                line_color="darkslategray",
+                fill_color="#6DA9E4",
+            ),
+        )
+    ]
+)
 st.plotly_chart(fig)
 
 st.divider()
 
-fig = px.treemap(df2, path=['keyword'], values='value',
-                 color_continuous_scale='Rainbow',
-                 title='Key Terms/Topics Extracted from your Resume')
+fig = px.treemap(
+    df2,
+    path=["keyword"],
+    values="value",
+    color_continuous_scale="Rainbow",
+    title="Key Terms/Topics Extracted from your Resume",
+)
 st.write(fig)
 
 avs.add_vertical_space(5)
@@ -209,65 +270,88 @@ avs.add_vertical_space(5)
 job_descriptions = get_filenames_from_dir("Data/Processed/JobDescription")
 
 
-st.markdown(f"##### There are {len(job_descriptions)} job descriptions present. Please select one from the menu below:")
+st.markdown(
+    f"##### There are {len(job_descriptions)} job descriptions present. Please select one from the menu below:"
+)
 output = st.selectbox("", job_descriptions)
 
 
 avs.add_vertical_space(5)
 
-selected_jd = read_json(
-    "Data/Processed/JobDescription/" + output)
+selected_jd = read_json("Data/Processed/JobDescription/" + output)
 
 avs.add_vertical_space(2)
 st.markdown("#### Job Description")
 st.caption(
-    "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste.")
+    "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste."
+)
 avs.add_vertical_space(3)
 # st.json(selected_file)
 st.write(selected_jd["clean_data"])
 
 st.markdown("#### Common Words between Job Description and Resumes Highlighted.")
 
-annotated_text(create_annotated_text(
-    selected_file["clean_data"], selected_jd["extracted_keywords"],
-    "JD", "#F24C3D"))
+annotated_text(
+    create_annotated_text(
+        selected_file["clean_data"], selected_jd["extracted_keywords"], "JD", "#F24C3D"
+    )
+)
 
 st.write("Now let's take a look at the extracted entities from the job description.")
 
 # Call the function with your data
-create_star_graph(selected_jd['keyterms'], "Entities from Job Description")
+create_star_graph(selected_jd["keyterms"], "Entities from Job Description")
 
-df2 = pd.DataFrame(selected_jd['keyterms'], columns=["keyword", "value"])
+df2 = pd.DataFrame(selected_jd["keyterms"], columns=["keyword", "value"])
 
 # Create the dictionary
 keyword_dict = {}
-for keyword, value in selected_jd['keyterms']:
+for keyword, value in selected_jd["keyterms"]:
     keyword_dict[keyword] = value * 100
 
-fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                           font=dict(size=12),
-                                           fill_color='#070A52'),
-                               cells=dict(values=[list(keyword_dict.keys()),
-                                                  list(keyword_dict.values())],
-                                          line_color='darkslategray',
-                                          fill_color='#6DA9E4'))
-                      ])
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Keyword", "Value"], font=dict(size=12), fill_color="#070A52"
+            ),
+            cells=dict(
+                values=[list(keyword_dict.keys()), list(keyword_dict.values())],
+                line_color="darkslategray",
+                fill_color="#6DA9E4",
+            ),
+        )
+    ]
+)
 st.plotly_chart(fig)
 
 st.divider()
 
-fig = px.treemap(df2, path=['keyword'], values='value',
-                 color_continuous_scale='Rainbow',
-                 title='Key Terms/Topics Extracted from the selected Job Description')
+fig = px.treemap(
+    df2,
+    path=["keyword"],
+    values="value",
+    color_continuous_scale="Rainbow",
+    title="Key Terms/Topics Extracted from the selected Job Description",
+)
 st.write(fig)
 
 avs.add_vertical_space(3)
 
-resume_string = ' '.join(selected_file["extracted_keywords"])
-jd_string = ' '.join(selected_jd["extracted_keywords"])
+resume_string = " ".join(selected_file["extracted_keywords"])
+jd_string = " ".join(selected_jd["extracted_keywords"])
 result = get_score(resume_string, jd_string)
-similarity_score = result[0].score
-st.write("Similarity Score obtained for the resume and job description is:", similarity_score)
+similarity_score = round(result[0].score * 100, 2)
+score_color = "green"
+if similarity_score < 60:
+    score_color = "red"
+elif 60 <= similarity_score < 75:
+    score_color = "orange"
+st.markdown(
+    f"Similarity Score obtained for the resume and job description is "
+    f'<span style="color:{score_color};font-size:24px; font-weight:Bold">{similarity_score}</span>',
+    unsafe_allow_html=True,
+)
 
 # Go back to top
-st.markdown('[:arrow_up: Back to Top](#resume-matcher)')
+st.markdown("[:arrow_up: Back to Top](#resume-matcher)")

streamlit_interactive.py

@@ -13,25 +13,29 @@ from annotated_text import annotated_text, parameters
 from streamlit_extras import add_vertical_space as avs
 from streamlit_extras.badges import badge
 
-from scripts import ResumeProcessor, JobDescriptionProcessor
+from scripts import JobDescriptionProcessor, ResumeProcessor
+from scripts.parsers import ParseJobDesc, ParseResume
 from scripts.ReadPdf import read_single_pdf
-from scripts.similarity import get_similarity_score, find_path, read_config
-from scripts.parsers import ParseResume
-from scripts.parsers import ParseJobDesc
+from scripts.similarity.get_score import *
 from scripts.utils import get_filenames_from_dir
 
 # Set page configuration
-st.set_page_config(page_title='Resume Matcher', page_icon="Assets/img/favicon.ico", initial_sidebar_state='auto', layout='wide')
+st.set_page_config(
+    page_title="Resume Matcher",
+    page_icon="Assets/img/favicon.ico",
+    initial_sidebar_state="auto",
+    layout="wide",
+)
 
 # Find the current working directory and configuration path
-cwd = find_path('Resume-Matcher')
+cwd = find_path("Resume-Matcher")
 config_path = os.path.join(cwd, "scripts", "similarity")
 
 # Check if NLTK punkt data is available, if not, download it
 try:
-    nltk.data.find('tokenizers/punkt')
+    nltk.data.find("tokenizers/punkt")
 except LookupError:
-    nltk.download('punkt')
+    nltk.download("punkt")
 
 # Set some visualization parameters using the annotated_text library
 parameters.SHOW_LABEL_SEPARATOR = False
@@ -92,8 +96,13 @@ def create_star_graph(nodes_and_weights, title):
         edge_x.extend([x0, x1, None])
         edge_y.extend([y0, y1, None])
 
-    edge_trace = go.Scatter(x=edge_x, y=edge_y, line=dict(
-        width=0.5, color='#888'), hoverinfo='none', mode='lines')
+    edge_trace = go.Scatter(
+        x=edge_x,
+        y=edge_y,
+        line=dict(width=0.5, color="#888"),
+        hoverinfo="none",
+        mode="lines",
+    )
 
     # Create node trace
     node_x = []
@@ -103,10 +112,26 @@ def create_star_graph(nodes_and_weights, title):
         node_x.append(x)
         node_y.append(y)
 
-    node_trace = go.Scatter(x=node_x, y=node_y, mode='markers', hoverinfo='text',
-                            marker=dict(showscale=True, colorscale='Rainbow', reversescale=True, color=[], size=10,
-                                        colorbar=dict(thickness=15, title='Node Connections', xanchor='left',
-                                                      titleside='right'), line_width=2))
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode="markers",
+        hoverinfo="text",
+        marker=dict(
+            showscale=True,
+            colorscale="Rainbow",
+            reversescale=True,
+            color=[],
+            size=10,
+            colorbar=dict(
+                thickness=15,
+                title="Node Connections",
+                xanchor="left",
+                titleside="right",
+            ),
+            line_width=2,
+        ),
+    )
 
     # Color node points by number of connections
     node_adjacencies = []
@@ -114,25 +139,33 @@ def create_star_graph(nodes_and_weights, title):
     for node in graph.nodes():
         adjacencies = list(graph.adj[node])  # Changes here
         node_adjacencies.append(len(adjacencies))
-        node_text.append(f'{node}<br># of connections: {len(adjacencies)}')
+        node_text.append(f"{node}<br># of connections: {len(adjacencies)}")
 
     node_trace.marker.color = node_adjacencies
     node_trace.text = node_text
 
     # Create the figure
-    figure = go.Figure(data=[edge_trace, node_trace],
-                       layout=go.Layout(title=title, titlefont=dict(size=16), showlegend=False,
-                                        hovermode='closest', margin=dict(b=20, l=5, r=5, t=40),
-                                        xaxis=dict(
-                                            showgrid=False, zeroline=False, showticklabels=False),
-                                        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+    figure = go.Figure(
+        data=[edge_trace, node_trace],
+        layout=go.Layout(
+            title=title,
+            titlefont=dict(size=16),
+            showlegend=False,
+            hovermode="closest",
+            margin=dict(b=20, l=5, r=5, t=40),
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        ),
+    )
 
     # Show the figure
     st.plotly_chart(figure, use_container_width=True)
 
 
 # Function to create annotated text with highlighting
-def create_annotated_text(input_string: str, word_list: List[str], annotation: str, color_code: str):
+def create_annotated_text(
+    input_string: str, word_list: List[str], annotation: str, color_code: str
+):
     """
     Create annotated text with highlighted keywords.
 
@@ -210,16 +243,24 @@ if "jobDescriptionUploaded" not in st.session_state.keys():
     update_session_state("jobDescriptionPath", "")
 
 # Display the main title and sub-headers
-st.title(':blue[Resume Matcher]')
+st.title(":blue[Resume Matcher]")
 with st.sidebar:
-    st.image('Assets/img/header_image.png')
-    st.subheader('Free and Open Source ATS to help your resume pass the screening stage.')
-    st.markdown('Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)')
-    st.markdown('Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)')
+    st.image("Assets/img/header_image.png")
+    st.subheader(
+        "Free and Open Source ATS to help your resume pass the screening stage."
+    )
+    st.markdown(
+        "Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)"
+    )
+    st.markdown(
+        "Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)"
+    )
     badge(type="github", name="srbhr/Resume-Matcher")
-    st.markdown('For updates follow me on Twitter.')
+    st.markdown("For updates follow me on Twitter.")
     badge(type="twitter", name="_srbhr_")
-    st.markdown('If you like the project and would like to further help in development please consider 👇')
+    st.markdown(
+        "If you like the project and would like to further help in development please consider 👇"
+    )
     badge(type="buymeacoffee", name="srbhr")
 
 st.divider()
@@ -231,13 +272,17 @@ with st.container():
         uploaded_Resume = st.file_uploader("Choose a Resume", type="pdf")
         if uploaded_Resume is not None:
             if st.session_state["resumeUploaded"] == "Pending":
-                save_path_resume = os.path.join(cwd, "Data", "Resumes", uploaded_Resume.name)
+                save_path_resume = os.path.join(
+                    cwd, "Data", "Resumes", uploaded_Resume.name
+                )
 
-                with open(save_path_resume, mode='wb') as w:
+                with open(save_path_resume, mode="wb") as w:
                     w.write(uploaded_Resume.getvalue())
 
                 if os.path.exists(save_path_resume):
-                    st.toast(f'File {uploaded_Resume.name} is successfully saved!', icon="✔️")
+                    st.toast(
+                        f"File {uploaded_Resume.name} is successfully saved!", icon="✔️"
+                    )
                     update_session_state("resumeUploaded", "Uploaded")
                     update_session_state("resumePath", save_path_resume)
         else:
@@ -245,170 +290,247 @@ with st.container():
             update_session_state("resumePath", "")
 
     with jobDescriptionCol:
-        uploaded_JobDescription = st.file_uploader("Choose a Job Description", type="pdf")
+        uploaded_JobDescription = st.file_uploader(
+            "Choose a Job Description", type="pdf"
+        )
         if uploaded_JobDescription is not None:
             if st.session_state["jobDescriptionUploaded"] == "Pending":
-                save_path_jobDescription = os.path.join(cwd, "Data", "JobDescription", uploaded_JobDescription.name)
+                save_path_jobDescription = os.path.join(
+                    cwd, "Data", "JobDescription", uploaded_JobDescription.name
+                )
 
-                with open(save_path_jobDescription, mode='wb') as w:
+                with open(save_path_jobDescription, mode="wb") as w:
                     w.write(uploaded_JobDescription.getvalue())
 
                 if os.path.exists(save_path_jobDescription):
-                    st.toast(f'File {uploaded_JobDescription.name} is successfully saved!', icon="✔️")
+                    st.toast(
+                        f"File {uploaded_JobDescription.name} is successfully saved!",
+                        icon="✔️",
+                    )
                     update_session_state("jobDescriptionUploaded", "Uploaded")
                     update_session_state("jobDescriptionPath", save_path_jobDescription)
         else:
             update_session_state("jobDescriptionUploaded", "Pending")
             update_session_state("jobDescriptionPath", "")
 
-with st.spinner('Please wait...'):
-    if (uploaded_Resume is not None and
-            st.session_state["jobDescriptionUploaded"] == "Uploaded" and
-            uploaded_JobDescription is not None and
-            st.session_state["jobDescriptionUploaded"] == "Uploaded"):
+with st.spinner("Please wait..."):
+    if (
+        uploaded_Resume is not None
+        and st.session_state["jobDescriptionUploaded"] == "Uploaded"
+        and uploaded_JobDescription is not None
+        and st.session_state["jobDescriptionUploaded"] == "Uploaded"
+    ):
 
         resumeProcessor = ParseResume(read_single_pdf(st.session_state["resumePath"]))
-        jobDescriptionProcessor = ParseJobDesc(read_single_pdf(st.session_state["jobDescriptionPath"]))
+        jobDescriptionProcessor = ParseJobDesc(
+            read_single_pdf(st.session_state["jobDescriptionPath"])
+        )
 
         # Resume / JD output
         selected_file = resumeProcessor.get_JSON()
         selected_jd = jobDescriptionProcessor.get_JSON()
 
         # Add containers for each row to avoid overlap
+
+        # Parsed data
         with st.container():
             resumeCol, jobDescriptionCol = st.columns(2)
             with resumeCol:
                 with st.expander("Parsed Resume Data"):
                     st.caption(
                         "This text is parsed from your resume. This is how it'll look like after getting parsed by an "
-                        "ATS.")
-                    st.caption("Utilize this to understand how to make your resume ATS friendly.")
+                        "ATS."
+                    )
+                    st.caption(
+                        "Utilize this to understand how to make your resume ATS friendly."
+                    )
                     avs.add_vertical_space(3)
                     st.write(selected_file["clean_data"])
 
             with jobDescriptionCol:
                 with st.expander("Parsed Job Description"):
                     st.caption(
-                        "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste.")
+                        "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste."
+                    )
                     avs.add_vertical_space(3)
                     st.write(selected_jd["clean_data"])
 
+        # Extracted keywords
         with st.container():
             resumeCol, jobDescriptionCol = st.columns(2)
             with resumeCol:
                 with st.expander("Extracted Keywords"):
-                    st.write("Now let's take a look at the extracted keywords from the resume.")
-                    annotated_text(create_annotated_text(
-                        selected_file["clean_data"], selected_file["extracted_keywords"],
-                        "KW", "#0B666A"))
+                    st.write(
+                        "Now let's take a look at the extracted keywords from the resume."
+                    )
+                    annotated_text(
+                        create_annotated_text(
+                            selected_file["clean_data"],
+                            selected_file["extracted_keywords"],
+                            "KW",
+                            "#0B666A",
+                        )
+                    )
             with jobDescriptionCol:
                 with st.expander("Extracted Keywords"):
-                    st.write("Now let's take a look at the extracted keywords from the job description.")
-                    annotated_text(create_annotated_text(
-                        selected_jd["clean_data"], selected_jd["extracted_keywords"],
-                        "KW", "#0B666A"))
-
+                    st.write(
+                        "Now let's take a look at the extracted keywords from the job description."
+                    )
+                    annotated_text(
+                        create_annotated_text(
+                            selected_jd["clean_data"],
+                            selected_jd["extracted_keywords"],
+                            "KW",
+                            "#0B666A",
+                        )
+                    )
+
+        # Star graph visualization
         with st.container():
             resumeCol, jobDescriptionCol = st.columns(2)
             with resumeCol:
                 with st.expander("Extracted Entities"):
-                    st.write("Now let's take a look at the extracted entities from the resume.")
+                    st.write(
+                        "Now let's take a look at the extracted entities from the resume."
+                    )
 
                     # Call the function with your data
-                    create_star_graph(selected_file['keyterms'], "Entities from Resume")
+                    create_star_graph(selected_file["keyterms"], "Entities from Resume")
             with jobDescriptionCol:
                 with st.expander("Extracted Entities"):
-                    st.write("Now let's take a look at the extracted entities from the job description.")
+                    st.write(
+                        "Now let's take a look at the extracted entities from the job description."
+                    )
 
                     # Call the function with your data
-                    create_star_graph(selected_jd['keyterms'], "Entities from Job Description")
+                    create_star_graph(
+                        selected_jd["keyterms"], "Entities from Job Description"
+                    )
 
+        # Keywords and values
         with st.container():
             resumeCol, jobDescriptionCol = st.columns(2)
             with resumeCol:
                 with st.expander("Keywords & Values"):
-                    df1 = pd.DataFrame(selected_file['keyterms'], columns=["keyword", "value"])
+                    df1 = pd.DataFrame(
+                        selected_file["keyterms"], columns=["keyword", "value"]
+                    )
 
                     # Create the dictionary
                     keyword_dict = {}
-                    for keyword, value in selected_file['keyterms']:
+                    for keyword, value in selected_file["keyterms"]:
                         keyword_dict[keyword] = value * 100
 
-                    fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                                               font=dict(size=12, color="white"),
-                                                               fill_color='#1d2078'),
-                                                   cells=dict(values=[list(keyword_dict.keys()),
-                                                                      list(keyword_dict.values())],
-                                                              line_color='darkslategray',
-                                                              fill_color='#6DA9E4'))
-                                          ])
+                    fig = go.Figure(
+                        data=[
+                            go.Table(
+                                header=dict(
+                                    values=["Keyword", "Value"],
+                                    font=dict(size=12, color="white"),
+                                    fill_color="#1d2078",
+                                ),
+                                cells=dict(
+                                    values=[
+                                        list(keyword_dict.keys()),
+                                        list(keyword_dict.values()),
+                                    ],
+                                    line_color="darkslategray",
+                                    fill_color="#6DA9E4",
+                                ),
+                            )
+                        ]
+                    )
                     st.plotly_chart(fig, use_container_width=True)
             with jobDescriptionCol:
                 with st.expander("Keywords & Values"):
-                    df2 = pd.DataFrame(selected_jd['keyterms'], columns=["keyword", "value"])
+                    df2 = pd.DataFrame(
+                        selected_jd["keyterms"], columns=["keyword", "value"]
+                    )
 
                     # Create the dictionary
                     keyword_dict = {}
-                    for keyword, value in selected_jd['keyterms']:
+                    for keyword, value in selected_jd["keyterms"]:
                         keyword_dict[keyword] = value * 100
 
-                    fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                                               font=dict(size=12, color="white"),
-                                                               fill_color='#1d2078'),
-                                                   cells=dict(values=[list(keyword_dict.keys()),
-                                                                      list(keyword_dict.values())],
-                                                              line_color='darkslategray',
-                                                              fill_color='#6DA9E4'))
-                                          ])
+                    fig = go.Figure(
+                        data=[
+                            go.Table(
+                                header=dict(
+                                    values=["Keyword", "Value"],
+                                    font=dict(size=12, color="white"),
+                                    fill_color="#1d2078",
+                                ),
+                                cells=dict(
+                                    values=[
+                                        list(keyword_dict.keys()),
+                                        list(keyword_dict.values()),
+                                    ],
+                                    line_color="darkslategray",
+                                    fill_color="#6DA9E4",
+                                ),
+                            )
+                        ]
+                    )
                     st.plotly_chart(fig, use_container_width=True)
 
+        # Treemaps
         with st.container():
             resumeCol, jobDescriptionCol = st.columns(2)
             with resumeCol:
                 with st.expander("Key Topics"):
-                    fig = px.treemap(df1, path=['keyword'], values='value',
-                                     color_continuous_scale='Rainbow',
-                                     title='Key Terms/Topics Extracted from your Resume')
+                    fig = px.treemap(
+                        df1,
+                        path=["keyword"],
+                        values="value",
+                        color_continuous_scale="Rainbow",
+                        title="Key Terms/Topics Extracted from your Resume",
+                    )
                     st.plotly_chart(fig, use_container_width=True)
 
             with jobDescriptionCol:
                 with st.expander("Key Topics"):
-                    fig = px.treemap(df2, path=['keyword'], values='value',
-                                     color_continuous_scale='Rainbow',
-                                     title='Key Terms/Topics Extracted from Job Description')
+                    fig = px.treemap(
+                        df2,
+                        path=["keyword"],
+                        values="value",
+                        color_continuous_scale="Rainbow",
+                        title="Key Terms/Topics Extracted from Job Description",
+                    )
                     st.plotly_chart(fig, use_container_width=True)
 
         avs.add_vertical_space(2)
-        config_file_path = config_path + "/config.yml"
-        if os.path.exists(config_file_path):
-            config_data = read_config(config_file_path)
-            if config_data:
-                print("Config file parsed successfully:")
-                resume_string = ' '.join(selected_file["extracted_keywords"])
-                jd_string = ' '.join(selected_jd["extracted_keywords"])
-                result = get_similarity_score(resume_string, jd_string)
-                similarity_score = round(result[0]["score"] * 100, 2)
-
-                # Default color to green
-                score_color = "green"
-                if similarity_score < 60:
-                    score_color = "red"
-                elif 60 <= similarity_score < 75:
-                    score_color = "orange"
-
-                st.markdown(f'Similarity Score obtained for the resume and job description is '
-                            f'<span style="color:{score_color};font-size:24px; font-weight:Bold">{similarity_score}</span>',
-                            unsafe_allow_html=True)
-        else:
-            print("Config file does not exist.")
+        st.markdown("#### Similarity Score")
+        print("Config file parsed successfully:")
+        resume_string = " ".join(selected_file["extracted_keywords"])
+        jd_string = " ".join(selected_jd["extracted_keywords"])
+        result = get_score(resume_string, jd_string)
+        similarity_score = round(result[0].score * 100, 2)
+
+        # Default color to green
+        score_color = "green"
+        if similarity_score < 60:
+            score_color = "red"
+        elif 60 <= similarity_score < 75:
+            score_color = "orange"
+
+        st.markdown(
+            f"Similarity Score obtained for the resume and job description is "
+            f'<span style="color:{score_color};font-size:24px; font-weight:Bold">{similarity_score}</span>',
+            unsafe_allow_html=True,
+        )
 
         avs.add_vertical_space(2)
         with st.expander("Common words between Resume and Job Description:"):
-            annotated_text(create_annotated_text(
-                selected_file["clean_data"], selected_jd["extracted_keywords"],
-                "JD", "#F24C3D"))
+            annotated_text(
+                create_annotated_text(
+                    selected_file["clean_data"],
+                    selected_jd["extracted_keywords"],
+                    "JD",
+                    "#F24C3D",
+                )
+            )
 
 st.divider()
 
 # Go back to top
-st.markdown('[:arrow_up: Back to Top](#resume-matcher)')
+st.markdown("[:arrow_up: Back to Top](#resume-matcher)")

streamlit_second.py

@@ -1,20 +1,26 @@
-import networkx as nx
+import json
 from typing import List
-import streamlit as st
+
+import networkx as nx
+import nltk
 import pandas as pd
-import json
 import plotly.express as px
 import plotly.graph_objects as go
-from scripts.utils import get_filenames_from_dir
-from streamlit_extras import add_vertical_space as avs
+import streamlit as st
 from annotated_text import annotated_text, parameters
+from streamlit_extras import add_vertical_space as avs
 from streamlit_extras.badges import badge
-import nltk
+
+from scripts.utils import get_filenames_from_dir
 
 # Set page configuration
-st.set_page_config(page_title='Resume Matcher', page_icon="Assets/img/favicon.ico", initial_sidebar_state='auto')
+st.set_page_config(
+    page_title="Resume Matcher",
+    page_icon="Assets/img/favicon.ico",
+    initial_sidebar_state="auto",
+)
 
-nltk.download('punkt')
+nltk.download("punkt")
 
 parameters.SHOW_LABEL_SEPARATOR = False
 parameters.BORDER_RADIUS = 3
@@ -32,7 +38,7 @@ def create_star_graph(nodes_and_weights, title):
     # Add nodes and edges with weights to the graph
     for node, weight in nodes_and_weights:
         G.add_node(node)
-        G.add_edge(central_node, node, weight=weight*100)
+        G.add_edge(central_node, node, weight=weight * 100)
 
     # Get position layout for nodes
     pos = nx.spring_layout(G)
@@ -46,8 +52,13 @@ def create_star_graph(nodes_and_weights, title):
         edge_x.extend([x0, x1, None])
         edge_y.extend([y0, y1, None])
 
-    edge_trace = go.Scatter(x=edge_x, y=edge_y, line=dict(
-        width=0.5, color='#888'), hoverinfo='none', mode='lines')
+    edge_trace = go.Scatter(
+        x=edge_x,
+        y=edge_y,
+        line=dict(width=0.5, color="#888"),
+        hoverinfo="none",
+        mode="lines",
+    )
 
     # Create node trace
     node_x = []
@@ -57,10 +68,26 @@ def create_star_graph(nodes_and_weights, title):
         node_x.append(x)
         node_y.append(y)
 
-    node_trace = go.Scatter(x=node_x, y=node_y, mode='markers', hoverinfo='text',
-                            marker=dict(showscale=True, colorscale='Rainbow', reversescale=True, color=[], size=10,
-                                        colorbar=dict(thickness=15, title='Node Connections', xanchor='left',
-                                                      titleside='right'), line_width=2))
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode="markers",
+        hoverinfo="text",
+        marker=dict(
+            showscale=True,
+            colorscale="Rainbow",
+            reversescale=True,
+            color=[],
+            size=10,
+            colorbar=dict(
+                thickness=15,
+                title="Node Connections",
+                xanchor="left",
+                titleside="right",
+            ),
+            line_width=2,
+        ),
+    )
 
     # Color node points by number of connections
     node_adjacencies = []
@@ -68,24 +95,32 @@ def create_star_graph(nodes_and_weights, title):
     for node in G.nodes():
         adjacencies = list(G.adj[node])  # changes here
         node_adjacencies.append(len(adjacencies))
-        node_text.append(f'{node}<br># of connections: {len(adjacencies)}')
+        node_text.append(f"{node}<br># of connections: {len(adjacencies)}")
 
     node_trace.marker.color = node_adjacencies
     node_trace.text = node_text
 
     # Create the figure
-    fig = go.Figure(data=[edge_trace, node_trace],
-                    layout=go.Layout(title=title, titlefont_size=16, showlegend=False,
-                                     hovermode='closest', margin=dict(b=20, l=5, r=5, t=40),
-                                     xaxis=dict(
-                                         showgrid=False, zeroline=False, showticklabels=False),
-                                     yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+    fig = go.Figure(
+        data=[edge_trace, node_trace],
+        layout=go.Layout(
+            title=title,
+            titlefont_size=16,
+            showlegend=False,
+            hovermode="closest",
+            margin=dict(b=20, l=5, r=5, t=40),
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        ),
+    )
 
     # Show the figure
     st.plotly_chart(fig)
 
 
-def create_annotated_text(input_string: str, word_list: List[str], annotation: str, color_code: str):
+def create_annotated_text(
+    input_string: str, word_list: List[str], annotation: str, color_code: str
+):
     # Tokenize the input string
     tokens = nltk.word_tokenize(input_string)
 
@@ -119,18 +154,26 @@ def tokenize_string(input_string):
 
 
 # Display the main title and subheaders
-st.title(':blue[Resume Matcher]')
+st.title(":blue[Resume Matcher]")
 with st.sidebar:
-    st.image('Assets/img/header_image.png')
-    st.subheader('Free and Open Source ATS to help your resume pass the screening stage.')
-    st.markdown('Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)')
-
-    st.markdown('Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)')
+    st.image("Assets/img/header_image.png")
+    st.subheader(
+        "Free and Open Source ATS to help your resume pass the screening stage."
+    )
+    st.markdown(
+        "Check the website [www.resumematcher.fyi](https://www.resumematcher.fyi/)"
+    )
+
+    st.markdown(
+        "Give Resume Matcher a ⭐ on [GitHub](https://github.com/srbhr/resume-matcher)"
+    )
 
     badge(type="github", name="srbhr/Resume-Matcher")
-    st.markdown('For updates follow me on Twitter.')
+    st.markdown("For updates follow me on Twitter.")
     badge(type="twitter", name="_srbhr_")
-    st.markdown('If you like the project and would like to further help in development please consider 👇')
+    st.markdown(
+        "If you like the project and would like to further help in development please consider 👇"
+    )
     badge(type="buymeacoffee", name="srbhr")
 
 st.divider()
@@ -138,16 +181,20 @@ avs.add_vertical_space(1)
 
 resume_names = get_filenames_from_dir("Data/Processed/Resumes")
 
-output = st.selectbox(f"There are {len(resume_names)} resumes present. Please select one from the menu below:", resume_names)
+output = st.selectbox(
+    f"There are {len(resume_names)} resumes present. Please select one from the menu below:",
+    resume_names,
+)
 
 avs.add_vertical_space(5)
 
-selected_file = read_json("Data/Processed/Resumes/"+output)
+selected_file = read_json("Data/Processed/Resumes/" + output)
 
 avs.add_vertical_space(2)
 st.markdown("#### Parsed Resume Data")
 st.caption(
-    "This text is parsed from your resume. This is how it'll look like after getting parsed by an ATS.")
+    "This text is parsed from your resume. This is how it'll look like after getting parsed by an ATS."
+)
 st.caption("Utilize this to understand how to make your resume ATS friendly.")
 avs.add_vertical_space(3)
 # st.json(selected_file)
@@ -156,92 +203,122 @@ st.write(selected_file["clean_data"])
 avs.add_vertical_space(3)
 st.write("Now let's take a look at the extracted keywords from the resume.")
 
-annotated_text(create_annotated_text(
-    selected_file["clean_data"], selected_file["extracted_keywords"],
-    "KW", "#0B666A"))
+annotated_text(
+    create_annotated_text(
+        selected_file["clean_data"],
+        selected_file["extracted_keywords"],
+        "KW",
+        "#0B666A",
+    )
+)
 
 avs.add_vertical_space(5)
 st.write("Now let's take a look at the extracted entities from the resume.")
 
 # Call the function with your data
-create_star_graph(selected_file['keyterms'], "Entities from Resume")
+create_star_graph(selected_file["keyterms"], "Entities from Resume")
 
-df2 = pd.DataFrame(selected_file['keyterms'], columns=["keyword", "value"])
+df2 = pd.DataFrame(selected_file["keyterms"], columns=["keyword", "value"])
 
 # Create the dictionary
 keyword_dict = {}
-for keyword, value in selected_file['keyterms']:
-    keyword_dict[keyword] = value*100
-
-fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                           font=dict(size=12),
-                                           fill_color='#070A52'),
-                               cells=dict(values=[list(keyword_dict.keys()),
-                                                  list(keyword_dict.values())],
-                                          line_color='darkslategray',
-                                          fill_color='#6DA9E4'))
-                      ])
+for keyword, value in selected_file["keyterms"]:
+    keyword_dict[keyword] = value * 100
+
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Keyword", "Value"], font=dict(size=12), fill_color="#070A52"
+            ),
+            cells=dict(
+                values=[list(keyword_dict.keys()), list(keyword_dict.values())],
+                line_color="darkslategray",
+                fill_color="#6DA9E4",
+            ),
+        )
+    ]
+)
 st.plotly_chart(fig)
 
 st.divider()
 
-fig = px.treemap(df2, path=['keyword'], values='value',
-                 color_continuous_scale='Rainbow',
-                 title='Key Terms/Topics Extracted from your Resume')
+fig = px.treemap(
+    df2,
+    path=["keyword"],
+    values="value",
+    color_continuous_scale="Rainbow",
+    title="Key Terms/Topics Extracted from your Resume",
+)
 st.write(fig)
 
 avs.add_vertical_space(5)
 
 job_descriptions = get_filenames_from_dir("Data/Processed/JobDescription")
 
-output = st.selectbox(f"There are {len(job_descriptions)} job descriptions present. Please select one from the menu below:", job_descriptions)
+output = st.selectbox(
+    f"There are {len(job_descriptions)} job descriptions present. Please select one from the menu below:",
+    job_descriptions,
+)
 
 avs.add_vertical_space(5)
 
-selected_jd = read_json(
-    "Data/Processed/JobDescription/"+output)
+selected_jd = read_json("Data/Processed/JobDescription/" + output)
 
 avs.add_vertical_space(2)
 st.markdown("#### Job Description")
 st.caption(
-    "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste.")
+    "Currently in the pipeline I'm parsing this from PDF but it'll be from txt or copy paste."
+)
 avs.add_vertical_space(3)
 # st.json(selected_file)
 st.write(selected_jd["clean_data"])
 
 st.markdown("#### Common Words between Job Description and Resumes Highlighted.")
 
-annotated_text(create_annotated_text(
-    selected_file["clean_data"], selected_jd["extracted_keywords"],
-    "JD", "#F24C3D"))
+annotated_text(
+    create_annotated_text(
+        selected_file["clean_data"], selected_jd["extracted_keywords"], "JD", "#F24C3D"
+    )
+)
 
 st.write("Now let's take a look at the extracted entities from the job description.")
 
 # Call the function with your data
-create_star_graph(selected_jd['keyterms'], "Entities from Job Description")
+create_star_graph(selected_jd["keyterms"], "Entities from Job Description")
 
-df2 = pd.DataFrame(selected_jd['keyterms'], columns=["keyword", "value"])
+df2 = pd.DataFrame(selected_jd["keyterms"], columns=["keyword", "value"])
 
 # Create the dictionary
 keyword_dict = {}
-for keyword, value in selected_jd['keyterms']:
-    keyword_dict[keyword] = value*100
-
-fig = go.Figure(data=[go.Table(header=dict(values=["Keyword", "Value"],
-                                           font=dict(size=12),
-                                           fill_color='#070A52'),
-                               cells=dict(values=[list(keyword_dict.keys()),
-                                                  list(keyword_dict.values())],
-                                          line_color='darkslategray',
-                                          fill_color='#6DA9E4'))
-                      ])
+for keyword, value in selected_jd["keyterms"]:
+    keyword_dict[keyword] = value * 100
+
+fig = go.Figure(
+    data=[
+        go.Table(
+            header=dict(
+                values=["Keyword", "Value"], font=dict(size=12), fill_color="#070A52"
+            ),
+            cells=dict(
+                values=[list(keyword_dict.keys()), list(keyword_dict.values())],
+                line_color="darkslategray",
+                fill_color="#6DA9E4",
+            ),
+        )
+    ]
+)
 st.plotly_chart(fig)
 
 st.divider()
 
-fig = px.treemap(df2, path=['keyword'], values='value',
-                 color_continuous_scale='Rainbow',
-                 title='Key Terms/Topics Extracted from the selected Job Description')
+fig = px.treemap(
+    df2,
+    path=["keyword"],
+    values="value",
+    color_continuous_scale="Rainbow",
+    title="Key Terms/Topics Extracted from the selected Job Description",
+)
 st.write(fig)
 
 avs.add_vertical_space(5)
@@ -252,69 +329,135 @@ st.markdown("## Vector Similarity Scores")
 st.caption("Powered by Qdrant Vector Search")
 st.info("These are pre-computed queries", icon="ℹ")
 st.warning(
-    "Running Qdrant or Sentence Transformers without having capacity is not recommended", icon="⚠")
+    "Running Qdrant or Sentence Transformers without having capacity is not recommended",
+    icon="⚠",
+)
 
 
 # Your data
 data = [
-    {'text': "{'resume': 'Alfred Pennyworth",
-        'query': 'Job Description Product Manager', 'score': 0.62658},
-    {'text': "{'resume': 'Barry Allen",
-        'query': 'Job Description Product Manager', 'score': 0.43777737},
-    {'text': "{'resume': 'Bruce Wayne ",
-        'query': 'Job Description Product Manager', 'score': 0.39835533},
-    {'text': "{'resume': 'JOHN DOE",
-        'query': 'Job Description Product Manager', 'score': 0.3915512},
-    {'text': "{'resume': 'Harvey Dent",
-        'query': 'Job Description Product Manager', 'score': 0.3519544},
-    {'text': "{'resume': 'Barry Allen",
-        'query': 'Job Description Senior Full Stack Engineer', 'score': 0.6541866},
-    {'text': "{'resume': 'Alfred Pennyworth",
-        'query': 'Job Description Senior Full Stack Engineer', 'score': 0.59806436},
-    {'text': "{'resume': 'JOHN DOE",
-        'query': 'Job Description Senior Full Stack Engineer', 'score': 0.5951386},
-    {'text': "{'resume': 'Bruce Wayne ",
-        'query': 'Job Description Senior Full Stack Engineer', 'score': 0.57700855},
-    {'text': "{'resume': 'Harvey Dent",
-        'query': 'Job Description Senior Full Stack Engineer', 'score': 0.38489106},
-    {'text': "{'resume': 'Barry Allen",
-        'query': 'Job Description Front End Engineer', 'score': 0.76813436},
-    {'text': "{'resume': 'Bruce Wayne'",
-        'query': 'Job Description Front End Engineer', 'score': 0.60440844},
-    {'text': "{'resume': 'JOHN DOE",
-        'query': 'Job Description Front End Engineer', 'score': 0.56080043},
-    {'text': "{'resume': 'Alfred Pennyworth",
-        'query': 'Job Description Front End Engineer', 'score': 0.5395049},
-    {'text': "{'resume': 'Harvey Dent",
-        'query': 'Job Description Front End Engineer', 'score': 0.3859515},
-    {'text': "{'resume': 'JOHN DOE",
-        'query': 'Job Description Java Developer', 'score': 0.5449441},
-    {'text': "{'resume': 'Alfred Pennyworth",
-        'query': 'Job Description Java Developer', 'score': 0.53476423},
-    {'text': "{'resume': 'Barry Allen",
-        'query': 'Job Description Java Developer', 'score': 0.5313871},
-    {'text': "{'resume': 'Bruce Wayne ",
-        'query': 'Job Description Java Developer', 'score': 0.44446343},
-    {'text': "{'resume': 'Harvey Dent",
-        'query': 'Job Description Java Developer', 'score': 0.3616274}
+    {
+        "text": "{'resume': 'Alfred Pennyworth",
+        "query": "Job Description Product Manager",
+        "score": 0.62658,
+    },
+    {
+        "text": "{'resume': 'Barry Allen",
+        "query": "Job Description Product Manager",
+        "score": 0.43777737,
+    },
+    {
+        "text": "{'resume': 'Bruce Wayne ",
+        "query": "Job Description Product Manager",
+        "score": 0.39835533,
+    },
+    {
+        "text": "{'resume': 'JOHN DOE",
+        "query": "Job Description Product Manager",
+        "score": 0.3915512,
+    },
+    {
+        "text": "{'resume': 'Harvey Dent",
+        "query": "Job Description Product Manager",
+        "score": 0.3519544,
+    },
+    {
+        "text": "{'resume': 'Barry Allen",
+        "query": "Job Description Senior Full Stack Engineer",
+        "score": 0.6541866,
+    },
+    {
+        "text": "{'resume': 'Alfred Pennyworth",
+        "query": "Job Description Senior Full Stack Engineer",
+        "score": 0.59806436,
+    },
+    {
+        "text": "{'resume': 'JOHN DOE",
+        "query": "Job Description Senior Full Stack Engineer",
+        "score": 0.5951386,
+    },
+    {
+        "text": "{'resume': 'Bruce Wayne ",
+        "query": "Job Description Senior Full Stack Engineer",
+        "score": 0.57700855,
+    },
+    {
+        "text": "{'resume': 'Harvey Dent",
+        "query": "Job Description Senior Full Stack Engineer",
+        "score": 0.38489106,
+    },
+    {
+        "text": "{'resume': 'Barry Allen",
+        "query": "Job Description Front End Engineer",
+        "score": 0.76813436,
+    },
+    {
+        "text": "{'resume': 'Bruce Wayne'",
+        "query": "Job Description Front End Engineer",
+        "score": 0.60440844,
+    },
+    {
+        "text": "{'resume': 'JOHN DOE",
+        "query": "Job Description Front End Engineer",
+        "score": 0.56080043,
+    },
+    {
+        "text": "{'resume': 'Alfred Pennyworth",
+        "query": "Job Description Front End Engineer",
+        "score": 0.5395049,
+    },
+    {
+        "text": "{'resume': 'Harvey Dent",
+        "query": "Job Description Front End Engineer",
+        "score": 0.3859515,
+    },
+    {
+        "text": "{'resume': 'JOHN DOE",
+        "query": "Job Description Java Developer",
+        "score": 0.5449441,
+    },
+    {
+        "text": "{'resume': 'Alfred Pennyworth",
+        "query": "Job Description Java Developer",
+        "score": 0.53476423,
+    },
+    {
+        "text": "{'resume': 'Barry Allen",
+        "query": "Job Description Java Developer",
+        "score": 0.5313871,
+    },
+    {
+        "text": "{'resume': 'Bruce Wayne ",
+        "query": "Job Description Java Developer",
+        "score": 0.44446343,
+    },
+    {
+        "text": "{'resume': 'Harvey Dent",
+        "query": "Job Description Java Developer",
+        "score": 0.3616274,
+    },
 ]
 
 # Create a DataFrame
 df = pd.DataFrame(data)
 
 # Create different DataFrames based on the query and sort by score
-df1 = df[df['query'] ==
-         'Job Description Product Manager'].sort_values(by='score', ascending=False)
-df2 = df[df['query'] ==
-         'Job Description Senior Full Stack Engineer'].sort_values(by='score', ascending=False)
-df3 = df[df['query'] == 'Job Description Front End Engineer'].sort_values(
-    by='score', ascending=False)
-df4 = df[df['query'] == 'Job Description Java Developer'].sort_values(
-    by='score', ascending=False)
+df1 = df[df["query"] == "Job Description Product Manager"].sort_values(
+    by="score", ascending=False
+)
+df2 = df[df["query"] == "Job Description Senior Full Stack Engineer"].sort_values(
+    by="score", ascending=False
+)
+df3 = df[df["query"] == "Job Description Front End Engineer"].sort_values(
+    by="score", ascending=False
+)
+df4 = df[df["query"] == "Job Description Java Developer"].sort_values(
+    by="score", ascending=False
+)
 
 
 def plot_df(df, title):
-    fig = px.bar(df, x='text', y=df['score']*100, title=title)
+    fig = px.bar(df, x="text", y=df["score"] * 100, title=title)
     st.plotly_chart(fig)
 
 
@@ -328,13 +471,13 @@ st.text("Bruce Wayne :  Fullstack Developer (MERN)")
 st.text("John Doe :  Fullstack Developer (Java)")
 
 
-plot_df(df1, 'Job Description Product Manager 10+ Years of Exper')
-plot_df(df2, 'Job Description Senior Full Stack Engineer 5+ Year')
-plot_df(df3, 'Job Description Front End Engineer 2 Years of Expe')
-plot_df(df4, 'Job Description Java Developer 3 Years of Experien')
+plot_df(df1, "Job Description Product Manager 10+ Years of Exper")
+plot_df(df2, "Job Description Senior Full Stack Engineer 5+ Year")
+plot_df(df3, "Job Description Front End Engineer 2 Years of Expe")
+plot_df(df4, "Job Description Java Developer 3 Years of Experien")
 
 
 avs.add_vertical_space(3)
 
 # Go back to top
-st.markdown('[:arrow_up: Back to Top](#resume-matcher)')
+st.markdown("[:arrow_up: Back to Top](#resume-matcher)")