def report_gifs(multi=False, count=False, html=False, dump_all=False):
""" report gifs sorted by number of upvotes per use
optionally filter to only gifs used multiple times """
if count:
print 'gifs: {}'.format(Gif.count())
print 'gif urls: {}'.format(GifUrl.count())
print 'uses: {}'.format(Usage.count())
gifscores = []
for gif in Gif.all():
uses = Usage.get_all_by_gif(gif)
use = uses[0]
if use.recent():
gifscores.append({
'score_per_use': sum([use.upvotes for use in uses]) / len(uses),
'uses': len(uses),
'imgur_id': GifUrl.by_id(use.gif_url_id).get_imgur_id(),
'url': GifUrl.by_id(use.gif_url_id).url })
env = Environment(loader=PackageLoader(__name__, 'templates'))
template = env.get_template('gif.html')
gifs=sorted(gifscores, key=lambda k: k['score_per_use'], reverse=True)
if not dump_all:
gifs = gifs[:30]
if html:
print template.render(gifs=gifs)
else:
for gif in gifs:
pprint(gif)
def record(id,metric,total,report=True):
from models import NamedBase, Usage
base = NamedBase.objects.get(pk=id)
usage = Usage(base=base,metric=metric,total=total,rate=0,rateCumulative=0,rateTime=datetime.datetime.now(),nInProgress=0,reports=1,squares=(total*total))
usage.save()
base.usages.add(usage)
base.save()
if report:
reportusage(base)
return usage
def render_usage(request):
"""Render the usage page"""
usagesummary = Usage.get_full_usagesummary()
_dict = {}
_dict["usagesummary"] = usagesummary
return render_to_response('allusage.html', append_dict(_dict, request), \
context_instance=RequestContext(request))
def home(request):
"""Render the home page """
hostings = HostingContainer.objects.all()
usagesummary = Usage.usages_to_summary(Usage.objects.all())
servicerequestform = ServiceRequestForm()
_dict = {}
_dict["servicerequestform"] = servicerequestform
if request.user.is_authenticated() and request.user.is_staff:
_dict["hostingcontainers"] = hostings
_dict["hostingcontainerform"] = HostingContainerForm(initial={
'name': "Container",
})
_dict["serviceform"] = DataServiceForm(initial={
'name': "Service",
"starttime":datetime.datetime.today(),
"endtime":datetime.datetime.today() + datetime.timedelta(hours=1)
})
_dict["usagesummary"] = usagesummary
return render_to_response('home.html', append_dict(_dict, request), \
context_instance=RequestContext(request))
elif request.user.is_authenticated():
return render_to_response('home.html', append_dict(_dict, request), \
context_instance=RequestContext(request))
else:
return redirect(reverse('login'))
from django.contrib.auth.forms import AuthenticationForm
from django_openid_auth.forms import OpenIDLoginForm
_dict["authform"] = AuthenticationForm()
_dict["form"] = OpenIDLoginForm()
return render_to_response('login.html', append_dict(_dict, request), \
context_instance=RequestContext(request))
def read(self, request, containerid=None, serviceid=None,
mfileid=None, authid=None):
if containerid or serviceid or mfileid:
base = NamedBase.objects.get(
id__in=[containerid, serviceid, mfileid])
result = {}
result["usages"] = base.get_real_base().get_usage_summary()
result["reportnum"] = base.reportnum
return result
elif authid:
auth = Auth.objects.get(pk=authid)
base = utils.get_base_for_auth(auth)
result = {}
result["usages"] = base.get_real_base().get_usage_summary()
result["reportnum"] = base.reportnum
return result
elif request.user.is_staff:
result = {}
result["usages"] = Usage.get_full_usagesummary()
result["reportnum"] = -1
return result
else:
response = rc.BAD_REQUEST
response.write("Invalid Request!")
return response
def save_request(request):
usage = Usage()
usage.ip = request.META.get('REMOTE_ADDR')
usage.method = request.method
usage.path = request.path
usage.params = request.META.get('QUERY_STRING')
usage.save()
def stats(request, baseid=None):
from jobservice.models import Job
job_json = Job.get_job_plots(request, baseid=baseid)
mfile_json = MFile.get_mfile_plots(request, baseid=baseid)
usage_json = Usage.get_usage_plots(request, baseid=baseid)
json = job_json + mfile_json + usage_json
if json == None:
return HttpResponseNotFound()
_json = simplejson.dumps(json)
return HttpResponse(_json, mimetype="application/json")
def updaterecording(id,metric,rate,report=True):
from models import NamedBase, Usage
base = NamedBase.objects.get(pk=id)
try:
usage = Usage.objects.get(base=base,metric=metric)
if rate == usage.rate:
logging.debug("Usage allready exists for %s at current rate %s " % (usage.metric,rate))
else:
logging.debug("Usage allready exists for %s at rate %s, changing rate to %s " % (usage.metric, usage.rate, rate))
update_usage(usage,rate=rate)
if report:
reportusage(base)
return usage
except Usage.DoesNotExist:
usage = Usage(base=base,metric=metric,rate=rate,total=0.0,reports=1,nInProgress=1,rateCumulative=0,rateTime=datetime.datetime.now())
usage.save()
if report:
reportusage(base)
return usage
def run():
um = UsageManager()
y = getUptime()
um.update(Usage.create(y))
um.sync()
def run():
um = UsageManager()
y = getUptime()
um.update(Usage.create(y))
um.sync()
def main(argv=None):
if argv is None:
argv = sys.argv
try:
try:
opts, args = getopt.getopt(argv[1:], "shc", ["send", "help"])
except getopt.error, msg:
raise Usage(msg)
# option processing
send = False
for option, value in opts:
if option in ("-s", "--send"):
send = True
if option in ("-h", "--help"):
raise Usage(help_message)
# Parse configuration
config = parse_yaml()
for key in REQRD:
if key not in config.keys():
raise Exception(
'Required parameter %s not in yaml config file!' % (key,))
participants = config['PARTICIPANTS']
couples = config['COUPLES']
if len(participants) < 2:
raise Exception('Not enough participants specified.')
# Mail parsing
f = open('templates/mail.html', 'r')
mail_html = ""
while 1:
line = f.readline()
if not line:
break
mail_html += line
f.close()
givers = []
for person in participants:
name, email = re.match(r'([^<]*)<([^>]*)>', person).groups()
name = name.strip()
partner = None
for couple in couples:
names = [n.strip() for n in couple.split(',')]
if name in names:
# is part of this couple
for member in names:
if name != member:
partner = member
person = Person(name, email, partner)
givers.append(person)
recievers = givers[:]
pairs = create_pairs(givers, recievers)
if not send:
print """
Test pairings:
%s
To send out emails with new pairings,
call with the --send argument:
$ python secret_santa.py --send
""" % ("\n".join([str(p) for p in pairs]))
for pair in pairs:
if send:
to = "%s <%s>" % (pair.giver.name, pair.giver.email)
mail = HtmlMail(
config['SUBJECT'], config['FROM'], to, config['USERNAME'],
config['PASSWORD'])
mail.send(
parse_email(config['TEMPLATE']).format(
config['SUBJECT'], pair.giver.name, pair.reciever.name,
config['LIMIT'], config['DEATHLINE'])
)
print "Emailed %s <%s>" % (pair.giver.name, pair.giver.email)
