Clojure-Developer-2023-10/otus-18/src/otus_18/homework/pokemons.clj at f4e0539a3113331b44c816dcf05df198020f6a38 · Clojure-Developer/Clojure-Developer-2023-10 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
92
93
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
(ns otus-18.homework.pokemons
    (:require
        [clojure.core.async
         :as async
         :refer [chan <!! >!! <! >! go pipeline-async close! thread pipeline]]
        [clj-http.client :as http]
        [clojure.algo.generic.functor :refer [fmap]]))

(def base-url "https://pokeapi.co/api/v2")
(def pokemons-url (str base-url "/pokemon"))
(def type-url (str base-url "/type"))
(def cache-wrapper
    (let [cache (atom {})]
        (fn [http-map]
            (if-let [cached-result (get @cache http-map)]
                cached-result
                (let [result (http/request http-map)]
                    (swap! cache assoc http-map result)
                    result)))))

(defn async-request [http-map]
    (-> http-map
        cache-wrapper
        :body
        thread))

(defn pageable->urls [pages-urls> url entities-urls>]
    (go
        (let [response (<! (async-request {:url    url
                                           :method :get
                                           :as     :json}))
              next-url (:next response)]
            (doseq [entity (:results response)]
                (>! entities-urls> (:url entity)))
            (if next-url
                (>! pages-urls> next-url)
                (close! pages-urls>))
            (close! entities-urls>))))

(defn urls->entities [url entities-content>]
    (go
        (let [response (<! (async-request {:url    url
                                           :method :get
                                           :as     :json}))]
            (>! entities-content> response)
            (close! entities-content>))))

(defn get-entities-data [initial-page-url parse-fn]
    (let [pages-urls> (chan 2)
          entities-urls> (chan 8)
          entities-data> (chan 8)
          entities-parsed> (chan 8)]
        (pipeline-async 1 entities-urls> (partial pageable->urls pages-urls>) pages-urls>)
        (pipeline-async 8 entities-data> urls->entities entities-urls>)
        (pipeline 8 entities-parsed> (map parse-fn) entities-data>)
        (>!! pages-urls> initial-page-url)
        entities-parsed>))

(defn construct-type-lang-hierarchy [name m]
    [(get-in m [:language :name])
     {name (get-in m [:name])}])

(defn parse-type-names [response]
    (let [name (:name response)]
        [name
         ;TODO transducer smells below
         (into {} (map (partial construct-type-lang-hierarchy name) (:names response)))]))

(defn parse-pokemon-types [response]
    [(:name response)
     (mapv #(get-in % [:type :name]) (:types response))])

(defn extract-types-by-lang [lang types-map]
    ;TODO transducer smells below
    (partial mapv ((reduce (partial merge-with into) {} (vals types-map)) lang)))

(defn get-pokemons
    "Асинхронно запрашивает список покемонов и название типов в заданном языке. Возвращает map, где ключами являются
  имена покемонов (на английском английский), а значения - коллекция названий типов на заданном языке."
    [& {:keys [limit lang] :or {limit 50 lang "ja"}}]
    (let [pokemon-types (->> (get-entities-data type-url parse-type-names)
                             (async/into {})
                             <!!
                             (extract-types-by-lang lang))]
        (->> (async/take limit (get-entities-data pokemons-url parse-pokemon-types))
             (async/into {})
             <!!
             (fmap pokemon-types)
             )))

(comment
    (get-pokemons))

(comment

    (fmap (partial mapv ((reduce (partial merge-with into) {} (vals (get-types))) "ja")) (get-pokemons))

    (map #(get-in (get-types) [% "en"]) ["bug" "flying"])

    (reduce (partial merge-with into) {} (vals (get-types)))


    (defn- get-types
        [& {:keys [limit lang] :or {limit 50 lang "ja"}}]
        (let [pokemon-types (->> (get-entities-data type-url parse-type-names)
                                 (into {})
                                 <!!)]
            pokemon-types))

    (def pika
        {:url          (str pokemons-url "/" "pikachu")
         :method       :get
         :as           :json
         :query-params {:lang "jp"}})

    (def pika
        {:url    type-url
         :method :get
         :as     :json})

    (go (let [start# (. System (nanoTime))
              pokemons-result (<! (async-request {:url          pokemons-url
                                                  :method       :get
                                                  :as           :json
                                                  :query-params {:lang "jp" :limit 50}}))
              pokemon-names (->> pokemons-result
                                 :body
                                 :results
                                 (map :name))]
            (println pokemon-names)
            (println (str "Elapsed time: " (/ (double (- (. System (nanoTime)) start#)) 1000000.0) " msecs"))))


    (time (-> (cache-wrapper pika)
              :body
              keys))

    (let [ch> (async-request pika)]
        (->> ch>
             <!!))

    (let [out> (get-entities-data type-url parse-type-names)]
        (go-loop []
                 (if-let [res (<! out>)]
                     (do (println res) (recur))
                     "end")))

    (get-pokemons)
    )