class Content(ParseObject):
# Class Properties
_embedly_client = Embedly("74388f950f1d4a4f965cd185bfff2df3")
_parse_client = parse_rest.connection.register(
"OLjnAy2bGdU2J1AcQ118Ay5MV20ekLPqCb8U299K",
"9rTz13ih8HEXNqnzT5jvBR0ExfkFNSl3kJA2J7G8")
# Initializers
def __init__(self, source_url):
ParseObject.__init__(self)
obj = Content._embedly_client.oembed(source_url)
self.object_description = obj[
'description'] if 'description' in obj else None
self.title = obj['title'] if 'title' in obj else None
self.url = source_url
self.thumbnail_url = obj[
'thumbnail_url'] if 'thumbnail_url' in obj else None
self.provider_name = obj[
'provider_name'] if 'provider_name' in obj else None
self.type = obj['type'] if 'type' in obj else 'unknown'
# Push Handlers
def push(self):
message = "Your next Mystery Box is ready to be opened!"
ParsePush.message(message, channels=[""])
def replace(match):
url = match.group('url')
try:
url_validate(url)
if match.group('kind') == 'externaltask':
return '<button class="external-task" data-url="%s">%s</button>' % (
url, # TODO: Should we escape/encode this somehow?
_('Start This Task')
)
expiration_date = datetime.now() - settings.EMBEDLY_CACHE_EXPIRES
embedded_urls = EmbeddedUrl.objects.filter(original_url=url,
created_on__gte=expiration_date).order_by('-created_on')
embedded_url = None
if embedded_urls.exists():
embedded_url = embedded_urls[0]
else:
embedly_key = getattr(settings, 'EMBEDLY_KEY', False)
if embedly_key:
client = Embedly(embedly_key)
obj = client.oembed(url, maxwidth=460)
embedded_url = EmbeddedUrl(original_url=obj.original_url,
html=(obj.html or ''), extra_data=obj.dict)
embedded_url.save()
if embedded_url and embedded_url.html:
return embedded_url.html
except ValidationError:
return '[embed:Invalid Url]'
return DEFAULT_EMBED % (url, url)
def replace(match):
url = match.group('url')
try:
url_validate(url)
expiration_date = datetime.now() - settings.EMBEDLY_CACHE_EXPIRES
embedded_urls = EmbeddedUrl.objects.filter(
original_url=url,
created_on__gte=expiration_date).order_by('-created_on')
embedded_url = None
if embedded_urls.exists():
embedded_url = embedded_urls[0]
else:
embedly_key = getattr(settings, 'EMBEDLY_KEY', False)
if embedly_key:
client = Embedly(embedly_key)
obj = client.oembed(url, maxwidth=460)
embedded_url = EmbeddedUrl(original_url=obj.original_url,
html=(obj.html or ''),
extra_data=obj.dict)
embedded_url.save()
if embedded_url and embedded_url.html:
return embedded_url.html
except ValidationError:
return '[embed:Invalid Url]'
return DEFAULT_EMBED % (url, url)
def embedly_link(URL):
#Takes a URL, returns a populated Link object
#Returns "error" if Embedly API fails
client = Embedly(embedly_key)
response = client.extract(URL)
try:
#Get link information from Embedly
headline = response['title']
URL = clean_url(response['url'])
summary = response['description']
source = response['provider_name']
path = page_path(headline)
keywords_response = response['keywords']
keyword1 = str(keywords_response[0]['name'])
keyword2 = str(keywords_response[1]['name'])
keyword3 = str(keywords_response[2]['name'])
keyword4 = str(keywords_response[3]['name'])
keyword5 = str(keywords_response[4]['name'])
#Create Link object with info from Embedly
link = Link(headline=headline,
url=URL,
source=source,
summary=summary,
path=path,
keyword1=keyword1,
keyword2=keyword2,
keyword3=keyword3,
keyword4=keyword4,
keyword5=keyword5,
votes=0)
return link
except:
return "error"
def replace(match):
url = match.group('url')
kind = match.group('kind')
external_task = (match.group('kind') == 'externaltask')
try:
url_validate(url)
except ValidationError:
return '[%s:Invalid Url]' % kind
for prefix in settings.P2PU_EMBEDS:
if url.startswith(prefix):
return render_to_string('richtext/_p2pu_embed.html', {'url': url})
if not external_task:
expiration_date = datetime.now() - settings.EMBEDLY_CACHE_EXPIRES
embedded_urls = EmbeddedUrl.objects.filter(original_url=url,
created_on__gte=expiration_date).order_by('-created_on')
embedded_url = None
if embedded_urls.exists():
embedded_url = embedded_urls[0]
else:
embedly_key = getattr(settings, 'EMBEDLY_KEY', False)
if embedly_key:
client = Embedly(embedly_key)
obj = client.oembed(url, maxwidth=460)
embedded_url = EmbeddedUrl(original_url=obj.original_url,
html=(obj.html or ''), extra_data=obj.dict)
embedded_url.save()
if embedded_url and embedded_url.html:
return embedded_url.html
context = {'url': url, 'external_task': external_task}
return render_to_string('richtext/_external_link.html', context)
def noembed(self):
"""
use noembed MILLER_EMBEDLY_API_KEY to get videos from url
"""
if self.url:
logger.debug('document {pk:%s, url:%s} init embedly' % (self.pk, self.url))
from embedly import Embedly
client = Embedly(settings.MILLER_EMBEDLY_API_KEY)
embed = client.oembed(self.url, raw=True)
self.contents = embed['raw']
def set_media():
link = request.form.get('value')
contribution = get_contribution(get_referer())
client = Embedly('a54233f91473419f9a947e1300f27f9b')
obj = client.oembed(link)
meta = obj.__dict__
media = {
'type': request.form.get('type'),
'url': meta.get('url'),
'meta': meta
}
contrib = update_media(media, get_referer())
return dumps(contrib)
def embedly(url):
try:
client = Embedly(settings.EMBEDLY_KEY)
obj = client.oembed(url)
except:
return None
if obj.type == "photo":
return '<a href="%s" class="embed"><img src="%s"></a>' % (obj.url,
obj.url)
return None
def get_article():
url = request.args.get('url')
client = Embedly('f2f84ff5013b443ab711b204590d9aa2')
result = client.extract(url)
article = {}
article["url"] = result["url"]
article["headline"] = result["title"]
article["description"] = result["description"]
article["content"] = result["content"]
response = make_response(json.dumps(article, indent=4))
response.headers['Access-Control-Allow-Origin'] = "*"
return response
def embedly(url, max_width=None, key=None):
from embedly import Embedly
# Get embedly key
if key is None:
try:
key = settings.WAGTAILEMBEDS_EMBEDLY_KEY
except AttributeError:
key = settings.EMBEDLY_KEY
warnings.warn(
"EMBEDLY_KEY is now deprecated. Use WAGTAILEMBEDS_EMBEDLY_KEY instead",
RemovedInWagtail14Warning)
# Get embedly client
client = Embedly(key=key)
# Call embedly
if max_width is not None:
oembed = client.oembed(url, maxwidth=max_width, better=False)
else:
oembed = client.oembed(url, better=False)
# Check for error
if oembed.get('error'):
if oembed['error_code'] in [401, 403]:
raise AccessDeniedEmbedlyException
elif oembed['error_code'] == 404:
raise EmbedNotFoundException
else:
raise EmbedlyException
# Convert photos into HTML
if oembed['type'] == 'photo':
html = '<img src="%s" />' % (oembed['url'], )
else:
html = oembed.get('html')
# Return embed as a dict
return {
'title': oembed['title'] if 'title' in oembed else '',
'author_name':
oembed['author_name'] if 'author_name' in oembed else '',
'provider_name':
oembed['provider_name'] if 'provider_name' in oembed else '',
'type': oembed['type'],
'thumbnail_url': oembed.get('thumbnail_url'),
'width': oembed.get('width'),
'height': oembed.get('height'),
'html': html,
}
def find_embed(self, url, max_width=None, key=None):
from embedly import Embedly
# Get embedly key
if key is None:
key = self.get_key()
# Get embedly client
client = Embedly(key=key)
# Call embedly
if max_width is not None:
oembed = client.oembed(url, maxwidth=max_width, better=False)
else:
oembed = client.oembed(url, better=False)
# Check for error
if oembed.get("error"):
if oembed["error_code"] in [401, 403]:
raise AccessDeniedEmbedlyException
elif oembed["error_code"] == 404:
raise EmbedNotFoundException
else:
raise EmbedlyException
# Convert photos into HTML
if oembed["type"] == "photo":
html = '<img src="%s" alt="">' % (oembed["url"], )
else:
html = oembed.get("html")
# Return embed as a dict
return {
"title":
oembed["title"] if "title" in oembed else "",
"author_name":
oembed["author_name"] if "author_name" in oembed else "",
"provider_name":
oembed["provider_name"] if "provider_name" in oembed else "",
"type":
oembed["type"],
"thumbnail_url":
oembed.get("thumbnail_url"),
"width":
oembed.get("width"),
"height":
oembed.get("height"),
"html":
html,
}
def find_embed(self, url, max_width=None, key=None):
from embedly import Embedly
# Get embedly key
if key is None:
key = self.get_key()
# Get embedly client
client = Embedly(key=key)
# Call embedly
if max_width is not None:
oembed = client.oembed(url, maxwidth=max_width, better=False)
else:
oembed = client.oembed(url, better=False)
# Check for error
if oembed.get('error'):
if oembed['error_code'] in [401, 403]:
raise AccessDeniedEmbedlyException
elif oembed['error_code'] == 404:
raise EmbedNotFoundException
else:
raise EmbedlyException
# Convert photos into HTML
if oembed['type'] == 'photo':
html = '<img src="%s" />' % (oembed['url'], )
else:
html = oembed.get('html')
# Return embed as a dict
return {
'title':
oembed['title'] if 'title' in oembed else '',
'author_name':
oembed['author_name'] if 'author_name' in oembed else '',
'provider_name':
oembed['provider_name'] if 'provider_name' in oembed else '',
'type':
oembed['type'],
'thumbnail_url':
oembed.get('thumbnail_url'),
'width':
oembed.get('width'),
'height':
oembed.get('height'),
'html':
html,
}
def clean(self):
# http://embed.ly/docs/api/extract/endpoints/1/extract#error-codes
self.data = {}
if settings.DJANGOCMS_EMBED_API_KEY is None:
msg = _(
'DJANGOCMS_EMBED_API_KEY is not defined in the project settings.'
)
logger.error(msg)
raise ImproperlyConfigured(msg)
client = Embedly(settings.DJANGOCMS_EMBED_API_KEY)
try:
data = client.extract(self.url)
except ValueError, e:
raise ValidationError(str(e))
def handle(self, *args, **options):
client = Embedly(key=os.environ.get('EMBEDLY_KEY'),
timeout=settings.EMBEDLY_TIMEOUT)
qs = (
Video.objects
# skip source-less videos
.filter(~Q(source_url='') & ~Q(source_url__isnull=True)).filter(
# attempt to obtain embed code for videos
Q(embed='') |
# or fix youtube videos with broken embed code
(Q(source_url__contains='youtube.com')
& ~Q(embed__contains='embed'))))
for video in qs:
video.fetch_embed(client=client)
video.save()
self.stdout.write(u'Updated %s' % video.title)
def fetch_embed(self, client=None):
"""
Update the embed data fields (embed and thumbnail_url) using embedly.
:param client: Embedly instance
:return:
"""
if not 'EMBEDLY_KEY' in os.environ:
return
client = client or Embedly(key=os.environ['EMBEDLY_KEY'],
timeout=settings.EMBEDLY_TIMEOUT)
try:
data = client.oembed(self.source_url).data
except socket.timeout:
return
# check for errors
if data['type'] not in ('video', ):
return
self.embed = data['html']
self.thumbnail_url = data.get('thumbnail_url', None)
@app.route('/search/lol', methods=['GET', 'POST'])
def wew():
form = forms.SearchTrace(request.form)
trends = ''
if request.method == 'POST' and form.validate():
key = request.form["searchTrace"]
trends = models.Search.query.filter_by(tweet=key).order_by(
models.Search.id.desc())
print trends
else:
trends = models.Search.query.order_by(models.Search.id.desc())
return render_template('trace.html', result=trends, form=form)
key = '29fd40eda47344aa93268b96a3e86879'
client = Embedly(key)
@app.route('/track/<path:key>')
def lol(key):
api = auth()
for item in api.request('statuses/filter', {'track': key}):
res = item['text'] if 'text' in item else item
retweet = item['retweet_count'] if 'text' in item else item
favorites = item['favorite_count'] if 'text' in item else item
name = item['user']['screen_name'] if 'text' in item else item
real = item['user']['name'] if 'text' in item else item
pic = item['user'][
'profile_image_url_https'] if 'text' in item else item
followers = item['user']['followers_count'] if 'text' in item else item
date = item['created_at'] if 'text' in item else item
# session for interactions outside of app context.
def gen_session():
return scoped_session(sessionmaker(bind=engine))
db_session = gen_session()
db_session.execute('SET TIMEZONE TO UTC')
# redis connection
rds = redis.from_url(settings.REDIS_URL)
# task queues
queues = {k: Queue(k, connection=rds) for k in TASK_QUEUE_NAMES}
# migrations
migrate = Migrate(app, db)
# gzip compression
Compress(app)
# optional bitly api for shortening
if settings.BITLY_ENABLED:
bitly_api = bitly.Connection(
access_token=settings.BITLY_ACCESS_TOKEN)
# optional embedly api for shortening
if settings.EMBEDLY_ENABLED:
embedly_api = Embedly(settings.EMBEDLY_API_KEY)
from rest_framework.renderers import JSONRenderer
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.contrib.auth.models import User
from django.http import HttpResponse
from django.utils import timezone
from django.contrib.admin.views.decorators import staff_member_required
from embedly import Embedly
from settings import EMBEDLY_KEY
from notifications import notify
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from forms import UsernameForm
from django.template.loader import render_to_string
from django.template import RequestContext
from django.core.urlresolvers import reverse
embedly_client = Embedly(EMBEDLY_KEY)
def index(request):
""" List all topics. """
if 'login_prefix' in request.session:
del request.session['login_prefix']
TOPICS_PER_PAGE = 6
paginator = Paginator(Topic.objects.filter(hidden=False).order_by(
'-featured', '-pinned', '-last_post'), TOPICS_PER_PAGE)
page = request.GET.get('page')
if request.user.is_authenticated():
p = request.user.profile
# using embedly with python
import csv
import itertools
import json
import requests
from urlparse import urljoin
# below currently works in the command line, but not sure how to translate it into this python document, run it and have it work
from embedly import Embedly
# key = 'f2f84ff5013b443ab711b204590d9aa2'
client = Embedly('f2f84ff5013b443ab711b204590d9aa2')
result = client.extract(
'https://medium.com/message/yes-to-the-dress-5ec06c06aca4')
article = {}
article["url"] = result["url"]
article["headline"] = result["title"]
article["description"] = result["description"]
article["content"] = result["content"]
print "URL:", result["url"]
print "Headline:", result["title"]
print "Description:", result["description"]
print "Article:", result["content"]
subjects_file = open("../articles/dressarticle.json", "w")
print >> json.dump(article, subjects_file, indent=4)
def get_client(key):
if not key:
return None
return Embedly(key)
def __init__(self):
self.client = Embedly(KEY)
def get_embedly_client():
api_key = get_setting('module', 'videos', 'embedly_apikey')
if not api_key:
api_key = "438be524153e11e18f884040d3dc5c07"
return Embedly(api_key)
from django import forms
from tendenci.apps.videos.models import Video
from tendenci.libs.tinymce.widgets import TinyMCE
from tendenci.apps.perms.forms import TendenciBaseForm
from embedly import Embedly
# Create Embedly instance
client = Embedly("438be524153e11e18f884040d3dc5c07")
class VideoForm(TendenciBaseForm):
description = forms.CharField(required=False,
widget=TinyMCE(
attrs={'style': 'width:100%'},
mce_attrs={
'storme_app_label':
Video._meta.app_label,
'storme_model':
Video._meta.model_name.lower()
}))
status_detail = forms.ChoiceField(choices=(('active', 'Active'),
('pending', 'Pending')))
clear_image = forms.BooleanField(required=False)
class Meta:
model = Video
fields = (
from embedly import Embedly
from chappy.config import Config
client = Embedly(Config.EMBEDLY_API_KEY)
def get_video_metadata(video_url):
data = client.extract(video_url)
data_dict = {
'source': data.get('provider_display'),
'length': data.get('media').get('duration'),
'html': data.get('media').get('html')
}
return data_dict
def get_img_metadata(img_url):
data = client.extract(img_url)
data_dict = {
'height': data.get('media').get('height'),
'width': data.get('media').get('width'),
}
return data_dict
from config import SECRET_KEY, GOOGLE_ID, GOOGLE_SECRET, EMBEDLY_KEY, CELERY_BROKER, REDIS_CACHE_URL
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_oauthlib.client import OAuth
from embedly import Embedly
from celery import Celery
from config import CELERY_BROKER
import redis
app = Flask(__name__)
app.config.from_object('config')
app.secret_key = SECRET_KEY
db = SQLAlchemy(app)
cli = Embedly(EMBEDLY_KEY)
redis_cache = redis.from_url(REDIS_CACHE_URL)
celery = Celery('app', broker=CELERY_BROKER)
oauth = OAuth(app)
google = oauth.remote_app(
'google',
consumer_key=GOOGLE_ID,
consumer_secret=GOOGLE_SECRET,
request_token_params={'scope': 'email'},
base_url='https://www.googleapis.com/oauth2/v1/',
request_token_url=None,
access_token_method='POST',
access_token_url='https://accounts.google.com/o/oauth2/token',
