···

       
137
       
 
       
			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)

     

       
138
       
 
       
			defer cancel()

     

       
139
       
 
       


     

       
140
       
-
       
			nervanaItems, err := p.makeNervanaRequest(ctx, rec.Text)

     

       
141
       
 
       
			if err != nil {

     

       
142
       
 
       
				p.logger.Error("error making nervana items request", "error", err)

     

       
143
       
 
       
				return

     

···

       
137
       
 
       
			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)

     

       
138
       
 
       
			defer cancel()

     

       
139
       
 
       


     

       
140
       
+
       
			nervanaItems, err := p.nervanaClient.MakeRequest(ctx, rec.Text)

     

       
141
       
 
       
			if err != nil {

     

       
142
       
 
       
				p.logger.Error("error making nervana items request", "error", err)

     

       
143
       
 
       
				return

     

···

       
1
       
-
       
package photocopy

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"bytes"

     
···

       
7
       
 
       
	"fmt"

     

       
8
       
 
       
	"io"

     

       
9
       
 
       
	"net/http"

     

       
0
       
 
       

     

       
10
       
 
       
)

     

       
11
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       
type NervanaItem struct {

     

       
13
       
 
       
	Text        string `json:"text"`

     

       
14
       
 
       
	Label       string `json:"label"`

     
···

       
16
       
 
       
	Description string `json:"description"`

     

       
17
       
 
       
}

     

       
18
       
 
       


     

       
19
       
-
       
func (p *Photocopy) newNervanaRequest(ctx context.Context, text string) (*http.Request, error) {

     

       
20
       
 
       
	payload := map[string]string{

     

       
21
       
 
       
		"text":     text,

     

       
22
       
 
       
		"language": "en",

     
···

       
27
       
 
       
		return nil, err

     

       
28
       
 
       
	}

     

       
29
       
 
       


     

       
30
       
-
       
	req, err := http.NewRequestWithContext(ctx, "POST", p.nervanaEndpoint, bytes.NewReader(b))

     

       
31
       
 
       


     

       
32
       
-
       
	req.Header.Set("Authorization", "Bearer "+p.nervanaApiKey)

     

       
33
       
 
       


     

       
34
       
 
       
	return req, err

     

       
35
       
 
       
}

     

       
36
       
 
       


     

       
37
       
-
       
func (p *Photocopy) makeNervanaRequest(ctx context.Context, text string) ([]NervanaItem, error) {

     

       
38
       
-
       
	req, err := p.newNervanaRequest(ctx, text)

     

       
39
       
 
       
	if err != nil {

     

       
40
       
 
       
		return nil, err

     

       
41
       
 
       
	}

     

       
42
       
 
       


     

       
43
       
-
       
	resp, err := p.nervanaClient.Do(req)

     

       
44
       
 
       
	if err != nil {

     

       
45
       
 
       
		return nil, err

     

       
46
       
 
       
	}

     

···

       
1
       
+
       
package nervana

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"bytes"

     
···

       
7
       
 
       
	"fmt"

     

       
8
       
 
       
	"io"

     

       
9
       
 
       
	"net/http"

     

       
10
       
+
       
	"time"

     

       
11
       
 
       
)

     

       
12
       
 
       


     

       
13
       
+
       
type Client struct {

     

       
14
       
+
       
	cli      *http.Client

     

       
15
       
+
       
	endpoint string

     

       
16
       
+
       
	apiKey   string

     

       
17
       
+
       
}

     

       
18
       
+
       


     

       
19
       
+
       
func NewClient(endpoint string, apiKey string) *Client {

     

       
20
       
+
       
	return &Client{

     

       
21
       
+
       
		cli: &http.Client{

     

       
22
       
+
       
			Timeout: 5 * time.Second,

     

       
23
       
+
       
		},

     

       
24
       
+
       
		endpoint: endpoint,

     

       
25
       
+
       
		apiKey:   apiKey,

     

       
26
       
+
       
	}

     

       
27
       
+
       
}

     

       
28
       
+
       


     

       
29
       
 
       
type NervanaItem struct {

     

       
30
       
 
       
	Text        string `json:"text"`

     

       
31
       
 
       
	Label       string `json:"label"`

     
···

       
33
       
 
       
	Description string `json:"description"`

     

       
34
       
 
       
}

     

       
35
       
 
       


     

       
36
       
