add forced technologies

app.py

@@ -1,6 +1,6 @@
 from fastapi import FastAPI
-from pydantic import BaseModel
-from typing import Dict, List
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional
 import gradio as gr
 import pandas as pd
 import json
@@ -18,13 +18,6 @@ app = FastAPI(
     description="Find relevant technologies from a problem",
 )
 
-class InputProblem(BaseModel):
-    problem: str
-
-class InputConstraints(BaseModel):
-    constraints: Dict[str, str]
-    
-# This schema defines the structure for a single technology object
 class Technology(BaseModel):
     """Represents a single technology entry with its details."""
     name: str
@@ -34,6 +27,14 @@ class Technology(BaseModel):
     limitations: str
     domain_tags: str
 
+class InputProblem(BaseModel):
+    problem: str
+    forced_technologies: Optional[List[str]] = Field(default=None)
+
+class InputConstraints(BaseModel):
+    constraints: Dict[str, str]
+    forced_technologies: Optional[List[str]] = Field(default=None)
+    
 class OutputPriorArt(BaseModel):
     """Represents the search of prior art using the technology combinations"""
     content: str
@@ -60,7 +61,7 @@ async def process(data: InputProblem):
 
 @app.post("/process-constraints", response_model=TechnologyData)
 async def process_constraints(constraints: InputConstraints):
-    result= process_input(constraints.constraints, dataset, "constraints")
+    result= process_input(constraints, dataset, "constraints")
     return {"technologies": result}
 
 @app.post("/prior-art-constraints", response_model=OutputPriorArt)
@@ -73,6 +74,7 @@ async def prior_art_problems(data: InputPriorArtProblem):
     prior_art = process_prior_art(data.technologies, data.problem, "problem", "pydantic")
     return prior_art
 
+
 def make_json_serializable(data):
     if isinstance(data, dict):
         return {k: make_json_serializable(v) for k, v in data.items()}

src/core.py

@@ -5,12 +5,13 @@ dataset = load_data()
 
 
 def process_input(data, dataset, data_type):
+    print(data)
     if data_type == "problem":
         prompt = set_prompt(data.problem)
         constraints = retrieve_constraints(prompt)
     
     elif data_type == "constraints":
-        constraints = data
+        constraints = data.constraints
         
     constraints_stemmed = stem(constraints, "constraints")
     
@@ -18,8 +19,15 @@ def process_input(data, dataset, data_type):
     
     save_to_pickle(result_similarities)
     
+    if data.forced_technologies:
+        forced_technologies = search_technology_by_name(data.forced_technologies, dataset)
+        res,forced_matrix = get_contrastive_similarities(constraints_stemmed, dataset)
+        forced_combination = find_best_list_combinations(constraints_stemmed, forced_technologies, forced_matrix)
+    else:
+        forced_combination = []
+
     best_combinations = find_best_list_combinations(constraints_stemmed, dataset, matrix)
-    best_technologies_id = select_technologies(best_combinations)
+    best_technologies_id = select_technologies(best_combinations, forced_combination)
     best_technologies = get_technologies_by_id(best_technologies_id, dataset)
     
     return best_technologies

src/services/processor.py

@@ -4,6 +4,8 @@ import json
 import nltk
 import itertools
 import numpy as np
+import requests
+from datasets import concatenate_datasets
 
 from sentence_transformers import *
 model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
@@ -79,6 +81,8 @@ def find_best_list_combinations(list1: list[str], list2: list[str], matrix) -> l
         print("Warning: One or both input lists are empty. Returning an empty list.")
         return []
 
+    print(list2)
+
     MIN_SIMILARITY = 0.3
     MAX_SIMILARITY = 0.8
 
@@ -88,12 +92,11 @@ def find_best_list_combinations(list1: list[str], list2: list[str], matrix) -> l
         for j, row_j in enumerate(list2):
             score = matrix[i][j]
 
-            # print(row_j)
-            # print(type(row_j))
             if MIN_SIMILARITY <= score <= MAX_SIMILARITY:
-                del row_j["embeddings"]
-                row_j["id"] = j
-                valid_matches_for_l1_element.append((row_j, score))
+                data = row_j
+                del data["embeddings"]
+                data["id"] = j
+                valid_matches_for_l1_element.append((data, score))
 
         if not valid_matches_for_l1_element:
             print(f"No valid matches found in list2 for '{row_i}' from list1 "
@@ -119,18 +122,53 @@ def find_best_list_combinations(list1: list[str], list2: list[str], matrix) -> l
     result = remove_over_repeated_technologies(result)
     return result
 
-
-def select_technologies(problem_technology_list):
+def search_technology_by_name(user_input, dataset):
+    url = "https://heymenn-search-technologies-api.hf.space/search-technologies"
+
+    headers = {
+        "accept": "application/json",
+        "Content-Type": "application/json"
+    }
+
+    results = []
+    for input in user_input:
+        payload = {
+            "title": input,
+            "type": "title"
+        }
+        response = requests.post(url, headers=headers, json=payload)
+        print(response.json())
+        results.append(response.json())
+    
+    technologies = []
+    for result in results:
+        technology = dataset.filter(lambda row: row["name"] == result["title"])
+        technologies.append(technology)
+
+    combined_dataset = concatenate_datasets(technologies)
+    return combined_dataset
+
+
+def select_technologies(problem_technology_list, forced_technology_list=[]):
     distinct_techs = set()
     candidate_map = []
 
+    if len(forced_technology_list) == 0:
+        for problem_data in forced_technology_list:
+                cand_dict = {}
+                for tech_info, sim in problem_data['technologies']:
+                    tech_id = tech_info['id']
+                    distinct_techs.add(tech_id)
+                    cand_dict[tech_id] = float(sim)
+
     for problem_data in problem_technology_list:
         cand_dict = {}
         for tech_info, sim in problem_data['technologies']:
             tech_id = tech_info['id']
             distinct_techs.add(tech_id)
             cand_dict[tech_id] = float(sim)
-        candidate_map.append(cand_dict)
+        if cand_dict not in candidate_map:
+            candidate_map.append(cand_dict)
 
     distinct_techs = sorted(list(distinct_techs))
     n = len(problem_technology_list)
@@ -242,7 +280,6 @@ def add_citations_and_collect_uris(response):
                 for i in support.grounding_chunk_indices:
                     if i < len(chunks):
                         uri = chunks[i].web.uri
-                        # Add URI only if not already in text or collected
                         if uri not in text and uri not in uris_added:
                             citation_links.append(f"[{i + 1}]({uri})")
                             uris_added.add(uri)