Skip to content

Manual - Config

use_pytrends.config¤

Config ¤

Config for downloading trends

Parameters:

Name Type Description Default
request_params RequestParams

params for the TrendReq

 required
trend_params TrendParams

params for SingleTrend

 required
path_params PathParams

params to build the path

 required
Source code in sm_trendy/use_pytrends/config.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
class Config:
    """
    Config for downloading trends

    :param request_params: params for the TrendReq
    :param trend_params: params for SingleTrend
    :param path_params: params to build the path
    """

    def __init__(
        self,
        request_params: RequestParams,
        trend_params: TrendParams,
        path_params: PathParams,
    ):
        self.request_params = request_params
        self.trend_params = trend_params
        self.path_params = path_params

    @classmethod
    def from_dict(cls, config: Dict) -> Config:
        """
        Load config from a dictionary

        ```python
        config = {
            "request": {
                "tz": 120,
                "hl": "en-US"
            },
            "trend": {
                "timeframe": "today 5-y",
                "cat": 0,
                "geo": "DE",
                "keyword": "phone case"
            },
            "path": {
                "keyword": "phone case",
                "cat": "all",
                "country": "DE",
                "frequency": "1W"
            }
        }
        ```

        :param config: config dictionary that contains
            the key and values to build the params
        """

        request_params = RequestParams(**config["request"])
        trend_params = TrendParams(**config["trend"])
        path_config = convert_path(config["path"])
        path_params = PathParams(**path_config)

        return Config(
            request_params=request_params,
            trend_params=trend_params,
            path_params=path_params,
        )

    def _validate(self):
        assert (
            self.trend_params.keyword == self.path_params.keyword
        ), "trend keyword and path keyword should match"

from_dict(config) classmethod ¤

Load config from a dictionary

config = {
    "request": {
        "tz": 120,
        "hl": "en-US"
    },
    "trend": {
        "timeframe": "today 5-y",
        "cat": 0,
        "geo": "DE",
        "keyword": "phone case"
    },
    "path": {
        "keyword": "phone case",
        "cat": "all",
        "country": "DE",
        "frequency": "1W"
    }
}

Parameters:

Name Type Description Default
config Dict

config dictionary that contains the key and values to build the params

 required
Source code in sm_trendy/use_pytrends/config.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
@classmethod
def from_dict(cls, config: Dict) -> Config:
    """
    Load config from a dictionary

    ```python
    config = {
        "request": {
            "tz": 120,
            "hl": "en-US"
        },
        "trend": {
            "timeframe": "today 5-y",
            "cat": 0,
            "geo": "DE",
            "keyword": "phone case"
        },
        "path": {
            "keyword": "phone case",
            "cat": "all",
            "country": "DE",
            "frequency": "1W"
        }
    }
    ```

    :param config: config dictionary that contains
        the key and values to build the params
    """

    request_params = RequestParams(**config["request"])
    trend_params = TrendParams(**config["trend"])
    path_config = convert_path(config["path"])
    path_params = PathParams(**path_config)

    return Config(
        request_params=request_params,
        trend_params=trend_params,
        path_params=path_params,
    )

ConfigBundle ¤

Build a list of configs from file

Parameters:

Name Type Description Default
file_path AnyPath

path to the file

 required
Source code in sm_trendy/use_pytrends/config.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
class ConfigBundle:
    """Build a list of configs from file

    :param file_path: path to the file
    """

    def __init__(self, file_path: AnyPath):
        self.file_path = file_path
        raw_configs = self._load_json(self.file_path)
        self.configs, self.global_config = self._combine_configs(
            raw_configs=raw_configs
        )

    def _combine_configs(self, raw_configs: Dict) -> Tuple[List[Config], Dict]:
        global_config = self._transform_raw_global_config(raw_configs["global"])

        combined_configs = [
            self._combine_with_global(global_config=global_config, keyword_config=k)
            for k in raw_configs["keywords"]
        ]

        return combined_configs, global_config

    @staticmethod
    def _transform_raw_global_config(raw_global_config: Dict) -> Dict:
        """
        Convert string to path object if exist
        """
        global_config = copy.deepcopy(raw_global_config)

        if "path" in global_config:
            global_config["path"] = convert_path(global_config["path"])

        return global_config

    @staticmethod
    def _combine_with_global(global_config: Dict, keyword_config: Dict) -> Config:
        new_keyword_config = {}

        for key in ["request", "trend", "path"]:
            new_keyword_config[key] = keyword_config.get(key, {}) | global_config.get(
                key, {}
            )

        return Config.from_dict(new_keyword_config)

    @staticmethod
    def _load_json(file_path: AnyPath) -> Dict:

        with open(file_path, "r") as fp:
            data = json.load(fp)

        return data

    def __getitem__(self, idx: int) -> Config:
        return self.configs[idx]

    def __len__(self) -> int:
        return len(self.configs)

    def __iter__(self):
        for item in self.configs:
            yield item

RequestParams ¤

Parameters for trend

  1. Get tz info from here.
Source code in sm_trendy/use_pytrends/config.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
@dataclass
class RequestParams:
    """
    Parameters for trend

    1. Get tz info from [here](https://forbrains.co.uk/international_tools/earth_timezones).
    """

    tz: int = 120
    hl: str = "en-US"
    headers: Optional[Dict] = None
    timeout: Optional[Tuple] = (5, 14)
    proxies: Optional[Dict] = None