157
158
def test_register_unregister_format(self):
158
# Test deprecated format registration functions
159
159
format = SampleRepositoryFormat()
160
160
# make a control dir
161
161
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
163
163
format.initialize(dir)
164
164
# register a format for it.
165
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
166
repository.RepositoryFormat.register_format, format)
165
repository.RepositoryFormat.register_format(format)
167
166
# which repository.Open will refuse (not supported)
168
self.assertRaises(UnsupportedFormatError, repository.Repository.open,
167
self.assertRaises(UnsupportedFormatError, repository.Repository.open, self.get_url())
170
168
# but open(unsupported) will work
171
169
self.assertEqual(format.open(dir), "opened repository.")
172
170
# unregister the format
173
self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
174
repository.RepositoryFormat.unregister_format, format)
177
class TestRepositoryFormatRegistry(TestCase):
180
super(TestRepositoryFormatRegistry, self).setUp()
181
self.registry = repository.RepositoryFormatRegistry()
183
def test_register_unregister_format(self):
184
format = SampleRepositoryFormat()
185
self.registry.register(format)
186
self.assertEquals(format, self.registry.get("Sample .bzr repository format."))
187
self.registry.remove(format)
188
self.assertRaises(KeyError, self.registry.get, "Sample .bzr repository format.")
190
def test_get_all(self):
191
format = SampleRepositoryFormat()
192
self.assertEquals([], self.registry._get_all())
193
self.registry.register(format)
194
self.assertEquals([format], self.registry._get_all())
196
def test_register_extra(self):
197
format = SampleExtraRepositoryFormat()
198
self.assertEquals([], self.registry._get_all())
199
self.registry.register_extra(format)
200
self.assertEquals([format], self.registry._get_all())
202
def test_register_extra_lazy(self):
203
self.assertEquals([], self.registry._get_all())
204
self.registry.register_extra_lazy("bzrlib.tests.test_repository",
205
"SampleExtraRepositoryFormat")
206
formats = self.registry._get_all()
207
self.assertEquals(1, len(formats))
208
self.assertIsInstance(formats[0], SampleExtraRepositoryFormat)
171
repository.RepositoryFormat.unregister_format(format)
174
class TestFormat6(TestCaseWithTransport):
176
def test_attribute__fetch_order(self):
177
"""Weaves need topological data insertion."""
178
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
179
repo = weaverepo.RepositoryFormat6().initialize(control)
180
self.assertEqual('topological', repo._format._fetch_order)
182
def test_attribute__fetch_uses_deltas(self):
183
"""Weaves do not reuse deltas."""
184
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
185
repo = weaverepo.RepositoryFormat6().initialize(control)
186
self.assertEqual(False, repo._format._fetch_uses_deltas)
188
def test_attribute__fetch_reconcile(self):
189
"""Weave repositories need a reconcile after fetch."""
190
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
191
repo = weaverepo.RepositoryFormat6().initialize(control)
192
self.assertEqual(True, repo._format._fetch_reconcile)
194
def test_no_ancestry_weave(self):
195
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
196
repo = weaverepo.RepositoryFormat6().initialize(control)
197
# We no longer need to create the ancestry.weave file
198
# since it is *never* used.
199
self.assertRaises(NoSuchFile,
200
control.transport.get,
203
def test_supports_external_lookups(self):
204
control = bzrdir.BzrDirFormat6().initialize(self.get_url())
205
repo = weaverepo.RepositoryFormat6().initialize(control)
206
self.assertFalse(repo._format.supports_external_lookups)
209
class TestFormat7(TestCaseWithTransport):
211
def test_attribute__fetch_order(self):
212
"""Weaves need topological data insertion."""
213
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
214
repo = weaverepo.RepositoryFormat7().initialize(control)
215
self.assertEqual('topological', repo._format._fetch_order)
217
def test_attribute__fetch_uses_deltas(self):
218
"""Weaves do not reuse deltas."""
219
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
220
repo = weaverepo.RepositoryFormat7().initialize(control)
221
self.assertEqual(False, repo._format._fetch_uses_deltas)
223
def test_attribute__fetch_reconcile(self):
224
"""Weave repositories need a reconcile after fetch."""
225
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
226
repo = weaverepo.RepositoryFormat7().initialize(control)
227
self.assertEqual(True, repo._format._fetch_reconcile)
229
def test_disk_layout(self):
230
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
231
repo = weaverepo.RepositoryFormat7().initialize(control)
232
# in case of side effects of locking.
236
# format 'Bazaar-NG Repository format 7'
238
# inventory.weave == empty_weave
239
# empty revision-store directory
240
# empty weaves directory
241
t = control.get_repository_transport(None)
242
self.assertEqualDiff('Bazaar-NG Repository format 7',
243
t.get('format').read())
244
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
245
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
246
self.assertEqualDiff('# bzr weave file v5\n'
249
t.get('inventory.weave').read())
250
# Creating a file with id Foo:Bar results in a non-escaped file name on
252
control.create_branch()
253
tree = control.create_workingtree()
254
tree.add(['foo'], ['Foo:Bar'], ['file'])
255
tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
257
tree.commit('first post', rev_id='first')
258
except errors.IllegalPath:
259
if sys.platform != 'win32':
261
self.knownFailure('Foo:Bar cannot be used as a file-id on windows'
264
self.assertEqualDiff(
265
'# bzr weave file v5\n'
267
'1 7fe70820e08a1aac0ef224d9c66ab66831cc4ab1\n'
275
t.get('weaves/74/Foo%3ABar.weave').read())
277
def test_shared_disk_layout(self):
278
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
279
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
281
# format 'Bazaar-NG Repository format 7'
282
# inventory.weave == empty_weave
283
# empty revision-store directory
284
# empty weaves directory
285
# a 'shared-storage' marker file.
286
# lock is not present when unlocked
287
t = control.get_repository_transport(None)
288
self.assertEqualDiff('Bazaar-NG Repository format 7',
289
t.get('format').read())
290
self.assertEqualDiff('', t.get('shared-storage').read())
291
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
292
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
293
self.assertEqualDiff('# bzr weave file v5\n'
296
t.get('inventory.weave').read())
297
self.assertFalse(t.has('branch-lock'))
299
def test_creates_lockdir(self):
300
"""Make sure it appears to be controlled by a LockDir existence"""
301
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
302
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
303
t = control.get_repository_transport(None)
304
# TODO: Should check there is a 'lock' toplevel directory,
305
# regardless of contents
306
self.assertFalse(t.has('lock/held/info'))
309
self.assertTrue(t.has('lock/held/info'))
311
# unlock so we don't get a warning about failing to do so
314
def test_uses_lockdir(self):
315
"""repo format 7 actually locks on lockdir"""
316
base_url = self.get_url()
317
control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
318
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
319
t = control.get_repository_transport(None)
323
# make sure the same lock is created by opening it
324
repo = repository.Repository.open(base_url)
326
self.assertTrue(t.has('lock/held/info'))
328
self.assertFalse(t.has('lock/held/info'))
330
def test_shared_no_tree_disk_layout(self):
331
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
332
repo = weaverepo.RepositoryFormat7().initialize(control, shared=True)
333
repo.set_make_working_trees(False)
335
# format 'Bazaar-NG Repository format 7'
337
# inventory.weave == empty_weave
338
# empty revision-store directory
339
# empty weaves directory
340
# a 'shared-storage' marker file.
341
t = control.get_repository_transport(None)
342
self.assertEqualDiff('Bazaar-NG Repository format 7',
343
t.get('format').read())
344
## self.assertEqualDiff('', t.get('lock').read())
345
self.assertEqualDiff('', t.get('shared-storage').read())
346
self.assertEqualDiff('', t.get('no-working-trees').read())
347
repo.set_make_working_trees(True)
348
self.assertFalse(t.has('no-working-trees'))
349
self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
350
self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
351
self.assertEqualDiff('# bzr weave file v5\n'
354
t.get('inventory.weave').read())
356
def test_supports_external_lookups(self):
357
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
358
repo = weaverepo.RepositoryFormat7().initialize(control)
359
self.assertFalse(repo._format.supports_external_lookups)
211
362
class TestFormatKnit1(TestCaseWithTransport):
436
581
self.assertGetsDefaultInterRepository(dummy_a, dummy_b)
439
class TestRepositoryFormat1(knitrepo.RepositoryFormatKnit1):
441
def get_format_string(self):
442
return "Test Format 1"
445
class TestRepositoryFormat2(knitrepo.RepositoryFormatKnit1):
447
def get_format_string(self):
448
return "Test Format 2"
584
class TestInterWeaveRepo(TestCaseWithTransport):
586
def test_is_compatible_and_registered(self):
587
# InterWeaveRepo is compatible when either side
588
# is a format 5/6/7 branch
589
from bzrlib.repofmt import knitrepo, weaverepo
590
formats = [weaverepo.RepositoryFormat5(),
591
weaverepo.RepositoryFormat6(),
592
weaverepo.RepositoryFormat7()]
593
incompatible_formats = [weaverepo.RepositoryFormat4(),
594
knitrepo.RepositoryFormatKnit1(),
596
repo_a = self.make_repository('a')
597
repo_b = self.make_repository('b')
598
is_compatible = repository.InterWeaveRepo.is_compatible
599
for source in incompatible_formats:
600
# force incompatible left then right
601
repo_a._format = source
602
repo_b._format = formats[0]
603
self.assertFalse(is_compatible(repo_a, repo_b))
604
self.assertFalse(is_compatible(repo_b, repo_a))
605
for source in formats:
606
repo_a._format = source
607
for target in formats:
608
repo_b._format = target
609
self.assertTrue(is_compatible(repo_a, repo_b))
610
self.assertEqual(repository.InterWeaveRepo,
611
repository.InterRepository.get(repo_a,
451
615
class TestRepositoryConverter(TestCaseWithTransport):
453
617
def test_convert_empty(self):
454
source_format = TestRepositoryFormat1()
455
target_format = TestRepositoryFormat2()
456
repository.format_registry.register(source_format)
457
self.addCleanup(repository.format_registry.remove,
459
repository.format_registry.register(target_format)
460
self.addCleanup(repository.format_registry.remove,
462
t = self.get_transport()
618
t = get_transport(self.get_url('.'))
463
619
t.mkdir('repository')
464
620
repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
465
repo = TestRepositoryFormat1().initialize(repo_dir)
621
repo = weaverepo.RepositoryFormat7().initialize(repo_dir)
622
target_format = knitrepo.RepositoryFormatKnit1()
466
623
converter = repository.CopyConverter(target_format)
467
624
pb = bzrlib.ui.ui_factory.nested_progress_bar()
993
1143
packs.ensure_loaded()
994
1144
return tree, r, packs, [rev1, rev2, rev3]
996
def test__clear_obsolete_packs(self):
997
packs = self.get_packs()
998
obsolete_pack_trans = packs.transport.clone('obsolete_packs')
999
obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
1000
obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
1001
obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
1002
obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
1003
obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
1004
res = packs._clear_obsolete_packs()
1005
self.assertEqual(['a-pack', 'another-pack'], sorted(res))
1006
self.assertEqual([], obsolete_pack_trans.list_dir('.'))
1008
def test__clear_obsolete_packs_preserve(self):
1009
packs = self.get_packs()
1010
obsolete_pack_trans = packs.transport.clone('obsolete_packs')
1011
obsolete_pack_trans.put_bytes('a-pack.pack', 'content\n')
1012
obsolete_pack_trans.put_bytes('a-pack.rix', 'content\n')
1013
obsolete_pack_trans.put_bytes('a-pack.iix', 'content\n')
1014
obsolete_pack_trans.put_bytes('another-pack.pack', 'foo\n')
1015
obsolete_pack_trans.put_bytes('not-a-pack.rix', 'foo\n')
1016
res = packs._clear_obsolete_packs(preserve=set(['a-pack']))
1017
self.assertEqual(['a-pack', 'another-pack'], sorted(res))
1018
self.assertEqual(['a-pack.iix', 'a-pack.pack', 'a-pack.rix'],
1019
sorted(obsolete_pack_trans.list_dir('.')))
1021
1146
def test__max_pack_count(self):
1022
1147
"""The maximum pack count is a function of the number of revisions."""
1023
1148
# no revisions - one pack, so that we can have a revision free repo
1243
1341
self.assertEqual({revs[-1]:(revs[-2],)}, r.get_parent_map([revs[-1]]))
1244
1342
self.assertFalse(packs.reload_pack_names())
1246
def test_reload_pack_names_preserves_pending(self):
1247
# TODO: Update this to also test for pending-deleted names
1248
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1249
# We will add one pack (via start_write_group + insert_record_stream),
1250
# and remove another pack (via _remove_pack_from_memory)
1251
orig_names = packs.names()
1252
orig_at_load = packs._packs_at_load
1253
to_remove_name = iter(orig_names).next()
1254
r.start_write_group()
1255
self.addCleanup(r.abort_write_group)
1256
r.texts.insert_record_stream([versionedfile.FulltextContentFactory(
1257
('text', 'rev'), (), None, 'content\n')])
1258
new_pack = packs._new_pack
1259
self.assertTrue(new_pack.data_inserted())
1261
packs.allocate(new_pack)
1262
packs._new_pack = None
1263
removed_pack = packs.get_pack_by_name(to_remove_name)
1264
packs._remove_pack_from_memory(removed_pack)
1265
names = packs.names()
1266
all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
1267
new_names = set([x[0][0] for x in new_nodes])
1268
self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
1269
self.assertEqual(set(names) - set(orig_names), new_names)
1270
self.assertEqual(set([new_pack.name]), new_names)
1271
self.assertEqual([to_remove_name],
1272
sorted([x[0][0] for x in deleted_nodes]))
1273
packs.reload_pack_names()
1274
reloaded_names = packs.names()
1275
self.assertEqual(orig_at_load, packs._packs_at_load)
1276
self.assertEqual(names, reloaded_names)
1277
all_nodes, deleted_nodes, new_nodes, _ = packs._diff_pack_names()
1278
new_names = set([x[0][0] for x in new_nodes])
1279
self.assertEqual(names, sorted([x[0][0] for x in all_nodes]))
1280
self.assertEqual(set(names) - set(orig_names), new_names)
1281
self.assertEqual(set([new_pack.name]), new_names)
1282
self.assertEqual([to_remove_name],
1283
sorted([x[0][0] for x in deleted_nodes]))
1285
def test_autopack_obsoletes_new_pack(self):
1286
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1287
packs._max_pack_count = lambda x: 1
1288
packs.pack_distribution = lambda x: [10]
1289
r.start_write_group()
1290
r.revisions.insert_record_stream([versionedfile.FulltextContentFactory(
1291
('bogus-rev',), (), None, 'bogus-content\n')])
1292
# This should trigger an autopack, which will combine everything into a
1294
new_names = r.commit_write_group()
1295
names = packs.names()
1296
self.assertEqual(1, len(names))
1297
self.assertEqual([names[0] + '.pack'],
1298
packs._pack_transport.list_dir('.'))
1300
1344
def test_autopack_reloads_and_stops(self):
1301
1345
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1302
1346
# After we have determined what needs to be autopacked, trigger a
1314
1358
self.assertEqual(tree.branch.repository._pack_collection.names(),
1317
def test__save_pack_names(self):
1318
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1319
names = packs.names()
1320
pack = packs.get_pack_by_name(names[0])
1321
packs._remove_pack_from_memory(pack)
1322
packs._save_pack_names(obsolete_packs=[pack])
1323
cur_packs = packs._pack_transport.list_dir('.')
1324
self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
1325
# obsolete_packs will also have stuff like .rix and .iix present.
1326
obsolete_packs = packs.transport.list_dir('obsolete_packs')
1327
obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
1328
self.assertEqual([pack.name], sorted(obsolete_names))
1330
def test__save_pack_names_already_obsoleted(self):
1331
tree, r, packs, revs = self.make_packs_and_alt_repo(write_lock=True)
1332
names = packs.names()
1333
pack = packs.get_pack_by_name(names[0])
1334
packs._remove_pack_from_memory(pack)
1335
# We are going to simulate a concurrent autopack by manually obsoleting
1336
# the pack directly.
1337
packs._obsolete_packs([pack])
1338
packs._save_pack_names(clear_obsolete_packs=True,
1339
obsolete_packs=[pack])
1340
cur_packs = packs._pack_transport.list_dir('.')
1341
self.assertEqual([n + '.pack' for n in names[1:]], sorted(cur_packs))
1342
# Note that while we set clear_obsolete_packs=True, it should not
1343
# delete a pack file that we have also scheduled for obsoletion.
1344
obsolete_packs = packs.transport.list_dir('obsolete_packs')
1345
obsolete_names = set([osutils.splitext(n)[0] for n in obsolete_packs])
1346
self.assertEqual([pack.name], sorted(obsolete_names))
1350
1362
class TestPack(TestCaseWithTransport):
1351
1363
"""Tests for the Pack object."""
1482
1494
self.assertTrue(new_pack.signature_index._optimize_for_size)
1485
class TestGCCHKPacker(TestCaseWithTransport):
1487
def make_abc_branch(self):
1488
builder = self.make_branch_builder('source')
1489
builder.start_series()
1490
builder.build_snapshot('A', None, [
1491
('add', ('', 'root-id', 'directory', None)),
1492
('add', ('file', 'file-id', 'file', 'content\n')),
1494
builder.build_snapshot('B', ['A'], [
1495
('add', ('dir', 'dir-id', 'directory', None))])
1496
builder.build_snapshot('C', ['B'], [
1497
('modify', ('file-id', 'new content\n'))])
1498
builder.finish_series()
1499
return builder.get_branch()
1501
def make_branch_with_disjoint_inventory_and_revision(self):
1502
"""a repo with separate packs for a revisions Revision and Inventory.
1504
There will be one pack file that holds the Revision content, and one
1505
for the Inventory content.
1507
:return: (repository,
1508
pack_name_with_rev_A_Revision,
1509
pack_name_with_rev_A_Inventory,
1510
pack_name_with_rev_C_content)
1512
b_source = self.make_abc_branch()
1513
b_base = b_source.bzrdir.sprout('base', revision_id='A').open_branch()
1514
b_stacked = b_base.bzrdir.sprout('stacked', stacked=True).open_branch()
1515
b_stacked.lock_write()
1516
self.addCleanup(b_stacked.unlock)
1517
b_stacked.fetch(b_source, 'B')
1518
# Now re-open the stacked repo directly (no fallbacks) so that we can
1519
# fill in the A rev.
1520
repo_not_stacked = b_stacked.bzrdir.open_repository()
1521
repo_not_stacked.lock_write()
1522
self.addCleanup(repo_not_stacked.unlock)
1523
# Now we should have a pack file with A's inventory, but not its
1525
self.assertEqual([('A',), ('B',)],
1526
sorted(repo_not_stacked.inventories.keys()))
1527
self.assertEqual([('B',)],
1528
sorted(repo_not_stacked.revisions.keys()))
1529
stacked_pack_names = repo_not_stacked._pack_collection.names()
1530
# We have a couple names here, figure out which has A's inventory
1531
for name in stacked_pack_names:
1532
pack = repo_not_stacked._pack_collection.get_pack_by_name(name)
1533
keys = [n[1] for n in pack.inventory_index.iter_all_entries()]
1535
inv_a_pack_name = name
1538
self.fail('Could not find pack containing A\'s inventory')
1539
repo_not_stacked.fetch(b_source.repository, 'A')
1540
self.assertEqual([('A',), ('B',)],
1541
sorted(repo_not_stacked.revisions.keys()))
1542
new_pack_names = set(repo_not_stacked._pack_collection.names())
1543
rev_a_pack_names = new_pack_names.difference(stacked_pack_names)
1544
self.assertEqual(1, len(rev_a_pack_names))
1545
rev_a_pack_name = list(rev_a_pack_names)[0]
1546
# Now fetch 'C', so we have a couple pack files to join
1547
repo_not_stacked.fetch(b_source.repository, 'C')
1548
rev_c_pack_names = set(repo_not_stacked._pack_collection.names())
1549
rev_c_pack_names = rev_c_pack_names.difference(new_pack_names)
1550
self.assertEqual(1, len(rev_c_pack_names))
1551
rev_c_pack_name = list(rev_c_pack_names)[0]
1552
return (repo_not_stacked, rev_a_pack_name, inv_a_pack_name,
1555
def test_pack_with_distant_inventories(self):
1556
# See https://bugs.launchpad.net/bzr/+bug/437003
1557
# When repacking, it is possible to have an inventory in a different
1558
# pack file than the associated revision. An autopack can then come
1559
# along, and miss that inventory, and complain.
1560
(repo, rev_a_pack_name, inv_a_pack_name, rev_c_pack_name
1561
) = self.make_branch_with_disjoint_inventory_and_revision()
1562
a_pack = repo._pack_collection.get_pack_by_name(rev_a_pack_name)
1563
c_pack = repo._pack_collection.get_pack_by_name(rev_c_pack_name)
1564
packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
1565
[a_pack, c_pack], '.test-pack')
1566
# This would raise ValueError in bug #437003, but should not raise an
1570
def test_pack_with_missing_inventory(self):
1571
# Similar to test_pack_with_missing_inventory, but this time, we force
1572
# the A inventory to actually be gone from the repository.
1573
(repo, rev_a_pack_name, inv_a_pack_name, rev_c_pack_name
1574
) = self.make_branch_with_disjoint_inventory_and_revision()
1575
inv_a_pack = repo._pack_collection.get_pack_by_name(inv_a_pack_name)
1576
repo._pack_collection._remove_pack_from_memory(inv_a_pack)
1577
packer = groupcompress_repo.GCCHKPacker(repo._pack_collection,
1578
repo._pack_collection.all_packs(), '.test-pack')
1579
e = self.assertRaises(ValueError, packer.pack)
1580
packer.new_pack.abort()
1581
self.assertContainsRe(str(e),
1582
r"We are missing inventories for revisions: .*'A'")
1585
1497
class TestCrossFormatPacks(TestCaseWithTransport):
1587
1499
def log_pack(self, hint=None):