def test_should_search_for_memes(self):
meme_repository_mock = Mock()
when(meme_repository_mock).search('a query', 10).thenReturn(['search_result1'])
when(meme_repository_mock).search('a query', 40).thenReturn(['search_result2'])
Meme.meme_repository = meme_repository_mock
assert Meme.search('a query') == ['search_result1']
assert Meme.search('a query', count=40) == ['search_result2']
def create_meme(ai_settings, screen, memes, meme_number, column_number):
"""create a meme and place it in the row"""
meme = Meme(ai_settings, screen)
meme_height = meme.rect.height
meme.rect.x = (meme.rect.width +
300) + 2 * meme.rect.height * column_number
meme.y = meme_height + 2 * meme_height * meme_number
meme.rect.y = meme.y
memes.add(meme)
def scrape_memes(soup: BeautifulSoup) -> list:
"""Scrapes the html to get a list of memes."""
memes = []
soup_meme = soup.select('td[class*="entry"]')
print(soup_meme)
for item in soup_meme:
meme = Meme(item.h2.get_text(strip=True), item.a['href'])
while MANUAL and not meme.is_alphanumspace():
meme.name = input(f'Replace {meme.name}:')
memes.append(meme)
return memes
def setUp(self):
class Gui(object):
def __init__(self, *x):
self.json = ''
self.count =0
def __getitem__(self, x):
return self
def __le__(self, x):
return self
def setAttribute(self, *x):
self.opacity = 0.5
def cling(self, *x):
pass
def send(self, operation, **x):
self.count +=1
self.json = x
self.gui = Gui()
self.gui.onclick = object()
self.app = Meme(self.gui)
def test_sources_have_content(self, mock_ts):
mock_ts.return_value.searchTweets.return_value = {
'content': {
'statuses': [{
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}, {
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}, {
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}]
}
}
t = Twitter()
m = Meme("all your * -base")
s = t.get_sources(m, 3).pop()
self.assertNotEqual(s.handle, "")
self.assertNotEqual(s.text, "")
self.assertNotEqual(s.link, "")
def test_gets_sources(self, mock_ts):
mock_ts.return_value.searchTweets.return_value = {
'content': {
'statuses': [{
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}, {
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}, {
'text': 'all your data',
'id_str': '471774952379932673',
'user': {
'name': 'bob'
}
}]
}
}
t = Twitter()
m = Meme("all your * -base")
self.assertGreater(len(t.get_sources(m, 3)), 0)
def test_should_get_meme_by_name(self):
meme_repository_mock = Mock()
when(meme_repository_mock).get('some_name').thenReturn('ok')
Meme.meme_repository = meme_repository_mock
assert Meme.get(name='some_name') == 'ok'
async def meme(ctx: discord.ext.commands.context.Context,
get_set,
name,
url=""):
await ctx.message.delete()
if get_set.lower().startswith("get"):
file = Meme.getter(name)
if file:
await ctx.send(ctx.author, file=file)
else:
await ctx.send(
f"Couldn't get {name}\nIf you want to save {name} you should use\n!meme set {name} {name}_url",
delete_after=5)
elif get_set.lower().startswith('set'):
Meme.setter(name, url)
await ctx.send(name + " set with sucess", delete_after=5)
def expand_vertex(v):
if v in expandedVertices:
return 0
expandedVertices.add(v)
G.set_vertex_attribute(v, "color", YELLOW_COLOR)
root_name = vertexes[v]
print "Getting friends of %s..." % root_name
friends = Meme.get(name=root_name).following(100)
if len(friends) <= 0:
color_node = GREEN_COLOR if vertexes[v] != screenname else RED_COLOR
G.set_vertex_attribute(v, "color", color_node)
for friend in friends:
friend_name = friend.name
if vertexes_invert.get(friend_name) is not None:
edge = G.new_edge(v, vertexes_invert[friend_name])
G.set_edge_attribute(edge, "arrow", "true")
else:
new_vertex = G.new_vertex()
G.set_vertex_attribute(new_vertex, "label", friend_name)
G.set_vertex_attribute(new_vertex, "shape", "sphere")
vertexes.update({new_vertex: friend_name})
vertexes_invert.update({friend_name: new_vertex})
edge = G.new_edge(v, new_vertex)
G.set_edge_attribute(edge, "arrow", "true")
color_node = GREEN_COLOR if vertexes[v] != screenname else RED_COLOR
G.set_vertex_attribute(v, "color", color_node)
return 0
def test_should_get_meme_by_name(self):
meme_reporitory_mock = Mock()
when(meme_reporitory_mock).get("some_name").thenReturn("ok")
Meme.meme_repository = meme_reporitory_mock
assert Meme.get("some_name") == "ok"
def test_should_get_meme_by_name(self):
meme_reporitory_mock = Mock()
when(meme_reporitory_mock).get('some_name').thenReturn('ok')
Meme.meme_repository = meme_reporitory_mock
assert Meme.get('some_name') == 'ok'
def read_scraped_memes(path: str) -> list:
memes = []
with open(path, 'r', newline='') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
meme = Meme(row[0], row[1])
memes.append(meme)
return memes
def _parse_find_result(self, cursor):
memes = set()
for record in cursor:
meme = Meme(record.get('post_id'), record.get('site'),
record.get('text'), record.get('media_url'),
record.get('processed'))
memes.add(meme)
return memes
def test_should_log_twitter_exception(self):
t = Twitter()
m = Meme("all your * -base")
old_file_size = os.stat('errors.log').st_size
old_secret = Secrets.access_token_secret
Secrets.access_token_secret = "wrong secret"
t.get_sources(m, 3)
self.assertGreater(os.stat('errors.log').st_size, old_file_size)
Secrets.access_token_secret = old_secret #hmm, smells bad. Tests might not run in order
def test_handles_no_matches(self):
p = Parser()
m = Meme("all your * -base")
s = [
Source("", "foo", ""),
Source("", "bar", ""),
Source("", "baz", "")
]
self.assertEqual(p.collate_words(m, s).get_list(), [])
def test_collates_words(self):
p = Parser()
m = Meme("all your * -base")
s = [
Source("", "all your cake", ""),
Source("", "all your cake", ""),
Source("", "all your data", "")
]
self.assertEqual(
p.collate_words(m, s).get_list(), [("cake", 2), ("data", 1)])
async def join(self, ctx: commands.Context):
""" JOINS VOICE CHANNEL """
global channel
global vc
channel = ctx.author.voice.channel
vc = await channel.connect()
# Activating audio commands:
bot.add_cog(ShortAudio(bot, vc))
bot.add_cog(Meme(bot, vc))
await ctx.send(embed=self.botTalk.intro())
def create_fleet(ai_settings, screen, pepe, memes):
"""create a full fleet of meme"""
# create a meme and find the number of memes in a row
# spacing between each meme is equal to one meme width
meme = Meme(ai_settings, screen)
number_memes_y = get_number_memes_y(ai_settings, meme.rect.height)
number_columns = get_number_columns(ai_settings, pepe.rect.width,
meme.rect.width)
#create fleet of memes
for column_number in range(number_columns):
for meme_number in range(number_memes_y):
create_meme(ai_settings, screen, memes, meme_number, column_number)
def __init__(self):
self.root = Tk()
self.root.title('Memez!!!!1!')
self.mainframe = ttk.Frame(self.root, padding='3 3 12 12')
self.mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
self.mainframe.columnconfigure(0, weight=1)
self.mainframe.rowconfigure(0, weight=1)
self.top = StringVar()
self.top.trace('w', self.update_top)
self.top_entry = ttk.Entry(self.mainframe, textvariable=self.top)
self.top_entry.grid(column=0, row=0)
self.mid = StringVar()
self.mid.trace('w', self.update_mid)
self.mid_entry = ttk.Entry(self.mainframe, textvariable=self.mid)
self.mid_entry.grid(column=0, row=1)
self.bot = StringVar()
self.bot.trace('w', self.update_bot)
self.bot_entry = ttk.Entry(self.mainframe, textvariable=self.bot)
self.bot_entry.grid(column=0, row=2)
self.filename = 'gifs/this_is_fine.gif'
self.meme = Meme(self.filename)
self.img = self.meme.render('test.gif')
self.tkimg = ImageTk.PhotoImage(self.img)
self.button = ttk.Button(self.mainframe, image=self.tkimg)
self.button.grid(column=1, row=0, rowspan=3, stick=(W, E))
self.select_meme = ttk.Button(self.mainframe,
text='Select Image',
command=self.select_image)
self.select_meme.grid(column=0, row=3)
#self.button.pack()
self.mainframe.pack()
class KvMemeApp(App):
def build(self):
self.meme = Meme('gifs/this_is_fine.gif')
return MemeAppMainView(self)
def set_top(self, value):
self.meme.set_top(value)
def set_mid(self, value):
self.meme.set_mid(value)
def set_bot(self, value):
self.meme.set_bot(value)
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Meme_Invaders')
#make the play button
play_button = Button(ai_settings, screen, "Play Meme_Invaders")
#create an instance to store game statistics and create a scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
#make a meme
meme = Meme(ai_settings, screen)
#make a pepe
pepe = Pepe(ai_settings, screen)
#make a group of bullets and memes
bullets = Group()
memes = Group()
#create the fleet of memes
gf.create_fleet(ai_settings, screen, pepe, memes)
#start main loop of the game
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, pepe,
memes, bullets)
if stats.game_active:
pepe.update()
gf.update_bullets(ai_settings, screen, stats, sb, pepe, memes,
bullets)
gf.update_memes(ai_settings, screen, stats, sb, pepe, memes,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, pepe, memes, bullets,
play_button)
def memepie():
if 'meme' in request.values:
meme = Meme(request.values['meme'])
if meme.is_valid():
twitter = Twitter()
parser = Parser()
texts = twitter.get_sources(meme, 20)
#from source import Source
#texts = [Source("", "x is my middle name",""), Source("", "y is my middle name", ""), Source("", "x is my middle name","")]
result = parser.collate_words(meme, texts)
gchart = GChart()
g.clean_query = meme.get_clean_meme()
g.meme_exceptions = meme.get_exceptions()
g.meme_parts = meme.get_parts()
g.pie_data = gchart.generate_pie_data(result)
#first_word_source_list = result.get_source_list(result.get_list()[0][0])
return render_template("memepie.htm")
else:
g.clean_query = meme.get_clean_meme() #our understanding of meme
g.error_message = meme.get_problem()
return render_template("error.htm")
def memepie():
if 'meme' in request.values:
meme = Meme(request.values['meme'])
if meme.is_valid():
twitter = Twitter()
parser = Parser()
texts = twitter.get_sources(meme, 20)
#from source import Source
#texts = [Source("", "x is my middle name",""), Source("", "y is my middle name", ""), Source("", "x is my middle name","")]
result = parser.collate_words(meme, texts)
gchart = GChart()
g.clean_query = meme.get_clean_meme()
g.meme_exceptions = meme.get_exceptions()
g.meme_parts = meme.get_parts()
g.pie_data = gchart.generate_pie_data(result)
#first_word_source_list = result.get_source_list(result.get_list()[0][0])
return render_template("memepie.htm")
else:
g.clean_query = meme.get_clean_meme() #our understanding of meme
g.error_message = meme.get_problem()
return render_template("error.htm")
def test_get_parts_valid_3(self):
m = Meme("foo * bar")
self.assertEqual(m.get_parts(), ["foo", "bar"])
def test_get_parts_valid_2(self):
m = Meme("foo *")
self.assertEqual(m.get_parts(), ["foo", ""])
def test_valid_meme_has_exceptions(self):
m = Meme("all your * -base")
self.assertEqual(m.get_exceptions(), "-base")
from meme import Meme obunga = Meme()
def test_generates_valid_regex(self):
p = Parser()
m = Meme("all your * -base")
self.assertEqual(p._format_regex(m), "all your ([\\w'\\-]+)")
def test_get_parts_valid_1(self):
m = Meme("* foo")
self.assertEqual(m.get_parts(), ["", "foo"])
def test_generates_valid_weird_regex(self):
p = Parser()
m = Meme("amn't foo-bar * -isn't")
self.assertEqual(p._format_regex(m), "amn't foo-bar ([\\w'\\-]+)")
def test_get_parts_valid_2(self):
m = Meme("foo *")
self.assertEqual(m.get_parts(), ["foo", ""])
def test_hypen_is_not_exception(self):
m = Meme("foo-bar -baz")
self.assertEqual(m.get_body(), "foo-bar")
self.assertEqual(m.get_exceptions(), "-baz")
print '========== Popular memes from Brazil =========='
print Meme.Posts.popular(locale='pt')
print '========== Sample search =========='
posts = Meme.Posts.search('meme rocks')
print posts
print '---------- Results for "meme rocks" ----------'
for post in posts:
print 'Content: %s' % post.content
print 'Caption: %s' % post.caption
print '----------------------------------------------'
print '========== Get gchapiewski Meme =========='
meme = Meme.get(name='gchapiewski')
print meme
print meme.title
print meme.description
print meme.url
print '========== Memes that guilherme_chapiewski is following =========='
print meme.following()
print '========== 50 Memes that guilherme_chapiewski is following =========='
print meme.following(count=50)
print '========== Memes following guilherme_chapiewski Meme =========='
print meme.followers()
print '========== 50 Memes following guilherme_chapiewski Meme =========='
def test_invalid_meme_is_invalid(self):
m = Meme("nothing here")
self.assertFalse(m.is_valid())
self.assertEqual(m.get_problem(), "has no wildcard (*)")
from meme import Meme
from generator import Generator
meme = Meme('horse.jpg', (20, 20), (120, 200), 'comic.otf', (0, 0, 0, 255))
generator = Generator(meme)
generator.generate("Yes hello, \n This is a test.").save(
'/home/jon/i/testpy.jpg', 'jpeg')
def test_accents_ok(self):
m = Meme("milano é *")
self.assertTrue(m.is_valid)
self.assertEqual(m.raw_meme, "milano é *")
self.assertEqual(m.get_body(), "milano é *")
def test_invalid_characters(self):
m = Meme("ok <>\"(){}[],.")
self.assertEqual(m.get_body(), "ok")
def test_accents_ok(self):
m = Meme("milano é *")
self.assertTrue(m.is_valid)
self.assertEqual(m.raw_meme, "milano é *")
self.assertEqual(m.get_body(), "milano é *")
def test_two_stars_is_invalid(self):
m = Meme("* into *")
self.assertFalse(m.is_valid())
self.assertEqual(m.get_problem(), "has too many wildcards (*)")
def test_hypen_is_not_exception(self):
m = Meme("foo-bar -baz")
self.assertEqual(m.get_body(), "foo-bar")
self.assertEqual(m.get_exceptions(), "-baz")
def test_apostrophe_is_ok(self):
m = Meme("amn't * -isn't")
self.assertEqual(m.get_body(), "amn't *")
self.assertEqual(m.get_exceptions(), "-isn't")
def test_apostrophe_is_ok(self):
m = Meme("amn't * -isn't")
self.assertEqual(m.get_body(), "amn't *")
self.assertEqual(m.get_exceptions(), "-isn't")
def test_converts_to_lowercase(self):
p = Parser()
m = Meme("all your * -base")
s = [Source("", "ALL YOUR DATA", "")]
self.assertEqual(p.collate_words(m, s).get_list(), [("data", 1)])
def test_valid_meme_has_raw_meme(self):
m = Meme("all your * -base")
self.assertEqual(m.raw_meme, "all your * -base")
class TestMeme(unittest.TestCase):
def setUp(self):
class Gui(object):
def __init__(self, *x):
self.json = ''
self.count =0
def __getitem__(self, x):
return self
def __le__(self, x):
return self
def setAttribute(self, *x):
self.opacity = 0.5
def cling(self, *x):
pass
def send(self, operation, **x):
self.count +=1
self.json = x
self.gui = Gui()
self.gui.onclick = object()
self.app = Meme(self.gui)
def test_tabuleiro(self):
"garante que tem casas no tabuleiro."
self.app.build_tabuleiro(self.gui)
t = self.app.tabuleiro
self.assertEqual(len(t.casas), 27)
def test_mao(self):
"garante que tem pecas na mao."
self.app.build_mao(self.gui)
m = self.app.mao1
self.assertEqual(len(m.pecas), 9)
def test_escolhe_peca(self):
"peca sai da mao e vai para a base."
self.app.build_base(self.gui)
m = self.app.mao1
#: a peca inicia na mao
p = m.pecas[0]
self.assertEqual(p.local,m)
#: a peca escolhida vai para a casa
p.escolhida()
self.assertTrue('pec' in self.gui.json, "em vez json: %s"%self.gui.json)
self.assertEqual(self.gui.count,1,"chamado mais deuma vez %d"%self.gui.count)
self.assertEqual(p.local,self.app.casa)
self.assertEqual(len(m.pecas), 8)
def test_nao_pode_escolher_outra_peca(self):
"nao pode escolher outra peca, peca fica na mao."
self.app.build_base(self.gui)
#: a peca inicia na mao
p = self.app.mao1.pecas[0]
#: a peca escolhida vai para a casa
p.escolhida()
#: uma segunda peca nao pode ser escolhida
q = self.app.mao1.pecas[1]
q.escolhida()
self.assertEqual(q.local,self.app.mao1)
def _pega_peca_e_escolhe_casa(self):
"peca sai da base e vai para a casa."
self.app.build_base(self.gui)
self.m = self.app.mao1
self.t = self.app.tabuleiro
#: a peca inicia na mao
self.p = self.m.pecas[0]
#: a peca escolhida vai para a casa
self.p.escolhida()
#self.assertEqual(self.gui.count,1,"peca varias vezes:%d"%self.gui.count)
self.t.temporiza()
self.c = self.t.casas[0]
self.c.escolhida()
def test_escolhe_casa(self):
"peca vai para a casa"
self._pega_peca_e_escolhe_casa()
self.assertEquals(self.p.local, self.c)
self.assertTrue(self.p in self.t.pecas)
self.assertEquals(self.t.bomba, 0)
def test_escolhe_casa_registra(self):
"peca vai para a casa, regitra no banco e monta puzzle."
self._pega_peca_e_escolhe_casa()
self.assertTrue('cas' in self.gui.json, "em vez json: %s"%self.gui.json)
self.assertEqual(self.gui.json['cas'], 0, "em vez cas: %s"%self.gui.json['cas'])
self.assertEqual(self.gui.count,2,"casa varias vezes:%d"%self.gui.count)
self.assertEquals(self.p.local,self.c)
self.assertTrue(self.p in self.t.pecas)
self.assertEquals(self.app.casa.peca,None)
self.assertEquals(self.t.bomba, 0, "bomba nao mudou %d"%self.t.bomba)
self.assertEquals(self.t.puzzle, 1, "puzzle nao mudou %d"%self.t.puzzle)
def test_escolhe_peca_na_casa(self):
"peca volta para a base quando escolhida no tabuleiro."
self.app.build_base(self.gui)
m = self.app.mao1
t = self.app.tabuleiro
#: a peca inicia na mao
p = m.pecas[0]
#: a peca escolhida vai para a casa
p.escolhida()
c = t.casas[0]
c.escolhida()
#: a peca escolhida volta para a casa
p.escolhida()
self.assertEquals(p.local, self.app.casa)
self.assertEquals(self.app.casa.peca,p)
self.assertEquals(t.puzzle, 0, "puzzle nao zerou %d"%t.puzzle)
def test_escolhe_casa_sem_peca_selecionada(self):
"nada acontece, nenhuma peca pode ser movida para a casa."
self.app.build_base(self.gui)
m = self.app.mao1
t = self.app.tabuleiro
c = t.casas[0]
c.escolhida()
self.assertEquals(c.peca,None)
def test_verifica_combinacao_vencedora(self):
"indica nas pecas e na casa base que houve uma combinacao vencedora."
self.app.build_base(self.gui)
pecas = self.app.mao1.pecas
casas = self.app.tabuleiro.casas[0:9]
self.assertEquals(self.app.casa.peca,None)
return
#__ = [casa.recebe(peca) for casa, peca in zip(casas,pecas)]
__ = [peca.escolhida() or casa.escolhida() for casa, peca in zip(casas,pecas)]
print(self.app.casa)
[self.app.tabuleiro.temporiza() for t in range(10)]
self.assertEquals(self.app.casa._estado_corrente,self.app.casa._casa_morta)
self.assertEquals(self.app.casa.peca,None)
def test_verifica_mudanca_fase(self):
"rearruma as pecas na mao"
self.app.build_base(self.gui)
pecas = [p for p in self.app.mao1.pecas]
casas = self.app.tabuleiro.casas[0:9]
self.t = self.app.tabuleiro
#__ = [casa.recebe(peca) for casa, peca in zip(casas,pecas)]
__ = [peca.escolhida() or casa.escolhida() for casa, peca in zip(casas,pecas)]
[self.app.tabuleiro.temporiza() for t in range(10)]
self.assertEquals(self.app.fase, 1, "fase nao mudou : %d"%self.app.fase)
self.assertEqual(self.gui.count,19,"casa varias vezes:%d"%self.gui.count)
self.assertEquals(self.app.casa.peca,None)
self.assertTrue('fas' in self.gui.json)
self.assertEquals(self.gui.json['pcs'] ,range(9), "not %s"%self.gui.json['pcs'])
[self.assertEquals(p.local,c) for p, c in zip(pecas,casas)]
self.assertEquals(self.t.bomba, 0)
self.assertEquals(self.t.puzzle, 0)
def test_jogada_apos_mudanca_fase(self):
"joga o inicio da proxima fase"
self.app.build_base(self.gui)
pecas = [p for p in self.app.mao1.pecas]
casas = self.app.tabuleiro.casas[0:9]
self.t = self.app.tabuleiro
#__ = [casa.recebe(peca) for casa, peca in zip(casas,pecas)]
__ = [peca.escolhida() or casa.escolhida() for casa, peca in zip(casas,pecas)]
[self.app.tabuleiro.temporiza() for tempo in range(88)]
self.assertEqual(self.t.pingo, 8)
self.assertEquals(self.t.bomba, 7)
self._pega_peca_e_escolhe_casa()
self.assertEquals(self.t.puzzle, 1)
self.assertEquals(self.p.local, self.c)
self.assertTrue(self.p in self.t.pecas)
def test_verifica_fim_de_jogo(self):
"terminou todas as fases"
self.app.build_base(self.gui)
pecas = [p for p in self.app.mao1.pecas]
casas = self.app.tabuleiro.casas[0:9]
self.t = self.app.tabuleiro
for i in range(5):
__ = [peca.escolhida() or casa.escolhida() for casa, peca in zip(casas,pecas)]
self.assertEquals(self.t.puzzle, 9)
[self.app.tabuleiro.temporiza() for t in range(10)]
self.assertEquals(self.t.puzzle, 9)
self.assertEquals(self.app.fase, 5, "fase nao mudou : %d"%self.app.fase)
[self.app.tabuleiro.temporiza() for t in range(100)]
self.assertEquals(self.app.casa.peca,None)
self.assertTrue('fim' in self.gui.json, "no end in %s"%self.gui.json)
self.assertEquals(self.t.bomba, 0)
def test_get_parts_valid_1(self):
m = Meme("* foo")
self.assertEqual(m.get_parts(), ["", "foo"])
def test_get_parts_valid_3(self):
m = Meme("foo * bar")
self.assertEqual(m.get_parts(), ["foo", "bar"])
print '========== Popular memes from Brazil =========='
print Meme.Posts.popular(locale='pt')
print '========== Sample post search =========='
posts = Meme.Posts.search('meme rocks')
print posts
print '---------- Results for "meme rocks" ----------'
for post in posts:
print 'Content: %s' % post.content
print 'Caption: %s' % post.caption
print '----------------------------------------------'
print '========== Sample meme search =========='
memes = Meme.search('designer')
print memes
print '---------- Results for "designer" ----------'
for meme in memes:
print 'Name: %s' % meme.name
print 'Title: %s' % meme.title
print 'Description: %s' % meme.description
print '----------------------------------------------'
print '========== Get gchapiewski Meme =========='
meme = Meme.get(name='gchapiewski')
print meme
print meme.title
print meme.description
print meme.url
def test_valid_meme_has_body(self):
m = Meme("all your * -base")
self.assertEqual(m.get_body(), "all your *")
def test_valid_meme_is_valid(self):
m = Meme("all your * -base")
self.assertTrue(m.is_valid())
# --> examples - posts
print '========== Popular memes =========='
print Meme.Posts.popular()
print '========== Popular memes from Brazil =========='
print Meme.Posts.popular(locale='pt')
print '========== Sample search =========='
posts = Meme.Posts.search('meme rocks')
print posts
print '---------- Results for "meme rocks" ----------'
for post in posts:
print 'Content: %s' % post.content
print 'Caption: %s' % post.caption
print '----------------------------------------------'
# --> examples - memes
meme = Meme.get(name='guilherme_chapiewski')
print '========== guilherme_chapiewski Meme =========='
print meme
print meme.title
print meme.description
print meme.url
print '========== Memes following guilherme_chapiewski Meme =========='
print meme.following()
print '========== 50 Memes following guilherme_chapiewski Meme =========='
print meme.following(count=50)
def test_valid_meme_has_clean_meme(self):
m = Meme("all your., * -base")
self.assertEqual(m.get_clean_meme(), "all your * -base")
