def makemigrations(name='auto'):
"""
Makes migrations
"""
migrator = Router(db, logger=LOGGER)
migrator.migrate_dir = os.path.join(base_dir, 'application', 'migrations')
migrator.create(name=name, auto='project.application.models')
def create_migrations(name):
database = load_plugin("chain.plugins.database")
router = Router(database.db,
migrate_dir="chain/plugins/database/migrations")
# Create migration
router.create(name, auto="chain.plugins.database.models")
def migrate_tables():
from peewee_migrate import Router
router = Router(db)
# Create migration
router.create('migration_name', auto=True)
# Run migration/migrations
router.run('migration_name')
# Run all unapplied migrations
router.run()
def makemigrations(auto=False):
"""database makemigrations
:param auto: auto=True, run all unapplied migrations
"""
router = Router(db, ignore='basemodel')
if auto:
router.create(auto=models)
else:
router.create()
def create():
database = db.database
database.connect()
router = Router(database)
# Create migration
# router.create(name=BaseModel.sub_models())
router.create(auto=db)
# Run all unapplied migrations
router.run()
def run(path):
items.db.connect()
router = Router(items.db,
ignore="basemodel",
migrate_dir=path,
migrate_table='toolsmigrate')
router.create(auto=items)
router.run()
items.db.close()
def run(path):
db_items_module.db.connect()
# migrate_table: 迁移表的名称
router = Router(db_items_module.db,
ignore="basemodel",
migrate_dir=path,
migrate_table='toolsmigrate')
router.create(auto=db_items_module)
router.run()
db_items_module.db.close()
def create_migrations(name):
database = PostgresqlDatabase(
database='postgres',
user='******',
host='127.0.0.1',
port='5432',
# password='******'
)
router = Router(database)
# Create migration
router.create(name, auto='models')
def makemigrate(model, ignore=['basemodel'], name='auto'):
if models.db.is_closed():
models.db.connect()
router = Router(model.db,
ignore=['basemodel'],
migrate_dir=os.path.join(
os.path.dirname(
os.path.dirname(os.path.realpath(__file__))),
'migrations'))
router.create(name='auto', auto=model)
router.run()
if not models.db.is_closed():
models.db.close()
def migrate(name):
router = Router(models.database, ignore=[models.MyModel])
if name is None:
router.create(auto=models)
name = router.todo[-1]
try:
backup(name)
router.run()
except:
logging.exception("migrate失败")
clean(name, backup_py=True)
sys.exit(-1)
router = Router(database,
migrate_dir='../migrations'
if os.getcwd().endswith('scripts') else 'migrations',
ignore=['basemodel'])
parser = argparse.ArgumentParser(
description='Apply or manage database migrations.')
parser.add_argument('-c',
'--create',
metavar='NAME',
help='Creates a new migration')
parser.add_argument('-a',
'--auto',
metavar='NAME',
help='Creates a new migration (automatic)')
parser.add_argument('-r',
'--rollback',
metavar='NAME',
help='Rolls back a migration')
args = parser.parse_args()
if args.create:
router.create(args.create)
elif args.auto:
router.create(args.auto, 'app')
elif args.rollback:
router.rollback(args.rollback)
else:
router.run()
from shujuku.peewee_models import models
from peewee_migrate import Router
router = Router(models.db)
# 创建迁移
router.create(auto=models)
# 运行迁移/迁移
# router.run('xyl_user')
# 运行所有未应用的迁移
router.run()
models.db.close()
from bgm.models import db
from peewee_migrate import Router
router = Router(db)
# Create migration
router.create('create_database')
# Run migration/migrations
router.run('bgm.models')
# Run all unapplied migrations
router.run(fake=True)
class Manager:
def __init__(self, app: typing.Union[str, apistar.App, apistar.ASyncApp]):
"""
Create a database manager from API Star application.
:param app: API Star application.
:return: Manager instance.
"""
self.app = self.get_app(app) if isinstance(app, str) else app
self.component = self.get_database_component(self.app)
self.router = Router(self.component.database)
@classmethod
def get_app(cls, path: str) -> typing.Union[apistar.App, apistar.ASyncApp]:
"""
Get database manager from API Star app path.
:param path: API Star app path in format <package>.<module>:<variable>
:return: Database manager.
"""
try:
m, c = path.rsplit(":", 1)
module = importlib.import_module(m)
app = getattr(module, c)
except ValueError:
raise ImportError(
"Wrong path path, it should be: <package>.<module>:<variable>")
except (AttributeError, ImportError):
raise ImportError("API Star path not found '{}'".format(path))
return app
@classmethod
def get_database_component(
cls, app: typing.Union[apistar.App, apistar.ASyncApp]
) -> PeeweeDatabaseComponent:
"""
Get database component from API Star application.
:param app: API Star application.
:return: Database component
"""
for component in app.injector.components:
if isinstance(component, PeeweeDatabaseComponent):
return component
raise ValueError(
"No 'PeeweeDatabaseComponent' found in API Star application")
def upgrade(self, target: typing.Optional[str] = None, fake: bool = False):
"""
Apply migrations sequentially to a target.
:param target: Target migration name.
:param fake: Fake migrations.
"""
self.router.run(target, fake)
def downgrade(self, target: typing.Optional[str] = None):
"""
Rollback migrations sequentially to a target.
:param target: Target migration name.
"""
self.router.rollback(target)
def merge(self, name: typing.Optional[str] = None):
"""
Merge all migrations into a single one.
:param name: Migration name.
"""
self.router.merge(name)
def create(self, name: str, module: typing.Optional[str] = None):
"""
Create a new migration with given name. If module is provided, the migration will be generated automatically.
:param name: Migration name.
:param module: Module to infer changes.
"""
self.router.create(name, auto=module)
@property
def models(self) -> typing.List[peewee.Model]:
"""
Returns a list of registered models.
:return: List of registered models.
"""
return list(Model.register) # noqa
def create_tables(self):
"""
Create tables in database.
"""
self.component.database.create_tables(self.models)
def drop_tables(self):
"""
Drop tables from database.
"""
self.component.database.drop_tables(self.models)
def __repr__(self):
migrations = "\n".join(
[f" [x] {migration}" for migration in self.router.done])
migrations += "\n".join(
[f" [ ] {migration}" for migration in self.router.diff])
if len(Model.register) == 0:
models = "No models found."
elif len(Model.register) == 1:
models = f"{len(Model.register)} model found:\n"
else:
models = f"{len(Model.register)} models found:\n"
models += "\n".join([
f" - {model.__module__}.{model.__name__}"
for model in Model.register
])
return f"Migrations\n----------\n{migrations}\n\nModels\n------\n{models}"
price=9500,
resort=resort2_2,
)
residence2_1_2 = Residence.create(
type='Вилла',
price=29500,
resort=resort2_2,
)
resorts = [resort1_1, resort1_2, resort1_3, resort2_1, resort2_2]
for vehicle in vehicles:
for resort in resorts:
ResortVehicle.create(
resort=resort,
vehicle=vehicle,
)
if __name__ == '__main__':
router = Router(SqliteDatabase('tourism.db'))
# Create migration
router.create('init', "models")
#
# # Run migration/migrations
# router.run('init')
#
# # Run all unapplied migrations
router.run()
parser = ArgumentParser(description='Peewee migration wrapper')
parser.add_argument('action',
metavar='action',
type=str,
help='migrate / create')
parser.add_argument('name', default=None, metavar='migration name', type=str)
args = parser.parse_args()
if args.action == 'create':
if args.name:
try:
router.create(args.name)
except Exception:
print('Can`t create migration "{0}". Exiting'.format(args.name))
exit(1)
else:
ArgumentParser.error()
elif args.action == 'migrate':
if args.name == 'all':
try:
router.run()
except Exception:
print('Can`t apply migrations. Exiting')
exit(1)
else:
try:
from model.system.user import User
from utils.uid import gen_id
import traceback
def migrate():
router.create()
router.run()
# print(user.__path__)
# print(dairy.Dairy)
if __name__ == '__main__':
# print(__file__.__path__)
# try:
# base_model.db.create_tables([Article,Comment,Dairy,User])
# except Exception:
# traceback.print_exc()
# pass
# base_model.db.connect()
router = Router(base_model.db)
router.create(auto=blog)
router.run()
# base_model.db.close()
# print(test_obj.content)
# migrate()
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from peewee_migrate import Router
from playhouse.pool import PooledMySQLDatabase
from arch.task_manager.settings import DATABASE
data_base_config = DATABASE.copy()
# TODO: create instance according to the engine
engine = data_base_config.pop("engine")
db_name = data_base_config.pop("name")
DB = PooledMySQLDatabase(db_name, **data_base_config)
router = Router(DB)
# Create migration
router.create('task_manager')
# Run migration/migrations
router.run('task_manager')
# Run all unapplied migrations
router.run()
import inspect
from inspect import isfunction
from peewee import BaseModel
router = Router(SqliteDatabase(DATABASE_NAME))
# try:
if sys.argv[1] == 'makemigrations':
models = []
for module in ['plant', 'sensor', 'people', 'security', 'mesh', 'context']:
exec('import ' + module)
models.extend([
obj for name, obj in inspect.getmembers(
eval(module),
lambda obj: not isfunction(obj) and isinstance(obj, BaseModel)
and obj.__name__ != 'Model' and obj.__name__ != 'Base')
])
print(models)
# Create migration
router.create('models', auto=models)
elif sys.argv[1] == 'migrate':
router.run()
else:
print('sry, but this is not a valid command \n\n')
print('try: makemigrations or migrate')
# except:
# print('not specified anything')
def _createmigration(migration_name):
router = Router(DB)
router.create(migration_name)
def execute(self, options):
router = Router(persist.get_database(),
migrate_dir=persist.get_migrations_dir())
router.create(options.name,
auto=importlib.import_module(
settings.PROJECT_PACKAGE_NAME))
