Made Interface search as a separate tab

Author: rachelse

backend/alignment.go

@@ -562,6 +562,13 @@ func ComplexAlignments(id Id, entry []uint32, databases []string, jobsbase strin
 	return ReadAlignments[ComplexAlignmentEntry, uint32](id, entry, databases, jobsbase)
 }
 
+type InterfaceAlignmentEntry = ComplexAlignmentEntry
+
+func InterfaceAlignments(id Id, entry []uint32, databases []string, jobsbase string) ([]SearchResult, error) {
+	return ReadAlignments[InterfaceAlignmentEntry, uint32](id, entry, databases, jobsbase)
+}
+
+
 func FoldDiscoAlignments(id Id, databases []string, jobsbase string) ([]FoldDiscoResult, error) {
 	return ReadFoldDisco(id, databases, jobsbase)
 }

backend/interfacesearchjob.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+	"os"
+	"sort"
+	"strings"
+)
+
+type InterfaceSearchJob struct {
+	Size      int      `json:"size" validate:"required"`
+	Database  []string `json:"database" validate:"required"`
+	Mode      string   `json:"mode" validate:"oneof=3di tmalign 3diaa lolalign"`
+	TaxFilter string   `json:"taxfilter"`
+	query     string
+}
+
+func (r InterfaceSearchJob) Hash() Id {
+	h := sha256.New224()
+	h.Write(([]byte)(JobInterfaceSearch))
+	h.Write([]byte(r.query))
+	h.Write([]byte(r.Mode))
+	if r.TaxFilter != "" {
+		h.Write([]byte(r.TaxFilter))
+	}
+
+	sort.Strings(r.Database)
+
+	for _, value := range r.Database {
+		h.Write([]byte(value))
+	}
+
+	bs := h.Sum(nil)
+	return Id(base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(bs))
+}
+
+func (r InterfaceSearchJob) Rank() float64 {
+	return float64(r.Size * max(len(r.Database), 1))
+}
+
+func (r InterfaceSearchJob) WritePDB(path string) error {
+	err := os.WriteFile(path, []byte(r.query), 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func NewInterfaceSearchJobRequest(query string, dbs []string, validDbs []Params, mode string, resultPath string, email string, taxfilter string) (JobRequest, error) {
+	job := InterfaceSearchJob{
+		max(strings.Count(query, "HEADER"), 1),
+		dbs,
+		mode,
+		taxfilter,
+		query,
+	}
+
+	request := JobRequest{
+		job.Hash(),
+		StatusPending,
+		JobInterfaceSearch,
+		job,
+		email,
+	}
+
+	ids := make([]string, 0)
+	for _, item := range validDbs {
+		if item.Interface {
+			ids = append(ids, item.Path)
+		}
+	}
+
+	for _, item := range job.Database {
+		idx := isIn(item, ids)
+		if idx == -1 {
+			return request, errors.New("selected databases are not valid")
+		}
+	}
+
+	if !validTaxonFilter(taxfilter) {
+		return request, errors.New("invalid taxon filter")
+	}
+
+	return request, nil
+}

backend/jobsystem.go

@@ -25,6 +25,7 @@ const (
 	JobPair            JobType = "pair"
 	JobStructureSearch JobType = "structuresearch"
 	JobComplexSearch   JobType = "complexsearch"
+	JobInterfaceSearch JobType = "interfacesearch"
 	JobFoldMasonMSA    JobType = "foldmasoneasymsa"
 	JobFoldDisco       JobType = "folddisco"
 )
@@ -70,6 +71,13 @@ func (m *JobRequest) UnmarshalJSON(b []byte) error {
 		}
 		(*m).Job = j
 		return nil
+	case JobInterfaceSearch:
+		var j InterfaceSearchJob
+		if err := json.Unmarshal(msg, &j); err != nil {
+			return err
+		}
+		(*m).Job = j
+		return nil
 	case JobIndex:
 		var j IndexJob
 		if err := json.Unmarshal(msg, &j); err != nil {
@@ -127,6 +135,11 @@ func (m *JobRequest) WriteSupportFiles(base string) error {
 			return j.WritePDB(filepath.Join(base, "job.pdb"))
 		}
 		return errors.New("invalid job type")
+	case JobInterfaceSearch:
+		if j, ok := m.Job.(InterfaceSearchJob); ok {
+			return j.WritePDB(filepath.Join(base, "job.pdb"))
+		}
+		return errors.New("invalid job type")
 	case JobMsa:
 		if j, ok := m.Job.(MsaJob); ok {
 			return j.WriteFasta(filepath.Join(base, "job.fasta"))

backend/server.go

@@ -326,8 +326,12 @@ func server(jobsystem JobSystem, config ConfigRoot) {
 			request, err = NewSearchJobRequest(query, dbs, databases, mode, config.Paths.Results, email, taxfilter)
 		} else if config.App == AppFoldseek {
 			modes := strings.Split(mode, "-")
+			interfaceIdx := isIn("interface", modes)
 			modeIdx := isIn("complex", modes)
-			if modeIdx != -1 {
+			if interfaceIdx != -1 {
+				modeWithoutInterface := strings.Join(append(modes[:interfaceIdx], modes[interfaceIdx+1:]...), "-")
+				request, err = NewInterfaceSearchJobRequest(query, dbs, databases, modeWithoutInterface, config.Paths.Results, email, taxfilter)
+			} else if modeIdx != -1 {
 				modeWithoutComplex := strings.Join(append(modes[:modeIdx], modes[modeIdx+1:]...), "-")
 				request, err = NewComplexSearchJobRequest(query, dbs, databases, modeWithoutComplex, config.Paths.Results, email, taxfilter)
 			} else {
@@ -1092,6 +1096,38 @@ func server(jobsystem JobSystem, config ConfigRoot) {
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return
 			}
+		case InterfaceSearchJob:
+			mode = job.Mode
+			result, err := Lookup(ticket.Id, 0, math.MaxInt32, config.Paths.Results, false)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			keys := make([]uint32, 0)
+			for _, lookup := range result.Lookup {
+				if lookup.Set == uint32(id) {
+					keys = append(keys, uint32(lookup.Id))
+				}
+			}
+			isFoldseek = true
+			databases := job.Database
+			if database != "" {
+				if isIn(database, job.Database) == -1 {
+					http.Error(w, "Database not found", http.StatusBadRequest)
+					return
+				}
+				databases = []string{database}
+			}
+			results, err = InterfaceAlignments(ticket.Id, keys, databases, config.Paths.Results)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			fasta, err = ReadQueryByKeys(ticket.Id, keys, config.Paths.Results)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
 		default:
 			http.Error(w, "Invalid job type", http.StatusBadRequest)
 			return
@@ -1135,7 +1171,7 @@ func server(jobsystem JobSystem, config ConfigRoot) {
 							cnt++
 						}
 					}
-				case [][]ComplexAlignmentEntry:
+				case [][]ComplexAlignmentEntry: // Handle both ComplexSearchJob and InterfaceSearchJob
 					if resIndex == -1 {
 						for _, inner := range conv {
 							for i := range inner {