def receive(self, message):
post = Post()
html_bodies = message.bodies('text/html')
img_links = []
video_links = []
for content_type, body in html_bodies:
decoded_body = body.decode()
img_links.extend(self.find_image_links(decoded_body))
video_links.extend(self.find_video_links(decoded_body))
if hasattr(message, "attachments") and message.attachments:
post.attachments = []
for attachment in message.attachments:
post.attachments.append(db.Blob(attachment[1].decode()))
plaintext_bodies = message.bodies('text/plain')
allBodies = '';
for body in plaintext_bodies:
allBodies = allBodies + body[1].decode()
if hasattr(message, "subject"):
subject, encoding = decode_header(message.subject)[0]
post.caption = unicode(subject)
post.author = message.sender
post.content = allBodies
post.images = img_links
post.videos = video_links
post.source = "email"
post.put()
def __init__(self, src_path, exclude=() ):
post_list = []
for file_path in os.listdir(src_path):
if not file_path.endswith('.py') or file_path in SOURCE_EXCLUDE:
# TODO convert to regex matching
continue
full_path = os.path.join(src_path, file_path)
try:
post = Post(full_path)
post_list.append(post)
except Exception as e:
import traceback
traceback.print_exc()
print 'Error creating Post from '+str(full_path)+':'+str(e)
continue
self.posts = sorted(post_list, key=lambda p: p.updated)
self._check_monotonic()
self._resolve_links()
for post in self.posts:
errors = post.get_errors()
for error in errors:
print 'Error in',post.filename,'on line',str(error.line)+': ',error.message,
if error.text: print '('+error.text+')'
print
def update_site(self):
"""Updates only the static pages"""
files = os.listdir(self.datadir)
for f in files:
if f[0] != '.': # leave out hidden files
post = Post(self.datadir+f)
post.write(self.posts, self.tags)
def main():
# READ TEMPATE HTML FILES
base_html = open("templates/base.html")
post_html = open("templates/post.html")
# CREATE PAGE
page = base_html.readlines()
posts = []
# OPEN POST TXT FILES
postfiles = [ f for f in listdir("posts") if isfile(join("posts",f)) ]
for postfile in postfiles:
temp = open("posts/" + postfile, "r")
postlines = temp.readlines()
post_obj = Post(postlines[0], postlines[1], postlines[2:])
posts.append("".join(post_obj.render(post_html)))
post_html.seek(0)
temp.close()
# INSERT POSTS INTO PAGE
for i in range(len(page)):
page[i] = page[i].replace("[[posts]]", "\n\n".join(posts))
# WRITE PAGE TO OUTPUT HTML FILE
final = open("output/final.html", "a+")
final.write("".join(page))
# CLOSE FILES
base_html.close()
post_html.close()
def print_post(args):
if 'all' in args.postid:
posts = Post.load()
else:
try:
ids = [int(x) for x in args.postid]
except ValueError:
print('Post IDs should be numbers')
return
posts = Post.load(ids)
if not len(posts):
print('Post ID(s) not found: {}'.format(' '.join(args.postid)))
return
if args.s:
posts = order_by_date(posts)
for postid in posts.keys():
if len(posts[postid]['body']) > 74:
body = '\n '.join(trunc(posts[postid]['body'], 74))
else:
body = posts[postid]['body']
print('Title: {}\nPost ID: {}, last modification date: {}\nBody: {}'
.format(posts[postid]['title'],
postid,
posts[postid]['date'],
body))
print('-' * 80)
def publish(post_meta):
doc_id = Post.url_friendly_text(post_meta["title"])
# Open the database
couch = couchdb.Server()
db = couch["mrvoxel_blog"]
# Load the database settings
blog_settings = settings.loadSettings(db)
# Check to see if we have a valid category
if not post_meta["category"] in blog_settings["blog_categories"]:
raise ValueError("No such category: %s" % post_meta["category"])
print "checking for [%s]" % doc_id
# Load the post (if it exists in our database)
post = Post.load(db, doc_id)
# If it exists, warn the user
if post:
raw = raw_input("This will replace an existing post of the same title...\nContinue? (y/N)")
# if the existing post is published but we're trying to preview
if (post["published"] == False) and post_meta["published"]:
raise ValueError("Cannot yet preview posts that are already published")
if raw != "y":
print "Canceling publish."
return None
else:
for k, v in post_meta.iteritems():
if k not in ["published", "title"]:
print k
post[k] = v
print post
"""
post.markdown = mdtext
post.html = html
post.author = author
post.timestamp = timestamp
post.published = not preview
post.title = title
post.tags = tags
post.category = category
"""
post.store(db)
else:
post = Post.create(**post_meta)
print post["_id"]
post.store(db)
print post["_id"]
return post["_id"]
def load_post(self):
""" load post
"""
for post_source in glob.glob(self.post_path + self.post_pattern):
post = Post()
post.load_from_file(post_source)
# self.posts.append(post)
self.post_mapping[post.link] = post
def post(self):
user = users.get_current_user()
if user:
post = Post(parent = Post.post_db_key(), author = user, content = self.request.get("content"))
post.put()
self.redirect('/')
def new_post(self, title, content, date=datetime.datetime.utcnow()):
post = Post(blog_id=self._id,
title=title,
content=content,
author=self.author,
# formats the date string object into datetime
date=date)
post.save_to_mongo()
def mod_post(args):
posts = Post.load()
if not args.title and not args.body:
print('Either title or body are required for post modificaion')
else:
p = Post(args.title or posts[args.postid]['title'],
args.body or posts[args.postid]['body'],
postid=args.postid)
p.save()
def get(self):
post_id = self.request.get('post_id')
user_id = self.user.key().id()
if user_id and post_id and not LikePostRelation.check_like_status(user_id,post_id):
Post.updateLike(post_id)
like_post_relation = LikePostRelation.create_like_post_relation(user_id,post_id)
like_post_relation.put()
self.redirect('/blog/%s' % post_id)
def render_latest_posts(self, limit):
accu = ''
for post_path in self.latest_posts(limit):
post = Post(post_path)
accu += post.render('short-post')
output = open(os.path.join(
self.__render_base_path, 'latest_posts.rst'), 'w')
output.write(accu)
output.close()
def render_latest_posts(self, limit):
accu = ''
for post_path in self.latest_posts(limit):
post = Post(post_path)
accu += post.render("short-post")
output = open(os.path.join(
self.__render_base_path, "latest_posts.rst"), "w", encoding='utf-8')
output.write(accu)
output.close()
def get_post(self, post_id):
post = self.loaded_posts.get(post_id, None)
if post is None:
path = u"{0}/{1}.md".format(self.working_dir, post_id)
if os.path.exists(path):
post = Post(post_id, working_dir=self.working_dir)
self.loaded_posts[post_id] = post
else:
post.refresh()
return post
def get(self):
post_id = self.request.get('post_id')
if not self.user or not post_id:
self.redirect('/blog/%s' % post_id)
post = Post.by_id(post_id)
if post and post.created_by == self.user.key().id():
Post.delete(post_id)
self.redirect('/blog')
def post(self):
user = users.get_current_user()
if not user or not users.is_current_user_admin():
self.redirect(users.create_login_url(self.request.uri))
return
post = Post()
post.title = self.request.POST['title']
post.put()
self.redirect('/admin/posts/edit/' + str(post.key.id()))
def post(arg):
"""defines post command"""
postTypes = ["text", "photo", "quote", "link", "chat", "audio", "video"]
postStates = ["published", "draft", "queue", "private"]
args = arg.split(" ")
if args[0] in postTypes:
if args[0] == "text":
if '"' in args[1]:
quote_text = re.findall('"([^"]*)"', arg)
text = ""
if len(quote_text) > 1:
text = quote_text[0]
text_post = {"title": "", "state": "", "blog": "", "tags": []}
if "--title" in args:
if len(quote_text) == 1:
text_post['title'] = quote_text[0]
else:
text_post['title'] = quote_text[1]
if "-s" in args:
state = args[args.index('-s') + 1]
if state in postStates:
text_post['state'] = state
else:
print "Invalid state value found: " + state
print "Posting now"
if "-b" in args:
text_post['blog'] = args[args.index('-b') + 1]
else:
text_post['blog'] = USERNAME
if "-t" in args:
for s in args[args.index("-t") + 1:]:
if s not in ["--title", "-b", "-s"]:
text_post['tags'].append(s)
else:
break
print text_post
newPost = Post(client, text_post['blog'], "text", text_post['tags'])
newPost.publish(text_post['state'], title=text_post['title'], body=text)
else:
print "No text content found! Text must be in quotes."
else:
print "Invalid post type: " + args[0]
def get(self, post_id=None, action=None):
if action is None:
posts = Post.all()
self.response.out.write(helper.render('admin/posts', { 'posts': posts }))
elif action == "delete":
Post.get_by_id(int(post_id)).delete()
return self.redirect('/admin/posts')
elif action == "confirm":
post = Post.get_by_id(int(post_id))
post.confirmed_at = datetime.datetime.today()
post.put()
return self.redirect('/admin/posts')
def run(self):
while 1 == 1:
try:
for url in self.urls:
self.urls.remove(url)
print(url)
opener = urllib2.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)')]
response = opener.open(url)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
text = soup.text
links = soup.find_all('a')
images = soup.find_all('img')
post = Post(self.connection, url, url, 'url')
post.save()
download_path = 'sites/' + url
if not os.path.exists(download_path):
os.makedirs(download_path)
for image in images:
print('image')
src = urljoin(url, image.get('src'))
if src.startswith("http") or src.startswith("https"):
fname = self.basename(src)
if fname != None:
self.download_file(src, download_path + fname)
print('ok')
'''self.reset_config()
for p in self.config:
textElements = re.findall(p['regex'], text)
if textElements != None:
for element in textElements:
post = Post(self.connection, element, element, p['type'])
post.save()'''
for link in links:
href = urljoin(url, link.get('href'))
if href.startswith("http") or href.startswith("https"):
fname = self.basename(href)
if fname in self.extensions:
self.download_file(href, download_path + fname)
self.urls.append(href)
except:
pass
def create_post_with_bugs(data, cur, bugs=None):
post = Post(data)
if bugs != None:
post.populatebugs(bugs)
else:
cur.execute('''SELECT titles.title, bug.bugid, bug.status
FROM bugtitles AS titles, postbugs AS bug
WHERE bug.userid = ?
AND bug.postdate = ?
AND bug.bugid = titles.bugid''',
(post.userid, post.postdate.toordinal()))
post.populatebugs([Bug(title, id, statusnum) for title, id, statusnum in cur.fetchall()])
return post
def post(self,post_id):
if not self.user:
self.redirect('/blog/%s' % post_id)
subject = self.request.get('subject')
content = self.request.get('content')
user_id = self.user.key().id()
last_modified = datetime.datetime.now()
post = Post.by_id(post_id)
if post and post.created_by == user_id:
Post.update(post_id,subject,content,last_modified)
self.redirect('/blog/%s' % post_id)
def main():
try:
opts, args = getopt.getopt(
sys.argv[1:], "ht:d:s:p:", ["title", "help", "publish="])
except getopt.GetoptError:
usage()
sys.exit(2)
for opt, arg in opts:
if opt in ('-h', '--help'):
usage()
sys.exit()
elif opt in ('-p', '--publish'):
p = Post(arg)
p.write()
print('Post/page published, you might want to update now.')
elif opt in ('-t', '--title'):
# one-time modification of the template
f = codecs.open(templatedir+'base.html', 'r', encoding)
soup = BeautifulSoup(f.read(), 'html.parser')
f.close()
tag = soup.find('title')
tag.contents[0].replaceWith(arg + '${self.title()}')
tag = soup.find('a', 'title')
tag.contents[0].replaceWith(arg)
f = codecs.open(templatedir+'base.html', 'w', encoding)
f.write(str(soup).decode(encoding))
f.close()
print('Title was set to:' + arg)
sys.exit()
else:
assert False, "unhandled option"
blog = Blog()
for a in args:
if a == 'index':
blog.index()
elif a == 'archive':
blog.archive()
if args == []:
if site_type == 'blog':
print("--> Updating your blog")
blog.update_blog()
else:
print("--> Updating your site")
blog.update_site()
def list_posts():
request_data = get_json(request)
if 'thread' in request_data:
code, response = Post.list_by_thread(request_data['thread'], request_data)
elif 'forum' in request_data:
code, response = Post.list_by_forum(request_data['forum'], request_data)
else:
code, response = Codes.UNKNOWN_ERROR, 'Please enter thread or forum'
return json.dumps(
{'code': code,
'response': response}
)
def post(self):
if not self.user:
self.redirect('/blog')
subject = self.request.get('subject')
content = self.request.get('content')
created_by = self.user.name
if subject and content:
p = Post(parent = blog_key(), subject = subject, content = content, created_by = created_by)
p.put()
self.redirect('/blog/%s' % str(p.key().id()))
else:
error = "subject and content, please!"
self.render("newpost.html", subject=subject, content=content, error=error)
def post(self, post_subject):
# If any user does not logged in redirect to homepage
if not self.user:
self.redirect("/login")
post_to_delete = Post.find_by_subject(post_subject)
# If post couldn't find redirect 404 page
if not post_to_delete:
self.error(404)
return self.render('404.html')
if not self.user.owner_of(post_to_delete):
self.redirect("/")
else:
# delete post likes
for like in post_to_delete.postlike_set:
like.delete()
# delete comment and comment likes
for comment in post_to_delete.comment_set:
for like in comment.commentlike_set:
like.delete()
comment.delete()
# finally delete the post's itself
post_to_delete.delete()
self.redirect('/')
def get(self):
posts = Post.all().order('-created')
if self.user:
self.render('front.html', posts = posts,username = self.user.name)
else:
self.render('front.html', posts = posts)
def post(self, post_subject):
# If any user does not logged in redirect to homepage
if not self.user:
self.redirect('/')
# Post page contains a form to post comments,
# so a post request comes, lets put that comment into database
post_to_comment = Post.find_by_subject(post_subject)
# If post couldn't find redirect 404 page
if not post_to_comment:
self.error(404)
return self.render('404.html')
content = self.request.get('content').strip()
if content:
comment = Comment(
content=content,
post=post_to_comment,
user=self.user)
comment.put()
self.redirect(post_to_comment.link_to('show'))
else:
errors = {'content': "can't be blank"}
self.render(
"/posts/post.html", post=post_to_comment,
errors=errors)
def get(self):
db_sessions = db.Query(Session).filter('active =',True).order('ordering').fetch(100)
sessions = []
for s in db_sessions:
cur = {
'name' : s.name,
'day_of_week' : s.day_of_week,
'start_time' : s.start_time,
'end_time' : s.end_time,
'location' : s.location,
'quoted_loc' : quote(s.location),
'description' : s.description,
'member_price' : s.member_price,
'casual_price' : s.casual_price,
'courts' : s.courts,
'leader' : s.leader,
'coords' : s.coordinates,
}
if s.leader:
leader_name = s.leader.strip().split(' ')
cur['email'] = get_email(*leader_name[0:2])
else:
cur['email'] = 'holy moly'
sessions.append(cur)
data = {
'pages' : Post.get_pages(),
'session' : util_sess.Session(),
'sessions' : sessions,
}
return self.response.out.write(template.render('session/sessions.html',data))
def post(self, post_subject):
# If any user does not logged in redirect to homepage
if not self.user:
self.redirect('/')
post_to_update = Post.find_by_subject(post_subject)
# If post couldn't find redirect 404 page
if not post_to_update:
self.error(404)
return self.render('404.html')
# If user is not owner of the post, redirect with an error
if not self.user.owner_of(post_to_update):
self.redirect("/")
else:
values = {
'subject': self.request.get('subject'),
'content': self.request.get('content')}
if values['subject'] and values['content']:
values = {
'subject': self.request.get('subject').strip(),
'content': self.request.get('content').strip()}
post_to_update.subject = values['subject']
post_to_update.content = values['content']
post_to_update.put()
self.redirect(post_to_update.link_to('show'))
else:
errors = {}
if not values['subject']:
errors['subject'] = "can't be blank"
if not values['content']:
errors['content'] = "can't be blank"
self.render("/posts/edit.html", values=values, errors=errors)
def get(self):
db_posts = db.GqlQuery(
"""
SELECT * FROM Post
WHERE type IN ('announcement', 'news')
AND active = TRUE
ORDER BY date
DESC LIMIT 5
"""
)
posts = []
au_tz = pytz.timezone("Australia/Sydney")
utc_tz = pytz.utc
for db_post in db_posts:
post = SimplePost(
db_post.key,
db_post.title,
db_post.author,
utc_tz.localize(db_post.date).astimezone(au_tz),
db_post.content,
)
posts.append(post)
data = {
"upcoming": next_session_widget(8),
"picofday": pic_of_day_widget(),
"posts": posts,
"session": sessions.Session(),
"pages": Post.get_pages(),
}
return self.response.out.write(template.render("index.html", data))
def create_post(self, title, content):
self.posts.append(Post(title, content))
@app.route("/post/<int:blog_id>")
def get_post(blog_id):
id_exists = False
current_post = None
for post in all_posts:
if post.id == blog_id:
current_post = post
id_exists = True
# no need to check the rest
break
# just show the main page for non-existing blog_id's, rather than a semi-broken post.html
if id_exists:
return render_template("post.html", post=current_post, year=get_current_year())
else:
return render_template("index.html", posts=all_posts, year=get_current_year())
# get the test blog posts
response = requests.get(JSON_URL)
response.raise_for_status()
blog_posts = response.json()
# store posts as objects in a list
all_posts = []
for blog_post in blog_posts:
all_posts.append(Post(blog_post["id"], blog_post["author"], blog_post["date"], blog_post["title"],
blog_post["subtitle"], blog_post["image_url"], blog_post["body"]))
if __name__ == "__main__":
app.run(debug=True)
def test_json(self):
p = Post('test', 'test content')
expected = {'title': 'test', 'content': 'test content'}
self.assertDictEqual(p.json(), expected)
from flask import Flask, render_template
import requests
from post import Post
app = Flask(__name__)
all_posts = requests.get(
url=" https://api.npoint.io/5abcca6f4e39b4955965").json()
post_list = []
for post in all_posts:
post_features = Post(post['id'], post['title'], post['subtitle'],
post['body'])
post_list.append(post_features)
@app.route('/')
def home():
return render_template("index.html", blogs=post_list)
@app.route("/post/<int:index>")
def show_post(index):
requested_post = None
for blog_post in post_list:
if blog_post.id == index:
requested_post = blog_post
return render_template("post.html", post=requested_post)
if __name__ == "__main__":
app.run(debug=True)
def view_post():
return render_template("view.html", posts=Post.all())
def posts():
posts = Post.objects()
return render_template('posts.html', posts=posts)
def delete(post_id):
post = Post.objects().with_id(post_id)
post.delete()
return redirect(url_for('posts'))
def post(post_id):
post = Post.objects().with_id(post_id)
return render_template('post.html', post=post)
from flask import Flask, render_template
from post import Post
app = Flask(__name__)
data = Post()
num_len = len(data.title)
@app.route("/")
def home():
return render_template(
"index.html",
title=data.title,
subtitle=data.subtitle,
body=data.body,
num_len=num_len,
)
@app.route("/post/<num>")
def get_blog(num):
i = int(num)
return render_template("post.html",
title=data.title[i],
subtitle=data.subtitle[i],
body=data.body[i])
if __name__ == "__main__":
app.run(debug=True)
def test_create_post(self):
p = Post("Titulek", "Obsah")
self.assertEqual("Titulek", p.title)
self.assertEqual("Obsah", p.content)
def get(self):
posts = Post.query().order(-Post.created)
count = posts.count()
self.render("front.html", count=count, posts=posts)
def test_json(self):
p = Post('Test', 'Test Content')
expected = {'title': 'Test', 'content': 'Test Content'}
self.assertDictEqual(expected, p.json())
def post_entries():
return render_template("post_entries.html", posts=Post.all(request.args.get('available_from'), request.args.get('available_to')))
from flask import Flask
from flask import render_template, request, redirect, url_for
from post import Post
app = Flask(__name__)
db = {1: Post(1, 'Post 1', 'Gosho', 'Content 1')}
@app.route('/')
def hello_world():
return 'Hello, World!!!'
@app.route('/posts')
def list_posts():
return render_template('posts.html', posts=db.values())
@app.route('/posts/<int:id>')
def show_post(id):
post = db[id]
return render_template('post.html', post=post)
@app.route('/posts/new', methods=['GET', 'POST'])
def new_post():
if request.method == 'GET':
return render_template('new_post.html')
elif request.method == 'POST':
next_id = max(db.keys()) + 1
post = Post(next_id, request.form['name'], request.form['author'], request.form['content'])
db[next_id] = post
return redirect(url_for('list_posts'))
def setUp(self):
self.p = Post('Title Post','Content Post')
def test_create_post(self):
p = Post('Test', 'Test Content')
self.assertEqual('Test', p.title)
self.assertEqual('Test Content', p.content)
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
user = users.get_current_user()
myuser = None
timeline_posts = []
following_users = []
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'Log Out'
myuser =''
myuser_key = ndb.Key('User', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = User(id = user.user_id(), email_address = user.email())
myuser.username = user.email()
myuser.put()
else:
for i in myuser.following:
following_users.append(i)
following_users.append(myuser.key)
timeline_posts = Post.query(Post.owner_user.IN(following_users)).order(-Post.date).fetch()
else:
url = users.create_login_url(self.request.uri)
url_string = 'Log In'
#passing to html page
template_values = {
'url' : url,
'url_string' : url_string,
'user': user,
'myuser' : myuser,
'upload_url': blobstore.create_upload_url('/upload'),
'timeline_posts': timeline_posts
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def test_json(self):
p = Post("Titulek", "Obsah")
expected = {"title": "Titulek", "content": "Obsah"}
self.assertDictEqual(expected, p.json())
def create_new_post(self, title, content):
new_post = Post(title, content)
self.posts.append(new_post)
from flask import Flask, render_template
from post import Post
from datetime import date
# PROPS
app = Flask(__name__)
posts = Post().get_posts()
current_year = date.today().year
# METHODS
@app.route("/")
def get_home():
return render_template("index.html", all_posts=posts, year=current_year)
@app.route("/post/<int:index>")
def get_post(index):
return render_template("post.html", post=posts[index - 1], year=current_year)
# MAIN
if __name__ == "__main__":
app.run(debug=True)
def new_post(self,title,content,date=datetime.datetime.utcnow()):
post = Post(blog_id=self._id,title=title,content=content,author=self.author,date=date)
post.save_to_mongo()
def test_is_thread_false():
a = Post(1, "foo", 2, "comment")
b = a.is_thread()
assert (b == False)
* Day: 57- Jinja Donamic Html Pages - Project Blog *
* Date: 2021-01-20 *
*************************************************************************
"""
from flask import Flask, render_template
from datetime import date
import requests
from post import Post
actual_year = date.today().year
url = 'https://api.npoint.io/5abcca6f4e39b4955965'
posts = requests.get(url).json()
post_objects = []
for post in posts:
post_obj = Post(post['id'], post['title'], post['subtitle'], post['body'])
post_objects.append(post_obj)
app = Flask(__name__)
@app.route('/')
def home():
return render_template("index.html",
year=actual_year,
all_posts=post_objects)
@app.route('/post/<int:index>')
def show_post(index):
requested_post = None
def get(self):
deleted_post_id = self.request.get('deleted_post_id')
posts = greetings = Post.all().order('-created')
self.render('front.html', posts=posts, deleted_post_id=deleted_post_id)
def dados_posts_banco(self):
"""
Armazena o conteúdo da chave "items" de um json recebido via requisição GET em um banco MongoDB
colecao (MongoDB Collection)
url (REST API url)
paginas (int)
"""
for x in range(1, self.paginas):
print("iniciando requisição na linha ", x)
# requere usando o URL e o número de páginas, guarda o conteúdo da requisição em json_data
json_data = requisicao(url, pagina=x)
# se a requisição não vier vazia
if json_data is not None:
# checa se o campo "items" tem elementos a serem colhidos
tamanho_resposta = len(json_data["items"])
if tamanho_resposta > 0:
# se for maior que zero, continua e insere no banco
# começa o processo de filtragem
items = json_data["items"]
for item in items:
try:
json_post = {}
post_id = item["id"]
post_titulo = item["content"]["title"]
#post_titulo.replace("'","''")
post_data_publicacao = item["publication"]
post_resumo = item["content"]["summary"]
post_url = item["content"]["url"]
if post_id is None and post_titulo is not None:
print("ID do post inválido")
pass
elif post_titulo is None:
print("Título do post inválido")
continue
elif post_data_publicacao is None:
print("Data da publicação inválida")
continue
elif post_resumo is None:
print("Resumo do post inválido")
continue
elif post_url is None:
print("URL do post inválido")
continue
json_id = {"_id": post_id}
json_titulo = {"titulo": post_titulo}
json_data_publicacao = {"data_publicacao": post_data_publicacao}
json_resumo = {"resumo": post_resumo}
json_post_url = {"post_url": post_url}
json_post.update(json_id)
json_post.update(json_titulo)
json_post.update(json_data_publicacao)
json_post.update(json_resumo)
json_post.update(json_post_url)
# cria um objeto post com o conteúdo coletado em json
post = Post(json_post)
if self.sgbd == 'sqlite':
# inicializa a variavel caso ela não seja ocupada por causa de exceção
id_inserido = None
try:
id_inserido = banco_sqlite.inserir(post)
except TypeError:
print("inserção falhou com id do post: ", post_id)
if id_inserido == None:
print("inserção falhou com id do post: ", post_id)
# se retornou um id não vazio, inserção ocorreu sem problemas
else:
print("Post inserido com id: ", id_inserido)
"""
Comentar o trecho que trata do mongo, pois não vamos usar por enquanto
elif self.sgbd == 'mongodb':
pass
else:
print("SGBD inválido, não consigo salvar os dados")
break
if id_inserido is not None:
print("Post inserido com id: ", id_inserido)
else:
print("inserção falhou com id do post: ", post_id)
"""
del post
except KeyError as e:
print("Chave não encontrada", e)
else:
# página não tem elemento "items", exibe erro e interrompe o programa
print("Resposta do servidor sem conteúdo na página ", x)
break
else:
# requisição não recebeu nenhum dado, interrompe o programa
print("requisição vazia recebida na linha ", x)
break
from urllib.parse import unquote
def youdao(file_path):
with open(file_path, 'r', encoding='utf-8') as f:
txt = f.read()
pic_iter = re.finditer(r'\!\[.*?\]\((.*?)\)', txt)
for tag in pic_iter:
pic_path = unquote(
tag.group(1)) #图片名称含有汉字时，有道云笔记采用url编码的方式来记录，所以解码找到对应的图片位置
if re.search(r'^file:///(.+?)', pic_path):
pic_path = re.search(r'^file:///(.+)', pic_path).group(1)
print(pic_path)
pic_name = str(time.time()).replace('.', '') + '.png'
pic_url = post.upload_pic(pic_path, pic_name)
txt = txt.replace(tag.group(1), pic_url)
return txt
if __name__ == '__main__':
post = Post()
post.login()
category_name = 'WEB'
category_slug = 'web'
title = 'windows下使用phpstudy配置sqlilabs'
category_mid = post.category(category_name, category_slug)
file_path = r'D:\桌面\44.md'
text = youdao(file_path)
if category_mid:
post.send_text(title, text, category_mid)
print('发送成功')
def get_posts(self):
return Post.from_blog(self._id)
from flask import Flask
from flask import render_template
import datetime
from person import Person
import requests
from post import Post
app = Flask(__name__)
all_posts = all_posts = requests.get(
"https://api.npoint.io/5abcca6f4e39b4955965").json()
post_objects = []
for post in all_posts:
post_obj = Post(post["id"], post["title"], post["subtitle"], post["body"])
post_objects.append(post_obj)
@app.route('/')
def home_page():
year = datetime.datetime.today().year
return render_template("index.html", current_year=year)
@app.route('/guess/<name>')
def guesser(name):
person = Person(name=name)
return render_template(
"guess.html",
name=person.name,
gender=person.gender,
age=person.age,
def update_one_post(post_id, new_title):
post = Post.objects().with_id(post_id)
# post[key] = new
# update
# slug
post.update(set__title=new_title)
import time
from selenium import webdriver
from selenium.common import exceptions
from bs4 import BeautifulSoup
import pandas as pd
from page import Page
from post import Post
from scrap import Scrap
session = webdriver.Firefox(executable_path=r'C:\geckodriver.exe')
main_page = Page()
post = Post()
scrap = Scrap()
main_page.load_page(session)
main_page.show_all_posts(session)
bs = BeautifulSoup(session.page_source, 'html.parser')
list_posts = post.get_all_posts(session)
post.title, post.date, post.excerpt, post.url = [], [], [], []
for p in list_posts:
post.title.append(scrap.get_titles(p))
post.date.append(scrap.get_dates(p))
post.excerpt.append(scrap.get_excerpts(p))
post.url.append(scrap.get_url_image(bs))
df = pd.DataFrame({
