def init(db: str = None, schema: str = "schema.sql", overwrite: bool = False): """ Create an initial schema SQL file, optionally from an existing database. :param db: An optional database to create the schema from. :param schema: An optional file to write schema to. Default: schema.sql :param overwrite: Overwrite existing file. """ if os.path.exists(schema) and not overwrite: print(cf.bold_red("Error:"), f'File "{schema}" already exists.', file=sys.stderr) print("Run again with", cf.bold("--overwrite"), "to replace.") sys.exit(os.EX_OSFILE) if not db: with open(schema, "w") as f: f.write("") print(cf.bold("All done! ✨")) print(f'Created blank file "{schema}"') sys.exit() base_uri = copy_url(db) target_exists = database_exists(base_uri, test_can_select=True) if not target_exists: print( cf.bold_red("Error:"), f'Database "{base_uri.database}" does not exist.', ) sys.exit(os.EX_NOHOST) sql = "" patch = create_admin_patch(base_uri) patch.start() with temporary_database(base_uri) as sTemp, S(db) as sFrom: # Compare m = Migration(sTemp, sFrom) m.add_all_changes() m.set_safety(False) # Get SQL sql = m.sql with open(schema, "wb") as f: f.write(pg_format(sql.encode(), unquote=False)) print(cf.bold("All done! ✨")) print(f'Created file "{schema}" with schema from "{base_uri.database}"') sys.exit()
def mock_retrieve_company_non_find_a_supplier(retrieve_profile_data): retrieve_profile_data['is_published_find_a_supplier'] = (False) patch = mock.patch.object(api_client.company, 'retrieve_public_profile', return_value=create_response( 200, retrieve_profile_data)) yield patch.start() patch.stop()
def mock_retrieve_supplier(): data = {'company': None} response = create_response(data) patch = mock.patch.object(api_client.supplier, 'retrieve_profile', return_value=response) yield patch.start() patch.stop()
def setup(self): self._setting_override = override_settings( TESTING=True, DEBUG=True, CACHES={ "default": { "BACKEND": "django.core.cache.backends.locmem.LocMemCache", } }, CELERY_TASK_EAGER_PROPAGATES=True, CELERY_TASK_ALWAYS_EAGER=True, CELERY_BROKER_BACKEND="memory", ) self._setting_override.__enter__() self._patches = self.patches() for patch in self._patches: patch.start()
def on_train_start(self): if kwargs.get("amp_backend") != "apex": return # extremely ugly. APEX patches all the native torch optimizers on `_initialize` which we call on # `ApexMixedPrecisionPlugin.dispatch`. Additionally, their replacement `new_step` functions are locally # defined so can't even patch those, thus we need to create the mock after APEX has been initialized nonlocal apex_optimizer_patches, apex_optimizer_steps for opt in self.trainer.optimizers: # `amp.scale_loss` will also patch the step to avoid it when gradient overflow happens. avoid it opt._amp_stash.already_patched = True patch = mock.patch.object(opt, "step") apex_optimizer_patches.append(patch) apex_optimizer_steps.append(patch.start())
def mock_retrieve_company(): data = { 'name': 'Cool Company', 'is_publishable': True, 'expertise_products_services': {}, 'is_identity_check_message_sent': False, } response = create_response(data) patch = mock.patch.object(api_client.company, 'profile_retrieve', return_value=response) yield patch.start() patch.stop()
def _start_patches(self, *patches): self._current_patches.append(patches) for patch in patches: patch.start()
def diff( sql_statements: str, db: str, unsafe: bool = False, apply: bool = False, chatty: bool = False, ): base_uri = copy_url(db) patch = create_admin_patch(base_uri) patch.start() roles, statements = extract_roles(sql_statements) with temporary_database(base_uri) as sTemp: roles_m = Migration(sTemp, NullInspector()) from_roles = roles_m.changes.i_from.roles # Exclude all unspecified roles for k in set(from_roles.keys()) - set(roles.keys()): del from_roles[k] # Compare roles roles_m.add(statements_for_changes(from_roles, roles)) if roles_m.statements: roles_m.set_safety(True) roles_sql = roles_m.sql if chatty: print(pg_format(roles_sql.encode(), unquote=False).decode()) print(cf.bold("Applying roles...")) roles_m.apply() sTemp.commit() if chatty: print(cf.bold("Done.")) target_exists = database_exists(base_uri, test_can_select=True) with S(db) if target_exists else temporary_database(base_uri) as sFrom: # Run schema in temporary database try: raw_execute(sTemp, statements) except Exception as e: raise SQLSyntaxError(e, statements) # Compare m = Migration(sFrom, sTemp) m.set_safety(not unsafe) m.add_all_changes(privileges=True) if not m.statements: if chatty: print(cf.bold("All done! ✨")) print(f'Database "{base_uri.database}" is up to date.') return None, False sql = "" # Get SQL try: sql = m.sql except UnsafeMigrationException: m.set_safety(False) sql = m.sql formatted = pg_format(sql.encode(), unquote=False).decode() return formatted, True formatted = pg_format(sql.encode(), unquote=False).decode() if chatty: print(formatted) if apply: if chatty: print(cf.bold("Applying...")) m.apply() if chatty: print(cf.bold("All done! ✨")) print(f'Database "{base_uri.database}" has been updated.') return formatted, False