+
       
func (c *Client) newRequest(ctx context.Context, text string) (*http.Request, error) {

     

       
37
       
 
       
	payload := map[string]string{

     

       
38
       
 
       
		"text":     text,

     

       
39
       
 
       
		"language": "en",

     
···

       
44
       
 
       
		return nil, err

     

       
45
       
 
       
	}

     

       
46
       
 
       


     

       
47
       
+
       
	req, err := http.NewRequestWithContext(ctx, "GET", c.endpoint, bytes.NewReader(b))

     

       
48
       
 
       


     

       
49
       
+
       
	req.Header.Set("Authorization", "Bearer "+c.apiKey)

     

       
50
       
 
       


     

       
51
       
 
       
	return req, err

     

       
52
       
 
       
}

     

       
53
       
 
       


     

       
54
       
+
       
func (c *Client) MakeRequest(ctx context.Context, text string) ([]NervanaItem, error) {

     

       
55
       
+
       
	req, err := c.newRequest(ctx, text)

     

       
56
       
 
       
	if err != nil {

     

       
57
       
 
       
		return nil, err

     

       
58
       
 
       
	}

     

       
59
       
 
       


     

       
60
       
+
       
	resp, err := c.cli.Do(req)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
 
       
		return nil, err

     

       
63
       
 
       
	}

     

···

       
11
       
 
       
	"github.com/ClickHouse/clickhouse-go/v2"

     

       
12
       
 
       
	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"

     

       
13
       
 
       
	"github.com/haileyok/photocopy/clickhouse_inserter"

     

       
0
       
 
       

     

       
14
       
 
       
	"github.com/prometheus/client_golang/prometheus"

     

       
15
       
 
       
	"github.com/prometheus/client_golang/prometheus/promauto"

     

       
16
       
 
       
	"github.com/prometheus/client_golang/prometheus/promhttp"

     
···

       
33
       
 
       


     

       
34
       
 
       
	conn driver.Conn

     

       
35
       
 
       


     

       
36
       
-
       
	nervanaClient   *http.Client

     

       
37
       
 
       
	nervanaEndpoint string

     

       
38
       
 
       
	nervanaApiKey   string

     

       
39
       
 
       
}

     
···

       
212
       
 
       
	p.plcScraper = plcs

     

       
213
       
 
       


     

       
214
       
 
       
	if args.NervanaApiKey != "" && args.NervanaEndpoint != "" {

     

       
215
       
-
       
		p.nervanaClient = &http.Client{

     

       
216
       
-
       
			Timeout: 5 * time.Second,

     

       
217
       
-
       
		}

     

       
218
       
-
       
		p.nervanaEndpoint = args.NervanaEndpoint

     

       
219
       
-
       
		p.nervanaApiKey = args.NervanaApiKey

     

       
220
       
 
       
	}

     

       
221
       
 
       


     

       
222
       
 
       
	return p, nil

     

···

       
11
       
 
       
	"github.com/ClickHouse/clickhouse-go/v2"

     

       
12
       
 
       
	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"

     

       
13
       
 
       
	"github.com/haileyok/photocopy/clickhouse_inserter"

     

       
14
       
+
       
	"github.com/haileyok/photocopy/nervana"

     

       
15
       
 
       
	"github.com/prometheus/client_golang/prometheus"

     

       
16
       
 
       
	"github.com/prometheus/client_golang/prometheus/promauto"

     

       
17
       
 
       
	"github.com/prometheus/client_golang/prometheus/promhttp"

     
···

       
34
       
 
       


     

       
35
       
 
       
	conn driver.Conn

     

       
36
       
 
       


     

       
37
       
+
       
	nervanaClient   *nervana.Client

     

       
38
       
 
       
	nervanaEndpoint string

     

       
39
       
 
       
	nervanaApiKey   string

     

       
40
       
 
       
}

     
···

       
213
       
 
       
	p.plcScraper = plcs

     

       
214
       
 
       


     

       
215
       
 
       
	if args.NervanaApiKey != "" && args.NervanaEndpoint != "" {

     

       
216
       
+
       
		p.nervanaClient = nervana.NewClient(args.NervanaEndpoint, args.NervanaApiKey)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
217
       
 
       
	}

     

       
218
       
 
       


     

       
219
       
 
       
	return p, nil