func main() {
flag.Parse()
file := flag.Arg(0)
csv := csv.NewWriter(os.Stdout)
selector := "meta[name]" // All meta tags with name attribute
webdevdata.ProcessMatchingTags(file, selector, func(node *html.Node) {
name := webdevdata.GetAttr("name", node.Attr)
csv.Write([]string{file, name})
})
csv.Flush()
}
func main() {
flag.Parse()
file := flag.Arg(0)
csv := csv.NewWriter(os.Stdout)
selector := "html[manifest]" // all html tags with manifest attribute
webdevdata.ProcessMatchingTags(file, selector, func(node *html.Node) {
manifest := webdevdata.GetAttr("manifest", node.Attr)
if manifest != "" {
csv.Write([]string{file, manifest})
}
})
csv.Flush()
}
func main() {
library.Load()
api := lookupApi{}
api.ConnectWithConfig("lastfm.json")
artists := library.Artists()
artist_count := len(artists)
fmt.Printf("Artist Count: %d\n", artist_count)
outPath := path.Join(config.DataPath, "artist_tags.txt")
f, err := os.OpenFile(outPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0660)
if err != nil {
panic(fmt.Errorf("%q: %v", outPath, err))
}
csv := csv.NewWriter(f)
ticker := time.NewTicker(time.Millisecond * 201)
i := 0
for t := range ticker.C {
fmt.Println("Tick at", t)
if i >= len(artists) {
break
}
artist := artists[i]
i += 1
mbid, err := api.artistMbid(artist)
if err != nil {
fmt.Printf("%v\n", err)
continue
}
tags := api.topTagsMbid(mbid)
var row []string
row = append(row, artist)
row = append(row, mbid)
row = append(row, tags...)
csv.Write(row)
fmt.Printf("%q\t%s\n", artist, strings.Join(tags, "\t"))
fmt.Printf("progress:\t%d of %d (%d%%)\n", i, artist_count, i/artist_count*100)
}
}
func main() {
flag.Parse()
filesChan := make(chan string)
go webdevdata.GetFiles(filesChan, 0)
csv := csv.NewWriter(os.Stdout)
for file := range filesChan {
tags := make(map[string]int)
webdevdata.ProcessTags(file, func(token html.Token) {
tags[token.Data]++
})
for tag, count := range tags {
csv.Write([]string{file, tag, strconv.Itoa(count)})
}
}
csv.Flush()
}
func (o *output) writeLines() {
csv := csv.NewWriter(o.stream)
commLoop:
for {
select {
case r := <-o.receive:
switch r.Type {
case plumbing.UpdateQuestion:
csv.Write([]string{
r.Identifier,
r.Label,
r.Value,
})
case plumbing.Flush:
csv.Flush()
break commLoop
}
}
}
}
func IdentifySongs(songs []*Song, outFile string) {
log.Printf("Identifying songs...")
if len(songs) == 0 {
log.Printf("No songs to identify.")
return
}
// How many identification routines can run concurrently
const concurrency = 10
var sem = make(chan bool, concurrency)
var songsOutCh = make(chan *Song)
var songsErrCh = make(chan SongErr)
var wg sync.WaitGroup
if len(songs) != 0 {
// from Params
for _, song := range songs {
if song.Hash == "" {
wg.Add(1)
go func(song *Song) {
sem <- true
defer func() { <-sem }()
defer func() { wg.Done() }()
hash, err := audioFileChecksum(song.Path)
if err != nil {
var songErr SongErr
songErr.Song = song
songErr.Err = err
songsErrCh <- songErr
//log.Printf("ident: err: %v for %s", err, song.Path)
return
}
song.Hash = hash
songsOutCh <- song
}(song)
}
}
}
// Close the output channel when all the audioFileCheksums complete.
go func() {
wg.Wait()
close(songsOutCh)
close(songsErrCh)
}()
// Consumes from songsErrCh and writes song_errors.txt for unparsable files.
go func() {
songHashesPath := path.Join(config.DataPath, "song_errors.txt")
f, err := os.OpenFile(songHashesPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0660)
if err != nil {
panic(fmt.Errorf("%q: %v", songHashesPath, err))
}
for songErr := range songsErrCh {
f.WriteString(fmt.Sprintf("%q\t%q\n",
songErr.Song.Path,
songErr.Err))
}
}()
// Consumes songs via SongsOutChan, collects hash and metadata into song_hashes.txt
go func() {
songHashesPath := path.Join(config.DataPath, "song_hashes.txt")
f, err := os.OpenFile(songHashesPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0660)
if err != nil {
panic(fmt.Errorf("%q: %v", songHashesPath, err))
}
csv := csv.NewWriter(f)
i := 0
for song := range songsOutCh {
meta := song.Meta()
csv.Write([]string{
song.Hash,
song.Path,
meta.Artist,
meta.Album,
meta.Title})
i++
if i%100 == 0 {
log.Printf("Attempted identification of %d songs\n", i)
}
}
csv.Flush()
log.Printf("Identifying songs...done\n")
}()
}
func (w *csvFormatter) WriteResponse(resp Response) (n int, err error) {
csv := csv.NewWriter(w)
for _, result := range resp.Results {
if result.StatementID != w.statementID {
// If there are no series in the result, skip past this result.
if len(result.Series) == 0 {
continue
}
// Set the statement id and print out a newline if this is not the first statement.
if w.statementID >= 0 {
// Flush the csv writer and write a newline.
csv.Flush()
if err := csv.Error(); err != nil {
return n, err
}
if out, err := io.WriteString(w, "\n"); err != nil {
return n, err
} else {
n += out
}
}
w.statementID = result.StatementID
// Print out the column headers from the first series.
w.columns = make([]string, 2+len(result.Series[0].Columns))
w.columns[0] = "name"
w.columns[1] = "tags"
copy(w.columns[2:], result.Series[0].Columns)
if err := csv.Write(w.columns); err != nil {
return n, err
}
}
for _, row := range result.Series {
w.columns[0] = row.Name
if len(row.Tags) > 0 {
w.columns[1] = string(models.NewTags(row.Tags).HashKey()[1:])
} else {
w.columns[1] = ""
}
for _, values := range row.Values {
for i, value := range values {
switch v := value.(type) {
case float64:
w.columns[i+2] = strconv.FormatFloat(v, 'f', -1, 64)
case int64:
w.columns[i+2] = strconv.FormatInt(v, 10)
case string:
w.columns[i+2] = v
case bool:
if v {
w.columns[i+2] = "true"
} else {
w.columns[i+2] = "false"
}
case time.Time:
w.columns[i+2] = strconv.FormatInt(v.UnixNano(), 10)
}
}
csv.Write(w.columns)
}
}
}
csv.Flush()
if err := csv.Error(); err != nil {
return n, err
}
return n, nil
}