releaseparser: move group-agnostic parser to groups/, GB doc-blocks, per-group JSON reports
Generalise the parser: the MOONBLOOD group profile is gone, the parser and its dictionaries are now group-agnostic under internal/releaseparser/groups. Positional model: - [0]=Artist, [1]=Title are fixed and never matched against dictionaries, so titles like "Split"/"Demo"/"De" are never eaten. - [len-1]=Group is always read from the line, not from the query key. - [len-2]=Year when it is a 4-digit 19xx|20xx token; otherwise the slot is resolved as a middle-zone token (e.g. FLAC is still picked up as format). - The middle zone is resolved via case-insensitive dictionaries in the order format -> source -> bit-depth -> resolution -> edition -> language -> catalogue number; stored values keep their original case. Catalogue numbers: any "(...)" token in the middle zone is a catalogue number regardless of content (digits, roman numerals, dots, underscores, mixed case); splitting never breaks tokens inside parentheses. Dictionaries moved to internal/releaseparser/groups/resources/dicts and embedded via go:embed; dead profile fields (Name, ExpectedTailOrder) removed; profile comments rewritten in British English. File-based AnalyzeGroup/TestParseMoonblood removed — titles now come from the database (cmd/srrdb: srrdb <releaser>..., config/secret.yaml DSN). Validation output (cmd/srrdb): - tmp/releaseparser/<group>.json — per-group parsed ParsedRelease records - tmp/releaseparser/<releaser>.report.json — per-request aggregate (same as console) - review_unknown_tokens.txt — unknown/warning rows for manual review Tests updated for the positional model; added TestParseCatalogNumberWithDotAndRoman for (DYN.3140-2) and (GOWP_DCCCLXXXIX). go build, go vet and go test all pass.
This commit is contained in:
Yevhen Odynets
@@ -0,0 +1,213 @@
|
||||
package groups
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"git.kplus.net.ua/yevhen/resource-scraper/internal/releaseparser"
|
||||
)
|
||||
|
||||
var yearRegexp = regexp.MustCompile(`^(19|20)\d{2}$`)
|
||||
|
||||
// Parse splits a release line into tokens and maps them onto a fixed
|
||||
// positional model while the interior is resolved solely through the
|
||||
// group profile's dictionaries.
|
||||
//
|
||||
// The release line is split on "-" (but never inside curved parentheses, so
|
||||
// that a catalogue number such as (BRC30-001-CD-RRR108) stays one token).
|
||||
// The positional layout is:
|
||||
//
|
||||
// [0] Artist - fixed; never matched against dictionaries.
|
||||
// [1] Title - fixed; never matched against dictionaries.
|
||||
// [len-2] Year - if the token is a 4-digit year (19xx | 20xx).
|
||||
// [len-1] Group - always read from the line, never from the query key.
|
||||
//
|
||||
// Everything between [1] and the reserved trailing slots ([2 .. len-3], or
|
||||
// [2 .. len-2] when there is no year) is the middle zone. Each token there is
|
||||
// looked up in the dictionaries (format, source, bit-depth, resolution,
|
||||
// language, edition) and, if it is a parenthesized token, as a catalogue
|
||||
// number. Position within the middle zone is irrelevant. Tokens that match
|
||||
// nothing are NOT silently consumed — they are reported in UnknownTokens so
|
||||
// that they can be reviewed and added to a dictionary.
|
||||
//
|
||||
// Why [0]/[1] are fixed and never matched against the dictionaries: titles
|
||||
// such as "Split" (Alone_In_The_Morgue-Split-...) or "Demo"
|
||||
// (Mystifier-Demo-Nized-...) are legitimate words that collide with edition
|
||||
// markers. Since index 1 is always the title, regardless of case or
|
||||
// dictionary membership, such words are never eaten.
|
||||
//
|
||||
// Values are preserved in their original case (as they appear in the line);
|
||||
// the dictionary lookups themselves are case-insensitive.
|
||||
func Parse(raw string) releaseparser.ParsedRelease {
|
||||
result := releaseparser.ParsedRelease{
|
||||
Raw: strings.TrimSpace(raw),
|
||||
Warnings: []string{},
|
||||
UnknownTokens: []string{},
|
||||
}
|
||||
|
||||
tokens, comments := extractComments(split(raw))
|
||||
if len(comments) > 0 {
|
||||
result.Comment = strings.Join(comments, ",")
|
||||
}
|
||||
if len(tokens) < 5 {
|
||||
result.Warnings = append(result.Warnings, "too few tokens")
|
||||
result.Confidence = 0.2
|
||||
return result
|
||||
}
|
||||
|
||||
// Fixed positional edges: [0]=Artist, [1]=Title, [len-1]=Group,
|
||||
// [len-2]=Year (when present).
|
||||
result.Artist = tokens[0]
|
||||
if len(tokens) > 1 {
|
||||
result.Title = tokens[1]
|
||||
}
|
||||
result.Group = tokens[len(tokens)-1]
|
||||
end := len(tokens) - 1
|
||||
if len(tokens) >= 3 && yearRegexp.MatchString(tokens[len(tokens)-2]) {
|
||||
result.Year, _ = strconv.Atoi(tokens[len(tokens)-2])
|
||||
end = len(tokens) - 2
|
||||
}
|
||||
// Resolve the middle zone tokens via the dictionaries.
|
||||
parseTailZone(tokens[2:end], &result)
|
||||
|
||||
score(&result)
|
||||
return result
|
||||
}
|
||||
|
||||
// split breaks a raw release line into tokens on "-", but never inside
|
||||
// curved parentheses, so that a catalogue number such as
|
||||
// (BRC30-001-CD-RRR108) remains a single token.
|
||||
func split(raw string) []string {
|
||||
s := strings.TrimSpace(raw)
|
||||
out := make([]string, 0, 8)
|
||||
var cur strings.Builder
|
||||
inParen := false
|
||||
for _, r := range s {
|
||||
switch {
|
||||
case r == '(':
|
||||
inParen = true
|
||||
cur.WriteRune(r)
|
||||
case r == ')':
|
||||
inParen = false
|
||||
cur.WriteRune(r)
|
||||
case r == '-' && !inParen:
|
||||
if t := strings.TrimSpace(cur.String()); t != "" {
|
||||
out = append(out, t)
|
||||
}
|
||||
cur.Reset()
|
||||
default:
|
||||
cur.WriteRune(r)
|
||||
}
|
||||
}
|
||||
if t := strings.TrimSpace(cur.String()); t != "" {
|
||||
out = append(out, t)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// extractComments removes service comments (CommentTokens) from the token
|
||||
// list and returns the cleaned list together with the removed comments.
|
||||
func extractComments(tokens []string) ([]string, []string) {
|
||||
out := make([]string, 0, len(tokens))
|
||||
var comments []string
|
||||
for _, tok := range tokens {
|
||||
if Profile.CommentTokens[strings.ToUpper(tok)] {
|
||||
comments = append(comments, tok)
|
||||
continue
|
||||
}
|
||||
out = append(out, tok)
|
||||
}
|
||||
return out, comments
|
||||
}
|
||||
|
||||
// catalogNumber reports whether the token is a parenthesized catalogue
|
||||
// number. In the positional model any token wrapped in curved parentheses
|
||||
// that sits in the middle zone ([2..]) is a catalogue number regardless of
|
||||
// its content (digits, letters, roman numerals, dots, underscores, mixed
|
||||
// case). Parenthesized tokens at [0]/[1] are handled as artist/title, not
|
||||
// here. It returns the parenthesized content, or "" when the token is not
|
||||
// a "(...)" group.
|
||||
func catalogNumber(token string) string {
|
||||
if len(token) < 3 || token[0] != '(' || token[len(token)-1] != ')' {
|
||||
return ""
|
||||
}
|
||||
return token[1 : len(token)-1]
|
||||
}
|
||||
|
||||
// parseTailZone resolves middle-zone tokens against the dictionaries.
|
||||
// The first match wins for each field; catalogue numbers are recognised
|
||||
// from parenthesized tokens, and anything unrecognised is appended to
|
||||
// UnknownTokens so that it can be reviewed and curated into a dictionary.
|
||||
func parseTailZone(zone []string, result *releaseparser.ParsedRelease) {
|
||||
for _, tok := range zone {
|
||||
up := strings.ToUpper(tok)
|
||||
switch {
|
||||
case Profile.FormatTokens[up]:
|
||||
if result.Format == "" {
|
||||
result.Format = tok
|
||||
}
|
||||
case Profile.SourceTokens[up]:
|
||||
if result.Source == "" {
|
||||
result.Source = tok
|
||||
}
|
||||
case Profile.BitDepthTokens[up]:
|
||||
if result.BitDepth == "" {
|
||||
result.BitDepth = tok
|
||||
}
|
||||
case Profile.ResolutionTokens[up]:
|
||||
if result.Resolution == "" {
|
||||
result.Resolution = tok
|
||||
}
|
||||
case Profile.EditionTokens[up]:
|
||||
if result.Edition == "" {
|
||||
result.Edition = tok
|
||||
}
|
||||
case Profile.LanguageMarkers[up]:
|
||||
if result.Language == "" {
|
||||
result.Language = tok
|
||||
}
|
||||
default:
|
||||
if cat := catalogNumber(tok); cat != "" && result.CatalogNo == "" {
|
||||
result.CatalogNo = cat
|
||||
} else {
|
||||
result.UnknownTokens = append(result.UnknownTokens, tok)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// score computes a heuristic confidence in [0,1] for a parsed release based
|
||||
// on how many core fields (group, year, format, source, artist) were resolved
|
||||
// and whether any warnings or unknown tokens are present.
|
||||
func score(result *releaseparser.ParsedRelease) {
|
||||
score := 0.0
|
||||
if result.Group != "" {
|
||||
score += 0.25
|
||||
}
|
||||
if result.Year != 0 {
|
||||
score += 0.20
|
||||
}
|
||||
if result.Format != "" {
|
||||
score += 0.15
|
||||
}
|
||||
if result.Source != "" {
|
||||
score += 0.15
|
||||
}
|
||||
if result.Artist != "" {
|
||||
score += 0.15
|
||||
}
|
||||
if len(result.Warnings) == 0 {
|
||||
score += 0.10
|
||||
}
|
||||
if len(result.UnknownTokens) > 0 {
|
||||
score -= 0.10
|
||||
}
|
||||
if score > 1 {
|
||||
score = 1
|
||||
}
|
||||
if score < 0 {
|
||||
score = 0
|
||||
}
|
||||
result.Confidence = score
|
||||
}
|
||||
Reference in New Issue
Block a user