View pull.py
1 2 3 4 5 6 7 8 9 10
#!/usr/bin/env python
 
import os
import sys
import github
 
username = "stephenmcd"
 
while True:
repo = os.getcwd()
View conf.py
1 2 3 4 5 6 7 8 9 10
# This is the gunicorn config file for the websocket server.
 
worker_class = "geventwebsocket.gunicorn.workers.GeventWebSocketWorker"
bind = "0.0.0.0:9000"
workers = 1
timeout = 10000000000
loglevel = "error"
proc_name = "websocket-server"
 
# Modify paths here as required - allows websocket server to run
View MergeSort.scala
1 2 3 4 5 6 7 8 9
 
import scala.math.{floor, log}
import scala.util.Random
import akka.actor.{ActorSystem, Actor, Props}
 
 
object MergeSort extends App {
 
case class Items(items: Vector[Int])
View admin.html
1 2 3 4 5 6 7 8 9 10
{% load pages_tags future %}
 
<ol>
{% for page in page_branch %}
<li id="ordering_{{ page.id }}">
<div>
<a href="#" class="tree-toggle" id="page-{{ page.id }}"
{% if not page.has_children %}style="visibility:hidden;"{% endif %}>
<span class="icon open">+</span>
<span class="icon close">-</span>
View generate_page_tree.py
1 2 3 4 5 6 7 8 9
from mezzanine.pages.models import RichTextPage
 
def generate_page_tree(per_branch):
for a in range(per_branch):
x = RichTextPage.objects.create(title="Page %s" % a)
for b in range(per_branch):
y = RichTextPage.objects.create(title="Page %s-%s" % (a, b), parent=x)
for c in range(per_branch):
z = RichTextPage.objects.create(title="Page %s-%s-%s" % (a, b, c), parent=y)
View MergeSort.scala
1 2 3 4 5 6 7 8 9 10
 
import scala.concurrent.Await
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.concurrent.Future
import scala.util.Random
import akka.actor.{ActorSystem, Actor, Props}
import akka.pattern.ask
import akka.util.Timeout
import akka.routing.RoundRobinPool
View parallel_merge_sort.py
1 2 3 4 5 6 7 8 9 10
import math
import multiprocessing
import random
import sys
import time
 
 
def merge(*args):
# Support explicit left/right args, as well as a two-item
# tuple which works more cleanly with multiprocessing.
View django_browsable_email_backend.py
1 2 3 4 5 6 7 8 9 10
from tempfile import NamedTemporaryFile
import webbrowser
from django.core.mail import EmailMultiAlternatives
 
 
class BrowsableEmailBackend(BaseEmailBackend):
 
def send_messages(self, email_messages):
for message in email_messages:
for body, content_type in getattr(message, "alternatives", []):
View hardcoded_url_field.py
1 2 3 4 5 6 7 8 9 10
from rest_framework import serializers
 
class HyperlinkedIdentityField(serializers.HyperlinkedIdentityField):
"""
This is a performance wrapper for HyperlinkedIdentityField.
We save a ton of time by not calling reverse potentially
thousands of times per request.
"""
 
def __init__(self, *args, **kwargs):
View metrics.py
1 2 3 4 5 6 7 8 9 10
import os
import time
 
from django.conf import settings
from django.contrib.auth.models import User
from django.core.management.base import NoArgsCommand
from django.db.models import Sum
import psutil
import redis
import statsd
Something went wrong with that request. Please try again.