import os
from post import Post
import datetime
from app import create_app, db
app = create_app('production')
if __name__ == '__main__':
app.app_context().push()
db.session.query(Post).delete()
posts = []
for i in range(0, 100000):
posts.append(Post({
'id': i,
'location': 'location',
'latitude': 124.2,
'description': 'text',
'content_total_value': 10,
'featured': 0,
'longitude': 125.2,
'parent_post_id': 0
}))
db.session.bulk_save_objects(posts)
db.session.commit()
print('END')
def test_create_post(self):
p = Post("Titulek", "Obsah")
self.assertEqual("Titulek", p.title)
self.assertEqual("Obsah", p.content)
def test_create_post(self):
p = Post('Test', 'Test Content')
self.assertEqual('Test', p.title)
self.assertEqual('Test Content', p.content)
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 create_new_post(self, title, content):
new_post = Post(title, content)
self.posts.append(new_post)
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 buy_post(post_id, id):
Post(post_id, None, None, None, None, None, None, user_bought=id).update_bought_post()
return redirect('/{}/'.format(id))
def create_post(
self, title,
content): # here we create a post and put it in self.post list
self.posts.append(Post(title, content))
import mlab from post import Post #1. Connect mlab.connect() #2. Create data p = Post(title="C4E21", author="Quan", content="Sap den project roi", likes=15) print(p.title) print(p.content) print(p.likes) print(p.author) #3. Write data p.save()
def main():
data = Data().get_post()
Picture(data[0], data[1], data[2]).get_picture()
Post().create_post()
def create_post(self, title, content):
#this method receives title,content and create post(s)
"""we not receiving a post object,we have to create it"""
self.posts.append(Post(title, content))
def create_posts(tags: List['Tag']) -> List[Post]:
"""
Returns a list of Post objects with Comment objects as attributes, created
from tags.
"""
return [Post(tag) for tag in tags]
def test_print_post(self):
post = Post('Test', 'Test Content')
expected = app.POST_TEMPLATE.format('Test', 'Test Content')
with patch('builtins.print') as mock_print:
app.print_post(post)
mock_print.assert_called_with(expected)
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 index():
post = Post(db, auth)
response.view = '%s/admin/manage.html' % myconf.take('general.theme')
return dict(grid=post.grid())
@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 comment():
post = Post(db, auth)
print "defined tables:" + str(db.tables())
return response.json(
{'collection': add_json_head(post.get_comment(), response)})
def create_post(self, title, content):
self.posts.append(Post(title, content))
def test_is_thread_true():
a = Post(1, "foo", 2, "thread")
assert (a.is_thread())
def setUp(self):
self.p = Post('Title Post','Content Post')
def test_is_thread_false():
a = Post(1, "foo", 2, "comment")
b = a.is_thread()
assert (b == False)
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
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
def test_json(self):
p = Post("Titulek", "Obsah")
expected = {"title": "Titulek", "content": "Obsah"}
self.assertDictEqual(expected, p.json())
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)
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({
* 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 test_json(self):
p = Post('Test', 'Test Content')
expected = {'title': 'Test', 'content': 'Test Content'}
self.assertDictEqual(expected, p.json())
def blog_decode(some_dict):
if set(some_dict.keys()) == {"__class__", "__args__", "__kw__"}:
class_ = eval(some_dict["__class__"])
return class_(*some_dict["__args__"], **some_dict["__kw__"])
else:
return some_dict
if __name__ == "__main__":
travel = Blog("Travel")
travel.title = "derdoo"
travel.append(
Post(date=datetime.datetime(2016, 6, 14, 1, 31, 24),
title="Dlo Bagari",
rst_text=" some other text",
tags=("#233AS", "#SDE45S")))
travel.append(
Post(date=datetime.datetime(2016, 6, 14, 1, 31, 24),
title="Dlo Bagari2",
rst_text=" some other text2",
tags=("#455AS6", "#66E4567")))
#output show how object translated from python to json notation
#indent is formationg option, is mean 4 space as in python
encoder = json.dumps(travel, indent=4, default=blog_encode2)
print(encoder)
#write json to file
with open("temp.json", "w", encoding="UTF-8") as target:
json.dump(travel, target, separators=(',', ':'), default=blog_encode2)
