farmap 0.2.1

A library for working with Farcaster label datasets
Documentation 
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

use crate::import::ImporterError;
use crate::pinata_parser::followers_from_pinata_response;
use crate::pinata_parser::reaction_times_from_response;
use crate::User;
use chrono::NaiveDateTime;
use log::trace;
use reqwest::{Client, Response};
use url::Url;

pub struct PinataFetcher {
    client: Client,
    base_url: Url,
}

impl Default for PinataFetcher {
    fn default() -> Self {
        Self {
            base_url: Url::parse("https://hub.pinata.cloud/v1/").unwrap(),
            client: Client::new(),
        }
    }
}

impl PinataFetcher {
    /// used to override the default url - mostly used for testing
    pub fn with_base_url(self, url: Url) -> Self {
        Self {
            base_url: url,
            ..self
        }
    }

    pub async fn fetch_followers_for_fid(&self, fid: u64) -> Result<Vec<u64>, ImporterError> {
        let api_response = self.link_request_for_fid(fid).await?;
        followers_from_pinata_response(api_response).await
    }

    // fetches reaction times (i.e. a collection of times when a user has either recasted or
    // liked)
    pub async fn fetch_reaction_times_for_fid(
        &self,
        fid: u64,
    ) -> Result<Vec<NaiveDateTime>, ImporterError> {
        let likes = self.likes_by_fid(fid).await?;
        let recasts = self.recasts_by_fid(fid).await?;
        let mut reaction_times = reaction_times_from_response(likes).await?;
        let mut recast_reaction_times = reaction_times_from_response(recasts).await?;
        reaction_times.append(&mut recast_reaction_times);
        Ok(reaction_times)
    }

    /// update a user with reaction times from pinata.
    /// The function returns the existing reaction_times, if the field was populated prior to the
    /// method call.
    pub async fn fetch_reaction_times_for_user(
        &self,
        user: &mut User,
    ) -> Result<Option<Vec<NaiveDateTime>>, ImporterError> {
        let reaction_times = self.fetch_reaction_times_for_fid(user.fid() as u64).await?;
        Ok(user.update_reaction_times(reaction_times))
    }

    pub async fn casts_by_fid(&self, id: u64) -> Result<Response, ImporterError> {
        let extension = "castsByFid";
        let mut url = self.base_url.clone().join(extension).unwrap();
        url.set_query(Some(&format!("fid={id}")));
        self.client
            .get(url)
            .send()
            .await
            .map_err(|_| ImporterError::FailedApiRequest)
    }

    pub async fn link_request_for_fid(&self, fid: u64) -> Result<Response, ImporterError> {
        let extension = "linksByTargetFid";
        let mut url = self.base_url.clone().join(extension).unwrap();
        url.set_query(Some(&format!("link_type=follow&target_fid={fid}")));
        trace!("{}", url);
        self.client
            .get(url)
            .send()
            .await
            .map_err(|_| ImporterError::FailedApiRequest)
    }

    async fn reactions_by_fid(
        &self,
        fid: u64,
        reaction: Reaction,
    ) -> Result<Response, ImporterError> {
        let reaction_str = match reaction {
            Reaction::Like => "Like",
            Reaction::Recast => "Recast",
        };

        let extension = "reactionsByFid";
        let mut url = self.base_url.clone().join(extension).unwrap();
        url.set_query(Some(&format!("reaction_type={reaction_str}&fid={fid}")));
        self.client
            .get(url)
            .send()
            .await
            .map_err(|_| ImporterError::FailedApiRequest)
    }

    pub async fn likes_by_fid(&self, fid: u64) -> Result<Response, ImporterError> {
        self.reactions_by_fid(fid, Reaction::Like).await
    }

    pub async fn recasts_by_fid(&self, fid: u64) -> Result<Response, ImporterError> {
        self.reactions_by_fid(fid, Reaction::Recast).await
    }
}

enum Reaction {
    Like,
    Recast,
}