← Back to branch summary

~mhall119/+junk/click-store-stats

« back to all changes in this revision

Viewing changes to ubuntustats/data.py

  • Committer: mhall119
  • Date: 2013-10-29 19:15:53 UTC
  • Revision ID: mhall119@ubuntu.com-20131029191553-fk065fquxynwlfh4
initial graph scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntustats/data.py
 
1
from . import launchpad, stats
 
2
 
 
3
from operator import itemgetter
 
4
from datetime import datetime
 
5
 
 
6
class Person(object):
 
7
    def __init__(self, lpid=None, email=None, name=None):
 
8
        self.lpid = None
 
9
        if lpid:
 
10
            self.lpid = lpid
 
11
        self.emails = []
 
12
        self.names = []
 
13
        self.uploader = False
 
14
 
 
15
        if email:
 
16
            if type(email) != unicode:
 
17
                email = unicode(email, errors="replace")
 
18
            self.emails += [ email ]
 
19
        if name:
 
20
            if type(name) != unicode:
 
21
                name = unicode(name, errors="replace")
 
22
            self.names += [ name ]
 
23
 
 
24
    def add_email(self, email):
 
25
        if email:
 
26
            if type(email) != unicode:
 
27
                email = unicode(email, errors="replace")
 
28
            if not email in self.emails:
 
29
                self.emails += [ email ]
 
30
 
 
31
    def add_name(self, name):
 
32
        if name:
 
33
            if type(name) != unicode:
 
34
                name = unicode(name, errors="replace")
 
35
            if not name in self.names:
 
36
                self.names += [ name ]
 
37
 
 
38
 
 
39
class PersonList(object):
 
40
    all_folks = []
 
41
    filename = "people"
 
42
    lp = None
 
43
 
 
44
    def __init__(self, lp=None):
 
45
        data = stats.read_data(self.filename)
 
46
        self.lp = lp
 
47
        for entry in data:
 
48
            person = Person()
 
49
            person.__dict__ = entry
 
50
            self.all_folks += [ person ]
 
51
 
 
52
    def save(self):
 
53
        data = []
 
54
        for person in self.all_folks:
 
55
            data += [ person.__dict__ ]
 
56
        stats.dump(self.filename, data)
 
57
 
 
58
    def size(self):
 
59
        return len(self.all_folks)
 
60
 
 
61
    def number_of_uploaders(self):
 
62
        return len(self.get_uploaders())
 
63
 
 
64
    def get_non_uploaders(self):
 
65
        return filter(lambda a: not getattr(a, "uploader", False),
 
66
                      self.all_folks)
 
67
 
 
68
    def get_uploaders(self):
 
69
        return filter(lambda a: getattr(a, "uploader", False),
 
70
                      self.all_folks)
 
71
 
 
72
    def find(self, lpid=None, email=None, name=None):
 
73
        if lpid:
 
74
            matches = filter(lambda a: a.lpid == lpid, self.all_folks)
 
75
            if matches:
 
76
                return matches[0]
 
77
        if email:
 
78
            matches = filter(lambda a: email in a.emails, self.all_folks)
 
79
            if matches:
 
80
                return matches[0]
 
81
        if name:
 
82
            matches = filter(lambda a: name in a.names, self.all_folks)
 
83
            if matches:
 
84
                return matches[0]
 
85
        return None
 
86
 
 
87
    def add(self, lpid=None, email=None, name=None):
 
88
        person = self.find(lpid, email, name)
 
89
        if not person:
 
90
            person = Person(lpid, email, name)
 
91
            self.all_folks += [person]
 
92
        if not person.lpid:
 
93
            if not self.lp:
 
94
                self.lp = launchpad.lp_login("stats")
 
95
            person.lpid = launchpad.lookup_email(self.lp, email)
 
96
        person.add_email(email)
 
97
        person.add_name(name)
 
98
        return person
 
99
 
 
100
class Upload(object):
 
101
    def __init__(self, timestamp, pkg, sponsor=None):
 
102
        if type(timestamp) == datetime:
 
103
            self.timestamp = timestamp.strftime("%Y-%m-%d")
 
104
        else:
 
105
            self.timestamp = timestamp
 
106
        self.pkg = pkg
 
107
        if sponsor:
 
108
            self.sponsor = sponsor
 
109
 
 
110
class UploadList(object):
 
111
    uploads = {}
 
112
    filename = "uploads"
 
113
    releases = []
 
114
 
 
115
    def __init__(self):
 
116
        data = stats.read_data(self.filename)
 
117
        self.releases = stats.read_data("all-releases")
 
118
        self.releases.reverse()
 
119
        if data:
 
120
            for release in data.keys():
 
121
                for who in data[release].keys():
 
122
                    for upload in data[release][who]:
 
123
                        self.add(release, who,
 
124
                                 upload["timestamp"], upload["pkg"])
 
125
 
 
126
    def save(self):
 
127
        data = {}
 
128
        for release in self.uploads.keys():
 
129
            data[release] = {}
 
130
            for who in self.uploads[release].keys():
 
131
                data[release][who] = []
 
132
                for upload in self.uploads[release][who]:
 
133
                    data[release][who] += [ upload.__dict__ ]
 
134
        stats.dump(self.filename, data)
 
135
 
 
136
    def add(self, release, who, timestamp, pkg, sponsor=None):
 
137
        if not self.uploads.has_key(release):
 
138
            self.uploads[release] = {}
 
139
        if not self.uploads[release].has_key(who):
 
140
            self.uploads[release][who] = []
 
141
        self.uploads[release][who] += [ Upload(timestamp, pkg, sponsor) ]
 
142
 
 
143
    def get_first_release_contributed_to(self, uploader):
 
144
        for release in self.releases:
 
145
            if self.uploads[release].has_key(uploader):
 
146
                return release
 
147
        return None
 
148
 
 
149
    def get_first_time_uploaders_in(self, release, pl=None):
 
150
        uploaders = set(self.uploads[release].keys())
 
151
 
 
152
        # if PersonList pl is passed we make sure that only real uploaders
 
153
        # are included in the list
 
154
        if pl:
 
155
            real_uploaders = set([b.lpid for b in pl.get_uploaders()])
 
156
            uploaders = uploaders.intersection(real_uploaders)
 
157
 
 
158
        return filter(lambda a: self.get_first_release_contributed_to(a) == release, uploaders)
 
159
 
 
160
    def get_first_time_uploads_in(self, release, pl=None):
 
161
        uploads = {}
 
162
        uploaders = self.get_first_time_uploaders_in(release, pl)
 
163
        for uploader in uploaders:
 
164
            uploads[uploader] = sorted([(a.pkg, a.timestamp) for a in \
 
165
                                            self.uploads[release][uploader]], 
 
166
                                        key=itemgetter(1))
 
167
        return uploads