Merge pull request #8 from codingpot/refactor-4-paper-method-list

feat: implement PaperMethodList()

Author: deep-diver

client.go

@@ -1,13 +1,11 @@
 package paperswithcode_go
 
 import (
-	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/codingpot/paperswithcode-go/internal/transport"
 	"net/http"
-	"net/url"
 	"time"
 )
 
@@ -53,38 +51,6 @@ type errorResponse struct {
 	Message string `json:"message"`
 }
 
-// Method list used by Paper's ID
-type MethodList struct {
-	Count   int      `json:"count"`
-	Methods []Method `json:"results"`
-}
-
-type Method struct {
-	ID          string `json:"id"`
-	Name        string `json:"name"`
-	FullName    string `json:"full_name"`
-	Description string `json:"description"`
-	Paper       string `json:"paper"`
-}
-
-func (c *Client) GetMethodList(ctx context.Context, id string) (*MethodList, error) {
-	fmt.Println(id)
-	url := fmt.Sprintf("%s/papers/%s/methods", c.BaseURL, url.QueryEscape(id))
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	req = req.WithContext(ctx)
-
-	res := MethodList{}
-	if err := c.sendRequest(req, &res); err != nil {
-		return nil, err
-	}
-
-	return &res, nil
-}
-
 func (c *Client) sendRequest(req *http.Request, v interface{}) error {
 	req.Header.Set("Content-Type", "application/json; charset=utf-8")
 	req.Header.Set("Accept", "application/json; charset=utf-8")

cmd/client/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"github.com/codingpot/paperswithcode-go"
 	"os"
@@ -15,7 +14,6 @@ func main() {
 	}
 
 	c := paperswithcode_go.NewClient(paperswithcode_go.WithAPIToken(token))
-	ctx := context.Background()
 	paper := "generative adversarial networks"
 	paper = strings.ReplaceAll(paper, " ", "-")
 
@@ -25,7 +23,7 @@ func main() {
 	fmt.Println()
 	fmt.Println()
 
-	methodList, _ := c.GetMethodList(ctx, paper)
+	methodList, _ := c.PaperMethodList(paper)
 	fmt.Println(methodList)
 	fmt.Println()
 	fmt.Println()

dummy/paper_method_list_response.json

@@ -0,0 +1,21 @@
+{
+  "count": 2,
+  "next": null,
+  "previous": null,
+  "results": [
+    {
+      "id": "gan",
+      "name": "GAN",
+      "full_name": "Generative Adversarial Network",
+      "description": "A **GAN**, or **Generative Adversarial Network**, is a generative model that simultaneously trains\r\ntwo models: a generative model $G$ that captures the data distribution, and a discriminative model $D$ that estimates the\r\nprobability that a sample came from the training data rather than $G$.\r\n\r\nThe training procedure for $G$ is to maximize the probability of $D$ making\r\na mistake. This framework corresponds to a minimax two-player game. In the\r\nspace of arbitrary functions $G$ and $D$, a unique solution exists, with $G$\r\nrecovering the training data distribution and $D$ equal to $\\frac{1}{2}$\r\neverywhere. In the case where $G$ and $D$ are defined by multilayer perceptrons,\r\nthe entire system can be trained with backpropagation. \r\n\r\n(Image Source: [here](http://www.kdnuggets.com/2017/01/generative-adversarial-networks-hot-topic-machine-learning.html))",
+      "paper": "generative-adversarial-networks"
+    },
+    {
+      "id": "convolution",
+      "name": "Convolution",
+      "full_name": "Convolution",
+      "description": "A **convolution** is a type of matrix operation, consisting of a kernel, a small matrix of weights, that slides over input data performing element-wise multiplication with the part of the input it is on, then summing the results into an output.\r\n\r\nIntuitively, a convolution allows for weight sharing - reducing the number of effective parameters - and image translation (allowing for the same feature to be detected in different parts of the input space).\r\n\r\nImage Source: [https://arxiv.org/pdf/1603.07285.pdf](https://arxiv.org/pdf/1603.07285.pdf)",
+      "paper": null
+    }
+  ]
+}

models/methods.go

@@ -0,0 +1,17 @@
+package models
+
+type Method struct {
+	ID          string  `json:"id"`
+	Name        string  `json:"name"`
+	FullName    string  `json:"full_name"`
+	Description string  `json:"description"`
+	Paper       *string `json:"paper"`
+}
+
+// MethodList represents methods used in the paper.
+type MethodList struct {
+	Count    int         `json:"count"`
+	Next     interface{} `json:"next"`
+	Previous interface{} `json:"previous"`
+	Results  []*Method   `json:"results"`
+}

paper_method_list.go

@@ -0,0 +1,25 @@
+package paperswithcode_go
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/codingpot/paperswithcode-go/models"
+	"net/http"
+	"net/url"
+)
+
+func (c *Client) PaperMethodList(paperID string) (*models.MethodList, error) {
+	pURL := fmt.Sprintf("%s/papers/%s/methods", c.BaseURL, url.QueryEscape(paperID))
+	response, err := http.Get(pURL)
+	if err != nil {
+		return nil, err
+	}
+
+	var methodList models.MethodList
+	err = json.NewDecoder(response.Body).Decode(&methodList)
+	if err != nil {
+		return nil, err
+	}
+
+	return &methodList, err
+}

paper_method_list_test.go

@@ -0,0 +1,37 @@
+package paperswithcode_go
+
+import (
+	"github.com/codingpot/paperswithcode-go/models"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestClient_PaperMethodList(t *testing.T) {
+	c := NewClient()
+	paperID := "generative-adversarial-networks"
+	got, err := c.PaperMethodList(paperID)
+	assert.NoError(t, err)
+
+	expected := &models.MethodList{
+		Count:    2,
+		Next:     nil,
+		Previous: nil,
+		Results: []*models.Method{
+			{
+				ID:          "gan",
+				Name:        "GAN",
+				FullName:    "Generative Adversarial Network",
+				Description: "A **GAN**, or **Generative Adversarial Network**, is a generative model that simultaneously trains\r\ntwo models: a generative model $G$ that captures the data distribution, and a discriminative model $D$ that estimates the\r\nprobability that a sample came from the training data rather than $G$.\r\n\r\nThe training procedure for $G$ is to maximize the probability of $D$ making\r\na mistake. This framework corresponds to a minimax two-player game. In the\r\nspace of arbitrary functions $G$ and $D$, a unique solution exists, with $G$\r\nrecovering the training data distribution and $D$ equal to $\\frac{1}{2}$\r\neverywhere. In the case where $G$ and $D$ are defined by multilayer perceptrons,\r\nthe entire system can be trained with backpropagation. \r\n\r\n(Image Source: [here](http://www.kdnuggets.com/2017/01/generative-adversarial-networks-hot-topic-machine-learning.html))",
+				Paper:       &paperID,
+			},
+			{
+				ID:          "convolution",
+				Name:        "Convolution",
+				FullName:    "Convolution",
+				Description: "A **convolution** is a type of matrix operation, consisting of a kernel, a small matrix of weights, that slides over input data performing element-wise multiplication with the part of the input it is on, then summing the results into an output.\r\n\r\nIntuitively, a convolution allows for weight sharing - reducing the number of effective parameters - and image translation (allowing for the same feature to be detected in different parts of the input space).\r\n\r\nImage Source: [https://arxiv.org/pdf/1603.07285.pdf](https://arxiv.org/pdf/1603.07285.pdf)",
+				Paper:       nil,
+			},
+		},
+	}
+	assert.Equal(t, expected, got)
+}