def test_models_maintain_their_own_scope_lists(self):
CarA = create_model(car_schema, Mock())
CarB = create_model(car_schema, Mock())
def scope_a():
return {}
def scope_b():
return {}
CarA.scope(scope_a)
CarB.scope(scope_b)
self.assertEquals(STANDARD_SCOPES + [scope_a], CarA.scopes)
self.assertEquals(STANDARD_SCOPES + [scope_b], CarB.scopes)
def setUp(self):
self.mock_collection = Mock()
self.mock_collection.name = "car"
self.Car = create_model(car_schema, self.mock_collection)
self.CarOffline = create_model_offline(car_schema, lambda: self.mock_collection, 'Car')
self.car = self.Car(doc)
self.car_offline = self.CarOffline(doc)
def get_model(db):
Variables = create_model(var_schema, db['vars'])
@Variables.class_method
def get_value(cls, name, def_val=None):
try:
return cls.find_one({'name': name})['value']
except:
return def_val
@Variables.class_method
def set_value(cls, name, value):
try:
var = cls.find_one({'name': name})
var.update({'value': value})
var.save()
except:
var = Variables({'name': name, 'value': value})
var.save()
return Variables
def get_model(db):
Variables = create_model(var_schema, db['vars'])
@Variables.class_method
def get_value(cls, name, def_val=None):
try:
return cls.find_one({'name': name})['value']
except:
return def_val
@Variables.class_method
def set_value(cls, name, value):
try:
var = cls.find_one({'name': name})
var.update({'value': value})
var.save()
except:
var = Variables({'name': name, 'value': value})
var.save()
return Variables
def get_model(db):
Lists = create_model(list_schema, db['vars'])
@Lists.class_method
def get_list(cls, name):
try:
return cls.find_one({'name': name})['value']
except:
return [ ]
@Lists.class_method
def set_list(cls, name, value):
try:
var = cls.find_one({'name': name})
var.update({'value': value})
var.save()
except:
var = Lists({'name': name, 'value': value})
var.save()
@Lists.class_method
def clear_list(cls, name):
cls.set_list(name, [ ])
@Lists.class_method
def remove_from_list(cls, name, val):
lst = cls.get_list(cls, name)
lst.remove(val)
cls.set_list(name, lst)
@Lists.class_method
def add_to_list(cls, name, val, force=True):
lst = cls.get_list(cls, name)
if force or val not in lst:
lst.append(val)
cls.set_list(name, lst)
return Lists
def get_model(db):
Lists = create_model(list_schema, db["vars"])
@Lists.class_method
def get_list(cls, name):
try:
return cls.find_one({"name": name})["value"]
except:
return []
@Lists.class_method
def set_list(cls, name, value):
try:
var = cls.find_one({"name": name})
var.update({"value": value})
var.save()
except:
var = Lists({"name": name, "value": value})
var.save()
@Lists.class_method
def clear_list(cls, name):
cls.set_list(name, [])
@Lists.class_method
def remove_from_list(cls, name, val):
lst = cls.get_list(cls, name)
lst.remove(val)
cls.set_list(name, lst)
@Lists.class_method
def add_to_list(cls, name, val, force=True):
lst = cls.get_list(cls, name)
if force or val not in lst:
lst.append(val)
cls.set_list(name, lst)
return Lists
import mongothon
from dbconnect import my_db
channels_schema = mongothon.Schema({
"server": {
"type": int,
"required": True
},
"channels": {
"type": dict
}
})
Channels = mongothon.create_model(channels_schema, my_db["channels"])
if __name__ == "__main__":
test = Channels({
"server": 123456,
"channels": {
"town-square": 264,
"yeah": 26
}
})
test.save()
x = Channels.find_one({"server": 123456})
print(type(x['_id']))
id_string = str(x['_id'])
print(id_string)
print(x)
# Create our schema for easy access to our entries
entry_schema = Schema({
'id': {'type': int, 'required': True},
'org_name': {'type': basestring, 'required': True},
'url': {'type': basestring},
'genre': {'type': Array(basestring), 'default':[], 'required':True},
'judges': {'type': Array(basestring), 'default':[]},
'keywords': {'type': Array(basestring), 'default':[]},
'price': {'type': basestring},
'submission_fee': {'type': float},
'deadline': {'type': datetime, 'default': datetime.utcnow},
'submission_type': {'type': basestring},
'opens': {'type': datetime, 'default': datetime.utcnow},
})
Entries = create_model(entry_schema, db['entries'])
# Start up our server
app = flask.Flask(__name__)
app.config['DEBUG'] = True
def sanitizeEntry(entry):
e = dict(entry)
e['genre'] = [] if e['genre'] == "" else ast.literal_eval(e['genre'])
e['keywords'] = [] if e['keywords'] == "" else ast.literal_eval(e['keywords'])
e['judges'] = [] if e['judges'] == "" else ast.literal_eval(e['judges'])
del e['_id']
return e
# Routes of interest
def get_model(db):
Scores = create_model(score_schema, db['scores'])
@Scores.class_method
def get_leaderboard(cls, leaderboard, count=10):
if leaderboard == 'death':
res = list(cls.find({"leaderboard": 'rooms'}))
keyf = Code("function(doc) {return{\"death_reason\": doc.death_reason}}")
reducer = Code("function(curr, result) { result.count++; }")
res = list(cls.get_collection().group(
key = keyf,
condition = {
"death_reason": { "$exists": True },
"leaderboard": "rate"
},
reduce = reducer,
initial = { "count": 0}
))
def sort_death(doc):
return -doc['count']
res.sort(key=sort_death)
return res[:count]
else:
def sort_by_score(doc):
return doc['score']
cursor = cls.find({"leaderboard": leaderboard})
sorted = cursor.sort('score', pymongo.DESCENDING)
res = list(sorted.limit(count))
return res[:count]
return list(cls.find({"leaderboard": leaderboard}))[:count]
@Scores.class_method
def add_to_leaderboard(cls, user, score, leaderboard_name='rooms'):
name = user.name
costume = costumes.get_costume(user.costume)
name += ' в костюме _{0}_'.format(costume['who'])
if user.pet:
pet = user.get_pet()
name += ' и {0} {1}'.format(pet.name, pet.real_name)
doc = {
'uid': user.uid,
'name': name,
'score': score,
'leaderboard': leaderboard_name
}
if hasattr(user, 'death_reason'):
doc['death_reason'] = user.death_reason
cls.insert(doc)
return Scores
def validate(value):
try:
time.strptime(value, '%H:%M')
h, m = value.split(':')
if int(h) < 10 and len(h) < 2:
return "Invalid time format"
except ValueError:
return "Invalid time format"
return validate
def validate_warning():
def validate(value):
if value > 180:
return "Warning has to be within three hours of nighttime"
return validate
server_schema = mongothon.Schema({
"server": {"type": int, "required": True},
"daytime": {"type": str, "default": "08:00", "validates": time_format()},
"nighttime": {"type": str, "default": "20:00", "validates": time_format()},
"warning": {"type": int, "default": 30, "validates": validate_warning()},
"announce_character": {"type": bool, "default": True},
"prefix": {"type": str, "default": "!"}
})
Server = mongothon.create_model(server_schema, my_db['server'])
},
"voted": {
"type": dict,
"default": {}
},
"locked": {
"type": list,
"default": []
},
"lynch": {
"type": bool,
"default": True
}
})
Election = mongothon.create_model(election_schema, my_db["elections"])
# x = Channels.find_one({"server": 123456})
if __name__ == "__main__":
test = Election({
"server": 163,
"people": ["hi", "what", "is"],
"channel": 163263523
})
test.save()
x = Election.find_one({"server": 163})
print(type(x['_id']))
id_string = str(x['_id'])
print(id_string)
x["people"].append("wow!")
"type": int,
"required": True
},
"spirits": {
"type": bool,
"default": True
},
"dead_wolves": {
"type": bool,
"default": True
},
"werewolves": {
"type": bool,
"default": True
},
"seer": {
"type": bool,
"default": True
},
"bodyguard": {
"type": bool,
"default": True
},
"cupid": {
"type": bool,
"default": True
}
})
Abilities = mongothon.create_model(ability_schema, my_db['abilities'])
client = MongoClient(config.MONGO_URL)
# dbNews = client['lovel-up']
db = client['twitter_bot']
user_schema = mongothon.Schema({
"id": {"type": basestring, "required": True},
"name": {"type": basestring},
"date_followed": {"type": datetime },
"date_unfollowed": {"type": datetime },
"following": {"type": bool},
"following_me": {"type": bool}
})
User = mongothon.create_model(user_schema, db['users'])
def get_user_by_id(id):
return User.find_one({'id': str(id)})
def get_users( following, following_me, days ):
users = []
query = { "following": following, "following_me": following_me }
if following == True and following_me == False:
query['$or'] = [
{'date_followed': { '$lt': datetime.utcnow() - timedelta( days=days )} },
{'date_followed': { '$exists': False } }
]
if following == False and following_me == False:
def test_different_classes_managed_their_own_handlers(self):
CarA = create_model(car_schema, Mock())
CarB = create_model(car_schema, Mock())
handler = Mock()
CarA.on('did_save', handler)
self.assertEquals([], CarB.handlers('did_save'))
"tire": "Michelin",
"diameter": 24
},
{
"position": "RL",
"tire": "Michelin",
"diameter": 24
}
],
"options": ['heated seats', 'leather steering wheel']
}
# This has to live here so pickle can find it.
mock_collection = Mock()
mock_collection.name = "pickleable"
Pickleable = create_model(Mock(), mock_collection)
class TestModel(TestCase):
def setUp(self):
self.mock_collection = Mock()
self.mock_collection.name = "car"
self.Car = create_model(car_schema, self.mock_collection)
self.CarOffline = create_model_offline(car_schema, lambda: self.mock_collection, 'Car')
self.car = self.Car(doc)
self.car_offline = self.CarOffline(doc)
def tearDown(self):
self.Car.remove_all_handlers()
Matches.LOVE: {
'type': basestring
},
Matches.CAREER: {
'type': basestring
}
}),
'default': {
Matches.FRIENDSHIP: HoroscopeType.ARIES,
Matches.LOVE: HoroscopeType.ARIES,
Matches.CAREER: HoroscopeType.ARIES
}
}
})
HoroscopeDayLog = create_model(horoscope_day_log_schema, db.horoscope_day_log,
"HoroscopeDayLog")
HoroscopeDayLog.collection.ensure_index([("date", -1), ('horoscope_type', -1)])
horoscope_week_log_schema = Schema({
"date": {
'type': basestring
}, # %Y-%U 2018-00, 具体规则参见datetime.strftime()
'horoscope_type': {
'type': basestring,
'default': HoroscopeType.ARIES
},
'content': {
'type': dict,
'default': {}
},
})
import mongothon
from dbconnect import my_db
def delete_many(filter):
my_db['villager'].delete_many(filter)
villager_schema = mongothon.Schema({
"discord_id": {"type": int, "required": True},
"server": {"type": int, "required": True},
"character": {"type": str, "required": True},
"werewolf": {"type": bool, "required": True},
"alive": {"type": bool, "default": True},
})
Villager = mongothon.create_model(villager_schema, my_db['villager'])
import os
from pymongo.connection import Connection
import unittest
from mongothon import create_model
from sample import blog_post_schema, valid_doc, expected_db_doc
from contextlib import contextmanager
host = os.environ.get("DB_IP", "localhost")
port = int(os.environ.get("DB_PORT", 27017))
def get_db(*args, **kwargs):
return Connection(host, port, *args, **kwargs).mongothon_test
blog_post_collection = get_db().blog_post
BlogPost = create_model(blog_post_schema, blog_post_collection)
class TestPyMongoIntegration(unittest.TestCase):
"""Test that when we use a model against an actual database using
pymongo, everything works as it should."""
def setUp(self):
self.maxDiff = None
def tearDown(self):
blog_post_collection.remove()
@contextmanager
def assert_no_difference(self, func):
"""Context manager which asserts the given function returns the
same value either side of the wrapped block."""
def test_class_name_defaults_to_camelcased_collection_name(self):
mock_collection = Mock()
mock_collection.name = "some_model"
SomeModel = create_model(Schema({}), mock_collection)
self.assertEquals("SomeModel", SomeModel.__name__)
def setUp(self):
self.mock_collection = Mock()
self.mock_collection.name = "car"
self.Car = create_model(car_schema, self.mock_collection)
self.car = self.Car(doc)
},
"formula_img": {
"type": basestring,
"required": True
},
"notes": {
"type": basestring
},
"correct_count": {
"type": basestring
},
"incorrect_count": {
"type": basestring
}
})
Compound = create_model(compound_schema, compounds)
for new_compound in encoded_images_dict.keys():
# check to see if the named compound is already present
compound_search = Compound.find_one({'name': new_compound})
if compound_search:
print new_compound + " already exists in db"
pass
else:
compound = Compound({
"name": new_compound,
"formula_img": encoded_images_dict[new_compound]
})
compound.save()
def test_class_name_can_be_overridden(self):
mock_collection = Mock()
mock_collection.name = "some_model"
SomeModel = create_model(Schema({}), mock_collection, "SomethingElse")
self.assertEquals("SomethingElse", SomeModel.__name__)
from pymongo.connection import Connection
import unittest
from mongothon import create_model
from sample import blog_post_schema, valid_doc, expected_db_doc
from contextlib import contextmanager
host = os.environ.get("DB_IP", "localhost")
port = int(os.environ.get("DB_PORT", 27017))
def get_db(*args, **kwargs):
return Connection(host, port, *args, **kwargs).mongothon_test
blog_post_collection = get_db().blog_post
BlogPost = create_model(blog_post_schema, blog_post_collection)
class TestPyMongoIntegration(unittest.TestCase):
"""Test that when we use a model against an actual database using
pymongo, everything works as it should."""
def setUp(self):
self.maxDiff = None
def tearDown(self):
blog_post_collection.remove()
@contextmanager
def assert_no_difference(self, func):
"""Context manager which asserts the given function returns the
same value either side of the wrapped block."""
from dbconnect import my_db
def delete_many(filter):
my_db['game'].delete_many(filter)
game_schema = mongothon.Schema({
"server": {"type": int, "required": True},
"players": {"type": list, "required": True}, # list of villager discord_id
"inlove": {"type": list, "default": []},
"bakerdead": {"type": bool, "default": False},
"voting": {"type": bool, "default": False},
"last_protected_id": {"type": int, "default": -1},
"morning_messages": {"type": list, "default": []},
"protected": {"type": int, "default": -1},
"hunter_ids": {"type": list, "default": []},
"real_time": {"type": bool, "default": True},
"starving": {"type": list, "default": []},
"werewolfcount": {"type": int, "required": True},
"villagercount": {"type": int, "required": True},
})
Game = mongothon.create_model(game_schema, my_db['game'])
if __name__ == '__main__':
x = Game.find_one({"server": 695805513480536074})
x["villagercount"] = 15
x.save()
