yhttp-dbmanager 7.0.2__tar.gz → 8.0.2__tar.gz

{yhttp_dbmanager-7.0.2/yhttp_dbmanager.egg-info → yhttp_dbmanager-8.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp-dbmanager
-Version: 7.0.2
+Version: 8.0.2
 Summary: Database manager command line interface and API for yhttp.
 Home-page: http://github.com/yhttp/yhttp-dbmanager
 Author: Vahid Mardani

yhttp_dbmanager-7.0.2/tests/test_cli.py → yhttp_dbmanager-8.0.2/tests/test_cli_createdrop.py

@@ -2,30 +2,21 @@ import os
 
 from bddcli import Given, Application as CLIApplication, status, stderr, \
     when, stdout
-import easycli
 from yhttp.core import Application
 
 from yhttp.ext.dbmanager import install
 
 
-class Bar(easycli.SubCommand):
-    __command__ = 'bar'
-
-    def __call__(self, args):
-        print('bar')
-
-
 app = Application('0.1.0', 'foo')
 app.settings.merge('''
 db:
   url: postgres://:@/foo
 ''')
-install(app, cliarguments=[Bar])
+install(app)
 
 
 def test_applicationcli(cicd):
-    app.ready()
-    cliapp = CLIApplication('example', 'tests.test_cli:app.climain')
+    cliapp = CLIApplication('example', f'{__name__}:app.climain')
     env = os.environ.copy()
     if cicd:
         env.setdefault('YHTTP_DB_DEFAULT_HOST', 'localhost')
@@ -45,12 +36,6 @@ def test_applicationcli(cicd):
         assert status == 0
         assert stderr == ''
 
-        # Custom Command line interface
-        when('db bar')
-        assert status == 0
-        assert stderr == ''
-        assert stdout == 'bar\n'
-
         when('db c')
         assert status == 0
         assert stderr == ''

yhttp_dbmanager-8.0.2/tests/test_cli_migration.py

@@ -0,0 +1,78 @@
+import os
+import tempfile
+
+from bddcli import Given, Application as CLIApplication, status, stderr, \
+    when, stdout
+from yhttp.core import Application
+
+from yhttp.ext.dbmanager import install
+
+
+vdir = tempfile.mkdtemp()
+app = Application('0.1.0', 'foo')
+app.settings.merge(f'''
+db:
+  url: postgres://:@/foo
+  migration:
+    directory: {vdir}
+''')
+if os.environ.get('CI') and os.environ.get('GITHUB_RUN_ID'):
+    app.settings.db.url = 'postgres://postgres:postgres@localhost/foo'
+
+install(app)
+
+
+foo_content = '''
+def upgrade(db):
+    db.execute("""
+    CREATE TABLE foo (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(50) NOT NULL
+    );
+    """)
+
+
+def downgrade(db):
+    db.execute("DROP TABLE foo")
+'''
+with open(f'{vdir}/0001-foo.py', 'w') as f:
+    f.write(foo_content)
+
+
+def test_cli_migration(cicd):
+    cliapp = CLIApplication('foo', f'{__name__}:app.climain')
+    env = os.environ.copy()
+    if cicd:
+        env.setdefault('YHTTP_DB_DEFAULT_HOST', 'localhost')
+        env.setdefault('YHTTP_DB_DEFAULT_ADMINUSER', 'postgres')
+        env.setdefault('YHTTP_DB_DEFAULT_ADMINPASS', 'postgres')
+        env.setdefault('YHTTP_DB_DEFAULT_USER', 'postgres')
+        env.setdefault('YHTTP_DB_DEFAULT_PASS', 'postgres')
+
+    with Given(cliapp, 'db migration', environ=env):
+        when('db drop')
+        when('db create')
+        assert status == 0
+
+        when('db migration upgrade 1')
+        assert stderr == ''
+        assert status == 0
+        assert stdout == 'database successfully upgraded to version 0001.\n'
+
+        when('db migration downgrade 0')
+        assert stderr == ''
+        assert stdout == 'database successfully downgraded to version 0000.\n'
+        assert status == 0
+
+        when('db migration upgrade')
+        assert stderr == ''
+        assert status == 0
+        assert stdout == 'database successfully upgraded to version 0001.\n'
+
+        when('db migration new bar')
+        assert stderr == ''
+        assert status == 0
+        assert stdout.endswith('/0002-bar.py.\n')
+
+        when('db drop')
+        assert status == 0

yhttp_dbmanager-8.0.2/tests/test_cli_usercommand.py

@@ -0,0 +1,30 @@
+from bddcli import Given, Application as CLIApplication, status, stderr, \
+    stdout
+import easycli
+from yhttp.core import Application
+
+from yhttp.ext.dbmanager import install
+
+
+class Bar(easycli.SubCommand):
+    __command__ = 'bar'
+
+    def __call__(self, args):
+        print('bar')
+
+
+app = Application('0.1.0', 'foo')
+app.settings.merge('''
+db:
+  url: postgres://:@/foo
+''')
+install(app, cliarguments=[Bar])
+
+
+def test_applicationcli():
+    cliapp = CLIApplication('example', f'{__name__}:app.climain')
+
+    with Given(cliapp, 'db bar'):
+        assert status == 0
+        assert stderr == ''
+        assert stdout == 'bar\n'

yhttp_dbmanager-8.0.2/tests/test_migrator.py

@@ -0,0 +1,68 @@
+import pytest
+
+
+foo_content = '''
+def upgrade(db):
+    db.execute("""
+    CREATE TABLE foo (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(50) NOT NULL
+    );
+    """)
+
+
+def downgrade(db):
+    db.execute("DROP TABLE foo")
+'''
+
+
+bar_content = '''
+def upgrade(db):
+    db.execute("""
+    CREATE TABLE bar (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(50) NOT NULL
+    );
+    """)
+
+
+def downgrade(db):
+    db.execute("DROP TABLE bar")
+'''
+
+
+def test_migrator_upgrade_downgrade(migrator, mktmptree):
+    root = mktmptree({
+        '0001-foo.py': foo_content,
+        '0002-bar.py': bar_content,
+    })
+
+    with pytest.raises(ValueError):
+        migrator.versions_directory
+
+    migrator.settings.directory = root
+
+    assert migrator.dbversion() == 0
+    assert migrator.lastversion == 2
+
+    assert 2 == migrator.upgrade()
+    assert migrator.db.table_exists('foo')
+    assert migrator.db.table_exists('bar')
+
+    assert 0 == migrator.downgrade()
+    assert not migrator.db.table_exists('foo')
+    assert not migrator.db.table_exists('bar')
+
+    with pytest.raises(FileNotFoundError):
+        migrator.upgrade(3)
+
+    migrator.dbversion_set(3)
+    with pytest.raises(FileNotFoundError):
+        migrator.downgrade(2)
+
+
+def test_migrator_newversion(migrator, tmpdir):
+    migrator.settings.directory = f'{tmpdir}/versions'
+
+    assert f'{tmpdir}/versions/0001-foo.py' == migrator.newversion('foo')
+    assert f'{tmpdir}/versions/0002-bar.py' == migrator.newversion('bar')

{yhttp_dbmanager-7.0.2 → yhttp_dbmanager-8.0.2}/yhttp/ext/dbmanager/__init__.py

@@ -3,6 +3,7 @@ from .cli import DatabaseCommand
 from .install import install
 from .dbmanager import PostgresqlManager
 from .uri import DatabaseURI
+from .migration import Migrator
 
 
-__version__ = '7.0.2'
+__version__ = '8.0.2'

yhttp_dbmanager-8.0.2/yhttp/ext/dbmanager/cli.py

@@ -0,0 +1,167 @@
+import os
+import functools
+import getpass
+
+from easycli import SubCommand, Argument
+
+from . import dbmanager, migration
+from .uri import DatabaseURI
+
+
+getdbpass = functools.partial(getpass.getpass, 'Enter db password: ')
+
+
+DEFAULT_DBUSER = os.environ['USER']
+
+
+class DatabaseAdministrativeCommand(SubCommand):
+    __arguments__ = [
+        Argument(
+            '-H',
+            '--host',
+            default=os.environ.get('YHTTP_DB_DEFAULT_HOST', ''),
+            help='DB hostname, default: empty.'
+        ),
+        Argument('-d', '--database', default='postgres', help='DB name'),
+        Argument(
+            '-u',
+            '--user',
+            default=os.environ.get(
+                'YHTTP_DB_DEFAULT_ADMINUSER',
+                DEFAULT_DBUSER
+            ),
+            help=f'DB administrator username, default: ${DEFAULT_DBUSER}'
+        ),
+        Argument(
+            '-p', '--password',
+            nargs='?',
+            default=os.environ.get(
+                'YHTTP_DB_DEFAULT_ADMINPASS',
+                'postgres'
+            ),
+            help='DB administrator password'
+        ),
+    ]
+
+    def getdbmanager(self, args):
+        password = args.password or getdbpass()
+
+        return dbmanager.PostgresqlManager(
+            user=args.user,
+            password=password,
+            host=args.host,
+            database=args.database
+        )
+
+    def getappdbinfo(self, args):
+        dbsettings = args.application.settings.db
+        url = DatabaseURI.loads(dbsettings.url)
+        return url
+
+
+class CreateDatabaseCommand(DatabaseAdministrativeCommand):
+    __command__ = 'create'
+    __aliases__ = ['c']
+
+    def __call__(self, args):
+        uri = self.getappdbinfo(args)
+        self.getdbmanager(args).create(uri.database, owner=uri.user)
+
+
+class DropDatabaseCommand(DatabaseAdministrativeCommand):
+    __command__ = 'drop'
+    __aliases__ = ['d']
+
+    def __call__(self, args):
+        uri = self.getappdbinfo(args)
+        self.getdbmanager(args).drop(uri.database)
+
+
+class MigrationSubCommand(SubCommand):
+    def migrator(self, args):
+        app = args.application
+        migrator = migration.Migrator(
+            app.settings.db.url,
+            app.settings.db.migration
+        )
+        return migrator
+
+
+class UpgradeCommand(MigrationSubCommand):
+    __command__ = 'upgrade'
+    __aliases__ = ['u', 'up']
+    __arguments__ = [
+        Argument(
+            'version',
+            nargs='?',
+            metavar='VERSION',
+            type=int,
+            help='Upgrade to this version, default: last version'
+        )
+    ]
+
+    def __call__(self, args):
+        with self.migrator(args) as m:
+            ver = m.upgrade(args.version)
+
+        print(f'database successfully upgraded to version {ver:04d}.')
+
+
+class DowngradeCommand(MigrationSubCommand):
+    __command__ = 'downgrade'
+    __aliases__ = ['d', 'down']
+    __arguments__ = [
+        Argument(
+            'version',
+            metavar='VERSION',
+            type=int,
+            help='Upgrade to this version.'
+        )
+    ]
+
+    def __call__(self, args):
+        with self.migrator(args) as m:
+            ver = m.downgrade(args.version)
+
+        print(f'database successfully downgraded to version {ver:04d}.')
+
+
+class NewVersionCommand(MigrationSubCommand):
+    __command__ = 'new'
+    __aliases__ = ['n']
+    __arguments__ = [
+        Argument(
+            'name',
+            metavar='TITLE',
+            help='Creates a new database version file'
+        )
+    ]
+
+    def __call__(self, args):
+        with self.migrator(args) as m:
+            ver = m.newversion(args.name)
+
+        print(f'File generated successfully: {ver}.')
+
+
+class MigrationCommand(SubCommand):
+    __command__ = 'migration'
+    __aliases__ = ['mi']
+    __arguments__ = [
+        UpgradeCommand,
+        DowngradeCommand,
+        NewVersionCommand
+    ]
+
+    def __call__(self, args):
+        self._parser.print_help()
+
+
+class DatabaseCommand(SubCommand):
+    __command__ = 'database'
+    __aliases__ = ['db']
+    __arguments__ = [
+        CreateDatabaseCommand,
+        DropDatabaseCommand,
+        MigrationCommand
+    ]

{yhttp_dbmanager-7.0.2 → yhttp_dbmanager-8.0.2}/yhttp/ext/dbmanager/install.py

@@ -1,4 +1,5 @@
 from .cli import DatabaseCommand
+from .migration import Migrator
 
 
 def install(app, cliarguments=None):
@@ -6,9 +7,15 @@ def install(app, cliarguments=None):
     if cliarguments:
         DatabaseCommand.__arguments__.extend(cliarguments)
 
+    app.settings.merge('''
+    db:
+      migration: {}
+    ''')
+    app.settings.db.migration.merge(Migrator.default_settings)
+
     @app.when
     def ready(app):
-        if 'db' not in app.settings:
+        if 'url' not in app.settings.db:
             raise ValueError(
                 'Please provide db.url configuration entry, for example: '
                 'postgres://:@/dbname'

yhttp_dbmanager-8.0.2/yhttp/ext/dbmanager/migration.py

@@ -0,0 +1,192 @@
+import os
+import glob
+import importlib
+from functools import cached_property
+from contextlib import contextmanager
+
+import psycopg2
+
+
+VERSIONFILE_TEMPLATE = '''\
+def upgrade(db):
+    raise NotImplementedError()
+
+
+def downgrade(db):
+    raise NotImplementedError()
+'''
+
+
+class Database:
+    def __init__(self, url):
+        self.url = url
+
+    @cached_property
+    def connection(self):
+        return psycopg2.connect(self.url)
+
+    def commit(self):
+        self.connection.commit()
+
+    def close(self):
+        self.connection.close()
+
+    def execute(self, query):
+        with self.connection.cursor() as c:
+            c.execute(query)
+
+    @contextmanager
+    def select(self, query):
+        with self.connection.cursor() as c:
+            c.execute(query)
+            yield c
+
+    def exists(self, query):
+        query = f'SELECT EXISTS ({query});'
+
+        with self.connection.cursor() as c:
+            c.execute(query)
+            r = c.fetchone()
+            return r[0]
+
+    def table_exists(self, name):
+        return self.exists(f'''
+            SELECT 1
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+            AND table_name = '{name}'
+        ''')
+
+
+class Migrator:
+    default_settings = '''
+      versiontable: yhttp_version
+    '''
+
+    def __init__(self, url, settings):
+        self.url = url
+        self.settings = settings
+
+    def __enter__(self):
+        self.db
+        return self
+
+    def __exit__(self, exctype, excvalue, traceback):
+        self.close()
+
+    @cached_property
+    def db(self):
+        return Database(self.url)
+
+    def close(self):
+        self.db.close()
+
+    @cached_property
+    def vtable(self):
+        return self.settings.versiontable
+
+    def ensure_versiontable(self):
+        if self.db.table_exists(self.vtable):
+            return
+
+        self.db.execute(f'''
+            CREATE TABLE {self.vtable} (
+                version INTEGER NOT NULL
+            );
+        ''')
+
+        self.db.execute(f'''
+            INSERT INTO {self.vtable} (version) VALUES (0);
+        ''')
+        self.db.commit()
+
+    def dbversion(self):
+        self.ensure_versiontable()
+        with self.db.select(f'SELECT version from {self.vtable}') as c:
+            return c.fetchone()[0]
+
+    def dbversion_set(self, ver):
+        self.db.execute(f'UPDATE {self.vtable} SET version={ver}')
+        self.db.commit()
+
+    @cached_property
+    def versions_directory(self):
+        try:
+            vdir = self.settings.directory
+        except AttributeError:
+            raise ValueError(
+                'Please provide db.migration.directory configuration entry.'
+            )
+
+        if not os.path.exists(vdir):
+            os.mkdir(vdir)
+
+        return vdir
+
+    @property
+    def lastversion(self):
+        files = glob.glob(f'{self.versions_directory}/*-*.py')
+        if not files:
+            return 0
+
+        lastfile = sorted(files)[-1]
+        ver = os.path.basename(lastfile).split('-', 1)[0]
+        return int(ver)
+
+    def newversion(self, name):
+        ver = self.lastversion + 1
+        filename = f'{ver:04d}-{name}.py'
+        filepath = os.path.join(self.versions_directory, filename)
+        with open(filepath, 'w') as f:
+            f.write(VERSIONFILE_TEMPLATE)
+
+        return filepath
+
+    def loadmodule(self, ver):
+        files = glob.glob(f'{self.versions_directory}/{ver:04d}-*.py')
+        if not files:
+            return None
+
+        modfile = files[0]
+        modname = os.path.splitext(os.path.basename(modfile))[0]
+        spec = importlib.util.spec_from_file_location(modname, modfile)
+        mod = importlib.util.module_from_spec(spec)
+        # sys.modules[module_name] = module
+        spec.loader.exec_module(mod)
+        return mod
+
+    def filenotfound(self, ver):
+        return FileNotFoundError(
+            f'script {ver:04d}_*.py not found within directory: '
+            f'{self.versions_directory}.'
+        )
+
+    def upgrade(self, targetver=None):
+        dbver = self.dbversion()
+        if targetver is None:
+            targetver = self.lastversion
+
+        while dbver < targetver:
+            cver = dbver + 1
+            mod = self.loadmodule(cver)
+            if mod is None:
+                raise self.filenotfound(cver)
+
+            mod.upgrade(self.db)
+            self.dbversion_set(cver)
+            dbver = cver
+
+        return targetver
+
+    def downgrade(self, targetver=0):
+        dbver = self.dbversion()
+        while dbver > targetver:
+            mod = self.loadmodule(dbver)
+            if mod is None:
+                raise self.filenotfound(dbver)
+
+            mod.downgrade(self.db)
+            dbver -= 1
+            self.dbversion_set(dbver)
+
+        return targetver

{yhttp_dbmanager-7.0.2 → yhttp_dbmanager-8.0.2/yhttp_dbmanager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yhttp-dbmanager
-Version: 7.0.2
+Version: 8.0.2
 Summary: Database manager command line interface and API for yhttp.
 Home-page: http://github.com/yhttp/yhttp-dbmanager
 Author: Vahid Mardani

{yhttp_dbmanager-7.0.2 → yhttp_dbmanager-8.0.2}/yhttp_dbmanager.egg-info/SOURCES.txt

@@ -1,14 +1,18 @@
 LICENSE
 README.md
 setup.py
-tests/test_cli.py
+tests/test_cli_createdrop.py
+tests/test_cli_migration.py
+tests/test_cli_usercommand.py
 tests/test_dbmanager.py
 tests/test_dburi.py
 tests/test_install.py
+tests/test_migrator.py
 yhttp/ext/dbmanager/__init__.py
 yhttp/ext/dbmanager/cli.py
 yhttp/ext/dbmanager/dbmanager.py
 yhttp/ext/dbmanager/install.py
+yhttp/ext/dbmanager/migration.py
 yhttp/ext/dbmanager/uri.py
 yhttp_dbmanager.egg-info/PKG-INFO
 yhttp_dbmanager.egg-info/SOURCES.txt

yhttp_dbmanager-7.0.2/yhttp/ext/dbmanager/cli.py

@@ -1,86 +0,0 @@
-import os
-import functools
-import getpass
-
-from easycli import SubCommand, Argument
-
-from . import dbmanager
-from .uri import DatabaseURI
-
-
-getdbpass = functools.partial(getpass.getpass, 'Enter db password: ')
-
-
-DEFAULT_DBUSER = os.environ['USER']
-
-
-class DatabaseAdministrativeCommand(SubCommand):
-    __arguments__ = [
-        Argument(
-            '-H',
-            '--host',
-            default=os.environ.get('YHTTP_DB_DEFAULT_HOST', ''),
-            help='DB hostname, default: empty.'
-        ),
-        Argument('-d', '--database', default='postgres', help='DB name'),
-        Argument(
-            '-u',
-            '--user',
-            default=os.environ.get(
-                'YHTTP_DB_DEFAULT_ADMINUSER',
-                DEFAULT_DBUSER
-            ),
-            help=f'DB administrator username, default: ${DEFAULT_DBUSER}'
-        ),
-        Argument(
-            '-p', '--password',
-            nargs='?',
-            default=os.environ.get(
-                'YHTTP_DB_DEFAULT_ADMINPASS',
-                'postgres'
-            ),
-            help='DB administrator password'
-        ),
-    ]
-
-    def getdbmanager(self, args):
-        password = args.password or getdbpass()
-
-        return dbmanager.PostgresqlManager(
-            user=args.user,
-            password=password,
-            host=args.host,
-            database=args.database
-        )
-
-    def getappdbinfo(self, args):
-        dbsettings = args.application.settings.db
-        url = DatabaseURI.loads(dbsettings.url)
-        return url
-
-
-class CreateDatabase(DatabaseAdministrativeCommand):
-    __command__ = 'create'
-    __aliases__ = ['c']
-
-    def __call__(self, args):
-        uri = self.getappdbinfo(args)
-        self.getdbmanager(args).create(uri.database, owner=uri.user)
-
-
-class DropDatabase(DatabaseAdministrativeCommand):
-    __command__ = 'drop'
-    __aliases__ = ['d']
-
-    def __call__(self, args):
-        uri = self.getappdbinfo(args)
-        self.getdbmanager(args).drop(uri.database)
-
-
-class DatabaseCommand(SubCommand):
-    __command__ = 'database'
-    __aliases__ = ['db']
-    __arguments__ = [
-        CreateDatabase,
-        DropDatabase
-    ]