christophersw/MemoryLane - Change Q4SPNTHA2FEZZHWBKAGTIW2ODRMRTIA2JZST7YMUH2KSLZUD26CQC

Basic captioning inplace.

Created by christophersw on January 5, 2022

Q4SPNTHA2FEZZHWBKAGTIW2ODRMRTIA2JZST7YMUH2KSLZUD26CQC

Dependencies

In channels

main

test

In discussions

#1 Basic Captioning

#2 Caption formatting #v1

Change contents

Deletion in web/search/results.go at line 6 [3.20396]
B:BD[3.20441] → [3.20441:20449]
```
	"sort"
```

Deletion in web/search/results.go at line 44 [3.20396]

B:BD[3.21377] → [3.21377:21488]

	sort.SliceStable(photos, func(i, j int) bool {
		return photos[i].DateTaken.After((photos[j].DateTaken))
	})

Insertion in data/wordSearch.go at line 2 [3.277673]

[3.277687]


import (
	"sort"
	"devt.de/krotik/eliasdb/graph"
)
func RankedWordSearch(terms []string, idx graph.IndexQuery) (RankedResultList, error) {
	termResults := []map[string][]uint64{}
	scoredResults := map[string]uint64{}
	// Search for each term, build a list of postion results and scaffold scoring map.
	for _, term := range terms {
		tResult, err := idx.LookupWord("text", term)
		if err != nil {
			return nil, err
		}
		if len(tResult) > 0 {
			termResults = append(termResults, tResult)
			for nodeId := range tResult {
				scoredResults[nodeId] = 0
			}
		}
	}

Replacement in data/wordSearch.go at line 28 [3.277673]

B:BD[3.277688] → [3.277688:277702]

import "sort"

[3.277688]

[3.277702]

	for i := 0; i < len(termResults)-1; i++ {
		scores := leastTermDistance(termResults[i], termResults[i+1])
		for k, v := range scores {
			scoredResults[k] = scoredResults[k] + v
		}
	}

Replacement in data/wordSearch.go at line 35 [3.277673]
B:BD[3.277703] → [3.277703:277751]
```
type Result struct {
	Key   string
	Score int
}
```
[3.277703]
[3.277751]
```
	sortableList := make(RankedResultList, len(scoredResults))
```

Replacement in data/wordSearch.go at line 37 [3.277673]

B:BD[3.277752] → [3.277752:277780]

type SearchResults []Result

[3.277752]

[3.277780]

	i := 0
	for k, v := range scoredResults {
		sortableList[i] = RankedResult{k, v}
		i++
	}
	sort.Sort(sortableList)

Replacement in data/wordSearch.go at line 44 [3.277673]
B:BD[3.277781] → [3.277781:277858]
```
func (r SearchResults) Less(i, j int) bool {
	return r[i].Score > r[j].Score
```
[3.277781]
[3.277858]
```
	return sortableList, nil
```
Replacement in data/wordSearch.go at line 47 [3.277673]
B:BD[3.277861] → [3.277861:277911]
```
func (r SearchResults) Len() int {
	return len(r)
```
[3.277861]
[3.277911]
```
type RankedResult struct {
	NodeId string
	Score  uint64
```
Insertion in data/wordSearch.go at line 51 [3.277673]
[3.277913]
[3.277913]
```
type RankedResultList []RankedResult
```

Replacement in data/wordSearch.go at line 54 [3.277673]

B:BD[3.277914] → [3.277914:277981]

func (r SearchResults) Swap(i, j int) {
	r[i], r[j] = r[j], r[i]
}

[3.277914]

[3.277981]

func (s RankedResultList) Less(i, j int) bool { return s[i].Score < s[j].Score }
func (p RankedResultList) Len() int           { return len(p) }
func (p RankedResultList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

Replacement in data/wordSearch.go at line 58 [3.277673]

B:BD[3.277982] → [3.277982:278138]

func ResultsFromMap(m map[string][]uint64) SearchResults {
	var results SearchResults
	for k, v := range m {
		results = append(results, Result{k, len(v)})

[3.277982]

[3.278138]

func leastTermDistance(aResults map[string][]uint64, bResults map[string][]uint64) map[string]uint64 {
	// create a map of the scores for each node
	scores := map[string]uint64{}
	localB := map[string][]uint64{}
	for nodeId, v := range bResults {
		localB[nodeId] = v

Deletion in data/wordSearch.go at line 66 [3.277673]
B:BD[3.278141] → [3.278141:278159]
```
	return results
}
```

Replacement in data/wordSearch.go at line 67 [3.277673]

B:BD[3.278160] → [3.278160:278206]

func (r SearchResults) Sort() {
	sort.Sort(r)

[3.278160]

[3.278206]

	// loop through the nodes in term A
	for nodeId, aPositions := range aResults {
		var shortestDistance uint64 = 99
		bPositions := localB[nodeId]
		if len(bPositions) > 0 {
			for _, aPosition := range aPositions {
				for _, bPosition := range bPositions {
					distance := absDiff(aPosition, bPosition)
					if distance < shortestDistance {
						shortestDistance = distance
					}
				}
			}
		}
		delete(localB, nodeId)
		scores[nodeId] = shortestDistance
	}
	for nodeId := range localB {
		scores[nodeId] = 100
	}
	return scores

Replacement in data/wordSearch.go at line 92 [3.277673]

B:BD[3.278209] → [3.278209:278391]

func GetSortedResultKeys(m map[string][]uint64) []string {
	results := ResultsFromMap(m)
	results.Sort()
	var keys []string
	for _, r := range results {
		keys = append(keys, r.Key)

[3.278209]

[3.278391]

func absDiff(x, y uint64) uint64 {
	if x < y {
		return y - x

Replacement in data/wordSearch.go at line 96 [3.277673]
B:BD[3.278394] → [3.278394:278407]
```
	return keys
```
[3.278394]
[3.278407]
```
	return x - y
```

Replacement in data/search.go at line 192 [3.293204]

B:BD[3.297532] → [2.0:120]

		// if len(searchTerms) == 0 {
		// 	return nil, errors.New("Caption search requires at least one search term")
		// }

[3.297532]

[3.297643]

		if len(searchTerms) == 0 {
			return nil, errors.New("Caption search requires at least one search term")
		}

Replacement in data/search.go at line 196 [3.293204]

B:BD[3.297644] → [2.121:251]

		// captions, err := SearchCaptions(strings.Join(searchTerms, " "), gm, gpart)
		// if err != nil {
		// 	return nil, err
		// }

[3.297644]

[3.297762]

		captions, err := SearchCaptions(searchTerms, gm, gpart)
		if err != nil {
			return nil, err
		}

Replacement in data/search.go at line 201 [3.293204]

B:BD[3.297763] → [2.252:482]

		// // Go through the captions and get captioned items
		// for _, caption := range captions {
		// 	item := caption.CaptionedItem
		// 	if err != nil {
		// 		return nil, err
		// 	}
		// 	results = append(results, item)
		// }

[3.297763]

[3.297969]

		// Go through the captions and get captioned items
		for _, caption := range captions {
			item := caption.CaptionedItem
			if err != nil {
				return nil, err
			}
			results = append(results, item)
		}

Insertion in data/dates.go at line 5 [3.370859]
[3.370890]
[3.370890]
```
	"sort"
```
Insertion in data/dates.go at line 7 [3.370859]
[3.370901]
[3.370901]
```
	"time"
```

Replacement in data/dates.go at line 141 [3.370859]

B:BD[3.374000] → [3.374000:374076]

	query += "traverse month:taken:type: end show 2:n:kind, 2:n:key, 2:n:name"

[3.374000]

[3.374076]

	query += "traverse month:taken:type: end show 2:n:kind, 2:n:key, 2:n:name, 2:n:date_taken"

Replacement in data/dates.go at line 151 [3.370859]

B:BD[3.374287] → [3.374287:374320]

	results := make([]GraphNode, 0)

[3.374287]

[3.374320]

	type searchResults struct {
		Key       string
		Kind      string
		Name      string
		DateTaken time.Time
	}
	results := make([]searchResults, 0)

Insertion in data/dates.go at line 161 [3.370859]

[3.374353]

		result := searchResults{
			Kind:      r[0].(string),
			Key:       r[1].(string),
			Name:      r[2].(string),
			DateTaken: time.Unix(r[3].(int64), 0),
		}
		results = append(results, result)
	}
	// Sort results by date taken
	sort.SliceStable(results, func(i, j int) bool {
		return results[i].DateTaken.After((results[j].DateTaken))
	})
	var nodes []GraphNode
	for _, result := range results {

Replacement in data/dates.go at line 179 [3.370859]

B:BD[3.374374] → [3.374374:374446]

			Kind: r[0].(string),
			Key:  r[1].(string),
			Name: r[2].(string),

[3.374374]

[3.374446]

			Key:  result.Key,
			Kind: result.Kind,
			Name: result.Name,

Replacement in data/dates.go at line 183 [3.370859]
B:BD[3.374450] → [3.374450:374484]
```
		results = append(results, node)
```
[3.374450]
[3.374484]
```
		nodes = append(nodes, node)
```
Replacement in data/dates.go at line 188 [3.370859]
B:BD[3.374547] → [3.374547:374568]
```
	return results, nil
```
[3.374547]
[3.374568]
```
	return nodes, nil
```

Replacement in data/dates.go at line 202 [3.370859]

B:BD[3.374794] → [3.374794:374869]

	query += "traverse year:taken:type: end show 2:n:kind, 2:n:key, 2:n:name"

[3.374794]

[3.374869]

	query += "traverse year:taken:type: end show 2:n:kind, 2:n:key, 2:n:name, 2:n:date_taken"

Deletion in data/dates.go at line 211 [3.370859]
B:BD[3.375078] → [3.375078:375112]
```
	results := make([]GraphNode, 0)
```

Replacement in data/dates.go at line 212 [3.370859]

B:BD[3.375113] → [3.375113:375276]

	for _, r := range res.Rows() {
		node := GraphNode{
			Kind: r[0].(string),
			Key:  r[1].(string),
			Name: r[2].(string),
		}
		results = append(results, node)

[3.375113]

[3.375276]

	type searchResults struct {
		Key       string
		Kind      string
		Name      string
		DateTaken time.Time

Replacement in data/dates.go at line 219 [3.370859]
B:BD[3.375280] → [3.375280:375338]
```
	log.Debug().Msgf("Query found %d results", len(results))
```
[3.375280]
[3.375338]
```
	results := make([]searchResults, 0)
```

Replacement in data/dates.go at line 221 [3.370859]

B:BD[3.375339] → [3.375339:375507]

	return results, nil
}
func FindTakenInYearAndMonth(year int, month int) ([]GraphNode, error) {
	if !_datesInitialized {
		ScaffoldMonths()
		_datesInitialized = true

[3.375339]

[3.375507]

	for _, r := range res.Rows() {
		result := searchResults{
			Kind:      r[0].(string),
			Key:       r[1].(string),
			Name:      r[2].(string),
			DateTaken: time.Unix(r[3].(int64), 0),
		}
		results = append(results, result)

Replacement in data/dates.go at line 231 [3.370859]

B:BD[3.375511] → [3.375511:375603]

	takenInMonth, err := FindTakenInMonths([]int{month})
	if err != nil {
		return nil, err
	}

[3.375511]

[3.375603]

	// Sort results by date taken
	sort.SliceStable(results, func(i, j int) bool {
		return results[i].DateTaken.After((results[j].DateTaken))
	})

Replacement in data/dates.go at line 236 [3.370859]

B:BD[3.375604] → [3.375604:375693]

	takenInYear, err := FindTakenInYears([]int{year})
	if err != nil {
		return nil, err
	}

[3.375604]

[3.375693]

	var nodes []GraphNode

Replacement in data/dates.go at line 238 [3.370859]

B:BD[3.375694] → [3.375694:375858]

	results := make([]GraphNode, 0)
	for _, t := range takenInMonth {
		for _, ty := range takenInYear {
			if t.Key == ty.Key {
				results = append(results, t)
			}

[3.375694]

[3.375858]

	for _, result := range results {
		node := GraphNode{
			Key:  result.Key,
			Kind: result.Kind,
			Name: result.Name,

Insertion in data/dates.go at line 244 [3.370859]
[3.375862]
[3.375862]
```
		nodes = append(nodes, node)
```
Replacement in data/dates.go at line 247 [3.370859]
B:BD[3.375866] → [3.375866:375887]
```
	return results, nil
```
[3.375866]
[3.375887]
```
	log.Debug().Msgf("Query found %d results", len(results))
	return nodes, nil
```

Deletion in data/caption.go at line 176 [3.376860]

B:BD[3.381890] → [2.483:619]

	// idx, idxerr := gm.NodeIndexQuery(gpart, "caption")
	// if idxerr == nil {
	// 	if idx == nil {
	// 		return []Caption{}, nil
	// 	}

Replacement in data/caption.go at line 177 [3.376860]

B:BD[3.382012] → [2.620:664]

	// 	termResults := []map[string][]uint64{}

[3.382012]

[3.382053]

	idx, idxerr := gm.NodeIndexQuery(gpart, "caption")
	if idxerr == nil {

Replacement in data/caption.go at line 180 [3.376860]

B:BD[3.382054] → [2.665:811]

	// 	for _, term := range terms {
	// 		tResult, err := idx.LookupWord("text", term)
	// 		if err != nil {
	// 			return []Caption{}, err
	// 		}

[3.382054]

[3.382185]

		if idx == nil {
			return []Caption{}, nil
		}

Replacement in data/caption.go at line 184 [3.376860]

B:BD[3.382186] → [2.812:868]

	// 		termResults = append(termResults, tResult)
	// 	}

[3.382186]

[3.382236]

		rankedList, err := RankedWordSearch(terms, idx)

Replacement in data/caption.go at line 186 [3.376860]
B:BD[3.382237] → [2.869:914]
```
	// 	keys := GetSortedResultKeys(resultsMap)
```
[3.382237]
[3.382279]
```
		if err != nil {
			return []Caption{}, err
		}
```

Replacement in data/caption.go at line 190 [3.376860]

B:BD[3.382280] → [2.915:1114]

	// 	if err == nil {
	// 		var captions []Caption
	// 		for _, key := range keys {
	// 			caption, err := GetCaptionByKey(key, gm, gpart)
	// 			if err != nil {
	// 				return captions, err
	// 			}

[3.382280]

[3.382567]

		//TODO - store a format-free lowercase version of the caption text for searching.

Replacement in data/caption.go at line 192 [3.376860]

B:BD[3.382568] → [2.1115:1167]

	// 			captions = append(captions, caption)
	// 		}

[3.382568]

[3.382651]

		var captions []Caption
		for _, result := range rankedList {
			caption, err := GetCaptionByKey(result.NodeId, gm, gpart)
			if err != nil {
				return captions, err
			}

Replacement in data/caption.go at line 199 [3.376860]

B:BD[3.382652] → [2.1168:1208]

	// 		return captions, nil
	// 	}
	// }

[3.382652]

[2.1208]

			captions = append(captions, caption)
		}
		return captions, nil
	}

Basic captioning inplace.

Dependencies

In channels

In discussions

Change contents

Deletion in web/search/results.go at line 6 [3.20396]

Deletion in web/search/results.go at line 44 [3.20396]

Insertion in data/wordSearch.go at line 2 [3.277673]

Replacement in data/wordSearch.go at line 28 [3.277673]

Replacement in data/wordSearch.go at line 35 [3.277673]

Replacement in data/wordSearch.go at line 37 [3.277673]

Replacement in data/wordSearch.go at line 44 [3.277673]

Replacement in data/wordSearch.go at line 47 [3.277673]

Insertion in data/wordSearch.go at line 51 [3.277673]

Replacement in data/wordSearch.go at line 54 [3.277673]

Replacement in data/wordSearch.go at line 58 [3.277673]

Deletion in data/wordSearch.go at line 66 [3.277673]

Replacement in data/wordSearch.go at line 67 [3.277673]

Replacement in data/wordSearch.go at line 92 [3.277673]

Replacement in data/wordSearch.go at line 96 [3.277673]

Replacement in data/search.go at line 192 [3.293204]

Replacement in data/search.go at line 196 [3.293204]

Replacement in data/search.go at line 201 [3.293204]

Insertion in data/dates.go at line 5 [3.370859]

Insertion in data/dates.go at line 7 [3.370859]