rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return self._code(self.new_field, self.old_field, self.old_def) | if not self.irreversible: return self._code(self.new_field, self.old_field, self.old_def) else: return self.irreversable_code(self.old_field) | def backwards_code(self): return self._code(self.new_field, self.old_field, self.old_def) |
set([self.fakeapp['0001_spam']]), set([ | [self.fakeapp['0001_spam']], [ | def test_forwards_plan(self): self.assertEqual([ set([self.fakeapp['0001_spam']]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'] ]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'], self.fakeapp['0003_alter_spam'], ]) ], [m.forwards_plan() for m in self.fakeapp], ) self.assertEqual([ set([ self.... |
]), set([ | ], [ | def test_forwards_plan(self): self.assertEqual([ set([self.fakeapp['0001_spam']]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'] ]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'], self.fakeapp['0003_alter_spam'], ]) ], [m.forwards_plan() for m in self.fakeapp], ) self.assertEqual([ set([ self.... |
]) | ] | def test_forwards_plan(self): self.assertEqual([ set([self.fakeapp['0001_spam']]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'] ]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'], self.fakeapp['0003_alter_spam'], ]) ], [m.forwards_plan() for m in self.fakeapp], ) self.assertEqual([ set([ self.... |
set([ | [ | def test_forwards_plan(self): self.assertEqual([ set([self.fakeapp['0001_spam']]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'] ]), set([ self.fakeapp['0001_spam'], self.fakeapp['0002_eggs'], self.fakeapp['0003_alter_spam'], ]) ], [m.forwards_plan() for m in self.fakeapp], ) self.assertEqual([ set([ self.... |
self.assertEqual([[], [self.deps_a['0001_a']], [self.deps_a['0002_a']], [self.deps_a['0003_a'], self.deps_b['0003_b']], [self.deps_a['0004_a']]], [m.dependencies for m in self.deps_a]) self.assertEqual([[], [self.deps_b['0001_b'], self.deps_a['0002_a']], [self.deps_b['0002_b'], self.deps_a['0003_a']], [self.deps_b['000... | self.assertEqual( [ set([]), set([self.deps_a['0001_a']]), set([self.deps_a['0002_a']]), set([ self.deps_a['0003_a'], self.deps_b['0003_b'], ]), set([self.deps_a['0004_a']]), ], [m.dependencies for m in self.deps_a], ) self.assertEqual( [ set([]), set([ self.deps_b['0001_b'], self.deps_a['0002_a'] ]), set([ self.deps_b... | def test_dependencies(self): self.assertEqual([[], [self.deps_a['0001_a']], [self.deps_a['0002_a']], [self.deps_a['0003_a'], self.deps_b['0003_b']], [self.deps_a['0004_a']]], [m.dependencies for m in self.deps_a]) self.assertEqual([[], [self.deps_b['0001_b'], self.deps_a['0002_a']], [self.deps_b['0002_b'], self.deps_a[... |
self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], | self.assertEqual([set([self.deps_a['0002_a']]), set([self.deps_c['0005_c'], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
deque([self.deps_b['0003_b'], | set([self.deps_b['0003_b'], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
deque([self.deps_a['0005_a']]), deque([])], | set([self.deps_a['0005_a']]), set([])], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
self.assertEqual([deque([self.deps_b['0002_b']]), deque([self.deps_b['0003_b']]), deque([self.deps_b['0004_b'], | self.assertEqual([set([self.deps_b['0002_b']]), set([self.deps_b['0003_b']]), set([self.deps_b['0004_b'], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
deque([self.deps_b['0005_b']]), deque([])], | set([self.deps_b['0005_b']]), set([])], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
self.assertEqual([deque([self.deps_c['0002_c']]), deque([self.deps_c['0003_c']]), deque([self.deps_c['0004_c']]), deque([self.deps_c['0005_c']]), deque([])], | self.assertEqual([set([self.deps_c['0002_c']]), set([self.deps_c['0003_c']]), set([self.deps_c['0004_c']]), set([self.deps_c['0005_c']]), set([])], | def test_dependents(self): self.assertEqual([deque([self.deps_a['0002_a']]), deque([self.deps_c['0005_c'], self.deps_b['0002_b'], self.deps_a['0003_a']]), deque([self.deps_b['0003_b'], self.deps_a['0004_a']]), deque([self.deps_a['0005_a']]), deque([])], [m.dependents for m in self.deps_a]) self.assertEqual([deque([self... |
[m.forwards_plan for m in self.deps_a]) | [m.forwards_plan() for m in self.deps_a]) | def test_forwards_plan(self): self.assertEqual([[self.deps_a['0001_a']], [self.deps_a['0001_a'], self.deps_a['0002_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a'], self.deps_b['0001_b'], self.deps_b['0002_b'], self.deps_b[... |
[m.forwards_plan for m in self.deps_b]) | [m.forwards_plan() for m in self.deps_b]) | def test_forwards_plan(self): self.assertEqual([[self.deps_a['0001_a']], [self.deps_a['0001_a'], self.deps_a['0002_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a'], self.deps_b['0001_b'], self.deps_b['0002_b'], self.deps_b[... |
[m.forwards_plan for m in self.deps_c]) | [m.forwards_plan() for m in self.deps_c]) | def test_forwards_plan(self): self.assertEqual([[self.deps_a['0001_a']], [self.deps_a['0001_a'], self.deps_a['0002_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a']], [self.deps_a['0001_a'], self.deps_a['0002_a'], self.deps_a['0003_a'], self.deps_b['0001_b'], self.deps_b['0002_b'], self.deps_b[... |
self.assertEqual([[self.deps_c['0005_c'], self.deps_b['0005_b'], self.deps_b['0004_b'], self.deps_a['0005_a'], self.deps_a['0004_a'], self.deps_b['0003_b'], self.deps_b['0002_b'], self.deps_a['0003_a'], self.deps_a['0002_a'], self.deps_a['0001_a']], [self.deps_c['0005_c'], self.deps_b['0005_b'], self.deps_b['0004_b'], ... | self.assertEqual([ [ self.deps_c['0005_c'], self.deps_b['0005_b'], self.deps_b['0004_b'], self.deps_a['0005_a'], self.deps_a['0004_a'], self.deps_b['0003_b'], self.deps_b['0002_b'], self.deps_a['0003_a'], self.deps_a['0002_a'], self.deps_a['0001_a'], ], [ self.deps_c['0005_c'], self.deps_b['0005_b'], self.deps_b['0004_... | def test_backwards_plan(self): self.assertEqual([[self.deps_c['0005_c'], self.deps_b['0005_b'], self.deps_b['0004_b'], self.deps_a['0005_a'], self.deps_a['0004_a'], self.deps_b['0003_b'], self.deps_b['0002_b'], self.deps_a['0003_a'], self.deps_a['0002_a'], self.deps_a['0001_a']], [self.deps_c['0005_c'], self.deps_b['00... |
self.assertEqual([(migrations['0002_eggs'], [migrations['0001_spam']])], e.problems) | self.assertEqual( [ ( migrations['0002_eggs'], migrations['0001_spam'], ) ], e.problems, ) | def test_migration_merge_forwards(self): MigrationHistory.objects.all().delete() migrations = Migrations("fakeapp") # We should start with no migrations self.assertEqual(list(MigrationHistory.objects.all()), []) # Insert one in the wrong order MigrationHistory.objects.create(app_name = "fakeapp", migration = "0002_eg... |
self.assertEqual([(migrations['0001_spam'], [migrations['0002_eggs']])], e.problems) | self.assertEqual( [ ( migrations['0002_eggs'], migrations['0001_spam'], ) ], e.problems, ) | def test_migration_merge_forwards(self): MigrationHistory.objects.all().delete() migrations = Migrations("fakeapp") # We should start with no migrations self.assertEqual(list(MigrationHistory.objects.all()), []) # Insert one in the wrong order MigrationHistory.objects.create(app_name = "fakeapp", migration = "0002_eg... |
self.assertEqual(['A1', 'A2', 'B1', 'A3'], depends('A3', lambda n: graph[n])) | self.assertEqual( ['B1', 'A1', 'A2', 'A3'], depends('A3', lambda n: graph[n]), ) | def test_depends(self): graph = {'A1': []} self.assertEqual(['A1'], depends('A1', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2']} self.assertEqual(['A1', 'A2', 'A3'], depends('A3', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2', 'A1']} self.assertEqual(['A1', 'A2', 'A3'], depends(... |
self.assertEqual(['A1', 'A2', 'B1', 'B2', 'A3'], depends('A3', lambda n: graph[n])) | self.assertEqual( ['B1', 'B2', 'A1', 'A2', 'A3'], depends('A3', lambda n: graph[n]), ) | def test_depends(self): graph = {'A1': []} self.assertEqual(['A1'], depends('A1', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2']} self.assertEqual(['A1', 'A2', 'A3'], depends('A3', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2', 'A1']} self.assertEqual(['A1', 'A2', 'A3'], depends(... |
self.assertEqual(['A1', 'A2', 'B1', 'C1', 'B2', 'A3'], depends('A3', lambda n: graph[n])) | self.assertEqual( ['B1', 'C1', 'B2', 'A1', 'A2', 'A3'], depends('A3', lambda n: graph[n]), ) | def test_depends(self): graph = {'A1': []} self.assertEqual(['A1'], depends('A1', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2']} self.assertEqual(['A1', 'A2', 'A3'], depends('A3', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2', 'A1']} self.assertEqual(['A1', 'A2', 'A3'], depends(... |
self.assertEqual(['A1', 'A2', 'B1', 'C1', 'C2', 'B2', 'A3'], depends('A3', lambda n: graph[n])) | self.assertEqual( ['A1', 'B1', 'C1', 'C2', 'B2', 'A2', 'A3'], depends('A3', lambda n: graph[n]), ) | def test_depends(self): graph = {'A1': []} self.assertEqual(['A1'], depends('A1', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2']} self.assertEqual(['A1', 'A2', 'A3'], depends('A3', lambda n: graph[n])) graph = {'A1': [], 'A2': ['A1'], 'A3': ['A2', 'A1']} self.assertEqual(['A1', 'A2', 'A3'], depends(... |
self.assertRaises(exceptions.CircularDependency, depends, target, lambda n: graph[n]) | "Custom assertion that checks a circular dependency is detected correctly." self.assertRaises( exceptions.CircularDependency, depends, target, lambda n: graph[n], ) | def assertCircularDependency(self, trace, target, graph): self.assertRaises(exceptions.CircularDependency, depends, target, lambda n: graph[n]) try: depends(target, lambda n: graph[n]) except exceptions.CircularDependency, e: self.assertEqual(trace, e.trace) |
db.delete_unique("test3", ["eggs"]) | if db.backend_name != "sqlite3": db.delete_unique("test3", ["eggs"]) | def test_index(self): """ Test the index operations """ db.create_table("test3", [ ('SELECT', models.BooleanField(default=False)), ('eggs', models.IntegerField(unique=True)), ]) db.execute_deferred_sql() # Add an index on that column db.create_index("test3", ["SELECT"]) # Add another index on two columns db.create_inde... |
name = "%s.%s" % (app_label, model_name) | def __init__(self, cls, app): self.default_app = app self.cls = cls # Try loading the models off the migration class; default to no models. self.models = {} try: self.models_source = cls.models except AttributeError: return # Start a 'new' AppCache hacks.clear_app_cache() # Now, make each model's data into a FakeMode... | |
name = name.lower() self.models[name] = name model_names.append((name, app_label, model_name, data)) | name = "%s.%s" % (app_label, model_name) self.models[name.lower()] = name model_names.append((name.lower(), app_label, model_name, data)) | def __init__(self, cls, app): self.default_app = app self.cls = cls # Try loading the models off the migration class; default to no models. self.models = {} try: self.models_source = cls.models except AttributeError: return # Start a 'new' AppCache hacks.clear_app_cache() # Now, make each model's data into a FakeMode... |
exists.add(m) | else: exists.add(m) | def check_migration_histories(histories, delete_ghosts=False): "Checks that there's no 'ghost' migrations in the database." exists = SortedSet() ghosts = [] for h in histories: try: m = h.get_migration() m.migration() except exceptions.UnknownMigration: ghosts.append(h) except ImproperlyConfigured: pass ... |
try: migrations = Migrations(app) except NoMigrations: Migrations.create_migrations_directory(app, verbose=verbosity > 0) migrations = Migrations(app) | migrations = Migrations(app, force_creation=True, verbose_creation=verbosity > 0) | def handle(self, app=None, name="", freeze_list=None, stdout=False, verbosity=1, **options): # Any supposed lists that are None become empty lists freeze_list = freeze_list or [] |
for last, migration in problems(reversed(pending), done): missing = [m for m in last.forwards_plan()[:-1] if m not in done] if verbosity: m = ", ".join(str(m) for m in missing) print (" ! Migration %s should not have been applied " "before %s but was." % (last, m)) result.append((last, missing)) return result def back... | for last, migration in problems: to_check = list(last.dependencies) while to_check: checking = to_check.pop() if checking not in done: if verbosity: print (" ! Migration %s should not have been applied " "before %s but was." % (last, checking)) result.append((last, checking)) else: to_check.extend(checking.dependenc... | def forwards_problems(pending, done, verbosity): """ Takes the list of linearised pending migrations, and the set of done ones, and returns the list of problems, if any. """ result = [] for last, migration in problems(reversed(pending), done): missing = [m for m in last.forwards_plan()[:-1] if m not in done] if verbosi... |
def current_model_from_key(self, key): app_label, model_name = key.split(".") return models.get_model(app_label, model_name) def current_field_from_key(self, key, fieldname): app_label, model_name = key.split(".") return models.get_model(app_label, model_name)._meta.get_field_by_name(fieldname)[0] | def __init__(self, migrations, old_defs, old_orm, new_defs): self.migrations = migrations self.old_defs = old_defs self.old_orm = old_orm self.new_defs = new_defs | |
if logging_file and len(_logger.handlers) < 2: _logger.addHandler(logging.FileHandler(logging_file)) _logger.setLevel(logging.DEBUG) | if logging_file: if len(_logger.handlers) < 2: _logger.addHandler(logging.FileHandler(logging_file)) _logger.setLevel(logging.DEBUG) | def get_logger(): "Attach a file handler to the logger if there isn't one already." debug_on = getattr(settings, "SOUTH_LOGGING_ON", False) logging_file = getattr(settings, "SOUTH_LOGGING_FILE", False) if debug_on: if logging_file and len(_logger.handlers) < 2: _logger.addHandler(logging.FileHandler(logging_file)) _lo... |
]) | ]) + "," | def forwards_code(self): "Produces the code snippet that gets put into forwards()" field_defs = ",\n ".join([ "(%r, %s)" % (name, defn) for name, defn in self.triples_to_defs(self.model_def).items() ]) return self.FORWARDS_TEMPLATE % { "model_name": self.model._meta.object_name, "table_name": self.model._me... |
new_to_old = {} | def _copy_data(self, src, dst, field_renames={}): "Used to copy data into a new table" # Make a list of all the fields to select cursor = self._get_connection().cursor() q_fields = [column_info[0] for column_info in self._get_connection().introspection.get_table_description(cursor, dst)] # Make sure renames are done co... | |
q_fields[q_fields.index(new)] = "%s AS %s" % (old, self.quote_name(new)) | new_to_old[new] = old q_fields_new = [] for field in q_fields: if field in new_to_old: q_fields_new.append("%s AS %s" % (self.quote_name(new_to_old[field]), self.quote_name(field))) else: q_fields_new.append(self.quote_name(field)) q_fields = q_fields_new | def _copy_data(self, src, dst, field_renames={}): "Used to copy data into a new table" # Make a list of all the fields to select cursor = self._get_connection().cursor() q_fields = [column_info[0] for column_info in self._get_connection().introspection.get_table_description(cursor, dst)] # Make sure renames are done co... |
return self._wrap_direction(migration.backwards(), self.orm(migration)) | return self._wrap_direction(migration.backwards(), migration.prev_orm()) | def backwards(self, migration): return self._wrap_direction(migration.backwards(), self.orm(migration)) |
return self._wrap_direction(migration.forwards(), self.orm(migration)) | return self._wrap_direction(migration.forwards(), migration.orm()) | def forwards(self, migration): return self._wrap_direction(migration.forwards(), self.orm(migration)) |
get_logger().debug('south execute "%s" with params "%s"' % (sql, params), extra={ 'sql': sql, 'params': params, }) | get_logger().debug('south execute "%s" with params "%s"' % (sql, params)) | def execute(self, sql, params=[]): """ Executes the given SQL statement, with optional parameters. If the instance's debug attribute is True, prints out what it executes. """ cursor = self._get_connection().cursor() if self.debug: print " = %s" % sql, params |
h = NullHandler() | def emit(self, record): pass | |
_logger.addHandler(h) | _logger.addHandler(NullHandler()) | def emit(self, record): pass |
if logging_file: _logger.addHandler( logging.FileHandler(logging_file) ) | if logging_file and len(_logger.handlers) < 2: _logger.addHandler(logging.FileHandler(logging_file)) | def get_logger(): debug_on = getattr(settings, "SOUTH_LOGGING_ON", False) logging_file = getattr(settings, "SOUTH_LOGGING_FILE", False) if debug_on: if logging_file: _logger.addHandler( logging.FileHandler(logging_file) ) _logger.setLevel(logging.DEBUG) else: raise IOError, "SOUTH_LOGGING_ON is True. You also need a S... |
db.add_column(%(table_name)r, %(field_name)r, %(field_def)s)''' | db.add_column(%(table_name)r, %(field_name)r, %(field_def)s, keep_default=False)''' | def backwards_code(self): return AddModel.forwards_code(self) |
yield ("DeleteField", {"model": self.old_orm[key], "field": self.old_orm[key + ":" + fieldname], "field_def": old_fields[fieldname]}) | field = self.old_orm[key + ":" + fieldname] field_allowed = True for field_type in self.IGNORED_FIELD_TYPES: if isinstance(field, field_type): field_allowed = False if field_allowed: yield ("DeleteField", { "model": self.old_orm[key], "field": field, "field_def": old_fields[fieldname], }) | def get_changes(self): """ Returns the difference between the old and new sets of models as a 5-tuple: added_models, deleted_models, added_fields, deleted_fields, changed_fields """ deleted_models = set() # See if anything's vanished for key in self.old_defs: if key not in self.new_defs: # We shouldn't delete it if i... |
yield ("AddField", {"model": self.current_model_from_key(key), "field": self.current_field_from_key(key, fieldname), "field_def": new_fields[fieldname]}) | field = self.current_field_from_key(key, fieldname) field_allowed = True for field_type in self.IGNORED_FIELD_TYPES: if isinstance(field, field_type): field_allowed = False if field_allowed: yield ("AddField", { "model": self.current_model_from_key(key), "field": field, "field_def": new_fields[fieldname], }) | def get_changes(self): """ Returns the difference between the old and new sets of models as a 5-tuple: added_models, deleted_models, added_fields, deleted_fields, changed_fields """ deleted_models = set() # See if anything's vanished for key in self.old_defs: if key not in self.new_defs: # We shouldn't delete it if i... |
return get_app_label(self._migrations) | return self._application.__name__.split('.')[-1] | def app_label(self): return get_app_label(self._migrations) |
return | sys.exit(1) | def handle(self, app=None, target=None, skip=False, merge=False, backwards=False, fake=False, db_dry_run=False, show_list=False, **options): |
if not hasattr(conn, 'settings_dict'): | if not hasattr(connection, 'settings_dict'): | def _get_setting(self, setting_name): """ Allows code to get a setting (like, for example, STORAGE_ENGINE) """ setting_name = setting_name.upper() connection = self._get_connection() if not hasattr(conn, 'settings_dict'): # Django 1.1 and below return getattr(settings, "DATABASE_%s" % setting_name) else: # Django 1.2 a... |
return conn.settings_dict[setting_name] | return connection.settings_dict[setting_name] | def _get_setting(self, setting_name): """ Allows code to get a setting (like, for example, STORAGE_ENGINE) """ setting_name = setting_name.upper() connection = self._get_connection() if not hasattr(conn, 'settings_dict'): # Django 1.1 and below return getattr(settings, "DATABASE_%s" % setting_name) else: # Django 1.2 a... |
if self.old_defs[key].get("Meta", {}).get("managed", "True") != "False": old_fields, old_meta, old_m2ms = self.split_model_def(self.old_orm[key], self.old_defs[key]) yield ("DeleteModel", { "model": self.old_orm[key], "model_def": old_fields, }) | old_fields, old_meta, old_m2ms = self.split_model_def(self.old_orm[key], self.old_defs[key]) if old_meta.get("managed", "True") != "False": | def get_changes(self): """ Returns the difference between the old and new sets of models as a 5-tuple: added_models, deleted_models, added_fields, deleted_fields, changed_fields """ deleted_models = set() # See if anything's vanished for key in self.old_defs: if key not in self.new_defs: # We shouldn't delete it if i... |
if self.new_defs[key].get("Meta", {}).get("managed", "True") != "False": new_fields, new_meta, new_m2ms = self.split_model_def(self.current_model_from_key(key), self.new_defs[key]) | new_fields, new_meta, new_m2ms = self.split_model_def(self.current_model_from_key(key), self.new_defs[key]) if new_meta.get("managed", "True") != "False": | def get_changes(self): """ Returns the difference between the old and new sets of models as a 5-tuple: added_models, deleted_models, added_fields, deleted_fields, changed_fields """ deleted_models = set() # See if anything's vanished for key in self.old_defs: if key not in self.new_defs: # We shouldn't delete it if i... |
USELESS_DB_KEYWORDS = ["related_name", "default"] | USELESS_DB_KEYWORDS = ["related_name", "default", "blank"] | def pprint_fields(fields): return "{\n %s\n }" % ",\n ".join([ "%r: %r" % (name, defn) for name, defn in sorted(fields.items()) ]) |
m = ", ".join(str(m) for m in missing) | def forwards_problems(pending, done, verbosity): """ Takes the list of linearised pending migrations, and the set of done ones, and returns the list of problems, if any. """ result = [] for last, migration in problems(reversed(pending), done): missing = [m for m in last.forwards_plan()[:-1] if m not in done] if verbosi... | |
"before %s but was." % (last, m)) | "before %s but was." % (last, migration)) | def forwards_problems(pending, done, verbosity): """ Takes the list of linearised pending migrations, and the set of done ones, and returns the list of problems, if any. """ result = [] for last, migration in problems(reversed(pending), done): missing = [m for m in last.forwards_plan()[:-1] if m not in done] if verbosi... |
m = ", ".join(str(m) for m in missing) print " ! Migration %s should have been applied before %s but wasn't." % (migration, m) | print " ! Migration %s should have been applied before %s but wasn't." % (migration, last) | def backwards_problems(pending, done, verbosity): result = [] for last, migration in problems(pending, done): missing = [m for m in migration.backwards_plan()[:-1] if m in done] if verbosity: m = ", ".join(str(m) for m in missing) print " ! Migration %s should have been applied before %s but wasn't." % (migration, m) r... |
models.get_apps = lambda: [models.get_app(target.app_label())] | new_get_apps = lambda: [models.get_app(target.app_label())] models.get_apps = new_get_apps loaddata.get_apps = new_get_apps | def load_initial_data(self, target): if target is None or target != target.migrations[-1]: return # Load initial data, if we ended up at target if self.verbosity: print " - Loading initial data for %s." % target.app_label() # Override Django's get_apps call temporarily to only load from the # current app old_get_apps =... |
if isinstance(base, models.Model) and not base._meta.abstract: | if issubclass(base, models.Model) and (base is not models.Model) and not base._meta.abstract: | def model_dependencies(model, checked_models=None): """ Returns a set of models this one depends on to be defined; things like OneToOneFields as ID, ForeignKeys everywhere, etc. """ depends = set() checked_models = checked_models or set() # Get deps for each field for field in model._meta.fields + model._meta.many_to_m... |
self.quote_name('%s_%s' % (table_name, '__'.join(columns))), self.quote_name(table_name), ', '.join(columns) | self.quote_name('%s_%s' % (table_name, '__'.join(columns))), self.quote_name(table_name), ', '.join(self.quote_name(c) for c in columns), | def _create_unique(self, table_name, columns): self.execute("CREATE UNIQUE INDEX %s ON %s(%s);" % ( self.quote_name('%s_%s' % (table_name, '__'.join(columns))), self.quote_name(table_name), ', '.join(columns) )) |
raise exceptions.FailedDryRun(sys.exc_info()) | raise exceptions.FailedDryRun(migration, sys.exc_info()) | def _run_migration(self, migration): if migration.no_dry_run() and self.verbosity: print " - Migration '%s' is marked for no-dry-run." return db.dry_run = True db.debug, old_debug = False, db.debug pending_creates = db.get_pending_creates() db.start_transaction() migration_function = self.direction(migration) try: try:... |
self.old_app_models = cache.app_models cache.app_models = {} | self.old_app_models, cache.app_models = cache.app_models, {} | def clear_app_cache(self): """ Clears the contents of AppCache to a blank state, so new models from the ORM can be added. """ self.old_app_models = cache.app_models cache.app_models = {} |
real_fields = {} meta = {} m2m_fields = {} | real_fields = SortedDict() meta = SortedDict() m2m_fields = SortedDict() | Given a model and its model def (a dict of field: triple), returns three |
index_name = ('%s_%s%s%s' % (table_name, column_names[0], index_unique_name, suffix)) | index_name = ('%s_%s%s%s' % (table_name, column_names[0], index_unique_name, suffix)).replace('"', '').replace('.', '_') | def create_index_name(self, table_name, column_names, suffix=""): """ Generate a unique name for the index """ index_unique_name = '' |
def _remake_table(self, table_name, added={}, renames={}, deleted=[], altered={}, primary_key_override=None): | def _remake_table(self, table_name, added={}, renames={}, deleted=[], altered={}, primary_key_override=None, uniques_deleted=[]): | def _remake_table(self, table_name, added={}, renames={}, deleted=[], altered={}, primary_key_override=None): """ Given a table and three sets of changes (renames, deletes, alters), recreates it with the modified schema. """ # Dry runs get skipped completely if self.dry_run: return # Temporary table's name temp_name = ... |
if indexes[name]['unique']: | if indexes[name]['unique'] and name not in uniques_deleted: | def _remake_table(self, table_name, added={}, renames={}, deleted=[], altered={}, primary_key_override=None): """ Given a table and three sets of changes (renames, deletes, alters), recreates it with the modified schema. """ # Dry runs get skipped completely if self.dry_run: return # Temporary table's name temp_name = ... |
Not supported under SQLite. """ print " ! WARNING: SQLite does not support adding unique constraints. Ignored." | Create an unique index on columns """ self._create_unique(table_name, columns) | def create_unique(self, table_name, columns): """ Not supported under SQLite. """ print " ! WARNING: SQLite does not support adding unique constraints. Ignored." |
Not supported under SQLite. """ print " ! WARNING: SQLite does not support removing unique constraints. Ignored." | Delete an unique index """ self._remake_table(table_name, uniques_deleted=columns) | def delete_unique(self, table_name, columns): """ Not supported under SQLite. """ print " ! WARNING: SQLite does not support removing unique constraints. Ignored." |
r'[^.]*' r'(\.pyc?)$') | r'[0-9a-zA-Z_]*' r'(\.pyc?)?$') | def _clear_cache(self): "Clears the cache of Migration objects." self.instances = {} |
r'[^.]*' | r'[0-9a-zA-Z_]*' | def _clear_cache(self): "Clears the cache of Migration objects." self.instances = {} |
""" % ifsc_table, ['public', table_name, type]) | """ % ifsc_table, [schema, table_name, type]) | def _constraints_affecting_columns(self, table_name, columns, type="UNIQUE"): """ Gets the names of the constraints affecting the given columns. If columns is None, returns all constraints of the type on the table. """ |
self.backwards(migration)() return sys.stdout.getvalue() except: raise | try: self.backwards(migration)() return sys.stdout.getvalue() except: raise | def format_backwards(self, migration): old_debug, old_dry_run = db.debug, db.dry_run db.debug = db.dry_run = True stdout = sys.stdout sys.stdout = StringIO() try: self.backwards(migration)() return sys.stdout.getvalue() except: raise finally: db.debug, db.dry_run = old_debug, old_dry_run sys.stdout = stdout |
print " - Migration '%s' is marked for no-dry-run." | print " - Migration '%s' is marked for no-dry-run." % migration | def _run_migration(self, migration): if migration.no_dry_run() and self.verbosity: print " - Migration '%s' is marked for no-dry-run." return db.dry_run = True db.debug, old_debug = False, db.debug pending_creates = db.get_pending_creates() db.start_transaction() migration_function = self.direction(migration) try: try:... |
self.alter_column(table_name, name, field, explicit_name=False) | self.alter_column(table_name, name, field, explicit_name=False, ignore_constraints=True) | def add_column(self, table_name, name, field, keep_default=True): """ Adds the column 'name' to the table 'table_name'. Uses the 'field' paramater, a django.db.models.fields.Field instance, to generate the necessary sql |
def alter_column(self, table_name, name, field, explicit_name=True): | def alter_column(self, table_name, name, field, explicit_name=True, ignore_constraints=False): | def alter_column(self, table_name, name, field, explicit_name=True): """ Alters the given column name so it will match the given field. Note that conversion between the two by the database must be possible. Will not automatically add _id by default; to have this behavour, pass explicit_name=False. |
if self.has_check_constraints: check_constraints = self._constraints_affecting_columns(table_name, [name], "CHECK") for constraint in check_constraints: self.execute(self.delete_check_sql % { 'table': self.quote_name(table_name), 'constraint': self.quote_name(constraint), }) try: self.delete_foreign_key(table_name, n... | if not ignore_constraints: if self.has_check_constraints: check_constraints = self._constraints_affecting_columns(table_name, [name], "CHECK") for constraint in check_constraints: self.execute(self.delete_check_sql % { 'table': self.quote_name(table_name), 'constraint': self.quote_name(constraint), }) try: self.dele... | def alter_column(self, table_name, name, field, explicit_name=True): """ Alters the given column name so it will match the given field. Note that conversion between the two by the database must be possible. Will not automatically add _id by default; to have this behavour, pass explicit_name=False. |
if field.rel and self.supports_foreign_keys: self.execute( self.foreign_key_sql( table_name, field.column, field.rel.to._meta.db_table, field.rel.to._meta.get_field(field.rel.field_name).column | if not ignore_constraints: if field.rel and self.supports_foreign_keys: self.execute( self.foreign_key_sql( table_name, field.column, field.rel.to._meta.db_table, field.rel.to._meta.get_field(field.rel.field_name).column ) | def alter_column(self, table_name, name, field, explicit_name=True): """ Alters the given column name so it will match the given field. Note that conversion between the two by the database must be possible. Will not automatically add _id by default; to have this behavour, pass explicit_name=False. |
) | def alter_column(self, table_name, name, field, explicit_name=True): """ Alters the given column name so it will match the given field. Note that conversion between the two by the database must be possible. Will not automatically add _id by default; to have this behavour, pass explicit_name=False. | |
results = {'app_label': app.lower()} | results = {'app_label': app} | def make_meta(self, app, model, data, stub=False): "Makes a Meta class out of a dict of eval-able arguments." results = {'app_label': app.lower()} for key, code in data.items(): # Some things we never want to use. if key in ["_bases"]: continue # Some things we don't want with stubs. if stub and key in ["order_with_res... |
if "_bases" in data['Meta']: | elif "_bases" in data['Meta']: | def make_model(self, app, name, data): "Makes a Model class out of the given app name, model name and pickled data." # Extract any bases out of Meta if "_ormbases" in data['Meta']: # Make sure everything we depend on is done already; otherwise, wait. for key in data['Meta']['_ormbases']: key = key.lower() if key not i... |
if '--verbosity' not in [opt.get_opt_string() for opt in BaseCommand.option_list]: | if '--verbosity' not in [opt.get_opt_string() for opt in syncdb.Command.option_list]: | def get_app_label(app): return '.'.join( app.__name__.split('.')[0:-1] ) |
""" try: | """ if self._is_multidb(): | def _get_connection(self): """ Returns a django connection for a given DB Alias """ try: from django.db import connections return connections[self.db_alias] except ImportError: from django.db import connection return connection |
except ImportError: | else: | def _get_connection(self): """ Returns a django connection for a given DB Alias """ try: from django.db import connections return connections[self.db_alias] except ImportError: from django.db import connection return connection |
try: from django.db import connections except ImportError: return getattr(settings, "DATABASE_%s" % setting_name) else: | if self._is_multidb(): | def _get_setting(self, setting_name): """ Allows code to get a setting (like, for example, STORAGE_ENGINE) """ setting_name = setting_name.upper() connection = self._get_connection() try: from django.db import connections except ImportError: # Django 1.1 and below return getattr(settings, "DATABASE_%s" % setting_name) ... |
models.signals.post_syncdb.send(sender=app, app=app, created_models=created_models, verbosity=verbosity, interactive=interactive) | if self._is_multidb(): models.signals.post_syncdb.send( sender=app, app=app, created_models=created_models, verbosity=verbosity, interactive=interactive, db=self.db_alias, ) else: models.signals.post_syncdb.send( sender=app, app=app, created_models=created_models, verbosity=verbosity, interactive=interactive, ) | def really_send_create_signal(self, app_label, model_names): """ Sends a post_syncdb signal for the model specified. |
sqls = [(self.alter_string_set_type % params, [])] | sqls = [] if params["type"] is not None: sqls.append((self.alter_string_set_type % params, [])) | def alter_column(self, table_name, name, field, explicit_name=True, ignore_constraints=False): """ Alters the given column name so it will match the given field. Note that conversion between the two by the database must be possible. Will not automatically add _id by default; to have this behavour, pass explicit_name=Fa... |
Migrations.calculate_dependencies() | Migrations.calculate_dependencies(force=True) | def setUp(self): super(TestMigration, self).setUp() self.fakeapp = Migrations('fakeapp') self.otherfakeapp = Migrations('otherfakeapp') Migrations.calculate_dependencies() |
Migrations.calculate_dependencies() | Migrations.calculate_dependencies(force=True) | def setUp(self): super(TestMigrationDependencies, self).setUp() self.deps_a = Migrations('deps_a') self.deps_b = Migrations('deps_b') self.deps_c = Migrations('deps_c') Migrations.calculate_dependencies() |
Migrations.calculate_dependencies() | Migrations.calculate_dependencies(force=True) | def test_plans(self): Migrations.calculate_dependencies() circular_a = Migrations('circular_a') circular_b = Migrations('circular_b') self.assertRaises( exceptions.CircularDependency, circular_a[-1].forwards_plan, ) self.assertRaises( exceptions.CircularDependency, circular_b[-1].forwards_plan, ) self.assertRaises( exc... |
migration_function() except: raise exceptions.FailedDryRun(sys.exc_info()) | try: migration_function() except: raise exceptions.FailedDryRun(sys.exc_info()) | def _run_migration(self, migration): if migration.no_dry_run() and self.verbosity: print " - Migration '%s' is marked for no-dry-run." return db.dry_run = True db.debug, old_debug = False, db.debug pending_creates = db.get_pending_creates() db.start_transaction() migration_function = self.direction(migration) try: migr... |
return (' ! Error found during real run of migration! Aborting.\n' '\n' ' ! Since you have a database that does not support running\n' ' ! schema-altering statements in transactions, we have had \n' ' ! to leave it in an interim state between migrations.\n' '%s\n' ' ! The South developers regret this has happened, and ... | return ( ' ! Error found during real run of migration! Aborting.\n' '\n' ' ! Since you have a database that does not support running\n' ' ! schema-altering statements in transactions, we have had \n' ' ! to leave it in an interim state between migrations.\n' '%s\n' ' ! The South developers regret this has happened, and... | def run_migration_error(self, migration, extra_info=''): return (' ! Error found during real run of migration! Aborting.\n' '\n' ' ! Since you have a database that does not support running\n' ' ! schema-altering statements in transactions, we have had \n' ' ! to leave it in an interim state between migrations.\n' '%s\n... |
urlh = urllib.urlopen(requestUrl) if urlh.code != 200: | try: urlo = urllib.URLopener() urlh =urlo.open(requestUrl) except IOError,e: | def _request(self, path='', basePath=None): """ Make a request to the rBuilder REST API. This should probably be replaced by an interface that supports more than just querying. """ |
% (urlh.code, requestUrl)) | % (e[1], requestUrl)) | def _request(self, path='', basePath=None): """ Make a request to the rBuilder REST API. This should probably be replaced by an interface that supports more than just querying. """ |
platformInformation = self._handle.product.getPlatformInformation() if (platformInformation and 'windows' in platformInformation.platformClassifier.get_tags()): rbuilder = self._handle.facade.rbuilder cfg.windowsBuildService = rbuilder.getWindowsBuildService() | if self._handle.product: platformInformation = self._handle.product.getPlatformInformation() if (platformInformation and 'windows' in platformInformation.platformClassifier.get_tags()): rbuilder = self._handle.facade.rbuilder cfg.windowsBuildService = rbuilder.getWindowsBuildService() | def _getRmakeConfig(self, useCache=True, includeContext=True): """ Returns an rmake configuration file that matches the product associated with the current handle. @param useCache: if True (default), uses a cached version of the rmake configuration file if available, and caches the results for future invocations. @type... |
@param hookFunction: a function that will be called before apiMethod. | @param hookFunction: a function that will be called after apiMethod. | def installPosthook(self, apiMethod, hookFunction): """ Installs a hook that will be called after the given apiMethod is called. @param apiMethod: api call to add the hook to. This should be a reference to the api object accessible from this handle. @param hookFunction: a function that will be called before apiMethod.... |
parser.add_option("--dir", "-d", dest="dir", help="Directory with packages.") | parser.add_option("--srv4-file", "-s", dest="srv4_file", help="Package to modify, e.g. foo-1.0-sparc-CSW.pkg.gz") | def main(): parser = optparse.OptionParser() parser.add_option("--dir", "-d", dest="dir", help="Directory with packages.") parser.add_option("--patch", "-p", dest="patch", help="Patch to apply") parser.add_option("--patch-sparc", dest="patch_sparc", help="Patch to apply (sparc specific)") parser.add_option("--patch-x86... |
parser.add_option("--patch-sparc", dest="patch_sparc", help="Patch to apply (sparc specific)") parser.add_option("--patch-x86", dest="patch_x86", help="Patch to apply (x86 specific)") parser.add_option("--catalogname", "-c", dest="catalogname", help="Catalogname") | def main(): parser = optparse.OptionParser() parser.add_option("--dir", "-d", dest="dir", help="Directory with packages.") parser.add_option("--patch", "-p", dest="patch", help="Patch to apply") parser.add_option("--patch-sparc", dest="patch_sparc", help="Patch to apply (sparc specific)") parser.add_option("--patch-x86... | |
logging.debug("Start!") ps = package.PackageSurgeon( "/home/maciej/tmp/mozilla-1.7.5-SunOS5.8-sparc-CSW.pkg.gz", debug=options.debug) ps.Patch("/home/maciej/tmp/0001-Removing-nspr.m4-and-headers.patch") ps.ToSrv4("/home/maciej/tmp") | if options.export and options.srv4_file: ps = package.PackageSurgeon( options.srv4_file, debug=options.debug) ps.Export(options.export) elif options.srv4_file and options.patch: ps = package.PackageSurgeon( options.srv4_file, debug=options.debug) ps.Patch(options.patch) base_dir, pkg_basename = os.path.split(options.sr... | def main(): parser = optparse.OptionParser() parser.add_option("--dir", "-d", dest="dir", help="Directory with packages.") parser.add_option("--patch", "-p", dest="patch", help="Patch to apply") parser.add_option("--patch-sparc", dest="patch_sparc", help="Patch to apply (sparc specific)") parser.add_option("--patch-x86... |
if not os.path.exists(CHECKPKG_DIR): | if not os.path.exists(checkpkg_dir): | def InitializeDatabase(self): """Established the connection to the database. |
gzip_suffix = ".gz" pkg_suffix = ".pkg" | def GetGunzippedPath(self): gzip_suffix = ".gz" pkg_suffix = ".pkg" if not self.gunzipped_path: if self.pkg_path.endswith("%s%s" % (pkg_suffix, gzip_suffix)): base_name_gz = os.path.split(self.pkg_path)[1] shutil.copy(self.pkg_path, self.GetWorkDir()) self.pkg_path = os.path.join(self.GetWorkDir(), base_name_gz) args =... | |
args = ["pkgchk", "-d", self.GetPkgname()] | args = ["pkgchk", "-d", self.GetGunzippedPath(), "all"] | def GetPkgchkOutput(self): """Returns: (exit code, stdout, stderr).""" args = ["pkgchk", "-d", self.GetPkgname()] pkgchk_proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = pkgchk_proc.communicate() ret = pkgchk_proc.wait() return ret, stdout, stderr |
g = HtmlGenerator(md5_sums) | g = HtmlGenerator(md5_sums, options.pkg_review_template) | def main(): parser = optparse.OptionParser(USAGE) parser.add_option("-d", "--debug", dest="debug", default=False, action="store_true", help="Turn on debugging messages") parser.add_option("-t", "--pkg-review-template", dest="pkg_review_template", help="A Cheetah template used for package review reports.") options, args... |
parsed = opencsw.ParsePackageFileName(file_name) self.assertEquals(file_name, opencsw.ComposePackageFileName(parsed)) | self.assertEquals(file_name, opencsw.ComposePackageFileName(self.parsed)) def testMoreRev(self): file_name = 'mysql5client-5.0.87,REV=2010.02.28,foo=bar-SunOS5.8-i386-CSW.pkg.gz' self.parsed["revision_info"]["foo"] = "bar" self.assertEquals(file_name, opencsw.ComposePackageFileName(self.parsed)) | def testSimple(self): file_name = 'mysql5client-5.0.87,REV=2010.02.28-SunOS5.8-i386-CSW.pkg.gz' parsed = opencsw.ParsePackageFileName(file_name) self.assertEquals(file_name, opencsw.ComposePackageFileName(parsed)) |
pkgmap.GetPkgmapLineByBasename("foo") lines1 = {"/opt/csw/lib/postgresql": "/opt/csw/lib/postgresql/foo.so.1 foo"} pkgmap.GetPkgmapLineByBasename("foo.so.1").AndReturn(lines1) | def testGetLinesBySoname_8(self): expected = {'foo.so.1': '/opt/csw/postgresql/lib/foo.so.1 foo'} pkgmap = self.pkgmap_mocker.CreateMock(checkpkg.SystemPkgmap) pkgmap.GetPkgmapLineByBasename("foo") lines1 = {"/opt/csw/lib/postgresql": "/opt/csw/lib/postgresql/foo.so.1 foo"} pkgmap.GetPkgmapLineByBasename("foo.so.1").An... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.