\\n assert_in(\\\"update.txt\\\",\\n dest.repo.get_files(DEFAULT_REMOTE + \\\"/\\\" + DEFAULT_BRANCH))\\n\\n # merge:\\n assert_status('ok', dest.update(merge=True))\\n # modification is now known to active branch:\\n assert_in(\\\"update.txt\\\",\\n dest.repo.get_files(dest.repo.get_active_branch()))\\n # it's known to annex, but has no content yet:\\n annexprops = dest.repo.get_file_annexinfo(\\\"update.txt\\\",\\n eval_availability=True)\\n annexprops['key'] # blows if unknown\\n eq_(False, annexprops['has_content'])\\n\\n # check subdataset path constraints, baseline (parent + 2 subds)\\n assert_result_count(dest.update(recursive=True),\\n 3, status='ok', type='dataset')\\n # no recursion and invalid path still updates the parent\\n res = dest.update(path='whatever')\\n assert_result_count(res, 1, status='ok', type='dataset')\\n assert_result_count(res, 1, status='ok', path=dest.path)\\n # invalid path with recursion also does\\n res = dest.update(recursive=True, path='whatever')\\n assert_result_count(res, 1, status='ok', type='dataset')\\n assert_result_count(res, 1, status='ok', path=dest.path)\\n # valid path and no recursion only updates the parent\\n res = dest.update(path='subm 1')\\n assert_result_count(res, 1, status='ok', type='dataset')\\n assert_result_count(res, 1, status='ok', path=dest.path)\\n # valid path and recursion updates matching\\n res = dest.update(recursive=True, path='subm 1')\\n assert_result_count(res, 2, status='ok', type='dataset')\\n assert_result_count(res, 1, status='ok', path=dest.path)\\n assert_result_count(res, 1, status='ok', path=str(dest.pathobj / 'subm 1'))\\n # additional invalid path doesn't hurt\\n res = dest.update(recursive=True, path=['subm 1', 'mike'])\\n assert_result_count(res, 2, status='ok', type='dataset')\\n # full match\\n res = dest.update(recursive=True, path=['subm 1', '2'])\\n assert_result_count(res, 3, status='ok', type='dataset')\\n\\n # test that update doesn't crash if we specify only a single path (submod) to\\n # operate on\\n with chpwd(dest.path):\\n # in 0.11.x it would be a single result since \\\"pwd\\\" dataset is not\\n # considered, and would be relative path (as specified).\\n # In 0.12.0 - it would include implicit pwd dataset, and paths would be absolute\\n res_update = update(path=['subm 1'], recursive=True)\\n assert_result_count(res_update, 2)\\n for p in dest.path, str(dest.pathobj / 'subm 1'):\\n assert_in_results(res_update, path=p, action='update', status='ok', type='dataset')\\n\\n # and with merge we would also try to save (but there would be no changes)\\n res_merge = update(path=['subm 1'], recursive=True, merge=True)\\n assert_result_count(res_merge, 2, action='update')\\n # 2 of \\\"updates\\\" really.\\n assert_in_results(res_merge, action='update', status='ok', type='dataset')\\n assert_in_results(res_merge, action='save', status='notneeded', type='dataset')\\n\\n # smoke-test if recursive update doesn't fail if submodule is removed\\n # and that we can run it from within a dataset without providing it\\n # explicitly\\n assert_result_count(\\n dest.remove('subm 1'), 1,\\n status='ok', action='remove', path=opj(dest.path, 'subm 1'))\\n with chpwd(dest.path):\\n assert_result_count(\\n update(recursive=True), 2,\\n status='ok', type='dataset')\\n assert_result_count(\\n dest.update(merge=True, recursive=True), 2,\\n action='update', status='ok', type='dataset')\\n\\n # and now test recursive update with merging in differences\\n create_tree(opj(source.path, '2'), {'load.dat': 'heavy'})\\n source.save(opj('2', 'load.dat'),\\n message=\\\"saving changes within subm2\\\",\\n recursive=True)\\n assert_result_count(\\n dest.update(merge=True, recursive=True), 2,\\n action='update', status='ok', type='dataset')\\n # and now we can get new file\\n dest.get(opj('2', 'load.dat'))\\n ok_file_has_content(opj(dest.path, '2', 'load.dat'), 'heavy')\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_update_git_smoke(src_path=None, dst_path=None):\\n # Apparently was just failing on git repos for basic lack of coverage, hence this quick test\\n ds = Dataset(src_path).create(annex=False)\\n target = install(\\n dst_path, source=src_path,\\n result_xfm='datasets', return_type='item-or-list')\\n create_tree(ds.path, {'file.dat': '123'})\\n ds.save('file.dat')\\n assert_result_count(\\n target.update(recursive=True, merge=True), 1,\\n action='update', status='ok', type='dataset')\\n ok_file_has_content(opj(target.path, 'file.dat'), '123')\\n\\n\\n@slow # ~9s\\n@with_tempfile(mkdir=True)\\ndef test_update_fetch_all(path=None):\\n path = Path(path)\\n remote_1 = str(path / \\\"remote_1\\\")\\n remote_2 = str(path / \\\"remote_2\\\")\\n\\n ds = Dataset(path / \\\"src\\\").create()\\n src = ds.repo.path\\n\\n ds_rmt1 = clone(source=src, path=remote_1)\\n ds_rmt2 = clone(source=src, path=remote_2)\\n\\n ds.siblings('add', name=\\\"sibling_1\\\", url=remote_1)\\n ds.siblings('add', name=\\\"sibling_2\\\", url=remote_2)\\n\\n # modify the remotes:\\n (ds_rmt1.pathobj / \\\"first.txt\\\").write_text(\\\"some file load\\\")\\n ds_rmt1.save()\\n\\n # TODO: Modify an already present file!\\n\\n (ds_rmt2.pathobj / \\\"second.txt\\\").write_text(\\\"different file load\\\")\\n ds_rmt2.save()\\n\\n # Let's init some special remote which we couldn't really update/fetch\\n if not dl_cfg.get('datalad.tests.dataladremote'):\\n ds.repo.init_remote(\\n 'datalad',\\n ['encryption=none', 'type=external', 'externaltype=datalad'])\\n # fetch all remotes\\n assert_result_count(\\n ds.update(), 1, status='ok', type='dataset')\\n\\n # no merge, so changes are not in active branch:\\n assert_not_in(\\\"first.txt\\\",\\n ds.repo.get_files(ds.repo.get_active_branch()))\\n assert_not_in(\\\"second.txt\\\",\\n ds.repo.get_files(ds.repo.get_active_branch()))\\n # but we know the changes in remote branches:\\n assert_in(\\\"first.txt\\\", ds.repo.get_files(\\\"sibling_1/\\\" + DEFAULT_BRANCH))\\n assert_in(\\\"second.txt\\\", ds.repo.get_files(\\\"sibling_2/\\\" + DEFAULT_BRANCH))\\n\\n # no merge strategy for multiple remotes yet:\\n # more clever now, there is a tracking branch that provides a remote\\n #assert_raises(NotImplementedError, ds.update, merge=True)\\n\\n # merge a certain remote:\\n assert_result_count(\\n ds.update(sibling='sibling_1', merge=True),\\n 1, action='update', status='ok', type='dataset')\\n\\n # changes from sibling_2 still not present:\\n assert_not_in(\\\"second.txt\\\",\\n ds.repo.get_files(ds.repo.get_active_branch()))\\n # changes from sibling_1 merged:\\n assert_in(\\\"first.txt\\\",\\n ds.repo.get_files(ds.repo.get_active_branch()))\\n # it's known to annex, but has no content yet:\\n annexprops = ds.repo.get_file_annexinfo(\\n \\\"first.txt\\\", eval_availability=True)\\n annexprops['key'] # blows if unknown\\n eq_(False, annexprops['has_content'])\\n\\n\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\ndef test_newthings_coming_down(originpath=None, destpath=None):\\n origin = GitRepo(originpath, create=True)\\n create_tree(originpath, {'load.dat': 'heavy'})\\n Dataset(originpath).save('load.dat')\\n ds = install(\\n source=originpath, path=destpath,\\n result_xfm='datasets', return_type='item-or-list')\\n assert_is_instance(ds.repo, GitRepo)\\n assert_in(DEFAULT_REMOTE, ds.repo.get_remotes())\\n # turn origin into an annex\\n origin = AnnexRepo(originpath, create=True)\\n # clone doesn't know yet\\n assert_false(knows_annex(ds.path))\\n # but after an update it should\\n # no merge, only one sibling, no parameters should be specific enough\\n assert_result_count(ds.update(), 1, status='ok', type='dataset')\\n assert(knows_annex(ds.path))\\n # no branches appeared\\n eq_(ds.repo.get_branches(), [DEFAULT_BRANCH])\\n # now merge, and get an annex\\n assert_result_count(ds.update(merge=True),\\n 1, action='update', status='ok', type='dataset')\\n assert_in('git-annex', ds.repo.get_branches())\\n assert_is_instance(ds.repo, AnnexRepo)\\n # should be fully functional\\n testfname = opj(ds.path, 'load.dat')\\n assert_false(ds.repo.file_has_content(testfname))\\n ds.get('.')\\n ok_file_has_content(opj(ds.path, 'load.dat'), 'heavy')\\n # check that a new tag comes down\\n origin.tag('first!')\\n assert_result_count(ds.update(), 1, status='ok', type='dataset')\\n eq_(ds.repo.get_tags(output='name')[0], 'first!')\\n\\n # and now we destroy the remote annex\\n origin.call_git(['config', '--remove-section', 'annex'])\\n rmtree(opj(origin.path, '.git', 'annex'), chmod_files=True)\\n origin.call_git(['branch', '-D', 'git-annex'])\\n origin = GitRepo(originpath)\\n assert_false(knows_annex(originpath))\\n\\n # and update the local clone\\n # for now this should simply not fail (see gh-793), later might be enhanced to a\\n # graceful downgrade\\n before_branches = ds.repo.get_branches()\\n ok_(any(\\\"git-annex\\\" in b\\n for b in ds.repo.get_remote_branches()))\\n assert_result_count(ds.update(), 1, status='ok', type='dataset')\\n eq_(before_branches, ds.repo.get_branches())\\n # annex branch got pruned\\n assert_false(any(\\\"git-annex\\\" in b\\n for b in ds.repo.get_remote_branches()))\\n # check that a new tag comes down even if repo types mismatch\\n origin.tag('second!')\\n assert_result_count(ds.update(), 1, status='ok', type='dataset')\\n eq_(ds.repo.get_tags(output='name')[-1], 'second!')\\n\\n\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\ndef test_update_volatile_subds(originpath=None, otherpath=None, destpath=None):\\n origin = Dataset(originpath).create()\\n repo = origin.repo\\n if repo.is_managed_branch() and repo.git_annex_version <= \\\"8.20201129\\\":\\n # Fails before git-annex's fd161da2c (adjustTree: Consider submodule\\n # deletions, 2021-01-06).\\n raise SkipTest(\\n \\\"On adjusted branch, test requires fix in more recent git-annex\\\")\\n ds = install(\\n source=originpath, path=destpath,\\n result_xfm='datasets', return_type='item-or-list')\\n # as a submodule\\n sname = 'subm 1'\\n osm1 = origin.create(sname)\\n assert_result_count(ds.update(), 1, status='ok', type='dataset')\\n # nothing without a merge, no inappropriate magic\\n assert_not_in(sname, ds.subdatasets(result_xfm='relpaths'))\\n assert_result_count(ds.update(merge=True),\\n 1, action='update', status='ok', type='dataset')\\n # and we should be able to do update with recursive invocation\\n assert_result_count(ds.update(merge=True, recursive=True),\\n 1, action='update', status='ok', type='dataset')\\n # known, and placeholder exists\\n assert_in(sname, ds.subdatasets(result_xfm='relpaths'))\\n ok_(exists(opj(ds.path, sname)))\\n\\n # remove from origin\\n origin.remove(sname, reckless='availability')\\n assert_result_count(ds.update(merge=True),\\n 1, action='update', status='ok', type='dataset')\\n # gone locally, wasn't checked out\\n assert_not_in(sname, ds.subdatasets(result_xfm='relpaths'))\\n assert_false(exists(opj(ds.path, sname)))\\n\\n # re-introduce at origin\\n osm1 = origin.create(sname)\\n create_tree(osm1.path, {'load.dat': 'heavy'})\\n origin.save(opj(osm1.path, 'load.dat'))\\n assert_result_count(ds.update(merge=True),\\n 1, action='update', status='ok', type='dataset')\\n # grab new content of uninstall subdataset, right away\\n ds.get(opj(ds.path, sname, 'load.dat'))\\n ok_file_has_content(opj(ds.path, sname, 'load.dat'), 'heavy')\\n\\n # modify ds and subds at origin\\n create_tree(origin.path, {'mike': 'this', sname: {'probe': 'little'}})\\n origin.save(recursive=True)\\n assert_repo_status(origin.path)\\n\\n # updates for both datasets should come down the pipe\\n assert_result_count(ds.update(merge=True, recursive=True),\\n 2, action='update', status='ok', type='dataset')\\n assert_repo_status(ds.path)\\n\\n # now remove just-installed subdataset from origin again\\n origin.remove(sname, reckless='kill')\\n assert_not_in(sname, origin.subdatasets(result_xfm='relpaths'))\\n assert_in(sname, ds.subdatasets(result_xfm='relpaths'))\\n # merge should disconnect the installed subdataset, but leave the actual\\n # ex-subdataset alone\\n assert_result_count(ds.update(merge=True, recursive=True),\\n 1, action='update', type='dataset')\\n assert_not_in(sname, ds.subdatasets(result_xfm='relpaths'))\\n ok_file_has_content(opj(ds.path, sname, 'load.dat'), 'heavy')\\n ok_(Dataset(opj(ds.path, sname)).is_installed())\\n\\n # now remove the now disconnected subdataset for further tests\\n remove(dataset=op.join(ds.path, sname), reckless='kill')\\n assert_repo_status(ds.path)\\n\\n # new separate subdataset, not within the origin dataset\\n otherds = Dataset(otherpath).create()\\n # install separate dataset as a submodule\\n ds.install(source=otherds.path, path='other')\\n create_tree(otherds.path, {'brand': 'new'})\\n otherds.save()\\n assert_repo_status(otherds.path)\\n # pull in changes\\n res = ds.update(merge=True, recursive=True)\\n assert_result_count(\\n res, 2, status='ok', action='update', type='dataset')\\n # the next is to check for #2858\\n assert_repo_status(ds.path)\\n\\n\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\ndef test_reobtain_data(originpath=None, destpath=None):\\n origin = Dataset(originpath).create()\\n ds = install(\\n source=originpath, path=destpath,\\n result_xfm='datasets', return_type='item-or-list')\\n # no harm\\n assert_result_count(ds.update(merge=True, reobtain_data=True),\\n 1, action=\\\"update\\\", status=\\\"ok\\\")\\n # content\\n create_tree(origin.path, {'load.dat': 'heavy'})\\n origin.save(opj(origin.path, 'load.dat'))\\n # update does not bring data automatically\\n assert_result_count(ds.update(merge=True, reobtain_data=True),\\n 1, action=\\\"update\\\", status=\\\"ok\\\")\\n assert_in('load.dat', ds.repo.get_annexed_files())\\n assert_false(ds.repo.file_has_content('load.dat'))\\n # now get data\\n ds.get('load.dat')\\n ok_file_has_content(opj(ds.path, 'load.dat'), 'heavy')\\n # new content at origin\\n create_tree(origin.path, {'novel': 'but boring'})\\n origin.save()\\n # update must not bring in data for new file\\n result = ds.update(merge=True, reobtain_data=True)\\n assert_in_results(result, action='get', status='notneeded')\\n\\n ok_file_has_content(opj(ds.path, 'load.dat'), 'heavy')\\n assert_in('novel', ds.repo.get_annexed_files())\\n assert_false(ds.repo.file_has_content('novel'))\\n # modify content at origin\\n os.remove(opj(origin.path, 'load.dat'))\\n create_tree(origin.path, {'load.dat': 'light'})\\n origin.save()\\n # update must update file with existing data, but leave empty one alone\\n res = ds.update(merge=True, reobtain_data=True)\\n assert_result_count(res, 1, status='ok', type='dataset', action='update')\\n assert_result_count(res, 1, status='ok', type='file', action='get')\\n ok_file_has_content(opj(ds.path, 'load.dat'), 'light')\\n assert_false(ds.repo.file_has_content('novel'))\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_multiway_merge(path=None):\\n # prepare ds with two siblings, but no tracking branch\\n ds = Dataset(op.join(path, 'ds_orig')).create()\\n r1 = AnnexRepo(path=op.join(path, 'ds_r1'), git_opts={'bare': True})\\n r2 = GitRepo(path=op.join(path, 'ds_r2'), git_opts={'bare': True})\\n ds.siblings(action='add', name='r1', url=r1.path)\\n ds.siblings(action='add', name='r2', url=r2.path)\\n assert_status('ok', ds.push(to='r1'))\\n # push unlike publish reports on r2 not being an annex remote with a\\n # 'notneeded'\\n assert_status(('ok', 'notneeded'), ds.push(to='r2'))\\n # just a fetch should be no issue\\n assert_status('ok', ds.update())\\n # ATM we do not support multi-way merges\\n assert_status('impossible', ds.update(merge=True, on_failure='ignore'))\\n\\n\\ndef test_unrelated_history_merge(tmp_path):\\n # prepare two independent datasets and try merging one into another\\n ds = Dataset(tmp_path / 'ds').create()\\n repo = AnnexRepo(tmp_path / 'repo')\\n f = (tmp_path / 'repo' / 'file.dat')\\n f.write_text(\\\"data\\\")\\n repo.add(str(f))\\n repo.commit()\\n # ATM we do not do any checks and allow such addition\\n assert_status('ok', ds.siblings(action='add', name='repo', url=repo.path))\\n res = ds.update(how='merge', on_failure='ignore')\\n # ATM we do not have any special handling, just that the first result record\\n # would have that error in \\\"message\\\" field\\n assert_status('error', res[0])\\n assert_in('refusing to merge unrelated histories', res[0]['message'])\\n\\n\\n# `git annex sync REMOTE` rather than `git merge TARGET` is used on an\\n# adjusted branch, so we don't give an error if TARGET can't be\\n# determined.\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_merge_no_merge_target(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n assert_repo_status(ds_src.path)\\n ds_clone.repo.checkout(DEFAULT_BRANCH, options=[\\\"-bnew\\\"])\\n res = ds_clone.update(merge=True, on_failure=\\\"ignore\\\")\\n assert_in_results(res, status=\\\"impossible\\\", action=\\\"update\\\")\\n\\n\\n# `git annex sync REMOTE` is used on an adjusted branch, but this error\\n# depends on `git merge TARGET` being used.\\n@skip_if_adjusted_branch\\n@slow # 17sec on Yarik's laptop\\n@with_tempfile(mkdir=True)\\ndef test_merge_conflict(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"src\\\").create()\\n ds_src_s0 = ds_src.create(\\\"s0\\\")\\n ds_src_s1 = ds_src.create(\\\"s1\\\")\\n ds_src.save()\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_s0 = Dataset(path / \\\"clone\\\" / \\\"s0\\\")\\n ds_clone_s1 = Dataset(path / \\\"clone\\\" / \\\"s1\\\")\\n\\n (ds_src.pathobj / \\\"foo\\\").write_text(\\\"src content\\\")\\n ds_src.save(to_git=True)\\n\\n (ds_clone.pathobj / \\\"foo\\\").write_text(\\\"clone content\\\")\\n ds_clone.save(to_git=True)\\n\\n # Top-level merge failure\\n res = ds_clone.update(merge=True, on_failure=\\\"ignore\\\")\\n assert_in_results(res, action=\\\"merge\\\", status=\\\"error\\\")\\n assert_in_results(res, action=\\\"update\\\", status=\\\"error\\\")\\n # Deal with the conflicts. Note that save() won't handle this gracefully\\n # because it will try to commit with a pathspec, which git doesn't allow\\n # during a merge.\\n ds_clone.repo.call_git([\\\"checkout\\\", \\\"--theirs\\\", \\\"--\\\", \\\"foo\\\"])\\n ds_clone.repo.call_git([\\\"add\\\", \\\"--\\\", \\\"foo\\\"])\\n ds_clone.repo.call_git([\\\"commit\\\", \\\"--no-edit\\\"])\\n assert_repo_status(ds_clone.path)\\n\\n # Top-level and subdataset merge failure\\n (ds_src_s0.pathobj / \\\"foo\\\").write_text(\\\"src s0 content\\\")\\n (ds_src_s1.pathobj / \\\"foo\\\").write_text(\\\"no conflict\\\")\\n ds_src.save(recursive=True, to_git=True)\\n\\n (ds_clone_s0.pathobj / \\\"foo\\\").write_text(\\\"clone s0 content\\\")\\n ds_clone.save(recursive=True, to_git=True)\\n res = ds_clone.update(merge=True, recursive=True, on_failure=\\\"ignore\\\")\\n assert_result_count(res, 2, action=\\\"merge\\\", status=\\\"error\\\")\\n assert_result_count(res, 2, action=\\\"update\\\", status=\\\"error\\\")\\n assert_in_results(res, action=\\\"merge\\\", status=\\\"ok\\\",\\n path=ds_clone_s1.path)\\n assert_in_results(res, action=\\\"update\\\", status=\\\"ok\\\",\\n path=ds_clone_s1.path)\\n # No saving happens if there's a top-level conflict.\\n assert_repo_status(ds_clone.path,\\n modified=[ds_clone_s0.path, ds_clone_s1.path])\\n\\n\\n# `git annex sync REMOTE` is used on an adjusted branch, but this error\\n# depends on `git merge TARGET` being used.\\n@skip_if_adjusted_branch\\n@slow # 13sec on Yarik's laptop\\n@with_tempfile(mkdir=True)\\ndef test_merge_conflict_in_subdataset_only(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"src\\\").create()\\n ds_src_sub_conflict = ds_src.create(\\\"sub_conflict\\\")\\n ds_src_sub_noconflict = ds_src.create(\\\"sub_noconflict\\\")\\n ds_src.save()\\n\\n # Set up a scenario where one subdataset has a conflict between the remote\\n # and local version, but the parent dataset does not have a conflict\\n # because it hasn't recorded the subdataset state.\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_sub_conflict = Dataset(path / \\\"clone\\\" / \\\"sub_conflict\\\")\\n ds_clone_sub_noconflict = Dataset(path / \\\"clone\\\" / \\\"sub_noconflict\\\")\\n\\n (ds_src_sub_conflict.pathobj / \\\"foo\\\").write_text(\\\"src content\\\")\\n ds_src_sub_conflict.save(to_git=True)\\n\\n (ds_clone_sub_conflict.pathobj / \\\"foo\\\").write_text(\\\"clone content\\\")\\n ds_clone_sub_conflict.save(to_git=True)\\n\\n (ds_src_sub_noconflict.pathobj / \\\"foo\\\").write_text(\\\"src content\\\")\\n ds_src_sub_noconflict.save()\\n\\n res = ds_clone.update(merge=True, recursive=True, on_failure=\\\"ignore\\\")\\n assert_in_results(res, action=\\\"merge\\\", status=\\\"error\\\",\\n path=ds_clone_sub_conflict.path)\\n assert_in_results(res, action=\\\"merge\\\", status=\\\"ok\\\",\\n path=ds_clone_sub_noconflict.path)\\n assert_in_results(res, action=\\\"save\\\", status=\\\"ok\\\",\\n path=ds_clone.path)\\n # We saved the subdataset without a conflict...\\n assert_repo_status(ds_clone_sub_noconflict.path)\\n # ... but the one with the conflict leaves it for the caller to handle.\\n ok_(ds_clone_sub_conflict.repo.call_git(\\n [\\\"ls-files\\\", \\\"--unmerged\\\", \\\"--\\\", \\\"foo\\\"], read_only=True).strip())\\n\\n\\n# `git annex sync REMOTE` is used on an adjusted branch, but this error\\n# depends on `git merge --ff-only ...` being used.\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_merge_ff_only(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"src\\\").create()\\n ds_clone_ff = install(source=ds_src.path, path=path / \\\"clone_ff\\\",\\n result_xfm=\\\"datasets\\\")\\n\\n ds_clone_nonff = install(source=ds_src.path, path=path / \\\"clone_nonff\\\",\\n result_xfm=\\\"datasets\\\")\\n\\n (ds_clone_nonff.pathobj / \\\"foo\\\").write_text(\\\"local change\\\")\\n ds_clone_nonff.save(recursive=True)\\n\\n (ds_src.pathobj / \\\"bar\\\").write_text(\\\"remote change\\\")\\n ds_src.save(recursive=True)\\n\\n assert_in_results(\\n ds_clone_ff.update(merge=\\\"ff-only\\\", on_failure=\\\"ignore\\\"),\\n action=\\\"merge\\\", status=\\\"ok\\\")\\n\\n # ff-only prevents a non-fast-forward ...\\n assert_in_results(\\n ds_clone_nonff.update(merge=\\\"ff-only\\\", on_failure=\\\"ignore\\\"),\\n action=\\\"merge\\\", status=\\\"error\\\")\\n # ... that would work with \\\"any\\\".\\n assert_in_results(\\n ds_clone_nonff.update(merge=\\\"any\\\", on_failure=\\\"ignore\\\"),\\n action=\\\"merge\\\", status=\\\"ok\\\")\\n\\n\\n@slow # 11sec on Yarik's laptop\\n@with_tempfile(mkdir=True)\\ndef test_merge_follow_parentds_subdataset_other_branch(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n on_adjusted = ds_src.repo.is_managed_branch()\\n ds_src_subds = ds_src.create(\\\"subds\\\")\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_subds = Dataset(ds_clone.pathobj / \\\"subds\\\")\\n\\n ds_src_subds.repo.call_git([\\\"checkout\\\", \\\"-b\\\", \\\"other\\\"])\\n (ds_src_subds.pathobj / \\\"foo\\\").write_text(\\\"foo content\\\")\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n res = ds_clone.update(merge=True, follow=\\\"parentds\\\", recursive=True,\\n on_failure=\\\"ignore\\\")\\n if on_adjusted:\\n # Our git-annex sync based on approach on adjusted branches is\\n # incompatible with follow='parentds'.\\n assert_in_results(res, action=\\\"update\\\", status=\\\"impossible\\\")\\n return\\n else:\\n assert_in_results(res, action=\\\"update\\\", status=\\\"ok\\\")\\n eq_(ds_clone.repo.get_hexsha(), ds_src.repo.get_hexsha())\\n ok_(ds_clone_subds.repo.is_under_annex(\\\"foo\\\"))\\n\\n (ds_src_subds.pathobj / \\\"bar\\\").write_text(\\\"bar content\\\")\\n ds_src.save(recursive=True)\\n ds_clone_subds.repo.checkout(DEFAULT_BRANCH, options=[\\\"-bnew\\\"])\\n ds_clone.update(merge=True, follow=\\\"parentds\\\", recursive=True)\\n if not on_adjusted:\\n eq_(ds_clone.repo.get_hexsha(), ds_src.repo.get_hexsha())\\n\\n\\n# This test depends on the source repo being an un-adjusted branch.\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_merge_follow_parentds_subdataset_adjusted_warning(path=None):\\n path = Path(path)\\n\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_subds = ds_src.create(\\\"subds\\\")\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_subds = Dataset(ds_clone.pathobj / \\\"subds\\\")\\n maybe_adjust_repo(ds_clone_subds.repo)\\n # Note: Were we to save ds_clone here, we would get a merge conflict in the\\n # top repo for the submodule (even if using 'git annex sync' rather than\\n # 'git merge').\\n\\n ds_src_subds.repo.call_git([\\\"checkout\\\", DEFAULT_BRANCH + \\\"^0\\\"])\\n (ds_src_subds.pathobj / \\\"foo\\\").write_text(\\\"foo content\\\")\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n assert_in_results(\\n ds_clone.update(merge=True, recursive=True, follow=\\\"parentds\\\",\\n on_failure=\\\"ignore\\\"),\\n status=\\\"impossible\\\",\\n path=ds_clone_subds.path,\\n action=\\\"update\\\")\\n eq_(ds_clone.repo.get_hexsha(), ds_src.repo.get_hexsha())\\n\\n\\n@slow # 12 + 21sec on Yarik's laptop\\n@pytest.mark.parametrize(\\\"on_adjusted\\\", [True, False])\\n# Skip non-adjusted case for systems that only support adjusted branches.\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_merge_follow_parentds_subdataset_detached(path=None, *, on_adjusted):\\n if on_adjusted and DEFAULT_REMOTE != \\\"origin\\\" and \\\\\\n external_versions['cmd:annex'] <= \\\"8.20210330\\\":\\n raise SkipTest(\\n \\\"'git annex init' with adjusted branch currently fails \\\"\\n \\\"due to hard-coded 'origin'\\\")\\n\\n # Note: For the adjusted case, this is not much more than a smoke test that\\n # on an adjusted branch we fail sensibly. The resulting state is not easy\\n # to reason about nor desirable.\\n path = Path(path)\\n # $path/source/s0/s1\\n # The additional dataset level is to gain some confidence that this works\\n # for nested datasets.\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_s0 = ds_src.create(\\\"s0\\\")\\n ds_src_s1 = ds_src_s0.create(\\\"s1\\\")\\n ds_src.save(recursive=True)\\n if on_adjusted:\\n # Note: We adjust after creating all the datasets above to avoid a bug\\n # fixed in git-annex 7.20191024, specifically bbdeb1a1a (sync: Fix\\n # crash when there are submodules and an adjusted branch is checked\\n # out, 2019-10-23).\\n for ds in [ds_src, ds_src_s0, ds_src_s1]:\\n maybe_adjust_repo(ds.repo)\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_s1 = Dataset(ds_clone.pathobj / \\\"s0\\\" / \\\"s1\\\")\\n\\n ds_src_s1.repo.checkout(DEFAULT_BRANCH + \\\"^0\\\")\\n (ds_src_s1.pathobj / \\\"foo\\\").write_text(\\\"foo content\\\")\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n res = ds_clone.update(merge=True, recursive=True, follow=\\\"parentds\\\",\\n on_failure=\\\"ignore\\\")\\n if on_adjusted:\\n # The top-level update is okay because there is no parent revision to\\n # update to.\\n assert_in_results(\\n res,\\n status=\\\"ok\\\",\\n path=ds_clone.path,\\n action=\\\"update\\\")\\n # The subdataset, on the other hand, is impossible.\\n assert_in_results(\\n res,\\n status=\\\"impossible\\\",\\n path=ds_clone_s1.path,\\n action=\\\"update\\\")\\n return\\n assert_repo_status(ds_clone.path)\\n\\n # We brought in the revision and got to the same state of the remote.\\n # Blind saving here without bringing in the current subdataset revision\\n # would have resulted in a new commit in ds_clone that reverting the\\n # last subdataset ID recorded in ds_src.\\n eq_(ds_clone.repo.get_hexsha(), ds_src.repo.get_hexsha())\\n\\n # Record a revision in the parent and then move HEAD away from it so that\\n # the explicit revision fetch fails.\\n (ds_src_s1.pathobj / \\\"bar\\\").write_text(\\\"bar content\\\")\\n ds_src.save(recursive=True)\\n ds_src_s1.repo.checkout(DEFAULT_BRANCH)\\n # This is the default, but just in case:\\n ds_src_s1.repo.config.set(\\\"uploadpack.allowAnySHA1InWant\\\", \\\"false\\\",\\n scope=\\\"local\\\")\\n # Configure the fetcher to use v0 because Git defaults to v2 as of\\n # v2.26.0, which allows fetching unadvertised objects regardless\\n # of the value of uploadpack.allowAnySHA1InWant.\\n ds_clone_s1.repo.config.set(\\\"protocol.version\\\", \\\"0\\\", scope=\\\"local\\\")\\n res = ds_clone.update(merge=True, recursive=True, follow=\\\"parentds\\\",\\n on_failure=\\\"ignore\\\")\\n # The fetch with the explicit ref fails because it isn't advertised.\\n assert_in_results(\\n res,\\n status=\\\"impossible\\\",\\n path=ds_clone_s1.path,\\n action=\\\"update\\\")\\n\\n # Back to the detached head.\\n ds_src_s1.repo.checkout(\\\"HEAD@{1}\\\")\\n # Set up a case where update() will not resolve the sibling.\\n ds_clone_s1.repo.call_git([\\\"branch\\\", \\\"--unset-upstream\\\"])\\n ds_clone_s1.config.reload(force=True)\\n ds_clone_s1.repo.call_git([\\\"remote\\\", \\\"add\\\", \\\"other\\\", ds_src_s1.path])\\n res = ds_clone.update(recursive=True, follow=\\\"parentds\\\",\\n on_failure=\\\"ignore\\\")\\n # In this case, update() won't abort if we call with merge=False, but\\n # it does if the revision wasn't brought down in the `fetch(all_=True)`\\n # call.\\n assert_in_results(\\n res,\\n status=\\\"impossible\\\",\\n path=ds_clone_s1.path,\\n action=\\\"update\\\")\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_update_unborn_master(path=None):\\n ds_a = Dataset(op.join(path, \\\"ds-a\\\")).create()\\n ds_a.repo.call_git([\\\"branch\\\", \\\"-m\\\", DEFAULT_BRANCH, \\\"other\\\"])\\n ds_a.repo.checkout(DEFAULT_BRANCH, options=[\\\"--orphan\\\"])\\n ds_b = install(source=ds_a.path, path=op.join(path, \\\"ds-b\\\"))\\n\\n ds_a.repo.checkout(\\\"other\\\")\\n (ds_a.pathobj / \\\"foo\\\").write_text(\\\"content\\\")\\n ds_a.save()\\n\\n # clone() will try to switch away from an unborn branch if there\\n # is another ref available. Reverse these efforts so that we can\\n # test that update() fails reasonably here because we should still\\n # be able to update from remotes that datalad didn't clone.\\n ds_b.repo.update_ref(\\\"HEAD\\\", \\\"refs/heads/\\\" + DEFAULT_BRANCH,\\n symbolic=True)\\n assert_false(ds_b.repo.commit_exists(\\\"HEAD\\\"))\\n assert_status(\\\"impossible\\\",\\n ds_b.update(merge=True, on_failure=\\\"ignore\\\"))\\n\\n ds_b.repo.checkout(\\\"other\\\")\\n assert_status(\\\"ok\\\",\\n ds_b.update(merge=True, on_failure=\\\"ignore\\\"))\\n eq_(ds_a.repo.get_hexsha(), ds_b.repo.get_hexsha())\\n\\n\\n@slow # ~25s\\n@with_tempfile(mkdir=True)\\ndef test_update_follow_parentds_lazy(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_s0 = ds_src.create(\\\"s0\\\")\\n ds_src_s0_s0 = ds_src_s0.create(\\\"s0\\\")\\n ds_src_s0.create(\\\"s1\\\")\\n ds_src_s1 = ds_src.create(\\\"s1\\\")\\n ds_src.create(\\\"s2\\\")\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_clone_s0 = Dataset(ds_clone.pathobj / \\\"s0\\\")\\n ds_clone_s0_s0 = Dataset(ds_clone.pathobj / \\\"s0\\\" / \\\"s0\\\")\\n ds_clone_s0_s1 = Dataset(ds_clone.pathobj / \\\"s0\\\" / \\\"s1\\\")\\n ds_clone_s1 = Dataset(ds_clone.pathobj / \\\"s1\\\")\\n ds_clone_s2 = Dataset(ds_clone.pathobj / \\\"s2\\\")\\n\\n (ds_src_s0_s0.pathobj / \\\"foo\\\").write_text(\\\"in s0 s0\\\")\\n ds_src_s0_s0.save()\\n (ds_src_s1.pathobj / \\\"foo\\\").write_text(\\\"in s1\\\")\\n ds_src.save(recursive=True)\\n # State:\\n # .\\n # |-- s0\\n # | |-- s0\\n # | `-- s1 * matches registered commit\\n # |-- s1\\n # `-- s2 * matches registered commit\\n res = ds_clone.update(follow=\\\"parentds-lazy\\\", merge=True, recursive=True,\\n on_failure=\\\"ignore\\\")\\n on_adjusted = ds_clone.repo.is_managed_branch()\\n # For adjusted branches, follow=parentds* bails with an impossible result,\\n # so the s0 update doesn't get brought in and s0_s0 also matches the\\n # registered commit.\\n n_notneeded_expected = 3 if on_adjusted else 2\\n assert_result_count(res, n_notneeded_expected,\\n action=\\\"update\\\", status=\\\"notneeded\\\")\\n assert_in_results(res, action=\\\"update\\\", status=\\\"notneeded\\\",\\n path=ds_clone_s0_s1.repo.path)\\n assert_in_results(res, action=\\\"update\\\", status=\\\"notneeded\\\",\\n path=ds_clone_s2.repo.path)\\n if on_adjusted:\\n assert_in_results(res, action=\\\"update\\\", status=\\\"notneeded\\\",\\n path=ds_clone_s0_s0.repo.path)\\n assert_repo_status(ds_clone.path,\\n modified=[ds_clone_s0.repo.path,\\n ds_clone_s1.repo.path])\\n else:\\n assert_repo_status(ds_clone.path)\\n\\n\\n@slow # ~10s\\n@with_tempfile(mkdir=True)\\ndef test_update_follow_parentds_lazy_other_branch(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_sub = ds_src.create(\\\"sub\\\")\\n ds_src_sub.repo.checkout(DEFAULT_BRANCH, options=[\\\"-bother\\\"])\\n (ds_src_sub.pathobj / \\\"foo\\\").write_text(\\\"on other branch\\\")\\n ds_src_sub.save()\\n ds_src_sub.repo.checkout(DEFAULT_BRANCH)\\n ds_src.save(recursive=True)\\n assert_repo_status(ds_src.path)\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n ds_src_sub.repo.checkout(\\\"other\\\")\\n ds_src.save(recursive=True)\\n\\n with patch(\\\"datalad.support.gitrepo.GitRepo.fetch\\\") as fetch_cmd:\\n ds_clone.update(follow=\\\"parentds\\\", merge=\\\"ff-only\\\",\\n recursive=True, on_failure=\\\"ignore\\\")\\n eq_(fetch_cmd.call_count, 2)\\n\\n # With parentds-lazy, an unneeded fetch call in the subdataset is dropped.\\n with patch(\\\"datalad.support.gitrepo.GitRepo.fetch\\\") as fetch_cmd:\\n ds_clone.update(follow=\\\"parentds-lazy\\\", merge=\\\"ff-only\\\",\\n recursive=True, on_failure=\\\"ignore\\\")\\n eq_(fetch_cmd.call_count, 1)\\n\\n if not ds_clone.repo.is_managed_branch():\\n # Now the real thing.\\n ds_clone.update(follow=\\\"parentds-lazy\\\", merge=\\\"ff-only\\\",\\n recursive=True)\\n ok_(op.lexists(str(ds_clone.pathobj / \\\"sub\\\" / \\\"foo\\\")))\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_update_adjusted_incompatible_with_ff_only(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n maybe_adjust_repo(ds_clone.repo)\\n\\n assert_in_results(\\n ds_clone.update(merge=\\\"ff-only\\\", on_failure=\\\"ignore\\\"),\\n action=\\\"update\\\", status=\\\"impossible\\\")\\n assert_in_results(\\n ds_clone.update(on_failure=\\\"ignore\\\"),\\n action=\\\"update\\\", status=\\\"ok\\\")\\n\\n\\n@pytest.mark.parametrize(\\\"follow,action\\\", [\\n # Ideally each combination would be checked, but this test is a bit slow.\\n (\\\"parentds\\\", \\\"reset\\\"),\\n (\\\"sibling\\\", \\\"checkout\\\"),\\n])\\n@slow # ~10s\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_update_how_subds_different(path=None, *, follow, action):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_sub = ds_src.create(\\\"sub\\\")\\n ds_src.save()\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n (ds_clone.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n ds_clone.save()\\n ds_clone_sub = Dataset(ds_clone.pathobj / \\\"sub\\\")\\n\\n (ds_src_sub.pathobj / \\\"bar\\\").write_text(\\\"bar\\\")\\n ds_src.save(recursive=True)\\n\\n # Add unrecorded state to make --follow=sibling/parentds differ.\\n (ds_src_sub.pathobj / \\\"baz\\\").write_text(\\\"baz\\\")\\n ds_src_sub.save()\\n\\n ds_clone_repo = ds_clone.repo\\n ds_clone_hexsha_pre = ds_clone_repo.get_hexsha()\\n\\n ds_clone_sub_repo = ds_clone_sub.repo\\n ds_clone_sub_branch_pre = ds_clone_sub_repo.get_active_branch()\\n\\n res = ds_clone.update(follow=follow, how=\\\"merge\\\", how_subds=action,\\n recursive=True)\\n\\n assert_result_count(res, 1, action=\\\"merge\\\", status=\\\"ok\\\",\\n path=ds_clone.path)\\n assert_result_count(res, 1, action=f\\\"update.{action}\\\", status=\\\"ok\\\",\\n path=ds_clone_sub.path)\\n\\n ds_clone_hexsha_post = ds_clone_repo.get_hexsha()\\n neq_(ds_clone_hexsha_pre, ds_clone_hexsha_post)\\n neq_(ds_src.repo.get_hexsha(), ds_clone_hexsha_post)\\n ok_(ds_clone_repo.is_ancestor(ds_clone_hexsha_pre, ds_clone_hexsha_post))\\n\\n eq_(ds_clone_sub.repo.get_hexsha(),\\n ds_src_sub.repo.get_hexsha(None if follow == \\\"sibling\\\" else \\\"HEAD~\\\"))\\n ds_clone_sub_branch_post = ds_clone_sub_repo.get_active_branch()\\n\\n if action == \\\"checkout\\\":\\n neq_(ds_clone_sub_branch_pre, ds_clone_sub_branch_post)\\n assert_false(ds_clone_sub_branch_post)\\n else:\\n eq_(ds_clone_sub_branch_pre, ds_clone_sub_branch_post)\\n\\n\\n@slow # ~15s\\n@skip_if_adjusted_branch\\n@with_tempfile(mkdir=True)\\ndef test_update_reset_dirty(path=None):\\n path = Path(path)\\n ds_src = Dataset(path / \\\"source\\\").create()\\n ds_src_s1 = ds_src.create(\\\"s1\\\")\\n ds_src_s2 = ds_src.create(\\\"s2\\\")\\n ds_src.save()\\n\\n ds_clone = install(source=ds_src.path, path=path / \\\"clone\\\",\\n recursive=True, result_xfm=\\\"datasets\\\")\\n\\n (ds_src_s1.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n (ds_src_s2.pathobj / \\\"bar\\\").write_text(\\\"bar\\\")\\n ds_src.save(recursive=True)\\n\\n ds_clone_s1 = Dataset(ds_clone.pathobj / \\\"s1\\\")\\n ds_clone_s2 = Dataset(ds_clone.pathobj / \\\"s2\\\")\\n (ds_clone_s1.pathobj / \\\"dirt\\\").write_text(\\\"\\\")\\n\\n res = ds_clone.update(follow=\\\"sibling\\\", how=\\\"reset\\\", recursive=True,\\n on_failure=\\\"ignore\\\")\\n\\n assert_result_count(res, 1, path=ds_clone.path,\\n action=f\\\"update.reset\\\", status=\\\"error\\\")\\n assert_result_count(res, 1, path=ds_clone_s1.path,\\n action=f\\\"update.reset\\\", status=\\\"error\\\")\\n assert_result_count(res, 1, path=ds_clone_s2.path,\\n action=f\\\"update.reset\\\", status=\\\"ok\\\")\\n\\n # s2 was reset...\\n eq_(ds_src_s2.repo.get_hexsha(), ds_clone_s2.repo.get_hexsha())\\n # ... but s1 and the top-level dataset stayed behind due to the dirty tree.\\n eq_(ds_src.repo.get_hexsha(\\\"HEAD~\\\"), ds_clone.repo.get_hexsha())\\n eq_(ds_src_s1.repo.get_hexsha(\\\"HEAD~\\\"), ds_clone_s1.repo.get_hexsha())\\n\\n assert_repo_status(ds_clone.path,\\n modified=[ds_clone_s1.repo.path,\\n ds_clone_s2.repo.path])\\n\\n\\ndef test_process_how_args():\\n # --merge maps onto --how values. It has no equivalent of --how-subds,\\n # --which just gets set to --how's value when unspecified.\\n eq_(_process_how_args(merge=False, how=None, how_subds=None),\\n (None, None))\\n eq_(_process_how_args(merge=True, how=None, how_subds=None),\\n (\\\"merge\\\", \\\"merge\\\"))\\n eq_(_process_how_args(merge=\\\"any\\\", how=None, how_subds=None),\\n (\\\"merge\\\", \\\"merge\\\"))\\n eq_(_process_how_args(merge=\\\"ff-only\\\", how=None, how_subds=None),\\n (\\\"ff-only\\\", \\\"ff-only\\\"))\\n\\n # Values other than the default --merge=False can not be mixed with\\n # non-default how values.\\n with assert_raises(ValueError):\\n _process_how_args(merge=True, how=\\\"merge\\\", how_subds=None)\\n with assert_raises(ValueError):\\n _process_how_args(merge=True, how=None, how_subds=\\\"merge\\\")\\n\\n # --how-subds inherits the value of --how...\\n eq_(_process_how_args(merge=False, how=\\\"fetch\\\", how_subds=None),\\n (None, None))\\n eq_(_process_how_args(merge=False, how=\\\"merge\\\", how_subds=None),\\n (\\\"merge\\\", \\\"merge\\\"))\\n eq_(_process_how_args(merge=False, how=\\\"ff-only\\\", how_subds=None),\\n (\\\"ff-only\\\", \\\"ff-only\\\"))\\n # ... unless --how-subds is explicitly specified.\\n eq_(_process_how_args(merge=False, how=\\\"merge\\\", how_subds=\\\"fetch\\\"),\\n (\\\"merge\\\", None))\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_update_fetch_failure(path=None):\\n path = Path(path)\\n\\n ds_a = Dataset(path / \\\"ds_a\\\").create()\\n s1 = ds_a.create(\\\"s1\\\")\\n ds_a.create(\\\"s2\\\")\\n\\n ds_b = install(source=ds_a.path, path=str(path / \\\"ds-b\\\"), recursive=True)\\n\\n # Rename s1 to make fetch fail.\\n s1.pathobj.rename(s1.pathobj.parent / \\\"s3\\\")\\n\\n res = ds_b.update(recursive=True, on_failure=\\\"ignore\\\")\\n assert_in_results(\\n res,\\n status=\\\"error\\\",\\n path=str(ds_b.pathobj / \\\"s1\\\"),\\n action=\\\"update\\\")\\n assert_in_results(\\n res,\\n status=\\\"ok\\\",\\n path=str(ds_b.pathobj / \\\"s2\\\"),\\n action=\\\"update\\\")\\n assert_in_results(\\n res,\\n status=\\\"ok\\\",\\n path=ds_b.path,\\n action=\\\"update\\\")\\n\"\n },\n {\n \"alpha_fraction\": 0.6416666507720947,\n \"alphanum_fraction\": 0.6416666507720947,\n \"avg_line_length\": 19,\n \"blob_id\": \"3d42aa21e6b36dbd33e1ba22cada2ce69b83245a\",\n \"content_id\": \"da8bbea15ab7205858ede313c3a5cb374c9a7c13\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 120,\n \"license_type\": \"permissive\",\n \"max_line_length\": 49,\n \"num_lines\": 6,\n \"path\": \"/tools/ci/appveyor_ssh2localhost.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/sh\\n\\nset -e -u\\n\\ncat tools/ci/appveyor_ssh_config >> ~/.ssh/config\\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys\\n\"\n },\n {\n \"alpha_fraction\": 0.5972180366516113,\n \"alphanum_fraction\": 0.600544273853302,\n \"avg_line_length\": 34.559139251708984,\n \"blob_id\": \"eeb94cd733b015ac4064965077622a79f56ff07a\",\n \"content_id\": \"80742b4c25ceb634ee11ed5a26ffe3d4485c33c0\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3307,\n \"license_type\": \"permissive\",\n \"max_line_length\": 87,\n \"num_lines\": 93,\n \"path\": \"/datalad/support/entrypoints.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Core utilities\\\"\\\"\\\"\\n\\nimport logging\\nimport sys\\n\\nfrom datalad.support.exceptions import CapturedException\\n\\nlgr = logging.getLogger('datalad.support.entrypoints')\\n\\n\\ndef iter_entrypoints(group, load=False):\\n \\\"\\\"\\\"Iterate over all entrypoints of a given group\\n\\n Parameters\\n ----------\\n group: str\\n Name of the entry point group to iterator over, such as\\n 'datalad.extensions'.\\n load: bool, optional\\n Whether to execute the entry point loader internally in a\\n protected manner that only logs a possible exception and emits\\n a warning, but otherwise skips over \\\"broken\\\" entrypoints.\\n If False, the loader callable is returned unexecuted.\\n\\n Yields\\n -------\\n (name, module, loade(r|d))\\n The first item in each yielded tuple is the entry point name (str).\\n The second is the name of the module that contains the entry point\\n (str). The type of the third items depends on the load parameter.\\n It is either a callable that can be used to load the entrypoint\\n (this is the default behavior), or the outcome of executing the\\n entry point loader.\\n \\\"\\\"\\\"\\n lgr.debug(\\\"Processing entrypoints\\\")\\n\\n if sys.version_info < (3, 10):\\n # 3.10 is when it was no longer provisional\\n from importlib_metadata import entry_points\\n else:\\n from importlib.metadata import entry_points\\n for ep in entry_points(group=group):\\n if not load:\\n yield ep.name, ep.module, ep.load\\n continue\\n\\n try:\\n lgr.debug('Loading entrypoint %s from %s', ep.name, group)\\n yield ep.name, ep.module, ep.load()\\n lgr.debug('Loaded entrypoint %s from %s', ep.name, group)\\n except Exception as e:\\n ce = CapturedException(e)\\n lgr.warning(\\n 'Failed to load entrypoint %s from %s: %s',\\n ep.name, group, ce)\\n continue\\n lgr.debug(\\\"Done processing entrypoints\\\")\\n\\n\\ndef load_extensions():\\n \\\"\\\"\\\"Load entrypoint for any configured extension package\\n\\n Log a warning in case a requested extension is not available, or if\\n a requested extension fails on load.\\n\\n Extensions to load are taken from the 'datalad.extensions.load'\\n configuration item.\\n \\\"\\\"\\\"\\n from datalad import cfg\\n load_extensions = cfg.get('datalad.extensions.load', get_all=True)\\n if load_extensions:\\n from datalad.utils import ensure_list\\n exts = {\\n ename: eload\\n for ename, _, eload in iter_entrypoints('datalad.extensions')\\n }\\n for el in ensure_list(load_extensions):\\n if el not in exts:\\n lgr.warning('Requested extension %r is not available', el)\\n continue\\n try:\\n exts[el]()\\n except Exception as e:\\n ce = CapturedException(e)\\n lgr.warning('Could not load extension %r: %s', el, ce)\\n\"\n },\n {\n \"alpha_fraction\": 0.518542468547821,\n \"alphanum_fraction\": 0.5201583504676819,\n \"avg_line_length\": 39.44771194458008,\n \"blob_id\": \"c0c076eaa0a08412abbdb07da24db16eb3d8e59a\",\n \"content_id\": \"21926641258d6b498d7ba41ddb9c8159e9d69b6b\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 12377,\n \"license_type\": \"permissive\",\n \"max_line_length\": 113,\n \"num_lines\": 306,\n \"path\": \"/datalad/runner/gitrunner.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Runner for command execution within the context of a Git repo\\n\\\"\\\"\\\"\\n\\nimport logging\\nimport os\\nimport os.path as op\\n\\nfrom typing import Optional\\n\\nfrom datalad.dochelpers import borrowdoc\\nfrom datalad.utils import (\\n generate_file_chunks,\\n make_tempfile,\\n)\\nfrom .runner import (\\n GeneratorMixIn,\\n WitlessRunner,\\n)\\n\\n\\nlgr = logging.getLogger('datalad.runner.gitrunner')\\n\\n# We use custom ssh runner while interacting with git\\nGIT_SSH_COMMAND = \\\"datalad sshrun\\\"\\n\\n\\nclass GitRunnerBase(object):\\n \\\"\\\"\\\"\\n Mix-in class for Runners to be used to run git and git annex commands\\n\\n Overloads the runner class to check & update GIT_DIR and\\n GIT_WORK_TREE environment variables set to the absolute path\\n if is defined and is relative path\\n \\\"\\\"\\\"\\n _GIT_PATH = None\\n\\n @staticmethod\\n def _check_git_path():\\n \\\"\\\"\\\"If using bundled git-annex, we would like to use bundled with it git\\n\\n Thus we will store _GIT_PATH a path to git in the same directory as annex\\n if found. If it is empty (but not None), we do nothing\\n \\\"\\\"\\\"\\n if GitRunnerBase._GIT_PATH is None:\\n from shutil import which\\n\\n # with all the nesting of config and this runner, cannot use our\\n # cfg here, so will resort to dark magic of environment options\\n if (os.environ.get('DATALAD_USE_DEFAULT_GIT', '0').lower()\\n in ('1', 'on', 'true', 'yes')):\\n git_fpath = which(\\\"git\\\")\\n if git_fpath:\\n GitRunnerBase._GIT_PATH = ''\\n lgr.log(9, \\\"Will use default git %s\\\", git_fpath)\\n return # we are done - there is a default git avail.\\n # if not -- we will look for a bundled one\\n GitRunnerBase._GIT_PATH = GitRunnerBase._get_bundled_path()\\n lgr.log(9, \\\"Will use git under %r (no adjustments to PATH if empty \\\"\\n \\\"string)\\\", GitRunnerBase._GIT_PATH)\\n assert(GitRunnerBase._GIT_PATH is not None) # we made the decision!\\n\\n @staticmethod\\n def _get_bundled_path():\\n from shutil import which\\n annex_fpath = which(\\\"git-annex\\\")\\n if not annex_fpath:\\n # not sure how to live further anyways! ;)\\n alongside = False\\n else:\\n annex_path = op.dirname(op.realpath(annex_fpath))\\n bundled_git_path = op.join(annex_path, 'git')\\n # we only need to consider bundled git if it's actually different\\n # from default. (see issue #5030)\\n alongside = op.lexists(bundled_git_path) and \\\\\\n bundled_git_path != op.realpath(which('git'))\\n\\n return annex_path if alongside else ''\\n\\n @staticmethod\\n def get_git_environ_adjusted(env=None):\\n \\\"\\\"\\\"\\n Replaces GIT_DIR and GIT_WORK_TREE with absolute paths if relative path and defined\\n \\\"\\\"\\\"\\n # if env set copy else get os environment\\n git_env = env.copy() if env else os.environ.copy()\\n if GitRunnerBase._GIT_PATH:\\n git_env['PATH'] = op.pathsep.join([GitRunnerBase._GIT_PATH, git_env['PATH']]) \\\\\\n if 'PATH' in git_env \\\\\\n else GitRunnerBase._GIT_PATH\\n\\n for varstring in ['GIT_DIR', 'GIT_WORK_TREE']:\\n var = git_env.get(varstring)\\n if var: # if env variable set\\n if not op.isabs(var): # and it's a relative path\\n git_env[varstring] = op.abspath(var) # to absolute path\\n lgr.log(9, \\\"Updated %s to %s\\\", varstring, git_env[varstring])\\n\\n if 'GIT_SSH_COMMAND' not in git_env:\\n git_env['GIT_SSH_COMMAND'] = GIT_SSH_COMMAND\\n git_env['GIT_SSH_VARIANT'] = 'ssh'\\n git_env['GIT_ANNEX_USE_GIT_SSH'] = '1'\\n\\n # We are parsing error messages and hints. For those to work more\\n # reliably we are doomed to sacrifice i18n effort of git, and enforce\\n # consistent language of the messages\\n git_env['LC_MESSAGES'] = 'C'\\n # But since LC_ALL takes precedence, over LC_MESSAGES, we cannot\\n # \\\"leak\\\" that one inside, and are doomed to pop it\\n git_env.pop('LC_ALL', None)\\n\\n return git_env\\n\\n\\nclass GitWitlessRunner(WitlessRunner, GitRunnerBase):\\n \\\"\\\"\\\"A WitlessRunner for git and git-annex commands.\\n\\n See GitRunnerBase it mixes in for more details\\n \\\"\\\"\\\"\\n\\n # Behavior option to load up from config upon demand\\n _CFG_PATHSPEC_FROM_FILE = None\\n\\n @borrowdoc(WitlessRunner)\\n def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n self._check_git_path()\\n\\n def _get_adjusted_env(self, env=None, cwd=None, copy=True):\\n env = GitRunnerBase.get_git_environ_adjusted(env=env)\\n return super()._get_adjusted_env(\\n env=env,\\n cwd=cwd,\\n # git env above is already a copy, so we have no choice,\\n # but we can prevent duplication\\n copy=False,\\n )\\n\\n def _get_chunked_results(self,\\n cmd,\\n files,\\n *,\\n protocol=None,\\n cwd=None,\\n env=None,\\n pathspec_from_file: Optional[bool] = False,\\n **kwargs):\\n\\n assert isinstance(cmd, list)\\n\\n if self._CFG_PATHSPEC_FROM_FILE is None:\\n from datalad import cfg # avoid circular import\\n GitWitlessRunner._CFG_PATHSPEC_FROM_FILE = cfg.obtain('datalad.runtime.pathspec-from-file')\\n assert GitWitlessRunner._CFG_PATHSPEC_FROM_FILE in ('multi-chunk', 'always')\\n file_chunks = list(generate_file_chunks(files, cmd))\\n\\n if pathspec_from_file and (len(file_chunks) > 1 or GitWitlessRunner._CFG_PATHSPEC_FROM_FILE == 'always'):\\n # if git supports pathspec---from-file and we need multiple chunks to do,\\n # just use --pathspec-from-file\\n with make_tempfile(content=b'\\\\x00'.join(f.encode() for f in files)) as tf:\\n cmd += ['--pathspec-file-nul', f'--pathspec-from-file={tf}']\\n yield self.run(\\n cmd=cmd,\\n protocol=protocol,\\n cwd=cwd,\\n env=env,\\n **kwargs)\\n return\\n\\n # \\\"classical\\\" chunking\\n for i, file_chunk in enumerate(file_chunks):\\n # do not pollute with message when there only ever is a single chunk\\n if len(file_chunk) < len(files):\\n lgr.debug(\\n 'Process file list chunk %i (length %i)', i, len(file_chunk))\\n\\n yield self.run(\\n cmd=cmd + ['--'] + file_chunk,\\n protocol=protocol,\\n cwd=cwd,\\n env=env,\\n **kwargs)\\n\\n def run_on_filelist_chunks(self,\\n cmd,\\n files,\\n *,\\n protocol=None,\\n cwd=None,\\n env=None,\\n pathspec_from_file: Optional[bool] = False,\\n **kwargs):\\n \\\"\\\"\\\"\\n Run a git-style command multiple times if `files` is too long,\\n using a non-generator protocol, i.e. a protocol that is not\\n derived from `datalad.runner.protocol.GeneratorMixIn`.\\n\\n Parameters\\n ----------\\n cmd : list\\n Sequence of program arguments.\\n files : list\\n List of files.\\n protocol : WitlessProtocol, optional\\n Protocol class handling interaction with the running process\\n (e.g. output capture). A number of pre-crafted classes are\\n provided (e.g `KillOutput`, `NoCapture`, `GitProgress`).\\n cwd : path-like, optional\\n If given, commands are executed with this path as PWD,\\n the PWD of the parent process is used otherwise. Overrides\\n any `cwd` given to the constructor.\\n env : dict, optional\\n Environment to be used for command execution. If `cwd`\\n was given, 'PWD' in the environment is set to its value.\\n This must be a complete environment definition, no values\\n from the current environment will be inherited. Overrides\\n any `env` given to the constructor.\\n pathspec_from_file : bool, optional\\n Could be set to True for a `git` command which supports\\n --pathspec-from-file and --pathspec-file-nul options. Then pathspecs\\n would be passed through a temporary file.\\n kwargs :\\n Passed to the Protocol class constructor.\\n\\n Returns\\n -------\\n dict\\n At minimum there will be keys 'stdout', 'stderr' with\\n unicode strings of the cumulative standard output and error\\n of the process as values.\\n\\n Raises\\n ------\\n CommandError\\n On execution failure (non-zero exit code) this exception is\\n raised which provides the command (cmd), stdout, stderr,\\n exit code (status), and a message identifying the failed\\n command, as properties.\\n FileNotFoundError\\n When a given executable does not exist.\\n \\\"\\\"\\\"\\n\\n assert not issubclass(protocol, GeneratorMixIn), \\\\\\n \\\"cannot use GitWitlessRunner.run_on_filelist_chunks() \\\" \\\\\\n \\\"with a protocol that inherits GeneratorMixIn, use \\\" \\\\\\n \\\"GitWitlessRunner.run_on_filelist_chunks_items_() instead\\\"\\n\\n results = None\\n for res in self._get_chunked_results(cmd=cmd,\\n files=files,\\n protocol=protocol,\\n cwd=cwd,\\n env=env,\\n pathspec_from_file=pathspec_from_file,\\n **kwargs):\\n if results is None:\\n results = res\\n else:\\n for k, v in res.items():\\n results[k] += v\\n return results\\n\\n def run_on_filelist_chunks_items_(self,\\n cmd,\\n files,\\n *,\\n protocol=None,\\n cwd=None,\\n env=None,\\n pathspec_from_file: Optional[bool] = False,\\n **kwargs):\\n \\\"\\\"\\\"\\n Run a git-style command multiple times if `files` is too long,\\n using a generator protocol, i.e. a protocol that is\\n derived from `datalad.runner.protocol.GeneratorMixIn`.\\n\\n Parameters\\n ----------\\n see GitWitlessRunner.run_on_filelist_chunks() for a definition\\n of parameters\\n\\n Returns\\n -------\\n Generator that yields output of the cmd\\n \\\"\\\"\\\"\\n\\n assert issubclass(protocol, GeneratorMixIn), \\\\\\n \\\"cannot use GitWitlessRunner.run_on_filelist_chunks_items_() \\\" \\\\\\n \\\"with a protocol that does not inherits GeneratorMixIn, use \\\" \\\\\\n \\\"GitWitlessRunner.run_on_filelist_chunks() instead\\\"\\n\\n for chunk_generator in self._get_chunked_results(cmd=cmd,\\n files=files,\\n protocol=protocol,\\n cwd=cwd,\\n env=env,\\n pathspec_from_file=pathspec_from_file,\\n **kwargs):\\n yield from chunk_generator\\n\"\n },\n {\n \"alpha_fraction\": 0.7437995672225952,\n \"alphanum_fraction\": 0.7565839886665344,\n \"avg_line_length\": 58.25757598876953,\n \"blob_id\": \"ed42cdfa157bfe73546696eac23c8cb26d9f3e98\",\n \"content_id\": \"eaac8d91e99096dc582a553bf850525d6fb047b8\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 3911,\n \"license_type\": \"permissive\",\n \"max_line_length\": 256,\n \"num_lines\": 66,\n \"path\": \"/docs/casts/simple_provenance_tracking.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"say \\\"It is often helpful to keep track of the origin of data files. When generating data from other data, it is also useful to know what process led to these new data and what inputs were used.\\\"\\nsay \\\"DataLad can be used to keep such a record...\\\"\\n\\nsay \\\"We start with a dataset\\\"\\nrun \\\"datalad create demo\\\"\\nrun \\\"cd demo\\\"\\n\\nsay \\\"Let's say we are taking a mosaic image composed of flowers from Wikimedia. We want extract some of them into individual files -- maybe to use them in an art project later.\\\"\\nsay \\\"We can use git-annex to obtain this image straight from the web\\\"\\nrun \\\"git annex addurl https://upload.wikimedia.org/wikipedia/commons/a/a5/Flower_poster_2.jpg --file sources/flowers.jpg\\\"\\n\\nsay \\\"We save it in the dataset\\\"\\nrun \\\"datalad save -m 'Added flower mosaic from wikimedia'\\\"\\n\\nsay \\\"Now we can use DataLad's 'run' command to process this image and extract one of the mosaic tiles into its own JPEG file. Let's extract the St. Bernard's Lily from the upper left corner.\\\"\\nrun \\\"datalad run convert -extract 1522x1522+0+0 sources/flowers.jpg st-bernard.jpg\\\"\\n\\nsay \\\"All we have to do is prefix ANY command with 'datalad run'. DataLad will inspect the dataset after the command has finished and save all modifications.\\\"\\nsay \\\"In order to reliably detect modifications, a dataset must not contain unsaved modifications prior to running a command. For example, if we try to extract the Scarlet Pimpernel image with unsaved changes...\\\"\\nrun \\\"touch dirt\\\"\\nrun_expfail \\\"datalad run convert -extract 1522x1522+1470+1470 sources/flowers.jpg pimpernel.jpg\\\"\\n\\nsay \\\"It has to be clean\\\"\\nrun \\\"rm dirt\\\"\\nrun \\\"datalad run convert -extract 1522x1522+1470+1470 sources/flowers.jpg pimpernel.jpg\\\"\\n\\nsay \\\"Every processing step is saved in the dataset, including the exact command and the content that was changed.\\\"\\nrun \\\"git show --stat\\\"\\n\\nsay \\\"On top of that, the origin of any dataset content obtained from elsewhere is on record too\\\"\\nrun \\\"git annex whereis sources/flowers.jpg\\\"\\n\\nsay \\\"Based on this information, we can always reconstruct how any data file came to be -- across the entire life-time of a project\\\"\\nrun \\\"git log --oneline @~3..@\\\"\\nrun \\\"datalad diff --revision @~3..@\\\"\\n\\nsay \\\"We can also rerun any previous commands with 'datalad rerun'. Without any arguments, the command from the last commit will be executed.\\\"\\nrun \\\"datalad rerun\\\"\\nrun \\\"git log --oneline --graph --name-only @~3..@\\\"\\n\\nsay \\\"In this case, a new commit isn't created because the output file didn't change. But let's say we add a step that displaces the Lily's pixels by a random amount.\\\"\\nrun \\\"datalad run convert -spread 10 st-bernard.jpg st-bernard-displaced.jpg\\\"\\n\\nsay \\\"Now, if we rerun the previous command, a new commit is created because the output's content changed.\\\"\\nrun \\\"datalad rerun\\\"\\nrun \\\"git log --graph --oneline --name-only @~2..\\\"\\n\\nsay \\\"(We don't actually want the repeated 'spread' command, so let's reset to the parent commit.)\\\"\\nrun \\\"git reset --hard @^\\\"\\n\\nsay \\\"We can also rerun multiple commits (with '--since') and choose where HEAD is when we start rerunning from (with --onto). When both arguments are set to empty strings, it means 'rerun all command with HEAD at the parent of the first commit a command'.\\\"\\nsay \\\"In other words, you can 'replay' the commands.\\\"\\nrun \\\"datalad rerun --since= --onto= --branch=verify\\\"\\n\\nsay \\\"Now we're on a new branch, 'verify', that contains the replayed history.\\\"\\nrun \\\"git log --oneline --graph master verify\\\"\\n\\nsay \\\"Let's compare the two branches.\\\"\\nrun \\\"datalad diff --revision master..verify\\\"\\n\\nsay \\\"We can see that the step that involved a random component produced different results.\\\"\\nsay \\\"And these are just two branches, so you can compare them using normal Git operations. The next command, for example, marks which commits are 'patch-equivalent'.\\\"\\n\\nrun \\\"git log --oneline --left-right --cherry-mark master...verify\\\"\\n\\nsay \\\"Notice that all commits are marked as equivalent (=) except the 'random spread' ones.\\\"\\n\"\n },\n {\n \"alpha_fraction\": 0.5783277153968811,\n \"alphanum_fraction\": 0.5891398191452026,\n \"avg_line_length\": 30.530303955078125,\n \"blob_id\": \"3446c46ad16ce4127760af202ce936b52067d873\",\n \"content_id\": \"aaa58af41726286296a5614eba4ac75f289dfcc8\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 4162,\n \"license_type\": \"permissive\",\n \"max_line_length\": 101,\n \"num_lines\": 132,\n \"path\": \"/datalad/tests/test_interface.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python-mode; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Test command call wrapper\\n\\\"\\\"\\\"\\n\\nimport re\\n\\nfrom datalad.interface.base import (\\n Interface,\\n get_api_name,\\n)\\nfrom datalad.support import constraints as cnstr\\nfrom datalad.support.param import Parameter\\nfrom datalad.tests.utils_pytest import (\\n assert_equal,\\n assert_in,\\n assert_is,\\n assert_raises,\\n assert_re_in,\\n assert_true,\\n swallow_outputs,\\n)\\n\\n\\nclass Demo(Interface):\\n \\\"\\\"\\\"I am a demo\\\"\\\"\\\"\\n _params_ = dict(\\n\\n demoposarg=Parameter(\\n doc=\\\"demoposdoc\\\",\\n constraints=cnstr.EnsureInt(),\\n nargs=2),\\n\\n demooptposarg1=Parameter(\\n args=('demooptposarg1',),\\n doc=\\\"demooptposdoc1\\\",\\n constraints=cnstr.EnsureInt(),\\n nargs='?'),\\n\\n demooptposarg2=Parameter(\\n args=('demooptposarg2',),\\n doc=\\\"demooptposdoc2\\\",\\n constraints=cnstr.EnsureInt(),\\n nargs='?'),\\n\\n demoarg=Parameter(\\n doc=\\\"demodoc\\\",\\n constraints=cnstr.EnsureInt()))\\n\\n def __call__(self, demoposarg, demooptposarg1=99, demooptposarg2=999, demoarg=100):\\n return demoarg\\n\\n\\ndef test_param():\\n # having a parameter with no information is fine\\n # it doesn't need a name, because it comes from the signature\\n # of the actual implementation that is described\\n p = Parameter()\\n pname = 'testname'\\n # minimal docstring\\n assert_equal(pname, p.get_autodoc('testname'))\\n doc = 'somedoc'\\n p = Parameter(doc=doc)\\n assert_equal('%s\\\\n %s.' % (pname, doc), p.get_autodoc('testname'))\\n # constraints\\n p = Parameter(doc=doc, constraints=cnstr.EnsureInt() | cnstr.EnsureStr())\\n autodoc = p.get_autodoc('testname')\\n assert_true('int or str' in autodoc)\\n\\n with assert_raises(ValueError) as cmr:\\n Parameter(unknown_arg=123)\\n assert_in('Detected unknown argument(s) for the Parameter: unknown_arg',\\n str(cmr.value))\\n\\n\\ndef test_interface():\\n di = Demo()\\n\\n import argparse\\n parser = argparse.ArgumentParser()\\n\\n from datalad.cli.parser import setup_parser_for_interface\\n setup_parser_for_interface(parser, di)\\n with swallow_outputs() as cmo:\\n assert_equal(parser.print_help(), None)\\n assert(cmo.out)\\n assert_equal(cmo.err, '')\\n args = parser.parse_args(['42', '11', '1', '2', '--demoarg', '23'])\\n assert_is(args.demoarg, 23)\\n assert_equal(args.demoposarg, [42, 11])\\n assert_equal(args.demooptposarg1, 1)\\n assert_equal(args.demooptposarg2, 2)\\n\\n # wrong type\\n with swallow_outputs() as cmo:\\n assert_raises(SystemExit, parser.parse_args, ['--demoarg', 'abc'])\\n # that is what we dump upon folks atm. TODO: improve reporting of illspecified options\\n assert_re_in(\\\".*invalid constraint:int value:.*\\\",\\n cmo.err, re.DOTALL)\\n\\n # missing argument to option\\n with swallow_outputs() as cmo:\\n assert_raises(SystemExit, parser.parse_args, ['--demoarg'])\\n assert_re_in(\\\".*--demoarg: expected one argument\\\", cmo.err, re.DOTALL)\\n\\n # missing positional argument\\n with swallow_outputs() as cmo:\\n assert_raises(SystemExit, parser.parse_args, [''])\\n # PY2|PY3\\n assert_re_in(\\\".*error: (too few arguments|the following arguments are required: demoposarg)\\\",\\n cmo.err, re.DOTALL)\\n\\n\\ndef test_name_generation():\\n assert_equal(\\n get_api_name((\\\"some.module\\\", \\\"SomeClass\\\")),\\n 'module')\\n assert_equal(\\n get_api_name((\\\"some.module\\\", \\\"SomeClass\\\", \\\"cmdline-override\\\")),\\n 'module')\\n assert_equal(\\n get_api_name((\\\"some.module\\\",\\n \\\"SomeClass\\\",\\n \\\"cmdline_override\\\",\\n \\\"api_override-dont-touch\\\")),\\n \\\"api_override-dont-touch\\\")\\n\"\n },\n {\n \"alpha_fraction\": 0.580012857913971,\n \"alphanum_fraction\": 0.5838689208030701,\n \"avg_line_length\": 27.290908813476562,\n \"blob_id\": \"5c6d4cfee42d6fddf67bfbb410071e691aa72d1a\",\n \"content_id\": \"16254166d7dd9bc971a1ee61f713f3583ff6dba2\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 6224,\n \"license_type\": \"permissive\",\n \"max_line_length\": 87,\n \"num_lines\": 220,\n \"path\": \"/datalad/support/json_py.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Simple wrappers to get uniform JSON input and output\\n\\\"\\\"\\\"\\n\\n\\nimport io\\nimport codecs\\nfrom os.path import (\\n dirname,\\n exists,\\n lexists,\\n)\\nfrom os import makedirs\\nimport os\\nimport os.path as op\\nimport json\\n\\nfrom datalad.support.exceptions import CapturedException\\n\\n\\n# produce relatively compact, but also diff-friendly format\\njson_dump_kwargs = dict(\\n indent=0,\\n separators=(',', ':\\\\n'),\\n sort_keys=True,\\n ensure_ascii=False,)\\n\\n# achieve minimal representation, but still deterministic\\ncompressed_json_dump_kwargs = dict(\\n json_dump_kwargs,\\n indent=None,\\n separators=(',', ':'))\\n\\n\\n# Let's just reuse top level one for now\\nfrom ..log import lgr\\n\\n\\ndef dump(obj, fname, compressed=False):\\n \\\"\\\"\\\"Dump a JSON-serializable objects into a file\\n\\n Parameters\\n ----------\\n obj : object\\n Structure to serialize.\\n fname : str\\n Name of the file to dump into.\\n compressed : bool\\n Flag whether to use LZMA compression for file content.\\n \\\"\\\"\\\"\\n\\n _open = LZMAFile if compressed else io.open\\n\\n indir = dirname(fname)\\n if not exists(indir):\\n makedirs(indir)\\n if lexists(fname):\\n os.unlink(fname)\\n with _open(fname, 'wb') as f:\\n return dump2fileobj(\\n obj,\\n f,\\n **(compressed_json_dump_kwargs if compressed else json_dump_kwargs)\\n )\\n\\n\\ndef dump2fileobj(obj, fileobj, **kwargs):\\n \\\"\\\"\\\"Dump a JSON-serializable objects into a file-like\\n\\n Parameters\\n ----------\\n obj : object\\n Structure to serialize.\\n fileobj : file\\n Writeable file-like object to dump into.\\n **kwargs\\n Keyword arguments to be passed on to simplejson.dump()\\n \\\"\\\"\\\"\\n return json.dump(\\n obj,\\n codecs.getwriter('utf-8')(fileobj),\\n **kwargs)\\n\\n\\ndef LZMAFile(*args, **kwargs):\\n \\\"\\\"\\\"A little decorator to overcome a bug in lzma\\n\\n A unique to yoh and some others bug with pyliblzma\\n calling dir() helps to avoid AttributeError __exit__\\n see https://bugs.launchpad.net/pyliblzma/+bug/1219296\\n \\\"\\\"\\\"\\n import lzma\\n lzmafile = lzma.LZMAFile(*args, **kwargs)\\n dir(lzmafile)\\n return lzmafile\\n\\n\\ndef dump2stream(obj, fname, compressed=False):\\n\\n _open = LZMAFile if compressed else open\\n\\n indir = dirname(fname)\\n\\n if op.lexists(fname):\\n os.remove(fname)\\n elif indir and not exists(indir):\\n makedirs(indir)\\n with _open(fname, mode='wb') as f:\\n jwriter = codecs.getwriter('utf-8')(f)\\n for o in obj:\\n json.dump(o, jwriter, **compressed_json_dump_kwargs)\\n f.write(b'\\\\n')\\n\\n\\ndef dump2xzstream(obj, fname):\\n dump2stream(obj, fname, compressed=True)\\n\\n\\ndef load_stream(fname, compressed=None):\\n with _suitable_open(fname, compressed)(fname, mode='rb') as f:\\n jreader = codecs.getreader('utf-8')(f)\\n cont_line = u''\\n for line in jreader:\\n if not line.endswith('\\\\n'):\\n cont_line += line\\n continue\\n if cont_line:\\n cont_line += line\\n else:\\n cont_line = line\\n yield loads(cont_line)\\n cont_line = u''\\n if cont_line: # The last line didn't end with a new line.\\n yield loads(cont_line)\\n\\n\\ndef loads(s, *args, **kwargs):\\n \\\"\\\"\\\"Helper to log actual value which failed to be parsed\\\"\\\"\\\"\\n try:\\n return json.loads(s, *args, **kwargs)\\n except:\\n lgr.error(\\n \\\"Failed to load content from %r with args=%r kwargs=%r\\\"\\n % (s, args, kwargs)\\n )\\n raise\\n\\n\\ndef load(fname, fixup=True, compressed=None, **kw):\\n \\\"\\\"\\\"Load JSON from a file, possibly fixing it up if initial load attempt fails\\n\\n Parameters\\n ----------\\n fixup : bool\\n In case of failed load, apply a set of fixups with hope to resolve issues\\n in JSON\\n compressed : bool or None\\n Flag whether to treat the file as XZ compressed. If None, this decision\\n is made automatically based on the presence of a '.xz' extension in the\\n filename\\n **kw\\n Passed into the load (and loads after fixups) function\\n \\\"\\\"\\\"\\n with _suitable_open(fname, compressed)(fname, 'rb') as f:\\n try:\\n jreader = codecs.getreader('utf-8')(f)\\n return json.load(jreader, **kw)\\n except json.JSONDecodeError as exc:\\n if not fixup:\\n raise\\n ce = CapturedException(exc)\\n lgr.warning(\\n \\\"Failed to decode content in %s: %s. Trying few tricks\\\",\\n fname, ce)\\n\\n # Load entire content and replace common \\\"abusers\\\" which break JSON\\n # comprehension but in general\\n # are Ok\\n with _suitable_open(fname)(fname,'rb') as f:\\n s_orig = s = codecs.getreader('utf-8')(f).read()\\n\\n for o, r in {\\n u\\\"\\\\xa0\\\": \\\" \\\", # non-breaking space\\n }.items():\\n s = s.replace(o, r)\\n\\n if s == s_orig:\\n # we have done nothing, so just reraise previous exception\\n raise\\n return loads(s, **kw)\\n\\n\\ndef _suitable_open(fname, compressed=None):\\n \\\"\\\"\\\"Helper to return an appropriate open() implementation for a JSON file\\n\\n Parameters\\n ----------\\n fname: str\\n The target file name which will be inspected for a '.xz' extension when\\n compressed is None.\\n compressed: None or bool, optional\\n If not None, determined when the return function will be capable of\\n (de)compression. If None, this will be guessed from the file name.\\n\\n Returns\\n -------\\n LZMAFile or io.open\\n LZMAFile is returned when (de)compression is requested, or the file name\\n suggests a compressed file.\\n \\\"\\\"\\\"\\n return LZMAFile \\\\\\n if compressed or compressed is None and fname.endswith('.xz') \\\\\\n else io.open\\n\"\n },\n {\n \"alpha_fraction\": 0.7328159809112549,\n \"alphanum_fraction\": 0.7328159809112549,\n \"avg_line_length\": 74.16666412353516,\n \"blob_id\": \"6f0a4ff5ccbb62991a0154ab0358b135b309d878\",\n \"content_id\": \"3bffa87936b573800dbabce14ace38eded49f0be\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": true,\n \"language\": \"Markdown\",\n \"length_bytes\": 902,\n \"license_type\": \"permissive\",\n \"max_line_length\": 141,\n \"num_lines\": 12,\n \"path\": \"/.github/PULL_REQUEST_TEMPLATE.md\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"### PR checklist\\n\\n- [ ] Provide an overview of the changes you're making and explain why you're proposing them.\\n- [ ] Create a changelog snippet (add the `CHANGELOG-missing` label to this pull request in order to have a snippet generated from its title;\\n or use `scriv create` locally and include the generated file in the pull request, see [scriv](https://scriv.readthedocs.io/)).\\n- [ ] Include `Fixes #NNN` somewhere in the description and `scriv` changelog entry if this PR addresses an existing issue.\\n- [ ] If this PR is not complete, select \\\"Create Draft Pull Request\\\" in the pull request button's menu.\\n Consider using a task list (e.g., `- [ ] add tests ...`) to indicate remaining to-do items.\\n- [ ] If you would like to list yourself as a DataLad contributor and your name is not mentioned please modify .zenodo.json file.\\n- [ ] **Delete these instructions**. :-)\\n\\nThanks for contributing!\\n\"\n },\n {\n \"alpha_fraction\": 0.6020413041114807,\n \"alphanum_fraction\": 0.6111363768577576,\n \"avg_line_length\": 34.15275192260742,\n \"blob_id\": \"a20fc7fa7dd0bb61b251745e90f94174dc1ec346\",\n \"content_id\": \"f0c00426ea4ae3a71dd51e54f82728f58735eb9f\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 19803,\n \"license_type\": \"permissive\",\n \"max_line_length\": 141,\n \"num_lines\": 563,\n \"path\": \"/datalad/support/s3.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8 -*-\\n# vi: set ft=python sts=4 ts=4 sw=4 et:\\n### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##g\\n\\\"\\\"\\\"Variety of helpers to deal with AWS S3\\n\\nUse as a script to generate test buckets via e.g.\\n\\n python -m datalad.support.s3 generate test1_dirs\\n\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\nimport mimetypes\\n\\nfrom os.path import splitext\\nimport re\\n\\nfrom datalad.support.network import urlquote, URL\\n\\nimport logging\\nimport datalad.log # Just to have lgr setup happen this one used a script\\nlgr = logging.getLogger('datalad.s3')\\n\\nfrom datalad.support.exceptions import (\\n CapturedException,\\n DownloadError,\\n AccessDeniedError,\\n AccessPermissionExpiredError,\\n AnonymousAccessDeniedError,\\n)\\nfrom datalad.utils import try_multiple_dec\\n\\nfrom urllib.request import urlopen, Request\\n\\n\\ntry:\\n import boto\\n from boto.s3.key import Key\\n from boto.exception import S3ResponseError\\n from boto.s3.connection import OrdinaryCallingFormat\\nexcept Exception as e:\\n if not isinstance(e, ImportError):\\n lgr.warning(\\n \\\"boto module failed to import although available: %s\\\",\\n CapturedException(e))\\n boto = Key = S3ResponseError = OrdinaryCallingFormat = None\\n\\n\\n# TODO: should become a config option and managed along with the rest\\nS3_ADMIN_CREDENTIAL = \\\"datalad-datalad-admin-s3\\\"\\nS3_TEST_CREDENTIAL = \\\"datalad-datalad-test-s3\\\"\\n\\n\\ndef _get_bucket_connection(credential):\\n # eventually we should be able to have multiple credentials associated\\n # with different resources. Thus for now just making an option which\\n # one to use\\n # do full shebang with entering credentials\\n from datalad.downloaders.credentials import AWS_S3\\n credential = AWS_S3(credential, None)\\n if not credential.is_known:\\n credential.enter_new()\\n creds = credential()\\n return boto.connect_s3(creds[\\\"key_id\\\"], creds[\\\"secret_id\\\"])\\n\\n\\ndef _handle_exception(e, bucket_name):\\n \\\"\\\"\\\"Helper to handle S3 connection exception\\\"\\\"\\\"\\n raise (\\n AccessDeniedError\\n if e.error_code == 'AccessDenied'\\n else DownloadError)(\\n \\\"Cannot connect to %s S3 bucket.\\\"\\n % (bucket_name)\\n ) from e\\n\\n\\ndef _check_S3ResponseError(e):\\n \\\"\\\"\\\"Returns True if should be retried.\\n\\n raises ... if token has expired\\\"\\\"\\\"\\n # https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList\\n if e.status in (\\n 307, # MovedTemporarily -- DNS updates etc\\n 503, # Slow down -- too many requests, so perfect fit to sleep a bit\\n ):\\n return True\\n if e.status == 400:\\n # Generic Bad Request -- could be many things! generally -- we retry, but\\n # some times provide more directed reaction\\n # ATM, as used, many requests we send with boto might be just HEAD requests\\n # (if I got it right) and we would not receive BODY back with the detailed\\n # error_code. Then we will allow to retry until we get something we know how to\\n # handle it more specifically\\n if e.error_code == 'ExpiredToken':\\n raise AccessPermissionExpiredError(\\n \\\"Used token to access S3 has expired\\\") from e\\n elif not e.error_code:\\n lgr.log(5, \\\"Empty error_code in %s\\\", e)\\n return True\\n return False\\n\\n\\ndef try_multiple_dec_s3(func):\\n \\\"\\\"\\\"An S3 specific adapter to @try_multiple_dec\\n\\n To decorate func to try multiple times after some sleep upon encountering\\n some intermittent error from S3\\n \\\"\\\"\\\"\\n return try_multiple_dec(\\n ntrials=4,\\n duration=2.,\\n increment_type='exponential',\\n exceptions=S3ResponseError,\\n exceptions_filter=_check_S3ResponseError,\\n logger=lgr.debug,\\n )(func)\\n\\n\\ndef get_bucket(conn, bucket_name):\\n \\\"\\\"\\\"A helper to get a bucket\\n\\n Parameters\\n ----------\\n bucket_name: str\\n Name of the bucket to connect to\\n \\\"\\\"\\\"\\n try:\\n return try_multiple_dec_s3(conn.get_bucket)(bucket_name)\\n except S3ResponseError as e:\\n ce = CapturedException(e)\\n # can initially deny or error to connect to the specific bucket by name,\\n # and we would need to list which buckets are available under following\\n # credentials:\\n lgr.debug(\\\"Cannot access bucket %s by name with validation: %s\\\",\\n bucket_name, ce)\\n if conn.anon:\\n raise AnonymousAccessDeniedError(\\n \\\"Access to the bucket %s did not succeed. Requesting \\\"\\n \\\"'all buckets' for anonymous S3 connection makes \\\"\\n \\\"little sense and thus not supported.\\\" % bucket_name,\\n supported_types=['aws-s3']\\n )\\n\\n if e.reason == \\\"Forbidden\\\":\\n # Could be just HEAD call boto issues is not allowed, and we should not\\n # try to verify that bucket is \\\"reachable\\\". Just carry on\\n try:\\n return try_multiple_dec_s3(conn.get_bucket)(bucket_name, validate=False)\\n except S3ResponseError as e2:\\n lgr.debug(\\\"Cannot access bucket %s even without validation: %s\\\",\\n bucket_name, CapturedException(e2))\\n _handle_exception(e, bucket_name)\\n\\n try:\\n all_buckets = try_multiple_dec_s3(conn.get_all_buckets)()\\n all_bucket_names = [b.name for b in all_buckets]\\n lgr.debug(\\\"Found following buckets %s\\\", ', '.join(all_bucket_names))\\n if bucket_name in all_bucket_names:\\n return all_buckets[all_bucket_names.index(bucket_name)]\\n except S3ResponseError as e2:\\n lgr.debug(\\\"Cannot access all buckets: %s\\\", CapturedException(e2))\\n _handle_exception(e, 'any (originally requested %s)' % bucket_name)\\n else:\\n _handle_exception(e, bucket_name)\\n\\n\\nclass VersionedFilesPool(object):\\n \\\"\\\"\\\"Just a helper which would help to create versioned files in the bucket\\\"\\\"\\\"\\n def __init__(self, bucket):\\n self._versions = {}\\n self._bucket = bucket\\n\\n @property\\n def bucket(self):\\n return self._bucket\\n\\n def __call__(self, filename, prefix='', load=None):\\n self._versions[filename] = version = self._versions.get(filename, 0) + 1\\n version_str = \\\"version%d\\\" % version\\n # if we are to upload fresh content\\n k = Key(self._bucket)\\n k.key = filename\\n #k.set_contents_from_filename('/home/yoh/.emacs')\\n base, ext = splitext(filename)\\n #content_type = None\\n mtype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'\\n headers = {'Content-Type': mtype}\\n\\n if load is None:\\n load = prefix\\n if ext == 'html':\\n load += '%s' % version_str\\n else:\\n load += version_str\\n\\n k.set_contents_from_string(load, headers=headers)\\n return k\\n\\n def reset_version(self, filename):\\n self._versions[filename] = 0\\n\\n\\ndef get_key_url(e, schema='http', versioned=True):\\n \\\"\\\"\\\"Generate an s3:// or http:// url given a key\\n\\n if versioned url is requested but version_id is None, no versionId suffix\\n will be added\\n \\\"\\\"\\\"\\n # TODO: here we would need to encode the name since urlquote actually\\n # can't do that on its own... but then we should get a copy of the thing\\n # so we could still do the .format....\\n # ... = e.name.encode('utf-8') # unicode isn't advised in URLs\\n e.name_urlquoted = urlquote(e.name)\\n if schema == 'http':\\n fmt = \\\"http://{e.bucket.name}.s3.amazonaws.com/{e.name_urlquoted}\\\"\\n elif schema == 's3':\\n fmt = \\\"s3://{e.bucket.name}/{e.name_urlquoted}\\\"\\n else:\\n raise ValueError(schema)\\n if versioned and e.version_id is not None:\\n fmt += \\\"?versionId={e.version_id}\\\"\\n return fmt.format(e=e)\\n\\n\\ndef prune_and_delete_bucket(bucket):\\n \\\"\\\"\\\"Deletes all the content and then deletes bucket\\n\\n Should be used with care -- no confirmation requested\\n \\\"\\\"\\\"\\n bucket.delete_keys(bucket.list_versions(''))\\n # this one doesn't work since it generates DeleteMarkers instead ;)\\n #for key in b.list_versions(''):\\n # b.delete_key(key)\\n bucket.delete()\\n lgr.info(\\\"Bucket %s was removed\\\", bucket.name)\\n\\n\\ndef set_bucket_public_access_policy(bucket):\\n # we need to enable permissions for making content available\\n bucket.set_policy(\\\"\\\"\\\"{\\n \\\"Version\\\":\\\"2012-10-17\\\",\\n \\\"Statement\\\":[{\\n \\\"Sid\\\":\\\"AddPerm\\\",\\n \\\"Effect\\\":\\\"Allow\\\",\\n \\\"Principal\\\": \\\"*\\\",\\n \\\"Action\\\":[\\\"s3:GetObject\\\", \\\"s3:GetObjectVersion\\\", \\\"s3:GetObjectTorrent\\\", \\\"s3:GetObjectVersionTorrent\\\"],\\n \\\"Resource\\\":[\\\"arn:aws:s3:::%s/*\\\"]\\n }\\n ]\\n }\\\"\\\"\\\" % bucket.name)\\n\\n\\ndef gen_test_bucket(bucket_name):\\n conn = _get_bucket_connection(S3_ADMIN_CREDENTIAL)\\n # assure we have none\\n try:\\n bucket = conn.get_bucket(bucket_name)\\n lgr.info(\\\"Deleting existing bucket %s\\\", bucket.name)\\n prune_and_delete_bucket(bucket)\\n except: # MIH: MemoryError?\\n # so nothing to worry about\\n pass\\n finally:\\n pass\\n\\n return conn.create_bucket(bucket_name)\\n\\n\\ndef _gen_bucket_test0(bucket_name=\\\"datalad-test0\\\", versioned=True):\\n\\n bucket = gen_test_bucket(bucket_name)\\n\\n # Enable web access to that bucket to everyone\\n bucket.configure_website('index.html')\\n set_bucket_public_access_policy(bucket)\\n\\n files = VersionedFilesPool(bucket)\\n\\n files(\\\"1version-nonversioned1.txt\\\")\\n files(\\\"2versions-nonversioned1.txt\\\")\\n\\n if versioned:\\n # make bucket versioned AFTER we uploaded one file already\\n bucket.configure_versioning(True)\\n\\n files(\\\"2versions-nonversioned1.txt\\\")\\n files(\\\"2versions-nonversioned1.txt_sameprefix\\\")\\n for v in range(3):\\n files(\\\"3versions-allversioned.txt\\\")\\n files(\\\"3versions-allversioned.txt_sameprefix\\\") # to test possible problems\\n\\n # File which was created and then removed\\n bucket.delete_key(files(\\\"1version-removed.txt\\\"))\\n\\n # File which was created/removed/recreated (with new content)\\n bucket.delete_key(files(\\\"2versions-removed-recreated.txt\\\"))\\n files(\\\"2versions-removed-recreated.txt\\\")\\n files(\\\"2versions-removed-recreated.txt_sameprefix\\\")\\n\\n # File which was created/removed/recreated (with new content)\\n f = \\\"1version-removed-recreated.txt\\\"\\n bucket.delete_key(files(f))\\n files.reset_version(f)\\n files(f)\\n lgr.info(\\\"Bucket %s was generated and populated\\\", bucket_name)\\n\\n return bucket\\n\\n\\ndef gen_bucket_test0_versioned():\\n return _gen_bucket_test0('datalad-test0-versioned', versioned=True)\\n\\n\\ndef gen_bucket_test0_nonversioned():\\n return _gen_bucket_test0('datalad-test0-nonversioned', versioned=False)\\n\\n\\ndef gen_bucket_test1_dirs():\\n bucket_name = 'datalad-test1-dirs-versioned'\\n bucket = gen_test_bucket(bucket_name)\\n bucket.configure_versioning(True)\\n\\n # Enable web access to that bucket to everyone\\n bucket.configure_website('index.html')\\n set_bucket_public_access_policy(bucket)\\n\\n files = VersionedFilesPool(bucket)\\n\\n files(\\\"d1\\\", load=\\\"\\\") # creating an empty file\\n # then we would like to remove that d1 as a file and make a directory out of it\\n files(\\\"d1/file1.txt\\\")\\n # and then delete it and place it back\\n files(\\\"d1\\\", load=\\\"smth\\\")\\n\\n\\ndef gen_bucket_test2_obscurenames_versioned():\\n # in principle bucket name could also contain ., but boto doesn't digest it\\n # well\\n bucket_name = 'datalad-test2-obscurenames-versioned'\\n bucket = gen_test_bucket(bucket_name)\\n bucket.configure_versioning(True)\\n\\n # Enable web access to that bucket to everyone\\n bucket.configure_website('index.html')\\n set_bucket_public_access_policy(bucket)\\n\\n files = VersionedFilesPool(bucket)\\n\\n # http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\\n files(\\\"f 1\\\", load=\\\"\\\")\\n files(\\\"f [1][2]\\\")\\n # Need to grow up for this .... TODO\\n #files(u\\\"юникод\\\")\\n #files(u\\\"юни/код\\\")\\n # all fancy ones at once\\n files(\\\"f!-_.*'( )\\\")\\n # the super-fancy which aren't guaranteed to be good idea (as well as [] above)\\n files(\\\"f &$=@:+,?;\\\")\\n\\n\\ndef gen_bucket_test1_manydirs():\\n # to test crawling with flexible subdatasets making decisions\\n bucket_name = 'datalad-test1-manydirs-versioned'\\n bucket = gen_test_bucket(bucket_name)\\n bucket.configure_versioning(True)\\n\\n # Enable web access to that bucket to everyone\\n bucket.configure_website('index.html')\\n set_bucket_public_access_policy(bucket)\\n\\n files = VersionedFilesPool(bucket)\\n\\n files(\\\"d1\\\", load=\\\"\\\") # creating an empty file\\n # then we would like to remove that d1 as a file and make a directory out of it\\n files(\\\"d1/file1.txt\\\")\\n files(\\\"d1/sd1/file1.txt\\\")\\n files(\\\"d1/sd2/file3.txt\\\", load=\\\"a\\\")\\n files(\\\"d1/sd2/ssd1/file4.txt\\\")\\n files(\\\"d2/file1.txt\\\")\\n files(\\\"d2/sd1/file1.txt\\\")\\n files(\\\"d2/sd1/ssd/sssd/file1.txt\\\")\\n\\n\\ndef add_version_to_url(url, version, replace=False):\\n \\\"\\\"\\\"Add a version ID to `url`.\\n\\n Parameters\\n ----------\\n url : datalad.support.network.URL\\n A URL.\\n version : str\\n The value of 'versionId='.\\n replace : boolean, optional\\n If a versionID is already present in `url`, replace it.\\n\\n Returns\\n -------\\n A versioned URL (str)\\n \\\"\\\"\\\"\\n version_id = \\\"versionId={}\\\".format(version)\\n if not url.query:\\n query = version_id\\n else:\\n ver_match = re.match(\\\"(?P.*&)?\\\"\\n \\\"(?PversionId=[^&]+)\\\"\\n \\\"(?P&.*)?\\\",\\n url.query)\\n if ver_match:\\n if replace:\\n query = \\\"\\\".join([ver_match.group(\\\"pre\\\") or \\\"\\\",\\n version_id,\\n ver_match.group(\\\"post\\\") or \\\"\\\"])\\n else:\\n query = url.query\\n else:\\n query = url.query + \\\"&\\\" + version_id\\n return URL(**dict(url.fields, query=query)).as_str()\\n\\n\\ndef get_versioned_url(url, guarantee_versioned=False, return_all=False, verify=False,\\n s3conn=None, update=False):\\n \\\"\\\"\\\"Given a url return a versioned URL\\n\\n Originally targeting AWS S3 buckets with versioning enabled\\n\\n Parameters\\n ----------\\n url : string\\n guarantee_versioned : bool, optional\\n Would fail if buckets is determined to have no versioning enabled.\\n It will not fail if we fail to determine if bucket is versioned or\\n not\\n return_all: bool, optional\\n If True, would return a list with URLs for all the versions of this\\n file, sorted chronologically with latest first (when possible, e.g.\\n for S3). Remove markers get ignored\\n verify: bool, optional\\n Verify that URL is accessible. As discovered some versioned keys might\\n be denied access to\\n update : bool, optional\\n If the URL already contains a version ID, update it to the latest version\\n ID. This option has no effect if return_all is true.\\n\\n Returns\\n -------\\n string or list of string\\n \\\"\\\"\\\"\\n url_rec = URL(url)\\n\\n s3_bucket, fpath = None, url_rec.path.lstrip('/')\\n\\n was_versioned = False\\n all_versions = []\\n\\n if url_rec.hostname.endswith('.s3.amazonaws.com'):\\n if url_rec.scheme not in ('http', 'https'):\\n raise ValueError(\\\"Do not know how to handle %s scheme\\\" % url_rec.scheme)\\n # bucket name could have . in it, e.g. openneuro.org\\n s3_bucket = url_rec.hostname[:-len('.s3.amazonaws.com')]\\n elif url_rec.hostname == 's3.amazonaws.com':\\n if url_rec.scheme not in ('http', 'https'):\\n raise ValueError(\\\"Do not know how to handle %s scheme\\\" % url_rec.scheme)\\n # url is s3.amazonaws.com/bucket/PATH\\n s3_bucket, fpath = fpath.split('/', 1)\\n elif url_rec.scheme == 's3':\\n s3_bucket = url_rec.hostname # must be\\n if url_rec.query and 'versionId=' in url_rec.query:\\n was_versioned = True\\n all_versions.append(url)\\n else:\\n # and for now implement magical conversion to URL\\n # TODO: wouldn't work if needs special permissions etc\\n # actually for now\\n raise NotImplementedError\\n\\n if s3_bucket:\\n # TODO: cache\\n if s3conn is None:\\n # we need to reuse our providers\\n from ..downloaders.providers import Providers\\n providers = Providers.from_config_files()\\n s3url = \\\"s3://%s/\\\" % s3_bucket\\n s3provider = providers.get_provider(s3url)\\n authenticator = s3provider.authenticator\\n if not authenticator:\\n # We will use anonymous one\\n from ..downloaders.s3 import S3Authenticator\\n authenticator = S3Authenticator()\\n if authenticator.bucket is not None and authenticator.bucket.name == s3_bucket:\\n # we have established connection before, so let's just reuse\\n bucket = authenticator.bucket\\n else:\\n bucket = authenticator.authenticate(s3_bucket, s3provider.credential) # s3conn or _get_bucket_connection(S3_TEST_CREDENTIAL)\\n else:\\n bucket = s3conn.get_bucket(s3_bucket)\\n\\n supports_versioning = True # assume that it does\\n try:\\n supports_versioning = bucket.get_versioning_status() # TODO cache\\n except S3ResponseError as e:\\n # might be forbidden, i.e. \\\"403 Forbidden\\\" so we try then anyways\\n supports_versioning = 'maybe'\\n\\n if supports_versioning:\\n all_keys = bucket.list_versions(fpath)\\n # Filter and sort them so the newest one on top\\n all_keys = [x for x in sorted(all_keys, key=lambda x: (x.last_modified, x.is_latest))\\n if ((x.name == fpath) # match exact name, not just prefix\\n )\\n ][::-1]\\n # our current assumptions\\n assert(all_keys[0].is_latest)\\n # and now filter out delete markers etc\\n all_keys = [x for x in all_keys if isinstance(x, Key)] # ignore DeleteMarkers\\n assert(all_keys)\\n\\n for key in all_keys:\\n url_versioned = add_version_to_url(\\n url_rec, key.version_id, replace=update and not return_all)\\n\\n all_versions.append(url_versioned)\\n if verify:\\n # it would throw HTTPError exception if not accessible\\n _ = urlopen(Request(url_versioned))\\n was_versioned = True\\n if not return_all:\\n break\\n\\n if guarantee_versioned and not was_versioned:\\n raise RuntimeError(\\\"Could not version %s\\\" % url)\\n\\n if not all_versions:\\n # we didn't get a chance\\n all_versions = [url_rec.as_str()]\\n\\n if return_all:\\n return all_versions\\n else:\\n return all_versions[0]\\n\\n\\nif __name__ == '__main__':\\n import sys\\n lgr.setLevel(logging.INFO)\\n # TODO: proper cmdline\\n if len(sys.argv) > 1 and sys.argv[1] == \\\"generate\\\":\\n if len(sys.argv) < 3:\\n raise ValueError(\\\"Say 'all' to regenerate all, or give a generators name\\\")\\n name = sys.argv[2]\\n if name.lower() == 'all':\\n for f in locals().keys():\\n if f.startswith('gen_bucket_'):\\n locals()[f]()\\n else:\\n locals()['gen_bucket_%s' % name]()\\n else:\\n print(\\\"nothing todo\\\")\\n\"\n },\n {\n \"alpha_fraction\": 0.5759270787239075,\n \"alphanum_fraction\": 0.5970732569694519,\n \"avg_line_length\": 39.59720230102539,\n \"blob_id\": \"5169a78c2efe47fc6416415b5bd1e992fe5bfd82\",\n \"content_id\": \"a64df33fd30f98e8bc32e9cb90d9a6425dcf7b98\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 26104,\n \"license_type\": \"permissive\",\n \"max_line_length\": 146,\n \"num_lines\": 643,\n \"path\": \"/datalad/support/tests/test_network.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\nimport logging\\nimport os\\nimport tempfile\\nfrom os.path import isabs\\nfrom os.path import join as opj\\n\\nimport pytest\\n\\nimport datalad.support.network\\nfrom datalad.distribution.dataset import Dataset\\nfrom datalad.support.network import (\\n RI,\\n SSHRI,\\n URL,\\n DataLadRI,\\n GitTransportRI,\\n PathRI,\\n _split_colon,\\n dlurljoin,\\n get_local_file_url,\\n get_response_disposition_filename,\\n get_tld,\\n get_url_straight_filename,\\n is_datalad_compat_ri,\\n is_ssh,\\n is_url,\\n iso8601_to_epoch,\\n local_path_representation,\\n local_path2url_path,\\n local_url_path_representation,\\n parse_url_opts,\\n quote_path,\\n same_website,\\n urlquote,\\n url_path2local_path,\\n)\\nfrom datalad.tests.utils_pytest import (\\n OBSCURE_FILENAME,\\n SkipTest,\\n assert_in,\\n assert_raises,\\n assert_status,\\n eq_,\\n get_most_obscure_supported_name,\\n known_failure_githubci_win,\\n neq_,\\n nok_,\\n ok_,\\n skip_if,\\n swallow_logs,\\n with_tempfile,\\n)\\nfrom datalad.utils import (\\n Path,\\n PurePosixPath,\\n on_windows,\\n)\\n\\n\\ndef test_same_website():\\n ok_(same_website(\\\"http://a.b\\\", \\\"http://a.b/2014/01/xxx/\\\"))\\n ok_(same_website(\\\"http://a.b/page/2/\\\", \\\"http://a.b/2014/01/xxx/\\\"))\\n ok_(same_website(\\\"https://a.b/page/2/\\\", \\\"http://a.b/2014/01/xxx/\\\"))\\n ok_(same_website(\\\"http://a.b/page/2/\\\", \\\"https://a.b/2014/01/xxx/\\\"))\\n\\n\\ndef test_get_tld():\\n eq_(get_tld('http://example.com'), 'example.com')\\n eq_(get_tld('http://example.com/1'), 'example.com')\\n eq_(get_tld('http://example.com/1/2'), 'example.com')\\n eq_(get_tld('example.com/1/2'), 'example.com')\\n eq_(get_tld('s3://example.com/1/2'), 'example.com')\\n assert_raises(ValueError, get_tld, \\\"\\\")\\n assert_raises(ValueError, get_tld, \\\"s3://\\\")\\n assert_raises(ValueError, get_tld, \\\"http://\\\")\\n\\ndef test_dlurljoin():\\n eq_(dlurljoin('http://a.b/', 'f'), 'http://a.b/f')\\n eq_(dlurljoin('http://a.b/page', 'f'), 'http://a.b/f')\\n eq_(dlurljoin('http://a.b/dir/', 'f'), 'http://a.b/dir/f')\\n eq_(dlurljoin('http://a.b/dir/', 'http://url'), 'http://url')\\n eq_(dlurljoin('http://a.b/dir/', '/'), 'http://a.b/')\\n eq_(dlurljoin('http://a.b/dir/', '/x/y'), 'http://a.b/x/y')\\n\\n@pytest.mark.parametrize(\\\"suf\\\", [\\n '',\\n '#',\\n '#tag',\\n '#tag/obscure',\\n '?param=1',\\n '?param=1&another=/',\\n])\\ndef test_get_url_straight_filename(suf):\\n eq_(get_url_straight_filename('http://a.b/' + suf), '')\\n eq_(get_url_straight_filename('http://a.b/p1' + suf), 'p1')\\n eq_(get_url_straight_filename('http://a.b/p1/' + suf), '')\\n eq_(get_url_straight_filename('http://a.b/p1/' + suf, allowdir=True), 'p1')\\n eq_(get_url_straight_filename('http://a.b/p1/p2' + suf), 'p2')\\n eq_(get_url_straight_filename('http://a.b/p1/p2/' + suf), '')\\n eq_(get_url_straight_filename('http://a.b/p1/p2/' + suf, allowdir=True), 'p2')\\n eq_(get_url_straight_filename('http://a.b/p1/p2/' + suf, allowdir=True, strip=('p2', 'xxx')), 'p1')\\n eq_(get_url_straight_filename('http://a.b/p1/p2/' + suf, strip=('p2', 'xxx')), '')\\n\\nfrom ..network import rfc2822_to_epoch\\n\\n\\ndef test_rfc2822_to_epoch():\\n eq_(rfc2822_to_epoch(\\\"Thu, 16 Oct 2014 01:16:17 EDT\\\"), 1413436577)\\n\\n\\ndef test_get_response_disposition_filename():\\n eq_(get_response_disposition_filename('attachment;filename=\\\"Part1-Subjects1-99.tar\\\"'), \\\"Part1-Subjects1-99.tar\\\")\\n eq_(get_response_disposition_filename('attachment'), None)\\n\\n\\ndef test_parse_url_opts():\\n url = 'http://map.org/api/download/?id=157'\\n output = parse_url_opts(url)\\n eq_(output, ('http://map.org/api/download/', {'id': '157'}))\\n\\n url = 's3://bucket/save/?key=891'\\n output = parse_url_opts(url)\\n eq_(output, ('s3://bucket/save/', {'key': '891'}))\\n\\n url = 'http://map.org/api/download/?id=98&code=13'\\n output = parse_url_opts(url)\\n eq_(output, ('http://map.org/api/download/', {'id': '98', 'code': '13'}))\\n\\n\\ndef test_split_colon():\\n eq_(_split_colon('a:b'), ['a', 'b'])\\n eq_(_split_colon('a:b:c'), ['a', 'b:c'])\\n eq_(_split_colon('a:b:c', 2), ['a', 'b', 'c'])\\n eq_(_split_colon('ab'), ['ab'])\\n eq_(_split_colon(r'a\\\\:b'), [r'a\\\\:b'])\\n\\n\\ndef test_url_eq():\\n assert URL() == URL()\\n # doesn't make sense to ask what kind of a url it is an empty URL\\n assert URL() != URL(hostname='x')\\n # Different types aren't equal even if have the same fields values\\n assert URL(path='x') != PathRI(path='x')\\n assert URL(hostname='x') != SSHRI(hostname='x')\\n assert str(URL(hostname='x')) != str(SSHRI(hostname='x'))\\n\\n\\ndef _check_ri(ri, cls, exact_str=True, localpath=None, **fields):\\n \\\"\\\"\\\"just a helper to carry out few checks on urls\\\"\\\"\\\"\\n with swallow_logs(new_level=logging.DEBUG) as cml:\\n ri_ = cls(**fields)\\n murl = RI(ri)\\n assert murl.__class__ == cls # not just a subclass\\n assert murl == ri_\\n if isinstance(ri, str):\\n assert str(RI(ri)) == ri\\n assert eval(repr(ri_)) == ri # repr leads back to identical ri_\\n assert ri == ri_ # just in case ;) above should fail first if smth is wrong\\n if not exact_str:\\n assert_in('Parsed version of', cml.out)\\n if exact_str:\\n assert str(ri) == str(ri_)\\n else:\\n assert str(ri) != str(ri_)\\n\\n # and that we have access to all those fields\\n nok_(set(fields).difference(set(cls._FIELDS)))\\n for f, v in fields.items():\\n assert getattr(ri_, f) == v\\n\\n if localpath:\\n if cls == URL:\\n local_representation = local_url_path_representation(localpath)\\n else:\\n local_representation = local_path_representation(localpath)\\n assert ri_.localpath == local_representation\\n old_localpath = ri_.localpath # for a test below\\n else:\\n # if not given -- must be a remote url, should raise exception on\\n # non-Windows systems. But not on Windows systems because we allow UNCs\\n # to be encoded in URLs\\n if not on_windows:\\n with assert_raises(ValueError):\\n ri_.localpath\\n\\n # This one does not have a path. TODO: either proxy path from its .RI or adjust\\n # hierarchy of classes to make it more explicit\\n if cls == GitTransportRI:\\n return\\n # do changes in the path persist?\\n old_str = str(ri_)\\n ri_.path = newpath = opj(ri_.path, 'sub')\\n assert ri_.path == newpath\\n assert str(ri_) != old_str\\n if localpath:\\n assert ri_.localpath == local_path_representation(opj(old_localpath, 'sub'))\\n\\n\\ndef test_url_base():\\n # Basic checks\\n assert_raises(ValueError, URL, \\\"http://example.com\\\", hostname='example.com')\\n url = URL(\\\"http://example.com\\\")\\n eq_(url.hostname, 'example.com')\\n eq_(url.scheme, 'http')\\n eq_(url.port, '') # not specified -- empty strings\\n eq_(url.username, '') # not specified -- empty strings\\n eq_(repr(url), \\\"URL(hostname='example.com', netloc='example.com', scheme='http')\\\")\\n eq_(url, \\\"http://example.com\\\") # automagic coercion in __eq__\\n\\n neq_(URL(), URL(hostname='x'))\\n\\n smth = URL('smth')\\n eq_(smth.hostname, '')\\n ok_(bool(smth))\\n nok_(bool(URL()))\\n\\n assert_raises(ValueError, url._set_from_fields, unknown='1')\\n\\n with swallow_logs(new_level=logging.WARNING) as cml:\\n # we don't \\\"care\\\" about params ATM so there is a warning if there are any\\n purl = URL(\\\"http://example.com/;param\\\")\\n eq_(str(purl), 'http://example.com/;param') # but we do maintain original string\\n assert_in('ParseResults contains params', cml.out)\\n eq_(purl.as_str(), 'http://example.com/')\\n\\n\\n@with_tempfile\\ndef test_pathri_guessing(filename=None):\\n # Complaining about ;param only at DEBUG level\\n # see https://github.com/datalad/datalad/issues/6872\\n with swallow_logs(new_level=logging.DEBUG) as cml:\\n # we don't \\\"care\\\" about params ATM so there is a warning if there are any\\n ri = RI(f\\\"{filename};param\\\")\\n assert isinstance(ri, PathRI)\\n if not on_windows:\\n # Does not happen on Windows since paths with \\\\ instead of / do not\\n # look like possible URLs\\n assert_in('ParseResults contains params', cml.out)\\n\\n\\n@skip_if(not on_windows)\\ndef test_pathri_windows_anchor():\\n assert RI('file:///c:/Windows').localpath == 'C:\\\\\\\\Windows'\\n\\n\\n@known_failure_githubci_win\\ndef test_url_samples():\\n _check_ri(\\\"http://example.com\\\", URL, scheme='http', hostname=\\\"example.com\\\", netloc='example.com')\\n # \\\"complete\\\" one for classical http\\n _check_ri(\\\"http://user:pw@example.com:8080/p/sp?p1=v1&p2=v2#frag\\\", URL,\\n scheme='http', netloc='user:pw@example.com:8080',\\n hostname=\\\"example.com\\\", port=8080, username='user', password='pw',\\n path='/p/sp', query='p1=v1&p2=v2', fragment='frag')\\n\\n # sample one for ssh with specifying the scheme\\n # XXX? might be useful? https://github.com/FriendCode/giturlparse.py\\n _check_ri(\\\"ssh://host/path/sp1\\\", URL, scheme='ssh', hostname='host',\\n netloc='host', path='/path/sp1')\\n _check_ri(\\\"user@host:path/sp1\\\", SSHRI,\\n hostname='host', path='path/sp1', username='user')\\n _check_ri(\\\"host:path/sp1\\\", SSHRI, hostname='host', path='path/sp1')\\n _check_ri(\\\"host:path\\\", SSHRI, hostname='host', path='path')\\n _check_ri(\\\"host:/path\\\", SSHRI, hostname='host', path='/path')\\n _check_ri(\\\"user@host\\\", SSHRI, hostname='host', username='user')\\n # TODO!!! should this be a legit URL like this?\\n # _check_ri(\\\"host\\\", SSHRI, hostname='host'))\\n eq_(repr(RI(\\\"host:path\\\")), \\\"SSHRI(hostname='host', path='path')\\\")\\n\\n # And now perspective 'datalad', implicit=True urls pointing to the canonical center location\\n _check_ri(\\\"///\\\", DataLadRI)\\n _check_ri(\\\"///p/s1\\\", DataLadRI, path='p/s1')\\n # could be considered by someone as \\\"URI reference\\\" relative to scheme\\n _check_ri(\\\"//a/\\\", DataLadRI, remote='a')\\n _check_ri(\\\"//a/data\\\", DataLadRI, path='data', remote='a')\\n\\n # here we will do custom magic allowing only schemes with + in them, such as dl+archive\\n # or not so custom as\\n _check_ri(\\\"hg+https://host/user/proj\\\", URL, scheme=\\\"hg+https\\\",\\n netloc='host', hostname='host', path='/user/proj')\\n # \\\"old\\\" style\\n _check_ri(\\\"dl+archive:KEY/path/sp1#size=123\\\", URL,\\n scheme='dl+archive', path='KEY/path/sp1', fragment='size=123')\\n # \\\"new\\\" style\\n _check_ri(\\\"dl+archive:KEY#path=path/sp1&size=123\\\", URL,\\n scheme='dl+archive', path='KEY', fragment='path=path/sp1&size=123')\\n # actually above one is probably wrong since we need to encode the path\\n _check_ri(\\\"dl+archive:KEY#path=path%2Fbsp1&size=123\\\", URL,\\n scheme='dl+archive', path='KEY', fragment='path=path%2Fbsp1&size=123')\\n\\n #https://en.wikipedia.org/wiki/File_URI_scheme\\n _check_ri(\\\"file://host\\\", URL, scheme='file', netloc='host', hostname='host')\\n _check_ri(\\\"file://host/path/sp1\\\", URL, scheme='file', netloc='host',\\n hostname='host', path='/path/sp1')\\n # stock libraries of Python aren't quite ready for ipv6\\n ipv6address = '2001:db8:85a3::8a2e:370:7334'\\n _check_ri(\\\"file://%s/path/sp1\\\" % ipv6address, URL,\\n scheme='file', netloc=ipv6address, hostname=ipv6address,\\n path='/path/sp1')\\n for lh in ('localhost', '::1', '', '127.3.4.155'):\\n if on_windows:\\n url = RI(f\\\"file://{lh}/path/sp1\\\")\\n assert url.localpath == f'\\\\\\\\\\\\\\\\{lh}\\\\\\\\path\\\\\\\\sp1' if lh else '\\\\\\\\path\\\\\\\\sp1'\\n else:\\n _check_ri(\\\"file://%s/path/sp1\\\" % lh, URL, localpath='/path/sp1',\\n scheme='file', netloc=lh, hostname=lh, path='/path/sp1')\\n\\n _check_ri('http://[1fff:0:a88:85a3::ac1f]:8001/index.html', URL,\\n scheme='http', netloc='[1fff:0:a88:85a3::ac1f]:8001',\\n hostname='1fff:0:a88:85a3::ac1f', port=8001, path='/index.html')\\n _check_ri(\\\"file:///path/sp1\\\", URL, localpath='/path/sp1', scheme='file', path='/path/sp1')\\n # we don't do any magical comprehension for home paths/drives for windows\\n # of file:// urls, thus leaving /~ and /c: for now:\\n _check_ri(\\\"file:///~/path/sp1\\\", URL, localpath='/~/path/sp1', scheme='file', path='/~/path/sp1')\\n _check_ri(\\\"file:///%7E/path/sp1\\\", URL, localpath='/~/path/sp1', scheme='file', path='/~/path/sp1', exact_str=False)\\n # not sure but let's check\\n if on_windows:\\n _check_ri(\\\"file:///C:/path/sp1\\\", URL, localpath='C:/path/sp1', scheme='file', path='/C:/path/sp1', exact_str=False)\\n _check_ri(\\\"file:/C:/path/sp1\\\", URL, localpath='C:/path/sp1', scheme='file', path='/C:/path/sp1', exact_str=False)\\n # git-annex style drive-letter encoding\\n _check_ri(\\\"file://C:/path/sp1\\\", URL, netloc=\\\"C:\\\", hostname=\\\"c\\\", localpath='C:/path/sp1', scheme='file', path='/path/sp1', exact_str=False)\\n else:\\n _check_ri(\\\"file:///C:/path/sp1\\\", URL, localpath='/C:/path/sp1', scheme='file', path='/C:/path/sp1', exact_str=False)\\n _check_ri(\\\"file:/C:/path/sp1\\\", URL, localpath='/C:/path/sp1', scheme='file', path='/C:/path/sp1', exact_str=False)\\n\\n # and now implicit paths or actually they are also \\\"URI references\\\"\\n _check_ri(\\\"f\\\", PathRI, localpath='f', path='f')\\n _check_ri(\\\"f/s1\\\", PathRI, localpath='f/s1', path='f/s1')\\n _check_ri(PurePosixPath(\\\"f\\\"), PathRI, localpath='f', path='f')\\n _check_ri(PurePosixPath(\\\"f/s1\\\"), PathRI, localpath='f/s1', path='f/s1')\\n # colons are problematic and might cause confusion into SSHRI\\n _check_ri(\\\"f/s:1\\\", PathRI, localpath='f/s:1', path='f/s:1')\\n _check_ri(\\\"f/s:\\\", PathRI, localpath='f/s:', path='f/s:')\\n _check_ri(\\\"/f\\\", PathRI, localpath='/f', path='/f')\\n _check_ri(\\\"/f/s1\\\", PathRI, localpath='/f/s1', path='/f/s1')\\n\\n # some github ones, just to make sure\\n _check_ri(\\\"git://host/user/proj\\\", URL, scheme=\\\"git\\\", netloc=\\\"host\\\",\\n hostname=\\\"host\\\", path=\\\"/user/proj\\\")\\n _check_ri(\\\"git@host:user/proj\\\", SSHRI, hostname=\\\"host\\\", path=\\\"user/proj\\\", username='git')\\n\\n _check_ri('weird:/', SSHRI, hostname='weird', path='/')\\n # since schema is not allowing some symbols so we need to add additional check\\n _check_ri('weird_url:/', SSHRI, hostname='weird_url', path='/')\\n _check_ri('example.com:/', SSHRI, hostname='example.com', path='/')\\n _check_ri('example.com:path/sp1', SSHRI, hostname='example.com', path='path/sp1')\\n _check_ri('example.com/path/sp1\\\\\\\\:fname', PathRI, localpath='example.com/path/sp1\\\\\\\\:fname',\\n path='example.com/path/sp1\\\\\\\\:fname')\\n # ssh is as stupid as us, so we will stay \\\"Consistently\\\" dumb\\n \\\"\\\"\\\"\\n $> ssh example.com/path/sp1:fname\\n ssh: Could not resolve hostname example.com/path/sp1:fname: Name or service not known\\n\\n edit 20190516 yoh: but this looks like a perfectly valid path.\\n SSH knows that it is not a path but its SSHRI so it can stay dumb.\\n We are trying to be smart and choose between RIs (even when we know that\\n it is e.g. a file).\\n \\\"\\\"\\\"\\n _check_ri('e.com/p/sp:f', PathRI, localpath='e.com/p/sp:f', path='e.com/p/sp:f')\\n _check_ri('user@someho.st/mydir', PathRI, localpath='user@someho.st/mydir', path='user@someho.st/mydir')\\n\\n # SSHRIs have .port, but it is empty\\n eq_(SSHRI(hostname='example.com').port, '')\\n\\n # check that we are getting a warning logged when url can't be reconstructed\\n # precisely\\n # actually failed to come up with one -- becomes late here\\n #_check_ri(\\\"http://host///..//p\\\", scheme='http', path='/..//p')\\n\\n # actually this one is good enough to trigger a warning and I still don't know\\n # what it should exactly be!?\\n with swallow_logs(new_level=logging.DEBUG) as cml:\\n weird_str = 'weird://'\\n weird_url = RI(weird_str)\\n repr(weird_url)\\n cml.assert_logged(\\n 'Parsed version of SSHRI .weird:/. '\\n 'differs from original .weird://.'\\n )\\n # but we store original str\\n eq_(str(weird_url), weird_str)\\n neq_(weird_url.as_str(), weird_str)\\n\\n raise SkipTest(\\\"TODO: file://::1/some does complain about parsed version dropping ::1\\\")\\n\\n\\ndef test_git_transport_ri():\\n _check_ri(\\\"gcrypt::http://somewhere\\\", GitTransportRI, RI='http://somewhere', transport='gcrypt')\\n # man git-push says\\n # ::\\n # where may be a path, a server and path, or an arbitrary URL-like string...\\n # so full path to my.com/... should be ok?\\n _check_ri(\\\"http::/my.com/some/path\\\", GitTransportRI, RI='/my.com/some/path', transport='http')\\n # some ssh server. And we allow for some additional chars in transport.\\n # Git doesn't define since it does not care! we will then be flexible too\\n _check_ri(\\\"trans-port::server:path\\\", GitTransportRI, RI='server:path', transport='trans-port')\\n\\n\\n@pytest.mark.parametrize(\\\"cls,clskwargs,target_url\\\", [\\n (SSHRI, {}, r'example.com:/ \\\"' + r\\\"';a&b&cd `| \\\"),\\n (URL, {'scheme': \\\"http\\\"}, 'http://example.com/%20%22%27%3Ba%26b%26cd%20%60%7C%20'),\\n (PathRI, {}, r'/ \\\"' + r\\\"';a&b&cd `| \\\"), # nothing is done to file:implicit\\n])\\ndef test_url_quote_path(cls, clskwargs, target_url):\\n path = '/ \\\"\\\\';a&b&cd `| '\\n if not (cls is PathRI):\\n clskwargs['hostname'] = hostname = 'example.com'\\n url = cls(path=path, **clskwargs)\\n eq_(url.path, path)\\n if 'hostname' in clskwargs:\\n eq_(url.hostname, hostname)\\n # all nasty symbols should be quoted\\n url_str = str(url)\\n eq_(url_str, target_url)\\n # no side-effects:\\n eq_(url.path, path)\\n if 'hostname' in clskwargs:\\n eq_(url.hostname, hostname)\\n\\n # and figured out and unquoted\\n url_ = RI(url_str)\\n ok_(isinstance(url_, cls))\\n eq_(url_.path, path)\\n if 'hostname' in clskwargs:\\n eq_(url.hostname, hostname)\\n\\n\\ndef test_url_compose_archive_one():\\n url = URL(scheme='dl+archive', path='KEY',\\n fragment=dict((('path', 'f/p/ s+'), ('size', 30))))\\n # funny - space is encoded as + but + is %2B\\n eq_(str(url), 'dl+archive:KEY#path=f/p/+s%2B&size=30')\\n eq_(url.fragment_dict, {'path': 'f/p/ s+', 'size': '30'})\\n\\n\\ndef test_url_fragments_and_query():\\n url = URL(hostname=\\\"host\\\", query=dict((('a', 'x/b'), ('b', 'y'))))\\n eq_(str(url), '//host?a=x%2Fb&b=y')\\n eq_(url.query, 'a=x%2Fb&b=y')\\n eq_(url.query_dict, {'a': 'x/b', 'b': 'y'})\\n\\n url = URL(hostname=\\\"host\\\", fragment=dict((('b', 'x/b'), ('a', 'y'))))\\n eq_(str(url), '//host#b=x/b&a=y')\\n eq_(url.fragment, 'b=x/b&a=y')\\n eq_(url.fragment_dict, {'a': 'y', 'b': 'x/b'})\\n\\n fname = get_most_obscure_supported_name()\\n url = URL(hostname=\\\"host\\\", fragment={'a': fname})\\n eq_(url.fragment_dict, {'a': fname})\\n\\n\\ndef test_url_dicts():\\n eq_(URL(\\\"http://host\\\").query_dict, {})\\n\\n\\ndef test_get_url_path_on_fileurls():\\n assert URL('file:///a').path == '/a'\\n assert URL('file:///a/b').path == '/a/b'\\n assert URL('file:///a/b').localpath == local_path_representation('/a/b')\\n assert URL('file:///a/b#id').path == '/a/b'\\n assert URL('file:///a/b?whatever').path == '/a/b'\\n\\n\\ndef test_is_url():\\n ok_(is_url('file://localhost/some'))\\n ok_(is_url('http://localhost'))\\n ok_(is_url('ssh://me@localhost'))\\n # in current understanding it is indeed a url but an 'ssh', implicit=True, not just\\n # a useless scheme=weird with a hope to point to a netloc\\n with swallow_logs():\\n ok_(is_url('weird://'))\\n nok_(is_url('relative'))\\n nok_(is_url('/absolute'))\\n ok_(is_url('like@sshlogin')) # actually we do allow ssh:implicit urls ATM\\n nok_(is_url(''))\\n nok_(is_url(' '))\\n nok_(is_url(123)) # stuff of other types wouldn't be considered a URL\\n\\n # we can pass RI instance directly\\n ok_(is_url(RI('file://localhost/some')))\\n nok_(is_url(RI('relative')))\\n\\n\\n# TODO: RF with test_is_url to avoid duplication\\ndef test_is_datalad_compat_ri():\\n ok_(is_datalad_compat_ri('ssh://user:passw@host/path'))\\n ok_(is_datalad_compat_ri('http://example.com'))\\n ok_(is_datalad_compat_ri('file://localhost/some'))\\n ok_(is_datalad_compat_ri('///localhost/some'))\\n nok_(is_datalad_compat_ri('relative'))\\n nok_(is_datalad_compat_ri('.///localhost/some'))\\n nok_(is_datalad_compat_ri(123))\\n\\n\\ndef test_get_local_file_url():\\n compat_annex = 'git-annex'\\n compat_git = 'git'\\n for path, url, compatibility in (\\n # relpaths are special-cased below\\n ('test.txt', 'test.txt', compat_annex),\\n (OBSCURE_FILENAME, urlquote(OBSCURE_FILENAME), compat_annex),\\n ) + ((\\n ('C:\\\\\\\\Windows\\\\\\\\notepad.exe', 'file://C:/Windows/notepad.exe', compat_annex),\\n ('C:\\\\\\\\Windows\\\\\\\\notepad.exe', 'file:///C:/Windows/notepad.exe', compat_git),\\n ) if on_windows else (\\n ('/a', 'file:///a', compat_annex),\\n ('/a/b/c', 'file:///a/b/c', compat_annex),\\n ('/a~', 'file:///a~', compat_annex),\\n # there are no files with trailing slashes in the name\\n #('/a b/', 'file:///a%20b/'),\\n ('/a b/name', 'file:///a%20b/name', compat_annex),\\n )):\\n # Yarik found no better way to trigger. .decode() isn't enough\\n print(\\\"D: %s\\\" % path)\\n if isabs(path):\\n assert get_local_file_url(path, compatibility=compatibility) == url\\n abs_path = path\\n else:\\n assert get_local_file_url(path, allow_relative_path=True, compatibility=compatibility) \\\\\\n == '/'.join((get_local_file_url(os.getcwd(), compatibility=compatibility), url))\\n abs_path = opj(os.getcwd(), path)\\n if compatibility == compat_git:\\n assert get_local_file_url(abs_path, compatibility=compatibility) == Path(abs_path).as_uri()\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_get_local_file_url_compatibility(path=None):\\n # smoke test for file:// URL compatibility with other datalad/git/annex\\n # pieces\\n path = Path(path)\\n ds1 = Dataset(path / 'ds1').create()\\n ds2 = Dataset(path / 'ds2').create()\\n testfile = path / 'testfile.txt'\\n testfile.write_text('some')\\n\\n # compat with annex addurl\\n ds1.repo.add_url_to_file(\\n 'test.txt',\\n get_local_file_url(str(testfile), compatibility='git-annex'))\\n\\n # compat with git clone/submodule\\n assert_status(\\n 'ok',\\n ds1.clone(get_local_file_url(ds2.path, compatibility='git'),\\n result_xfm=None, return_type='generator'))\\n\\n\\ndef test_is_ssh():\\n\\n ssh_locators = [\\\"ssh://host\\\",\\n \\\"ssh://host/some/where\\\",\\n \\\"user@host:path/sp1\\\",\\n \\\"user@host:/absolute/path/sp1\\\",\\n \\\"host:path/sp1\\\",\\n \\\"host:/absolute/path/sp1\\\",\\n \\\"user@host\\\"]\\n for ri in ssh_locators:\\n ok_(is_ssh(ri), \\\"not considered ssh (string): %s\\\" % ri)\\n ok_(is_ssh(RI(ri)), \\\"not considered ssh (RI): %s\\\" % ri)\\n\\n non_ssh_locators = [\\\"file://path/to\\\",\\n \\\"/abs/path\\\",\\n \\\"../rel/path\\\",\\n \\\"http://example.com\\\",\\n \\\"git://host/user/proj\\\",\\n \\\"s3://bucket/save/?key=891\\\"]\\n for ri in non_ssh_locators:\\n ok_(not is_ssh(ri), \\\"considered ssh (string): %s\\\" % ri)\\n ok_(not is_ssh(RI(ri)), \\\"considered ssh (RI): %s\\\" % ri)\\n\\n\\ndef test_iso8601_to_epoch():\\n epoch = 1467901515\\n eq_(iso8601_to_epoch('2016-07-07T14:25:15+00:00'), epoch)\\n eq_(iso8601_to_epoch('2016-07-07T14:25:15+11:00'),\\n epoch - 11 * 60 * 60)\\n eq_(iso8601_to_epoch('2016-07-07T14:25:15Z'), epoch)\\n eq_(iso8601_to_epoch('2016-07-07T14:25:15'), epoch)\\n\\n eq_(iso8601_to_epoch('2016-07-07T14:25:14'), epoch-1)\\n\\n\\ndef test_mapping_identity():\\n from datalad.tests.utils_pytest import OBSCURE_FILENAME\\n\\n absolute_obscure_path = str(Path('/').absolute() / OBSCURE_FILENAME)\\n temp_dir = tempfile.gettempdir()\\n print(f\\\"temp_dir: {temp_dir}\\\")\\n for name in (temp_dir, opj(temp_dir, \\\"x.txt\\\"), absolute_obscure_path):\\n # On some platforms, e.g. MacOS, `temp_dir` might contain trailing\\n # slashes. Since the conversion and its inverse normalize paths, we\\n # compare the result to the normalized path\\n normalized_name = str(Path(name))\\n assert url_path2local_path(local_path2url_path(name)) == normalized_name\\n\\n prefix = \\\"/C:\\\" if on_windows else \\\"\\\"\\n for name in map(quote_path, (prefix + \\\"/window\\\", prefix + \\\"/d\\\", prefix + \\\"/\\\" + OBSCURE_FILENAME)):\\n assert local_path2url_path(url_path2local_path(name)) == name\\n\\n\\ndef test_auto_resolve_path():\\n relative_path = str(Path(\\\"a/b\\\"))\\n with pytest.raises(ValueError):\\n local_path2url_path(relative_path)\\n local_path2url_path(\\\"\\\", allow_relative_path=True)\\n\\n\\n@skip_if(not on_windows)\\ndef test_hostname_detection():\\n with pytest.raises(ValueError):\\n local_path2url_path(\\\"\\\\\\\\\\\\\\\\server\\\\\\\\share\\\\\\\\path\\\")\\n\\n\\ndef test_url_path2local_path_excceptions():\\n with pytest.raises(ValueError):\\n url_path2local_path('')\\n with pytest.raises(ValueError):\\n url_path2local_path(None)\\n with pytest.raises(ValueError):\\n url_path2local_path('a/b')\\n with pytest.raises(ValueError):\\n url_path2local_path(PurePosixPath('a/b'))\\n with pytest.raises(ValueError):\\n url_path2local_path(PurePosixPath('//a/b'))\\n\\n\\ndef test_quote_path(monkeypatch):\\n with monkeypatch.context() as ctx:\\n ctx.setattr(datalad.support.network, 'on_windows', True)\\n assert quote_path(\\\"/c:/win:xxx\\\") == \\\"/c:/win%3Axxx\\\"\\n assert quote_path(\\\"/C:/win:xxx\\\") == \\\"/C:/win%3Axxx\\\"\\n\\n ctx.setattr(datalad.support.network, 'on_windows', False)\\n assert quote_path(\\\"/c:/win:xxx\\\") == \\\"/c%3A/win%3Axxx\\\"\\n assert quote_path(\\\"/C:/win:xxx\\\") == \\\"/C%3A/win%3Axxx\\\"\\n\"\n },\n {\n \"alpha_fraction\": 0.7521818280220032,\n \"alphanum_fraction\": 0.7596914768218994,\n \"avg_line_length\": 56.96470642089844,\n \"blob_id\": \"9a61960f2ea7f0d0bcd40f4eb5c750c7e2361b32\",\n \"content_id\": \"44907aa45ce5a85e24dca1c4452cd92dbba318d7\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 4927,\n \"license_type\": \"permissive\",\n \"max_line_length\": 276,\n \"num_lines\": 85,\n \"path\": \"/docs/casts/reproducible_analysis.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"say \\\"Scientific studies should be reproducible, and with the increasing accessibility of data, there is not much excuse for lack of reproducibility anymore.\\\"\\nsay \\\"DataLad can help with the technical aspects of reproducible science...\\\"\\nsay \\\"It always starts with a dataset\\\"\\nrun \\\"datalad create demo\\\"\\nrun \\\"cd demo\\\"\\n\\nsay \\\"For this demo we are using two public brain imaging datasets that were published on OpenFMRI.org, and are available from DataLad's datasets.datalad.org\\\"\\nrun \\\"datalad install -d . -s ///openfmri/ds000001 inputs/ds000001\\\"\\n\\nsay \\\"BTW: '///' is just short for https://datasets.datalad.org\\\"\\n\\nrun \\\"datalad install -d . -s ///openfmri/ds000002 inputs/ds000002\\\"\\n\\nsay \\\"Both datasets are now registered as subdatasets, and their precise versions are on record\\\"\\nrun \\\"datalad --output-format '{path}: {revision_descr}' subdatasets\\\"\\n\\nsay \\\"However, very little data were actually downloaded (the full datasets are several gigabytes in size):\\\"\\nrun \\\"du -sh inputs/\\\"\\n\\nsay \\\"DataLad datasets are fairly lightweight in size, they only contain pointers to data and history information in their minimal form.\\\"\\n\\nsay \\\"Both datasets contain brain imaging data, and are compliant with the BIDS standard. This makes it really easy to locate particular images and perform analysis across datasets.\\\"\\nsay \\\"Here we will use a small script that performs 'brain extraction' using FSL as a stand-in for a full analysis pipeline\\\"\\nrun \\\"mkdir code\\\"\\nrun \\\"cat << EOT > code/brain_extraction.sh\\n# enable FSL\\n. /etc/fsl/5.0/fsl.sh\\n\\n# obtain all inputs\\ndatalad get \\\\\\\\\\\\$@\\n# perform brain extraction\\ncount=1\\nfor nifti in \\\\\\\\\\\\$@; do\\n subdir=\\\\\\\"sub-\\\\\\\\\\\\$(printf %03d \\\\\\\\\\\\$count)\\\\\\\"\\n mkdir -p \\\\\\\\\\\\$subdir\\n echo \\\\\\\"Processing \\\\\\\\\\\\$nifti\\\\\\\"\\n bet \\\\\\\\\\\\$nifti \\\\\\\\\\\\$subdir/anat -m\\n count=\\\\\\\\\\\\$((count + 1)) \\ndone\\nEOT\\\"\\n\\nsay \\\"Note that this script uses the 'datalad get' command which automatically obtains the required files from their remote source -- we will see this in action shortly\\\"\\nsay \\\"We are saving this script in the dataset. This way we will know exactly which code was used for the analysis. Also, we track this code file with Git, so we can see more easily how it was edited over time.\\\"\\nrun \\\"datalad save code -m \\\\\\\"Brain extraction script\\\\\\\" --to-git\\\"\\n\\nsay \\\"In addition, we will \\\\\\\"tag\\\\\\\" this state of the dataset. This is optional, but it can help to identify important milestones more easily\\\"\\nrun \\\"datalad save --version-tag setup_done\\\"\\n\\nsay \\\"Now we can run our analysis code to produce results. However, instead of running it directly, we will run it with DataLad -- this will automatically create a record of exactly how this script was executed\\\"\\nsay \\\"For this demo we will just run it on the structural images of the first subject from each dataset. The uniform structure of the datasets makes this very easy. Of course we could run it on all subjects; we are simply saving some time for this demo.\\\"\\nsay \\\"While the command runs, you should notice a few things:\\\"\\nsay \\\"1) We run this command with 'bash -e' to stop at any failure that may occur\\\"\\nsay \\\"2) You'll see the required data files being obtained as they are needed -- and only those that are actually required will be downloaded\\\"\\nrun \\\"datalad run bash -e code/brain_extraction.sh inputs/ds*/sub-01/anat/sub-01_T1w.nii.gz\\\"\\n\\nsay \\\"The analysis step is done, all generated results were saved in the dataset. All changes, including the command that caused them are on record\\\"\\nrun \\\"git show --stat\\\"\\n\\nsay \\\"DataLad has enough information stored to be able to re-run a command.\\\"\\nsay \\\"On command exit, it will inspect the results and save them again, but only if they are different.\\\"\\nsay \\\"In our case, the re-run yields bit-identical results, hence nothing new is saved.\\\"\\nrun \\\"datalad rerun\\\"\\n\\nsay \\\"Now that we are done, and have checked that we can reproduce the results ourselves, we can clean up\\\"\\nsay \\\"DataLad can easily verify if any part of our input dataset was modified since we configured our analysis\\\"\\nrun \\\"datalad diff --revision setup_done inputs\\\"\\n\\nsay \\\"Nothing was changed.\\\"\\nsay \\\"With DataLad with don't have to keep those inputs around -- without losing the ability to reproduce an analysis.\\\"\\nsay \\\"Let's uninstall them -- checking the size on disk before and after\\\"\\n\\nrun \\\"du -sh\\\" .\\nrun \\\"datalad uninstall inputs/*\\\"\\nrun \\\"du -sh .\\\"\\nsay \\\"All inputs are gone...\\\"\\nrun \\\"ls inputs/*\\\"\\n\\nsay \\\"Only the remaining data (our code and the results) need to be kept and require a backup for long term archival. Everything else can be re-obtained as needed, when needed.\\\"\\n\\nsay \\\"As DataLad knows everything needed about the inputs, including where to get the right version, we can re-run the analysis with a single command. Watch how DataLad re-obtains all required data, re-runs the code, and checks that none of the results changed and need saving\\\"\\nrun \\\"datalad rerun\\\"\\n\\nsay \\\"Reproduced!\\\"\\n\\nsay \\\"This dataset could now be published and enable anyone to replicate the exact same analysis. Public data for the win!\\\"\\n\"\n },\n {\n \"alpha_fraction\": 0.5845750570297241,\n \"alphanum_fraction\": 0.5886815786361694,\n \"avg_line_length\": 36.11030578613281,\n \"blob_id\": \"8430fecb8c034b1733fdc193878d760f6a62fcae\",\n \"content_id\": \"646b9cdeb7dcb2ba1d4b5221dabb4c9782342fbc\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 25573,\n \"license_type\": \"permissive\",\n \"max_line_length\": 99,\n \"num_lines\": 689,\n \"path\": \"/datalad/log.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Logging setup and utilities, including progress reporting\\\"\\\"\\\"\\n\\nfrom contextlib import contextmanager\\nfrom functools import partial\\nimport inspect\\nimport logging\\nimport os\\nimport sys\\nimport platform\\nimport random\\nimport logging.handlers\\nimport warnings\\n\\nfrom os.path import basename, dirname\\n\\nfrom collections import defaultdict\\n\\nfrom .utils import is_interactive, optional_args\\nfrom .support import ansi_colors as colors\\n\\n__all__ = [\\n 'ColorFormatter',\\n 'LoggerHelper',\\n 'filter_noninteractive_progress',\\n 'log_progress',\\n 'with_progress',\\n 'with_result_progress',\\n]\\n\\n# Snippets from traceback borrowed from duecredit which was borrowed from\\n# PyMVPA upstream/2.4.0-39-g69ad545 MIT license (the same copyright as DataLad)\\n\\n\\ndef mbasename(s):\\n \\\"\\\"\\\"Returns an expanded basename, if the filename is deemed not informative\\n\\n A '.py' extension is stripped from file name, and the containing directory\\n is prepended for too generic file names like 'base', '__init__', and 'utils'\\n\\n Parameters\\n ----------\\n s: str\\n Platform-native path\\n\\n Returns\\n -------\\n str\\n \\\"\\\"\\\"\\n base = basename(s)\\n if base.endswith('.py'):\\n base = base[:-3]\\n if base in set(['base', '__init__', 'utils']):\\n base = basename(dirname(s)) + '.' + base\\n return base\\n\\n\\nclass TraceBack(object):\\n \\\"\\\"\\\"Customizable traceback for inclusion debug log messages\\n \\\"\\\"\\\"\\n\\n def __init__(self, limit=100, collide=False):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n collide : bool\\n if True, deduplicate a subsequent message by replacing a common\\n prefix string with an ellipsis.\\n \\\"\\\"\\\"\\n self.__prev = \\\"\\\"\\n self.limit = limit\\n self.collide = collide\\n\\n # delayed imports and preparing the regex substitution\\n if collide:\\n import re\\n self.__prefix_re = re.compile('>[^>]*$')\\n else:\\n self.__prefix_re = None\\n\\n def _extract_stack(self, limit=None):\\n \\\"\\\"\\\"Call traceback.extract_stack() with limit parameter\\n\\n Parameters\\n ----------\\n limit: int, optional\\n Limit stack trace entries (starting from the invocation point)\\n if limit is positive, or to the last `abs(limit)` entries.\\n If limit is omitted or None, all entries are printed.\\n\\n Returns\\n -------\\n traceback.StackSummary\\n \\\"\\\"\\\"\\n import traceback\\n return traceback.extract_stack(limit=limit)\\n\\n def __call__(self):\\n # get the stack description. All but the last three items, which\\n # represent the entry into this utility rather than the traceback\\n # relevant for the caller\\n ftb = self._extract_stack(limit=self.limit + 10)[:-3]\\n # each item in `ftb` is\\n # (filename, line, object, code-on-line)\\n # so entries is a list of (filename, line)\\n entries = [\\n [mbasename(x[0]), str(x[1])] for x in ftb\\n # the last entry in the filtered list will always come from\\n # this datalad/log.py facility, where the log record\\n # was emitted, it is not meaningful to always show a constant\\n # trailing end of the traceback\\n # more generally, we are hardly ever interested in traceback\\n # pieces from this file\\n if x[0] != __file__\\n ]\\n # remove more \\\"uninformative\\\" levels of the stack, given the space\\n # constraints of a log message\\n entries = [\\n e for e in entries\\n if e[0] not in ('unittest', 'logging.__init__')\\n ]\\n\\n if len(entries) > self.limit:\\n sftb = '…>'\\n entries = entries[-self.limit:]\\n else:\\n sftb = ''\\n\\n if not entries:\\n return \\\"\\\"\\n\\n # let's make it more concise\\n entries_out = [entries[0]]\\n for entry in entries[1:]:\\n # if the current filename is the same as the last one on the stack\\n # only append the line number to save space\\n if entry[0] == entries_out[-1][0]:\\n entries_out[-1][1] += ',%s' % entry[1]\\n else:\\n entries_out.append(entry)\\n\\n # format the traceback in a compact form\\n sftb += '>'.join(\\n ['%s:%s' % (mbasename(x[0]), x[1]) for x in entries_out]\\n )\\n\\n if self.collide:\\n # lets remove part which is common with previous invocation\\n prev_next = sftb\\n common_prefix = os.path.commonprefix((self.__prev, sftb))\\n common_prefix2 = self.__prefix_re.sub('', common_prefix)\\n\\n if common_prefix2 != \\\"\\\":\\n sftb = '…' + sftb[len(common_prefix2):]\\n self.__prev = prev_next\\n\\n return sftb\\n\\n\\nclass MemoryInfo(object):\\n def __init__(self):\\n try:\\n from psutil import Process\\n process = Process(os.getpid())\\n self.memory_info = process.memory_info \\\\\\n if hasattr(process, 'memory_info') \\\\\\n else process.get_memory_info\\n except:\\n self.memory_info = None\\n\\n\\n def __call__(self):\\n \\\"\\\"\\\"Return utilization of virtual memory\\n\\n Generic implementation using psutil\\n \\\"\\\"\\\"\\n if not self.memory_info:\\n return \\\"RSS/VMS: N/A\\\"\\n mi = self.memory_info()\\n # in later versions of psutil mi is a named tuple.\\n # but that is not the case on Debian squeeze with psutil 0.1.3\\n rss = mi[0] / 1024\\n vms = mi[1] / 1024\\n vmem = (rss, vms)\\n\\n try:\\n return \\\"RSS/VMS: %d/%d kB\\\" % vmem\\n except:\\n return \\\"RSS/VMS: %s\\\" % str(vmem)\\n\\n# Recipe from http://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output\\n# by Brandon Thomson\\n# Adjusted for automagic determination whether coloring is needed and\\n# prefixing of multiline log lines\\nclass ColorFormatter(logging.Formatter):\\n\\n def __init__(self, use_color=None, log_name=False, log_pid=False):\\n if use_color is None:\\n # if 'auto' - use color only if all streams are tty\\n use_color = is_interactive()\\n self.use_color = use_color and platform.system() != 'Windows' # don't use color on windows\\n msg = colors.format_msg(self._get_format(log_name, log_pid),\\n self.use_color)\\n log_env = os.environ.get('DATALAD_LOG_TRACEBACK', '')\\n collide = log_env == 'collide'\\n # if an integer level is given, we add one level to make the behavior\\n # more natural. The last frame will always be where the log record\\n # was emitted by out handler. However, user is more interested in the\\n # location where the log message originates.\\n # Saying DATALAD_LOG_TRACEBACK=1 will give that in most cases, with\\n # this internal increment\\n limit = 100 if collide else int(log_env) + 1 if log_env.isdigit() else 100\\n self._tb = TraceBack(collide=collide, limit=limit) if log_env else None\\n\\n self._mem = MemoryInfo() if os.environ.get('DATALAD_LOG_VMEM', '') else None\\n logging.Formatter.__init__(self, msg)\\n\\n def _get_format(self, log_name=False, log_pid=False):\\n from datalad import cfg\\n from datalad.config import anything2bool\\n show_timestamps = anything2bool(cfg.get('datalad.log.timestamp', False))\\n return ((\\\"\\\" if not show_timestamps else \\\"$BOLD%(asctime)-15s$RESET \\\") +\\n (\\\"%(name)-15s \\\" if log_name else \\\"\\\") +\\n (\\\"{%(process)d}\\\" if log_pid else \\\"\\\") +\\n \\\"[%(levelname)s] \\\"\\n \\\"%(message)s \\\")\\n\\n def format(self, record):\\n # safety guard if None was provided\\n if record.msg is None:\\n record.msg = \\\"\\\"\\n else:\\n # to avoid our logger puking on receiving exception instances etc.\\n # .getMessage, used to interpolate it, would cast it to str anyways\\n # and thus not puke\\n record.msg = str(record.msg)\\n if record.msg.startswith('| '):\\n # If we already log smth which supposed to go without formatting, like\\n # output for running a command, just return the message and be done\\n return record.msg\\n\\n levelname = record.levelname\\n\\n if self.use_color and levelname in colors.LOG_LEVEL_COLORS:\\n record.levelname = colors.color_word(\\n \\\"{:7}\\\".format(levelname),\\n colors.LOG_LEVEL_COLORS[levelname],\\n force=True)\\n record.msg = record.msg.replace(\\\"\\\\n\\\", \\\"\\\\n| \\\")\\n if self._tb:\\n if not getattr(record, 'notraceback', False):\\n record.msg = self._tb() + \\\" \\\" + record.msg\\n if self._mem:\\n record.msg = \\\"%s %s\\\" % (self._mem(), record.msg)\\n\\n return logging.Formatter.format(self, record)\\n\\n\\nclass ProgressHandler(logging.Handler):\\n from datalad.ui import ui\\n\\n def __init__(self, other_handler=None):\\n super(self.__class__, self).__init__()\\n self._other_handler = other_handler\\n self.pbars = {}\\n\\n def close(self):\\n if self._other_handler:\\n self._other_handler.close()\\n super().close()\\n\\n def emit(self, record):\\n from datalad.ui import ui\\n if not hasattr(record, 'dlm_progress'):\\n self._clear_all()\\n self._other_handler.emit(record)\\n self._refresh_all()\\n return\\n maint = getattr(record, 'dlm_progress_maint', None)\\n if maint == 'clear':\\n return self._clear_all()\\n elif maint == 'refresh':\\n return self._refresh_all()\\n pid = getattr(record, 'dlm_progress')\\n update = getattr(record, 'dlm_progress_update', None)\\n # would be an actual message, not used ATM here,\\n # and the record not passed to generic handler ATM\\n # (filtered away by NoProgressLog)\\n # so no final message is printed\\n # msg = record.getMessage()\\n if pid not in self.pbars:\\n # this is new\\n pbar = ui.get_progressbar(\\n label=getattr(record, 'dlm_progress_label', ''),\\n unit=getattr(record, 'dlm_progress_unit', ''),\\n total=getattr(record, 'dlm_progress_total', None,),\\n )\\n pbar.start(initial=getattr(record, 'dlm_progress_initial', 0))\\n self.pbars[pid] = pbar\\n elif update is None:\\n # not an update -> done\\n # TODO if the other logging that is happening is less frontpage\\n # we may want to actually \\\"print\\\" the completion message\\n self.pbars.pop(pid).finish()\\n else:\\n # Check for an updated label.\\n label = getattr(record, 'dlm_progress_label', None)\\n if label is not None:\\n self.pbars[pid].set_desc(label)\\n # an update\\n self.pbars[pid].update(\\n update,\\n increment=getattr(record, 'dlm_progress_increment', False),\\n total=getattr(record, 'dlm_progress_total', None))\\n\\n def _refresh_all(self):\\n for pb in self.pbars.values():\\n pb.refresh()\\n\\n def _clear_all(self):\\n # remove the progress bar\\n for pb in self.pbars.values():\\n pb.clear()\\n\\n\\ndef filter_noninteractive_progress(logger, record):\\n \\\"\\\"\\\"Companion of log_progress() to suppress undesired progress logging\\n\\n This filter is to be used with a log handler's addFilter() method\\n for the case of a non-interactive session (e.g., pipe to log file).\\n\\n It inspects the log record for `dlm_progress_noninteractive_level`\\n keys that can be injected via log_progress(noninteractive_level=).\\n\\n If a log-level was declared in this fashion, it will be evaluated\\n against the logger's effective level, and records are discarded\\n if their level is too low. If no log-level was declared, a log record\\n passes this filter unconditionally.\\n\\n Parameters\\n ----------\\n logger: logging.Logger\\n The logger instance whose effective level to check against.\\n record:\\n The log record to inspect.\\n\\n Returns\\n -------\\n bool\\n \\\"\\\"\\\"\\n level = getattr(record, \\\"dlm_progress_noninteractive_level\\\", None)\\n return level is None or level >= logger.level\\n\\n\\ndef log_progress(lgrcall, pid, *args, **kwargs):\\n \\\"\\\"\\\"Emit progress log messages\\n\\n This helper can be used to handle progress reporting without having\\n to maintain display mode specific code.\\n\\n Typical progress reporting via this function involves three types of\\n calls:\\n\\n 1. Start reporting progress about a process\\n 2. Update progress information about a process\\n 3. Report completion of a process\\n\\n In order to be able to associate all three steps with a particular process,\\n the `pid` identifier is used. This is an arbitrary string that must be\\n chosen to be unique across all different, but simultaneously running\\n progress reporting activities within a Python session. For many practical\\n purposes this can be achieved by, for example, including path information\\n in the identifier.\\n\\n To initialize a progress report this function is called without an\\n `update` parameter. To report a progress update, this function is called\\n with an `update` parameter. To finish a reporting on a particular activity\\n a final call without an `update` parameter is required.\\n\\n\\n Parameters\\n ----------\\n lgrcall : callable\\n Something like lgr.debug or lgr.info\\n pid : str\\n Some kind of ID for the process the progress is reported on.\\n *args : str\\n Log message, and potential arguments\\n total : int\\n Max progress quantity of the process.\\n label : str\\n Process description. Should be very brief, goes in front of progress bar\\n on the same line.\\n unit : str\\n Progress report unit. Should be very brief, goes after the progress bar\\n on the same line.\\n update : int\\n To (or by) which quantity to advance the progress. Also see `increment`.\\n increment : bool\\n If set, `update` is interpreted as an incremental value, not absolute.\\n initial : int\\n If set, start value for progress bar\\n noninteractive_level : int, optional\\n In a non-interactive session where progress bars are not displayed,\\n only log a progress report, if a logger's effective level includes the\\n specified level. This can be useful logging all progress is inappropriate\\n or too noisy for a log.\\n maint : {'clear', 'refresh'}\\n This is a special attribute that can be used by callers that are not\\n actually reporting progress, but need to ensure that their (console)\\n output does not interfere with any possibly ongoing progress reporting.\\n Setting this attribute to 'clear' will cause the central ProgressHandler\\n to temporarily stop the display of any active progress bars. With\\n 'refresh', all active progress bars will be redisplayed. After a 'clear'\\n individual progress bars would be reactivated upon the next update log\\n message, even without an explicit 'refresh'.\\n \\\"\\\"\\\"\\n d = dict(\\n # inject progress-related result properties as extra data\\n {'dlm_progress_{}'.format(n): v for n, v in kwargs.items()\\n # initial progress might be zero, but not sending it further\\n # would signal to destroy the progress bar, hence test for 'not None'\\n if v is not None},\\n dlm_progress=pid)\\n lgrcall(*args, extra=d)\\n\\n\\n@optional_args\\ndef with_result_progress(fn, label=\\\"Total\\\", unit=\\\" Files\\\", log_filter=None):\\n \\\"\\\"\\\"Wrap a progress bar, with status counts, around a function.\\n\\n Parameters\\n ----------\\n fn : generator function\\n This function should accept a collection of items as a\\n positional argument and any number of keyword arguments. After\\n processing each item in the collection, it should yield a status\\n dict.\\n log_filter : callable, optional\\n If defined, only result records for which callable evaluates to True will be\\n passed to log_progress\\n\\n label, unit : str\\n Passed to log.log_progress.\\n\\n Returns\\n -------\\n A variant of `fn` that shows a progress bar. Note that the wrapped\\n function is not a generator function; the status dicts will be\\n returned as a list.\\n \\\"\\\"\\\"\\n # FIXME: This emulates annexrepo.ProcessAnnexProgressIndicators. It'd be\\n # nice to rewire things so that it could be used directly.\\n\\n def count_str(count, verb, omg=False):\\n if count:\\n msg = \\\"{:d} {}\\\".format(count, verb)\\n if omg:\\n msg = colors.color_word(msg, colors.RED)\\n return msg\\n\\n\\n base_label = label\\n\\n def _wrap_with_result_progress_(items, *args, **kwargs):\\n counts = defaultdict(int)\\n\\n pid = \\\"%s:%s\\\" % (fn, random.randint(0, 100000))\\n\\n label = base_label\\n log_progress(lgr.info, pid,\\n \\\"%s: starting\\\", label,\\n total=len(items), label=label, unit=unit,\\n noninteractive_level=5)\\n\\n for res in fn(items, *args, **kwargs):\\n if not (log_filter and not log_filter(res)):\\n counts[res[\\\"status\\\"]] += 1\\n count_strs = (count_str(*args)\\n for args in [(counts[\\\"notneeded\\\"], \\\"skipped\\\", False),\\n (counts[\\\"error\\\"], \\\"failed\\\", True)])\\n if counts[\\\"notneeded\\\"] or counts[\\\"error\\\"]:\\n label = \\\"{} ({})\\\".format(\\n base_label,\\n \\\", \\\".join(filter(None, count_strs)))\\n\\n log_progress(\\n lgr.error if res[\\\"status\\\"] == \\\"error\\\" else lgr.info,\\n pid,\\n \\\"%s: processed result%s\\\", base_label,\\n \\\" for \\\" + res[\\\"path\\\"] if \\\"path\\\" in res else \\\"\\\",\\n label=label, update=1, increment=True,\\n noninteractive_level=5)\\n yield res\\n log_progress(lgr.info, pid, \\\"%s: done\\\", base_label,\\n noninteractive_level=5)\\n\\n def _wrap_with_result_progress(items, *args, **kwargs):\\n return list(_wrap_with_result_progress_(items, *args, **kwargs))\\n\\n return _wrap_with_result_progress_ \\\\\\n if inspect.isgeneratorfunction(fn) \\\\\\n else _wrap_with_result_progress\\n\\n\\ndef with_progress(items, lgrcall=None, label=\\\"Total\\\", unit=\\\" Files\\\"):\\n \\\"\\\"\\\"Wrap a progress bar, with status counts, around an iterable.\\n\\n Parameters\\n ----------\\n items : some iterable\\n lgrcall: callable\\n Callable for logging. If not specified - lgr.info is used\\n label, unit : str\\n Passed to log.log_progress.\\n\\n Yields\\n ------\\n Items of it while displaying the progress\\n \\\"\\\"\\\"\\n pid = \\\"with_progress-%d\\\" % random.randint(0, 100000)\\n base_label = label\\n if lgrcall is None:\\n lgrcall = lgr.info\\n\\n label = base_label\\n log_progress(lgrcall, pid,\\n \\\"%s: starting\\\", label,\\n total=len(items), label=label, unit=unit,\\n noninteractive_level=5)\\n\\n for item in items:\\n # Since we state \\\"processed\\\", and actual processing might be happening\\n # outside on the yielded value, we will yield before stating that\\n yield item\\n log_progress(\\n lgrcall,\\n pid,\\n \\\"%s: processed\\\", base_label,\\n label=label, update=1, increment=True,\\n noninteractive_level=5)\\n log_progress(lgr.info, pid, \\\"%s: done\\\", base_label, noninteractive_level=5)\\n\\n\\n@contextmanager\\ndef no_progress():\\n \\\"\\\"\\\"Context manager to clear progress bars for the duration of the context\\\"\\\"\\\"\\n log_progress(lgr.info, None, 'Clear progress bars', maint='clear',\\n noninteractive_level=5)\\n yield\\n log_progress(lgr.info, None, 'Refresh progress bars', maint='refresh',\\n noninteractive_level=5)\\n\\n\\nclass LoggerHelper(object):\\n \\\"\\\"\\\"Helper to establish and control a Logger\\\"\\\"\\\"\\n\\n def __init__(self, name='datalad', logtarget=None):\\n \\\"\\\"\\\"\\n\\n Parameters\\n ----------\\n name :\\n logtarget : string, optional\\n If we want to use our logger for other log targets, while having\\n a uniform control over them\\n \\\"\\\"\\\"\\n self.name = name\\n self.logtarget = logtarget\\n self.lgr = logging.getLogger(logtarget if logtarget is not None else name)\\n\\n def _get_config(self, var, default=None):\\n from datalad import cfg\\n return cfg.get(self.name.lower() + '.log.' + var, default)\\n\\n def set_level(self, level=None, default='INFO'):\\n \\\"\\\"\\\"Helper to set loglevel for an arbitrary logger\\n\\n By default operates for 'datalad'.\\n TODO: deduce name from upper module name so it could be reused without changes\\n \\\"\\\"\\\"\\n if level is None:\\n # see if nothing in the environment\\n level = self._get_config('level')\\n if level is None:\\n level = default\\n\\n try:\\n # it might be a string which still represents an int\\n log_level = int(level)\\n except ValueError:\\n # or a string which corresponds to a constant;)\\n log_level = getattr(logging, level.upper())\\n\\n self.lgr.setLevel(log_level)\\n # and set other related/used loggers to the same level to prevent their\\n # talkativity, if they are not yet known to this python session, so we\\n # have little chance to \\\"override\\\" possibly set outside levels\\n for dep in ('git',):\\n if dep not in logging.Logger.manager.loggerDict:\\n logging.getLogger(dep).setLevel(log_level)\\n\\n def get_initialized_logger(self, logtarget=None):\\n \\\"\\\"\\\"Initialize and return the logger\\n\\n Parameters\\n ----------\\n logtarget: {'stderr', str }, optional\\n Where to direct the logs. 'stderr' stands for the standard stream.\\n Any other string is considered a filename. Multiple entries could be\\n specified comma-separated\\n\\n Returns\\n -------\\n logging.Logger\\n \\\"\\\"\\\"\\n if not logtarget:\\n logtarget = self._get_config('target', 'stderr')\\n\\n # Allow for multiple handlers being specified, comma-separated\\n if ',' in logtarget:\\n for handler_ in logtarget.split(','):\\n self.get_initialized_logger(logtarget=handler_)\\n return self.lgr\\n\\n if logtarget.lower() == 'stderr':\\n loghandler = logging.StreamHandler(sys.stderr)\\n use_color = is_interactive() # explicitly decide here\\n elif logtarget.lower() == 'stdout':\\n warnings.warn(\\\"'stdout' was discontinued as valid log target and \\\"\\n \\\"will be ignored.\\\", DeprecationWarning)\\n else:\\n # must be a simple filename\\n # Use RotatingFileHandler for possible future parametrization to keep\\n # log succinct and rotating\\n loghandler = logging.handlers.RotatingFileHandler(logtarget)\\n use_color = False\\n # I had decided not to guard this call and just raise exception to go\\n # out happen that specified file location is not writable etc.\\n\\n for names_filter in 'names', 'namesre':\\n names = self._get_config(names_filter, '')\\n if names:\\n import re\\n # add a filter which would catch those\\n class LogFilter(object):\\n \\\"\\\"\\\"A log filter to filter based on the log target name(s)\\\"\\\"\\\"\\n def __init__(self, names):\\n self.target_names = set(n for n in names.split(',')) \\\\\\n if names_filter == 'names' \\\\\\n else re.compile(names)\\n if names_filter == 'names':\\n def filter(self, record):\\n return record.name in self.target_names\\n else:\\n def filter(self, record):\\n return self.target_names.match(record.name)\\n\\n loghandler.addFilter(LogFilter(names))\\n\\n # But now improve with colors and useful information such as time\\n loghandler.setFormatter(\\n ColorFormatter(use_color=use_color,\\n # TODO: config log.name, pid\\n log_name=self._get_config(\\\"name\\\", False),\\n log_pid=self._get_config(\\\"pid\\\", False),\\n ))\\n # logging.Formatter('%(asctime)-15s %(levelname)-6s %(message)s'))\\n if is_interactive():\\n phandler = ProgressHandler(other_handler=loghandler)\\n phandler.filters.extend(loghandler.filters)\\n self.lgr.addHandler(phandler)\\n else:\\n loghandler.addFilter(partial(filter_noninteractive_progress,\\n self.lgr))\\n self.lgr.addHandler(loghandler)\\n\\n self.set_level() # set default logging level\\n return self.lgr\\n\\n\\nlgr = LoggerHelper().get_initialized_logger()\\n\"\n },\n {\n \"alpha_fraction\": 0.5271317958831787,\n \"alphanum_fraction\": 0.5400516986846924,\n \"avg_line_length\": 15.69565200805664,\n \"blob_id\": \"b25e137ac8cd39655b4471bbd21c3649e1f21532\",\n \"content_id\": \"cc56f8e728eda85847b97618c26b6a5112687412\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 387,\n \"license_type\": \"permissive\",\n \"max_line_length\": 42,\n \"num_lines\": 23,\n \"path\": \"/datalad/cli/tests/test_renderer.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from datalad.tests.utils_pytest import eq_\\n\\nfrom ..renderer import (\\n NA_STRING,\\n nadict,\\n nagen,\\n)\\n\\n\\ndef test_nagen():\\n na = nagen()\\n eq_(str(na), NA_STRING)\\n eq_(repr(na), 'nagen()')\\n assert na.unknown is na\\n assert na['unknown'] is na\\n\\n eq_(str(nagen('-')), '-')\\n\\n\\ndef test_nadict():\\n d = nadict({1: 2})\\n eq_(d[1], 2)\\n eq_(str(d[2]), NA_STRING)\\n\\n\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.6142823696136475,\n \"alphanum_fraction\": 0.6164463758468628,\n \"avg_line_length\": 34.65797805786133,\n \"blob_id\": \"fb3f318213a154602e2e62d74e98b8a59668aff6\",\n \"content_id\": \"019e138517abc635f14640db718c88c6cb7337c7\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 34196,\n \"license_type\": \"permissive\",\n \"max_line_length\": 97,\n \"num_lines\": 959,\n \"path\": \"/datalad/interface/base.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"High-level interface generation\\n\\n\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\nimport inspect\\nimport logging\\n\\nlgr = logging.getLogger('datalad.interface.base')\\n\\nimport os\\nimport re\\nimport textwrap\\nimport warnings\\nfrom abc import (\\n ABC,\\n abstractmethod,\\n)\\n\\nfrom functools import wraps\\nfrom importlib import import_module\\nfrom typing import (\\n Callable,\\n Dict,\\n Generator,\\n TypeVar,\\n TYPE_CHECKING,\\n)\\n\\nimport datalad\\nfrom datalad import cfg as dlcfg\\nfrom datalad.core.local.resulthooks import (\\n get_jsonhooks_from_config,\\n match_jsonhook2result,\\n run_jsonhook,\\n)\\nfrom datalad.distribution.dataset import (\\n Dataset,\\n resolve_path,\\n)\\nfrom datalad.interface.common_opts import eval_params\\nfrom datalad.interface.results import known_result_xfms\\nfrom datalad.interface.utils import (\\n get_result_filter,\\n keep_result,\\n render_action_summary,\\n xfm_result,\\n _process_results\\n)\\nfrom datalad.support.exceptions import (\\n CapturedException,\\n IncompleteResultsError,\\n)\\nfrom datalad.utils import get_wrapped_class\\n\\ndefault_logchannels = {\\n '': 'debug',\\n 'ok': 'debug',\\n 'notneeded': 'debug',\\n 'impossible': 'warning',\\n 'error': 'error',\\n}\\nif TYPE_CHECKING:\\n from .base import Interface\\n\\nanInterface = TypeVar('anInterface', bound='Interface')\\n\\n\\ndef get_api_name(intfspec):\\n \\\"\\\"\\\"Given an interface specification return an API name for it\\\"\\\"\\\"\\n if len(intfspec) > 3:\\n name = intfspec[3]\\n else:\\n name = intfspec[0].split('.')[-1]\\n return name\\n\\n\\ndef get_interface_groups(include_plugins=False):\\n \\\"\\\"\\\"Return a list of command groups.\\n\\n Returns\\n -------\\n A list of tuples with the form (GROUP_NAME, GROUP_DESCRIPTION, COMMANDS).\\n \\\"\\\"\\\"\\n if include_plugins:\\n warnings.warn(\\\"Plugins are no longer supported.\\\", DeprecationWarning)\\n\\n from .. import interface as _interfaces\\n\\n grps = []\\n # auto detect all available interfaces and generate a function-based\\n # API from them\\n for _item in _interfaces.__dict__:\\n if not _item.startswith('_group_'):\\n continue\\n grp_name = _item[7:]\\n grp = getattr(_interfaces, _item)\\n grps.append((grp_name,) + grp)\\n return grps\\n\\n\\ndef get_cmd_summaries(descriptions, groups, width=79):\\n \\\"\\\"\\\"Return summaries for the commands in `groups`.\\n\\n Parameters\\n ----------\\n descriptions : dict\\n A map of group names to summaries.\\n groups : list of tuples\\n A list of groups and commands in the form described by\\n `get_interface_groups`.\\n width : int, optional\\n The maximum width of each line in the summary text.\\n\\n Returns\\n -------\\n A list with a formatted entry for each command. The first command of each\\n group is preceded by an entry describing the group.\\n \\\"\\\"\\\"\\n cmd_summary = []\\n for grp in sorted(groups, key=lambda x: x[0]):\\n grp_descr = grp[1]\\n grp_cmds = descriptions[grp[0]]\\n\\n cmd_summary.append('\\\\n*%s*\\\\n' % (grp_descr,))\\n for cd in grp_cmds:\\n cmd_summary.append(' %s\\\\n%s'\\n % ((cd[0],\\n textwrap.fill(\\n cd[1].rstrip(' .'),\\n width - 5,\\n initial_indent=' ' * 6,\\n subsequent_indent=' ' * 6))))\\n return cmd_summary\\n\\n\\ndef load_interface(spec):\\n \\\"\\\"\\\"Load and return the class for `spec`.\\n\\n Parameters\\n ----------\\n spec : tuple\\n For a standard interface, the first item is the datalad source module\\n and the second object name for the interface.\\n\\n Returns\\n -------\\n The interface class or, if importing the module fails, None.\\n \\\"\\\"\\\"\\n lgr.log(5, \\\"Importing module %s \\\", spec[0])\\n try:\\n mod = import_module(spec[0], package='datalad')\\n except Exception as e:\\n ce = CapturedException(e)\\n lgr.error(\\\"Internal error, cannot import interface '%s': %s\\\",\\n spec[0], ce)\\n intf = None\\n else:\\n intf = getattr(mod, spec[1])\\n return intf\\n\\n\\ndef get_cmd_doc(interface):\\n \\\"\\\"\\\"Return the documentation for the command defined by `interface`.\\n\\n Parameters\\n ----------\\n interface : subclass of Interface\\n \\\"\\\"\\\"\\n intf_doc = '' if interface.__doc__ is None else interface.__doc__.strip()\\n if hasattr(interface, '_docs_'):\\n # expand docs\\n intf_doc = intf_doc.format(**interface._docs_)\\n return intf_doc\\n\\n\\ndef dedent_docstring(text):\\n \\\"\\\"\\\"Remove uniform indentation from a multiline docstring\\\"\\\"\\\"\\n # Problem is that first line might often have no offset, so might\\n # need to be ignored from dedent call\\n if text is None:\\n return None\\n if not text.startswith(' '):\\n lines = text.split('\\\\n')\\n if len(lines) == 1:\\n # single line, no indentation, nothing to do\\n return text\\n text2 = '\\\\n'.join(lines[1:])\\n return lines[0] + \\\"\\\\n\\\" + textwrap.dedent(text2)\\n else:\\n return textwrap.dedent(text)\\n\\n\\ndef alter_interface_docs_for_api(docs):\\n \\\"\\\"\\\"Apply modifications to interface docstrings for Python API use.\\\"\\\"\\\"\\n # central place to alter the impression of docstrings,\\n # like removing cmdline specific sections\\n if not docs:\\n return docs\\n docs = dedent_docstring(docs)\\n # clean cmdline sections\\n docs = re.sub(\\n r'\\\\|\\\\| CMDLINE \\\\>\\\\>.*?\\\\<\\\\< CMDLINE \\\\|\\\\|',\\n '',\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n # clean cmdline in-line bits\\n docs = re.sub(\\n r'\\\\[CMD:\\\\s.*?\\\\sCMD\\\\]',\\n '',\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n docs = re.sub(\\n r'\\\\[PY:\\\\s(.*?)\\\\sPY\\\\]',\\n lambda match: match.group(1),\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n # select only the python alternative from argument specifications\\n docs = re.sub(\\n r'``([a-zA-Z0-9_,.]+)\\\\|\\\\|([a-zA-Z0-9-,.]+)``',\\n lambda match: f'``{match.group(1)}``',\\n docs)\\n docs = re.sub(\\n r'\\\\|\\\\| PYTHON \\\\>\\\\>(.*?)\\\\<\\\\< PYTHON \\\\|\\\\|',\\n lambda match: match.group(1),\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n if 'DATALAD_SPHINX_RUN' not in os.environ:\\n # remove :role:`...` RST markup for cmdline docs\\n docs = re.sub(\\n r':\\\\S+:`[^`]*`[\\\\\\\\]*',\\n lambda match: ':'.join(match.group(0).split(':')[2:]).strip('`\\\\\\\\'),\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n # make the handbook doc references more accessible\\n # the URL is a redirect configured at readthedocs\\n docs = re.sub(\\n r'(handbook:[0-9]-[0-9]*)',\\n '\\\\\\\\1 (http://handbook.datalad.org/symbols)',\\n docs)\\n docs = re.sub(\\n r'^([ ]*)\\\\|\\\\| REFLOW \\\\>\\\\>\\\\n(.*?)\\\\<\\\\< REFLOW \\\\|\\\\|',\\n lambda match: textwrap.fill(match.group(2), subsequent_indent=match.group(1)),\\n docs,\\n flags=re.MULTILINE | re.DOTALL)\\n return docs\\n\\n\\ndef is_api_arg(arg):\\n \\\"\\\"\\\"Return True if argument is our API argument or self or used for internal\\n purposes\\n \\\"\\\"\\\"\\n return arg != 'self' and not arg.startswith('_')\\n\\n\\ndef update_docstring_with_parameters(func, params, prefix=None, suffix=None,\\n add_args=None):\\n \\\"\\\"\\\"Generate a useful docstring from a parameter spec\\n\\n Amends any existing docstring of a callable with a textual\\n description of its parameters. The Parameter spec needs to match\\n the number and names of the callables arguments.\\n \\\"\\\"\\\"\\n from datalad.utils import getargspec\\n\\n # get the signature\\n args, varargs, varkw, defaults = getargspec(func, include_kwonlyargs=True)\\n defaults = defaults or tuple()\\n if add_args:\\n add_argnames = sorted(add_args.keys())\\n args.extend(add_argnames)\\n defaults = defaults + tuple(add_args[k] for k in add_argnames)\\n ndefaults = len(defaults)\\n # start documentation with what the callable brings with it\\n doc = prefix if prefix else u''\\n if len(args) > 1:\\n if len(doc):\\n if not doc.endswith('\\\\n'):\\n doc += '\\\\n'\\n doc += '\\\\n'\\n doc += \\\"Parameters\\\\n----------\\\\n\\\"\\n for i, arg in enumerate(args):\\n if not is_api_arg(arg):\\n continue\\n # we need a parameter spec for each argument\\n if not arg in params:\\n raise ValueError(\\\"function has argument '%s' not described as a parameter\\\" % arg)\\n param = params[arg]\\n # validate the default -- to make sure that the parameter description is\\n # somewhat OK\\n defaults_idx = ndefaults - len(args) + i\\n if defaults_idx >= 0:\\n if param.constraints is not None:\\n param.constraints(defaults[defaults_idx])\\n orig_docs = param._doc\\n param._doc = alter_interface_docs_for_api(param._doc)\\n doc += param.get_autodoc(\\n arg,\\n default=defaults[defaults_idx] if defaults_idx >= 0 else None,\\n has_default=defaults_idx >= 0)\\n param._doc = orig_docs\\n doc += '\\\\n'\\n doc += suffix if suffix else u\\\"\\\"\\n # assign the amended docs\\n func.__doc__ = doc\\n return func\\n\\n\\n# TODO should export code_field and indicator, rather than have modes\\n# TODO this should be a doc helper\\ndef build_example(example, api='python'):\\n \\\"\\\"\\\"Build a code example.\\n\\n Take a dict from a classes _example_ specification (list of dicts) and\\n build a string with an api or cmd example (for use in cmd help or\\n docstring).\\n\\n Parameters\\n ----------\\n api : {'python', 'cmdline'}\\n If 'python', build Python example for docstring. If 'cmdline', build\\n cmd example.\\n\\n Returns\\n -------\\n ex : str\\n Concatenated examples for the given class.\\n \\\"\\\"\\\"\\n if api == 'python' :\\n code_field='code_py'\\n indicator='>'\\n elif api == 'cmdline':\\n code_field='code_cmd'\\n indicator='%'\\n else:\\n raise ValueError(\\\"unknown API selection: {}\\\".format(api))\\n if code_field not in example:\\n # only show an example if it exist for the API\\n return ''\\n description = textwrap.fill(example.get('text'))\\n # this indent the code snippet to get it properly rendered as code\\n # we are not using textwrap.fill(), because it would not acknowledge\\n # any meaningful structure/formatting of code snippets. Instead, we\\n # maintain line content as is.\\n code = dedent_docstring(example.get(code_field))\\n needs_indicator = not code.startswith(indicator)\\n code = textwrap.indent(code, ' ' * (5 if needs_indicator else 3)).lstrip()\\n\\n ex = \\\"\\\"\\\"{}::\\\\n\\\\n {}{}\\\\n\\\\n\\\"\\\"\\\".format(\\n description,\\n # disable automatic prefixing, if the example already has one\\n # this enables providing more complex examples without having\\n # to infer its inner structure\\n '{} '.format(indicator)\\n if needs_indicator\\n # maintain spacing to avoid undesired relative indentation\\n else '',\\n code)\\n\\n return ex\\n\\n\\ndef update_docstring_with_examples(cls_doc, ex):\\n \\\"\\\"\\\"Update a commands docstring with examples.\\n\\n Take _examples_ of a command, build the Python examples, and append\\n them to the docstring.\\n\\n Parameters\\n ----------\\n cls_doc: str\\n docstring\\n ex: list\\n list of dicts with examples\\n \\\"\\\"\\\"\\n from textwrap import indent\\n if len(cls_doc):\\n cls_doc += \\\"\\\\n\\\"\\n cls_doc += \\\" Examples\\\\n --------\\\\n\\\"\\n # loop though provided examples\\n for example in ex:\\n cls_doc += indent(build_example(example, api='python'), ' '*4)\\n\\n return cls_doc\\n\\n\\ndef build_doc(cls, **kwargs):\\n \\\"\\\"\\\"Decorator to build docstrings for datalad commands\\n\\n It's intended to decorate the class, the __call__-method of which is the\\n actual command. It expects that __call__-method to be decorated by\\n eval_results.\\n\\n Note that values for any `eval_params` keys in `cls._params_` are\\n ignored. This means one class may extend another's `_params_`\\n without worrying about filtering out `eval_params`.\\n\\n Parameters\\n ----------\\n cls: Interface\\n DataLad command implementation\\n \\\"\\\"\\\"\\n if datalad.in_librarymode():\\n lgr.debug(\\\"Not assembling DataLad API docs in libary-mode\\\")\\n return cls\\n\\n # Note, that this is a class decorator, which is executed only once when the\\n # class is imported. It builds the docstring for the class' __call__ method\\n # and returns the original class.\\n #\\n # This is because a decorator for the actual function would not be able to\\n # behave like this. To build the docstring we need to access the attribute\\n # _params of the class. From within a function decorator we cannot do this\\n # during import time, since the class is being built in this very moment and\\n # is not yet available in the module. And if we do it from within the part\\n # of a function decorator, that is executed when the function is called, we\\n # would need to actually call the command once in order to build this\\n # docstring.\\n\\n lgr.debug(\\\"Building doc for %s\\\", cls)\\n\\n cls_doc = cls.__doc__\\n if hasattr(cls, '_docs_'):\\n # expand docs\\n cls_doc = cls_doc.format(**cls._docs_)\\n # get examples\\n ex = getattr(cls, '_examples_', [])\\n if ex:\\n cls_doc = update_docstring_with_examples(cls_doc, ex)\\n\\n call_doc = None\\n # suffix for update_docstring_with_parameters:\\n if cls.__call__.__doc__:\\n call_doc = cls.__call__.__doc__\\n\\n # build standard doc and insert eval_doc\\n spec = getattr(cls, '_params_', dict())\\n\\n\\n # update class attributes that may override defaults\\n if not _has_eval_results_call(cls):\\n add_args = None\\n else:\\n # defaults for all common parameters are guaranteed to be available\\n # from the class\\n add_args = {k: getattr(cls, k) for k in eval_params}\\n\\n # ATTN: An important consequence of this update() call is that it\\n # fulfills the docstring's promise of overriding any existing\\n # values for eval_params keys in _params_.\\n #\\n\\n # get docs for eval_results parameters:\\n spec.update(eval_params)\\n\\n update_docstring_with_parameters(\\n cls.__call__, spec,\\n prefix=alter_interface_docs_for_api(cls_doc),\\n suffix=alter_interface_docs_for_api(call_doc),\\n add_args=add_args\\n )\\n\\n if hasattr(cls.__call__, '_dataset_method'):\\n cls.__call__._dataset_method.__doc__ = cls.__call__.__doc__\\n\\n # return original\\n return cls\\n\\n\\nclass Interface(ABC):\\n '''Abstract base class for DataLad command implementations\\n\\n Any DataLad command implementation must be derived from this class. The\\n code snippet below shows a complete sketch of a Python class with such an\\n implementation.\\n\\n Importantly, no instances of command classes will created. Instead the main\\n entry point is a static ``__call__()`` method, which must be implemented\\n for any command. It is incorporated as a function in :mod:`datalad.api`, by\\n default under the name of the file the implementation resides (e.g.,\\n ``command`` for a ``command.py`` file). Therefore the file should have a\\n name that is a syntax-compliant function name. The default naming rule can\\n be overwritten with an explicit alternative name (see\\n :func:`datalad.interface.base.get_api_name`).\\n\\n For commands implementing functionality that is operating on DataLad\\n datasets, a command can be also be bound to the\\n :class:`~datalad.distribution.dataset.Dataset` class as a method using\\n the ``@datasetmethod`` decorator, under the specified name.\\n\\n Any ``__call__()`` implementation should be decorated with\\n :func:`datalad.interface.utils.eval_results`. This adds support for\\n standard result processing, and a range of common command parameters that\\n do not need to be manually added to the signature of ``__call__()``. Any\\n implementation decorated in this way should be implemented as a generator,\\n and ``yield`` :ref:`result records `.\\n\\n Any argument or keyword argument that appears in the signature of\\n ``__call__()`` must have a matching item in :attr:`Interface._params_`.\\n The dictionary maps argument names to\\n :class:`datalad.support.param.Parameter` specifications. The specification\\n contain CLI argument declarations, value constraint and data type\\n conversation specifications, documentation, and optional\\n ``argparse``-specific arguments for CLI parser construction.\\n\\n The class decorator :func:`datalad.interface.base.build_doc` inspects an\\n :class:`Interface` implementation, and builds a standard docstring from\\n various sources of structured information within the class (also see\\n below). The documentation is automatically tuned differently, depending on\\n the target API (Python vs CLI).\\n\\n .. code:: python\\n\\n @build_doc\\n class ExampleCommand(Interface):\\n \\\"\\\"\\\"SHORT DESCRIPTION\\n\\n LONG DESCRIPTION\\n ...\\n \\\"\\\"\\\"\\n\\n # COMMAND PARAMETER DEFINITIONS\\n _params_ = dict(\\n example=Parameter(\\n args=(\\\"--example\\\",),\\n doc=\\\"\\\"\\\"Parameter description....\\\"\\\"\\\",\\n constraints=...),\\n ...\\n )\\n )\\n\\n # RESULT PARAMETER OVERRIDES\\n return_type= 'list'\\n ...\\n\\n # USAGE EXAMPLES\\n _examples_ = [\\n dict(text=\\\"Example description...\\\",\\n code_py=\\\"Example Python code...\\\",\\n code_cmd=\\\"Example shell code ...\\\"),\\n ...\\n ]\\n\\n @staticmethod\\n @datasetmethod(name='example_command')\\n @eval_results\\n def __call__(example=None, ...):\\n ...\\n\\n yield dict(...)\\n\\n The basic implementation setup described above can be customized for\\n individual commands in various way that alter the behavior and\\n presentation of a specific command. The following overview uses\\n the code comment markers in the above snippet to illustrate where\\n in the class implementation these adjustments can be made.\\n\\n (SHORT/LONG) DESCRIPTION\\n\\n ``Interface.short_description`` can be defined to provide an\\n explicit short description to be used in documentation and help output,\\n replacing the auto-generated extract from the first line of the full\\n description.\\n\\n COMMAND PARAMETER DEFINITIONS\\n\\n When a parameter specification declares ``Parameter(args=tuple(), ...)``,\\n i.e. no arguments specified, it will be ignored by the CLI. Likewise, any\\n ``Parameter`` specification for which :func:`is_api_arg` returns ``False``\\n will also be ignored by the CLI. Additionally, any such parameter will\\n not be added to the parameter description list in the Python docstring.\\n\\n RESULT PARAMETER OVERRIDES\\n\\n The :func:`datalad.interface.utils.eval_results` decorator automatically\\n add a range of additional arguments to a command, which are defined in\\n :py:data:`datalad.interface.common_opts.eval_params`. For any such\\n parameter an Interface implementation can define an interface-specific\\n default value, by declaring a class member with the respective parameter\\n name and the desired default as its assigned value. This feature can be\\n used to tune the default command behavior, for example, with respect to the\\n default result rendering style, or its error behavior.\\n\\n In addition to the common parameters of the Python API, an additional\\n ``Interface.result_renderer_cmdline`` can be defined, in order to\\n instruct the CLI to prefer the specified alternative result renderer\\n over an ``Interface.result_renderer`` specification.\\n\\n USAGE EXAMPLES\\n\\n Any number of usage examples can be described in an ``_examples_`` list\\n class attribute. Such an example contains a description, and code examples\\n for Python and CLI.\\n '''\\n _params_ = {}\\n\\n @abstractmethod\\n def __call__():\\n \\\"\\\"\\\"Must be implemented by any command\\\"\\\"\\\"\\n\\n # https://github.com/datalad/datalad/issues/6376\\n @classmethod\\n def get_refds_path(cls, dataset):\\n \\\"\\\"\\\"Return a resolved reference dataset path from a `dataset` argument\\n\\n .. deprecated:: 0.16\\n Use ``require_dataset()`` instead.\\n \\\"\\\"\\\"\\n # theoretically a dataset could come in as a relative path -> resolve\\n if dataset is None:\\n return dataset\\n refds_path = dataset.path if isinstance(dataset, Dataset) \\\\\\n else Dataset(dataset).path\\n if refds_path:\\n refds_path = str(resolve_path(refds_path))\\n return refds_path\\n\\n\\n# pull all defaults from all eval_results() related parameters and assign them\\n# as attributes to the class, which then becomes the one place to query for\\n# default and potential overrides\\nfor k, p in eval_params.items():\\n setattr(Interface,\\n # name is always given\\n k,\\n # but there may be no default (rather unlikely, though)\\n p.cmd_kwargs.get('default', None))\\n\\n\\ndef get_allargs_as_kwargs(call, args, kwargs):\\n \\\"\\\"\\\"Generate a kwargs dict from a call signature and ``*args``, ``**kwargs``\\n\\n Basically resolving the argnames for all positional arguments, and\\n resolving the defaults for all kwargs that are not given in a kwargs\\n dict\\n \\\"\\\"\\\"\\n from datalad.utils import getargspec\\n argspec = getargspec(call, include_kwonlyargs=True)\\n defaults = argspec.defaults\\n nargs = len(argspec.args)\\n defaults = defaults or [] # ensure it is a list and not None\\n assert (nargs >= len(defaults))\\n # map any args to their name\\n argmap = list(zip(argspec.args[:len(args)], args))\\n kwargs_ = dict(argmap)\\n # map defaults of kwargs to their names (update below)\\n for k, v in zip(argspec.args[-len(defaults):], defaults):\\n if k not in kwargs_:\\n kwargs_[k] = v\\n # update with provided kwarg args\\n kwargs_.update(kwargs)\\n # XXX we cannot assert the following, because our own highlevel\\n # API commands support more kwargs than what is discoverable\\n # from their signature...\\n #assert (nargs == len(kwargs_))\\n return kwargs_\\n\\n\\n# Only needed to support command implementations before the introduction\\n# of @eval_results\\ndef _has_eval_results_call(cls):\\n \\\"\\\"\\\"Return True if cls has a __call__ decorated with @eval_results\\n \\\"\\\"\\\"\\n return getattr(getattr(cls, '__call__', None), '_eval_results', False)\\n\\n\\ndef eval_results(wrapped):\\n \\\"\\\"\\\"Decorator for return value evaluation of datalad commands.\\n\\n Note, this decorator is only compatible with commands that return\\n status dict sequences!\\n\\n Two basic modes of operation are supported: 1) \\\"generator mode\\\" that\\n `yields` individual results, and 2) \\\"list mode\\\" that returns a sequence of\\n results. The behavior can be selected via the kwarg `return_type`.\\n Default is \\\"list mode\\\".\\n\\n This decorator implements common functionality for result rendering/output,\\n error detection/handling, and logging.\\n\\n Result rendering/output configured via the `result_renderer` keyword\\n argument of each decorated command. Supported modes are: 'generic' (a\\n generic renderer producing one line per result with key info like action,\\n status, path, and an optional message); 'json' (a complete JSON line\\n serialization of the full result record), 'json_pp' (like 'json', but\\n pretty-printed spanning multiple lines), 'tailored' custom output\\n formatting provided by each command class (if any), or 'disabled' for\\n no result rendering.\\n\\n Error detection works by inspecting the `status` item of all result\\n dictionaries. Any occurrence of a status other than 'ok' or 'notneeded'\\n will cause an IncompleteResultsError exception to be raised that carries\\n the failed actions' status dictionaries in its `failed` attribute.\\n\\n Status messages will be logged automatically, by default the following\\n association of result status and log channel will be used: 'ok' (debug),\\n 'notneeded' (debug), 'impossible' (warning), 'error' (error). Logger\\n instances included in the results are used to capture the origin of a\\n status report.\\n\\n Parameters\\n ----------\\n func: function\\n __call__ method of a subclass of Interface,\\n i.e. a datalad command definition\\n \\\"\\\"\\\"\\n\\n @wraps(wrapped)\\n def eval_func(*args, **kwargs):\\n lgr.log(2, \\\"Entered eval_func for %s\\\", wrapped)\\n # determine the command class associated with `wrapped`\\n wrapped_class = get_wrapped_class(wrapped)\\n\\n # retrieve common options from kwargs, and fall back on the command\\n # class attributes, or general defaults if needed\\n kwargs = kwargs.copy() # we will pop, which might cause side-effect\\n common_params = {\\n p_name: kwargs.pop(\\n # go with any explicitly given default\\n p_name,\\n # otherwise determine the command class and pull any\\n # default set in that class\\n getattr(wrapped_class, p_name))\\n for p_name in eval_params}\\n\\n # short cuts and configured setup for common options\\n return_type = common_params['return_type']\\n\\n if return_type == 'generator':\\n # hand over the generator\\n lgr.log(2,\\n \\\"Returning generator_func from eval_func for %s\\\",\\n wrapped_class)\\n return _execute_command_(\\n interface=wrapped_class,\\n cmd=wrapped,\\n cmd_args=args,\\n cmd_kwargs=kwargs,\\n exec_kwargs=common_params,\\n )\\n else:\\n @wraps(_execute_command_)\\n def return_func(*args_, **kwargs_):\\n results = _execute_command_(\\n interface=wrapped_class,\\n cmd=wrapped,\\n cmd_args=args,\\n cmd_kwargs=kwargs,\\n exec_kwargs=common_params,\\n )\\n if inspect.isgenerator(results):\\n # unwind generator if there is one, this actually runs\\n # any processing\\n results = list(results)\\n if return_type == 'item-or-list' and \\\\\\n len(results) < 2:\\n return results[0] if results else None\\n else:\\n return results\\n\\n lgr.log(2,\\n \\\"Returning return_func from eval_func for %s\\\",\\n wrapped_class)\\n return return_func(*args, **kwargs)\\n\\n ret = eval_func\\n ret._eval_results = True\\n return ret\\n\\n\\ndef _execute_command_(\\n *,\\n interface: anInterface,\\n cmd: Callable[..., Generator[Dict, None, None]],\\n cmd_args: tuple,\\n cmd_kwargs: Dict,\\n exec_kwargs: Dict,\\n) -> Generator[Dict, None, None]:\\n \\\"\\\"\\\"Internal helper to drive a command execution generator-style\\n\\n Parameters\\n ----------\\n interface:\\n Interface class of associated with the `cmd` callable\\n cmd:\\n A DataLad command implementation. Typically the `__call__()` of\\n the given `interface`.\\n cmd_args:\\n Positional arguments for `cmd`.\\n cmd_kwargs:\\n Keyword arguments for `cmd`.\\n exec_kwargs:\\n Keyword argument affecting the result handling.\\n See `datalad.interface.common_opts.eval_params`.\\n \\\"\\\"\\\"\\n # for result filters and validation\\n # we need to produce a dict with argname/argvalue pairs for all args\\n # incl. defaults and args given as positionals\\n allkwargs = get_allargs_as_kwargs(\\n cmd,\\n cmd_args,\\n {**cmd_kwargs, **exec_kwargs},\\n )\\n\\n # validate the complete parameterization\\n _validate_cmd_call(interface, allkwargs)\\n\\n # look for potential override of logging behavior\\n result_log_level = dlcfg.get('datalad.log.result-level', 'debug')\\n # resolve string labels for transformers too\\n result_xfm = known_result_xfms.get(\\n allkwargs['result_xfm'],\\n # use verbatim, if not a known label\\n allkwargs['result_xfm'])\\n result_filter = get_result_filter(allkwargs['result_filter'])\\n result_renderer = allkwargs['result_renderer']\\n if result_renderer == 'tailored' and not hasattr(interface,\\n 'custom_result_renderer'):\\n # a tailored result renderer is requested, but the class\\n # does not provide any, fall back to the generic one\\n result_renderer = 'generic'\\n if result_renderer == 'default':\\n # standardize on the new name 'generic' to avoid more complex\\n # checking below\\n result_renderer = 'generic'\\n\\n # figure out which hooks are relevant for this command execution\\n # query cfg for defaults\\n # .is_installed and .config can be costly, so ensure we do\\n # it only once. See https://github.com/datalad/datalad/issues/3575\\n dataset_arg = allkwargs.get('dataset', None)\\n ds = None\\n if dataset_arg is not None:\\n from datalad.distribution.dataset import Dataset\\n if isinstance(dataset_arg, Dataset):\\n ds = dataset_arg\\n else:\\n try:\\n ds = Dataset(dataset_arg)\\n except ValueError:\\n pass\\n # look for hooks\\n hooks = get_jsonhooks_from_config(ds.config if ds else dlcfg)\\n # end of hooks discovery\\n\\n # flag whether to raise an exception\\n incomplete_results = []\\n # track what actions were performed how many times\\n action_summary = {}\\n\\n # if a custom summary is to be provided, collect the results\\n # of the command execution\\n results = []\\n do_custom_result_summary = result_renderer in (\\n 'tailored', 'generic', 'default') and hasattr(\\n interface,\\n 'custom_result_summary_renderer')\\n pass_summary = do_custom_result_summary \\\\\\n and getattr(interface,\\n 'custom_result_summary_renderer_pass_summary',\\n None)\\n\\n # process main results\\n for r in _process_results(\\n # execution\\n cmd(*cmd_args, **cmd_kwargs),\\n interface,\\n allkwargs['on_failure'],\\n # bookkeeping\\n action_summary,\\n incomplete_results,\\n # communication\\n result_renderer,\\n result_log_level,\\n # let renderers get to see how a command was called\\n allkwargs):\\n for hook, spec in hooks.items():\\n # run the hooks before we yield the result\\n # this ensures that they are executed before\\n # a potentially wrapper command gets to act\\n # on them\\n if match_jsonhook2result(hook, r, spec['match']):\\n lgr.debug('Result %s matches hook %s', r, hook)\\n # a hook is also a command that yields results\\n # so yield them outside too\\n # users need to pay attention to void infinite\\n # loops, i.e. when a hook yields a result that\\n # triggers that same hook again\\n for hr in run_jsonhook(hook, spec, r, dataset_arg):\\n # apply same logic as for main results, otherwise\\n # any filters would only tackle the primary results\\n # and a mixture of return values could happen\\n if not keep_result(hr, result_filter, **allkwargs):\\n continue\\n hr = xfm_result(hr, result_xfm)\\n # rationale for conditional is a few lines down\\n if hr:\\n yield hr\\n if not keep_result(r, result_filter, **allkwargs):\\n continue\\n r = xfm_result(r, result_xfm)\\n # in case the result_xfm decided to not give us anything\\n # exclude it from the results. There is no particular reason\\n # to do so other than that it was established behavior when\\n # this comment was written. This will not affect any real\\n # result record\\n if r:\\n yield r\\n\\n # collect if summary is desired\\n if do_custom_result_summary:\\n results.append(r)\\n\\n # result summary before a potential exception\\n # custom first\\n if do_custom_result_summary:\\n if pass_summary:\\n summary_args = (results, action_summary)\\n else:\\n summary_args = (results,)\\n interface.custom_result_summary_renderer(*summary_args)\\n elif result_renderer in ('generic', 'default') \\\\\\n and action_summary \\\\\\n and sum(sum(s.values())\\n for s in action_summary.values()) > 1:\\n # give a summary in generic mode, when there was more than one\\n # action performed\\n render_action_summary(action_summary)\\n\\n if incomplete_results:\\n raise IncompleteResultsError(\\n failed=incomplete_results,\\n msg=\\\"Command did not complete successfully\\\")\\n\\n\\ndef _validate_cmd_call(interface: anInterface, kwargs: Dict) -> None:\\n \\\"\\\"\\\"Validate a parameterization of a command call\\n\\n This is called by `_execute_command_()` before a command call, with\\n the respective Interface sub-type of the command, and all its\\n arguments in keyword argument dict style. This dict also includes\\n the default values for any parameter that was not explicitly included\\n in the command call.\\n\\n This expected behavior is to raise an exception whenever an invalid\\n parameterization is encountered.\\n\\n This default implementation performs no validation.\\n \\\"\\\"\\\"\\n pass\\n\"\n },\n {\n \"alpha_fraction\": 0.7572148442268372,\n \"alphanum_fraction\": 0.7572148442268372,\n \"avg_line_length\": 34.78688430786133,\n \"blob_id\": \"fd748ab0f648334dc2bd60209ac38a35d81c7e3c\",\n \"content_id\": \"7857be225537cb048b57341c2b17ad2da01eeea4\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"reStructuredText\",\n \"length_bytes\": 2183,\n \"license_type\": \"permissive\",\n \"max_line_length\": 77,\n \"num_lines\": 61,\n \"path\": \"/docs/config-format.rst\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"Config file format\\n==================\\n\\nIncludes\\n--------\\n\\n:mod:`~datalad.config` enhances class:`~ConfigParser.SafeConfigParser`\\nto also support includes. It makes it possible to specify within the\\n`INCLUDES` section of the config file which other config file should\\nbe considered before or after a currently read config file::\\n\\n [INCLUDES]\\n before = defaults.cfg\\n after = customizations.cfg\\n\\n [DEFAULTS]\\n ....\\n\\nSections\\n--------\\n\\nDownload section\\n~~~~~~~~~~~~~~~~\\n\\nIt is the only type of a section at this point. It specifies a single\\nresource which crawl/monitor and fetch specified content to be\\ndeposited into the git/git-annex repository. Following fields are\\nknown and could either be specified in the specific section or in\\n`DEFAULT` section to be reused across different sections\\n\\nmode\\n Could be `download`, `fast` or `relaxed`. In `download` mode files\\n are downloaded, and added to the git-annex, thus based on a checksum\\n backend. `fast` and `relaxed` modes correspond to the modes of `git\\n annex addurl`\\nincoming\\n Path to the `incoming` repository -- where everything gets initially\\n imported, e.g. original archives. If no archives to be extracted,\\n it usually then matches with `public`. Original idea for such a\\n separation was to cover the cases where incoming materials\\n (archives) might contain some non-distributable materials which\\n should be stripped before being placed into `public` repository\\npublic\\n Path to the `public` repository which is the target repository to be\\n shared\\ndescription\\n Textual description to be placed under :file:`.git/description`\\ninclude_href\\n Regular expression to specify which URLs, pointed to by HTML ``\\n should be considered to be added to the repository\\ninclude_href_a\\n Regular expression to specify which links with matching text should\\n be considered\\nexclude_href, exclude_href_a\\n Similar setups to specify which ones to exclude (e.g. if `include_href=.*`)\\nrecurse\\n Regular expression to specify which URLs to consider for further\\n traversal while crawling the website\\n\\nTODO. Some additional documentation is currently within\\n:meth:`datalad.config.EnhancedConfigParser.get_default`\\n\"\n },\n {\n \"alpha_fraction\": 0.6086508631706238,\n \"alphanum_fraction\": 0.6104531288146973,\n \"avg_line_length\": 30.07200050354004,\n \"blob_id\": \"abc0ae52d01f7c87f0d35b1afd4e75636e0436f3\",\n \"content_id\": \"7dda2fab5f93dbcb0dc83db262aa777eee7ccd67\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3884,\n \"license_type\": \"permissive\",\n \"max_line_length\": 87,\n \"num_lines\": 125,\n \"path\": \"/datalad/interface/tests/test_docs.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Tests for interface doc wranglers.\\n\\n\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\nfrom datalad.interface.base import (\\n alter_interface_docs_for_api,\\n dedent_docstring,\\n)\\nfrom datalad.tests.utils_pytest import (\\n assert_false,\\n assert_in,\\n assert_not_in,\\n)\\n\\ndemo_doc = \\\"\\\"\\\"\\\\\\n Bla bla summary\\n\\n Generic intro blurb. Ping pong ping pong ping pong ping pong. Ping pong ping\\n pong ping pong ping pong. Ping pong ping pong ping pong ping pong. Ping pong\\n ping pong ping pong ping pong. Ping pong ping pong ping pong ping pong. Ping\\n pong ping pong ping pong ping pong.\\n\\n || CMDLINE >>\\n || REFLOW >>\\n Something for the cmdline only\\n Multiline!\\n << REFLOW ||\\n << CMDLINE ||\\n\\n || REFLOW >>\\n a\\n b\\n << REFLOW ||\\n not\\n reflowed\\n || REFLOW >>\\n c\\n << REFLOW ||\\n\\n || PYTHON >>\\n\\n || REFLOW >>\\n Some Python-only bits\\n Multiline!\\n << REFLOW ||\\n\\n << PYTHON ||\\n\\n And an example for in-line markup: [PY: just for Python PY] and\\n the other one [CMD: just for the command line CMD]. [PY: multiline\\n python-only with [ brackets [] ] PY][CMD: multiline cli-only with [ brackets\\n [] ] CMD]. End of demo.\\n\\n Generic appendix. Ding dong ding dong ding dong. Ding dong ding dong ding\\n dong. Ding dong ding dong ding dong. Ding dong ding dong ding dong. Ding\\n dong ding dong ding dong.\\n\\n\\\"\\\"\\\"\\n\\ndemo_paramdoc = \\\"\\\"\\\"\\\\\\n\\n Parameters\\n ----------\\n dataset : Dataset or None, optional\\n something [PY: python only PY] in between [CMD: cmdline only CMD] appended\\n Brackets can also be within and we can deal with [PY: multiline\\n python-only with [ some brackets [] PY] [CMD: multiline cli-only [\\n brackets included [ can we also have || ?] CMD].\\n dataset is given, an attempt is made to identify the dataset based\\n Dataset (e.g. a path), or value must be `None`. [Default: None]\\n\\\"\\\"\\\"\\n\\ndemo_argdoc = \\\"\\\"\\\"\\\\\\n specify the dataset to perform the install operation\\n on. If no dataset is given, an attempt is made to\\n identify the dataset based on the current working\\n directory and/or the `path` given. Constraints: Value\\n must be a Dataset or a valid identifier of a Dataset\\n (e.g. a path), or value must be `None`. [Default:\\n None]\\n\\\"\\\"\\\"\\n\\n\\ndef test_dedent():\\n assert_false(dedent_docstring(\\\"one liner\\\").endswith(\\\"\\\\n\\\"))\\n\\n\\ndef test_alter_interface_docs_for_api():\\n alt = alter_interface_docs_for_api(demo_doc)\\n alt_l = alt.split('\\\\n')\\n # de-dented\\n assert_false(alt_l[0].startswith(' '))\\n assert_false(alt_l[-1].startswith(' '))\\n assert_not_in('CMD', alt)\\n assert_not_in('PY', alt)\\n assert_not_in('REFLOW', alt)\\n assert_in('a b', alt)\\n assert_in('not\\\\n reflowed', alt)\\n assert_in(\\\"Some Python-only bits Multiline!\\\", alt)\\n assert_in(\\\"Some Python-only bits\\\", alt)\\n assert_in(\\\"just for Python\\\", alt)\\n assert_not_in(\\\"just for the command line\\\", alt)\\n assert_not_in(\\\"multiline cli-only with [ brackets\\\\n[] ]\\\", alt)\\n assert_in(\\\"multiline\\\\npython-only with [ brackets [] ]\\\", alt)\\n\\n altpd = alter_interface_docs_for_api(demo_paramdoc)\\n assert_not_in(\\\"PY\\\", altpd)\\n assert_not_in(\\\"CMD\\\", altpd)\\n assert_in('python', altpd)\\n assert_in('in between', altpd)\\n assert_in('appended', altpd)\\n assert_in(\\\"multiline\\\\n python-only with [ some brackets []\\\", altpd)\\n assert_not_in('cmdline', altpd)\\n assert_not_in(\\\"multiline cli-only [\\\\n brackets included \\\"\\n \\\"[ can we also have || ?]\\\", altpd)\\n\"\n },\n {\n \"alpha_fraction\": 0.634854793548584,\n \"alphanum_fraction\": 0.6514523029327393,\n \"avg_line_length\": 25.77777862548828,\n \"blob_id\": \"9721f57a9a585cb7efdceedf43c608ed057402bb\",\n \"content_id\": \"180e32f1f5783ca07599f08ba55c0ba27ab73f3c\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 241,\n \"license_type\": \"permissive\",\n \"max_line_length\": 64,\n \"num_lines\": 9,\n \"path\": \"/tools/bisect-git-annex.scripts/bisect-git-annex-doublepasswd.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\nset -eu\\n\\nerr=\\\"thread blocked indefinitely\\\"\\n\\ncd ~/QA\\n# script doesn't work in a script since probably no tty\\ntimeout 10 script -f -c 'git annex get -J2 sub-*' || :\\ntest 1 -eq `sed -e 's, ,\\\\n,g' typescript | grep -c 'password:' `\\n\"\n },\n {\n \"alpha_fraction\": 0.6000000238418579,\n \"alphanum_fraction\": 0.6068181991577148,\n \"avg_line_length\": 27.387096405029297,\n \"blob_id\": \"9a8cba925d0622b51912cbf98a307521498c2182\",\n \"content_id\": \"fec42f32c500b7a4b29b65b617c0ce343b6a09ca\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 880,\n \"license_type\": \"permissive\",\n \"max_line_length\": 64,\n \"num_lines\": 31,\n \"path\": \"/tools/convert-git-annex-layout\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\n\\nset -eu\\n\\nto=\\\"$1\\\"\\n\\necho \\\"Initial fsck:\\\"\\ngit annex fsck --fast 2>&1 | python -m tqdm --null\\necho \\\"Going through objects: \\\"\\nfor f in .git/annex/objects/*/*/*; do\\n key=$(basename $f)\\n keydir=$(dirname $f)\\n newhashdir=$(git annex examinekey --format=\\\"\\\\${$to}\\\" \\\"$key\\\")\\n targetdir=\\\".git/annex/objects/$newhashdir\\\"\\n test -n \\\"$newhashdir\\\"\\n if [ \\\"$keydir\\\" = \\\"${targetdir%/}\\\" ]; then\\n continue\\n fi\\n echo \\\" $f -> $newhashdir\\\"\\n # This was a wrong assumption - there could be multiple\\n # keys in the same directory so we might have it already.\\n # But I still feel we might need some test here\\n #if test -e \\\"$targetdir\\\"; then\\n # echo \\\"$targetdir already exists\\\"\\n # exit 1\\n #fi\\n mkdir -p \\\"$(dirname $targetdir)\\\"\\n mv \\\"$keydir\\\" \\\"${targetdir%/}\\\"\\ndone\\necho \\\"Final fsck:\\\"\\ngit annex fsck --fast 2>&1 | python -m tqdm --null\\n\"\n },\n {\n \"alpha_fraction\": 0.7210769653320312,\n \"alphanum_fraction\": 0.7269667387008667,\n \"avg_line_length\": 45.6274528503418,\n \"blob_id\": \"e2efe806cd704b056b81bfc6bbe2594e25801d91\",\n \"content_id\": \"9ba1161e4fc4d2071212f6af8a0fe14600956792\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"reStructuredText\",\n \"length_bytes\": 2377,\n \"license_type\": \"permissive\",\n \"max_line_length\": 117,\n \"num_lines\": 51,\n \"path\": \"/docs/source/design/pos_vs_kw_parameters.rst\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \".. -*- mode: rst -*-\\n.. vi: set ft=rst sts=4 ts=4 sw=4 et tw=79:\\n\\n.. _chap_pos_vs_kw_parameters:\\n\\n********************************\\nPositional vs Keyword parameters\\n********************************\\n\\n.. topic:: Specification scope and status\\n\\n This specification is a proposal, subject to review and further discussion.\\n Technical preview was implemented in the `PR #6176 `_.\\n\\nMotivation\\n==========\\n\\nPython allows for keyword arguments (arguments with default values) to be specified positionally.\\nThat complicates addition or removal of new keyword arguments since such changes must account for their possible\\npositional use.\\nMoreover, in case of our Interface's, it contributes to inhomogeneity since when used in :term:`CLI`, all keyword\\narguments\\nmust be specified via non-positional ``--``'s, whenever Python interface allows for them to be used\\npositionally.\\n\\nPython 3 added possibility to use a ``*`` separator in the function definition to mandate that all keyword arguments\\n*after* it must be be used only via keyword (`` =``) specification.\\nIt is encouraged to use ``*`` to explicitly separate out positional from keyword arguments in majority of the cases,\\nand below we outline two major types of constructs.\\n\\nInterfaces\\n==========\\n\\nSubclasses of the :class:`~datalad.interface.base.Interface` provide specification and implementation for both\\n:term:`CLI` and Python API interfaces.\\nAll new interfaces must separate all CLI ``--options`` from positional arguments using ``*`` in their ``__call__``\\nsignature.\\n\\n**Note:** that some positional arguments could still be optional (e.g., destination ``path`` for ``clone``),\\nand thus should be listed **before** ``*``, despite been defined as a keyword argument in the ``__call__`` signature.\\n\\nA unit-test will be provided to guarantee such consistency between :term:`CLI` and Python interfaces.\\nOverall, exceptions to this rule could be only some old(er) interfaces.\\n\\nRegular functions and methods\\n=============================\\n\\nUse of ``*`` is encouraged for any function (or method) with keyword arguments.\\nGenerally, ``*`` should come before the first keyword argument, but similarly to the Interfaces above, it is left to\\nthe discretion of the developer to possibly allocate some (just few) arguments which could be used positionally if\\nspecified.\"\n },\n {\n \"alpha_fraction\": 0.54513019323349,\n \"alphanum_fraction\": 0.545923113822937,\n \"avg_line_length\": 28.443580627441406,\n \"blob_id\": \"39bba393fb5c6638204e60b245c3772f147b3651\",\n \"content_id\": \"8b11e3fe4bc62257ce7bd3635770d3a187ef78ad\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 7567,\n \"license_type\": \"permissive\",\n \"max_line_length\": 82,\n \"num_lines\": 257,\n \"path\": \"/datalad/runner/runnerthreads.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from __future__ import annotations\\n\\nimport logging\\nimport os\\nimport threading\\nfrom abc import (\\n ABCMeta,\\n abstractmethod,\\n)\\nfrom enum import Enum\\nfrom queue import (\\n Full,\\n Queue,\\n)\\nfrom subprocess import Popen\\nfrom typing import (\\n IO,\\n Any,\\n Optional,\\n)\\n\\nfrom datalad.utils import COPY_BUFSIZE\\n\\nlgr = logging.getLogger(\\\"datalad.runner.runnerthreads\\\")\\n\\n\\ndef _try_close(file_object: Optional[IO]) -> None:\\n if file_object is not None:\\n try:\\n file_object.close()\\n except OSError:\\n pass\\n\\n\\nclass IOState(Enum):\\n ok = \\\"ok\\\"\\n process_exit = \\\"process_exit\\\"\\n\\n\\nclass SignalingThread(threading.Thread):\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]]\\n ) -> None:\\n\\n super().__init__(daemon=True)\\n self.identifier = identifier\\n self.signal_queues = signal_queues\\n\\n def __repr__(self) -> str:\\n return f\\\"Thread<{self.identifier}>\\\"\\n\\n def __str__(self) -> str:\\n return self.__repr__()\\n\\n def signal(self,\\n content: tuple[Any, IOState, Optional[bytes]]\\n ) -> bool:\\n error_occurred = False\\n for signal_queue in self.signal_queues:\\n try:\\n signal_queue.put(content, block=True, timeout=.1)\\n except Full:\\n lgr.debug(\\\"timeout while trying to signal: %s\\\", content)\\n error_occurred = True\\n return not error_occurred\\n\\n\\nclass WaitThread(SignalingThread):\\n \\\"\\\"\\\"\\n Instances of this thread wait for a process to exit and enqueue\\n an exit event in the signal queues.\\n \\\"\\\"\\\"\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]],\\n process: Popen\\n ) -> None:\\n super().__init__(identifier, signal_queues)\\n self.process = process\\n\\n def run(self) -> None:\\n\\n lgr.log(5, \\\"%s (%s) started\\\", self.identifier, self)\\n\\n self.process.wait()\\n self.signal((self.identifier, IOState.process_exit, None))\\n\\n lgr.log(5, \\\"%s (%s) exiting\\\", self.identifier, self)\\n\\n\\nclass ExitingThread(SignalingThread):\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]]\\n ) -> None:\\n\\n super().__init__(identifier, signal_queues)\\n self.exit_requested = False\\n\\n def request_exit(self) -> None:\\n \\\"\\\"\\\"\\n Request the thread to exit. This is not guaranteed to\\n have any effect, because the instance has to check for\\n self.exit_requested and act accordingly. It might not\\n do that.\\n \\\"\\\"\\\"\\n self.exit_requested = True\\n\\n\\nclass TransportThread(ExitingThread, metaclass=ABCMeta):\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]],\\n user_info: Any\\n ) -> None:\\n\\n super().__init__(identifier, signal_queues)\\n self.user_info = user_info\\n\\n def __repr__(self) -> str:\\n return f\\\"Thread<({self.identifier}, {self.user_info})>\\\"\\n\\n def __str__(self) -> str:\\n return self.__repr__()\\n\\n def signal_event(self,\\n state: IOState,\\n data: Optional[bytes]\\n ) -> bool:\\n return self.signal((self.user_info, state, data))\\n\\n @abstractmethod\\n def read(self) -> Optional[bytes]:\\n \\\"\\\"\\\"\\n Read data from source return None, if source is close,\\n or destination close is required.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @abstractmethod\\n def write(self,\\n data: bytes\\n ) -> bool:\\n \\\"\\\"\\\"\\n Write given data to destination, return True if data is\\n written successfully, False otherwise.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n def run(self) -> None:\\n\\n lgr.log(5, \\\"%s (%s) started\\\", self.identifier, self)\\n\\n # Copy data from source queue to destination queue\\n # until exit is requested. If timeouts arise, signal\\n # them to the receiver via the signal queue.\\n data: Optional[bytes] = b\\\"\\\"\\n while not self.exit_requested:\\n\\n data = self.read()\\n # If the source sends None-data it wants\\n # us to exit the thread. Signal this to\\n # the downstream queues (which might or might\\n # not be contain the output queue),\\n # and exit the thread.\\n if data is None:\\n break\\n\\n if self.exit_requested:\\n break\\n\\n succeeded = self.write(data)\\n if not succeeded:\\n break\\n\\n self.signal_event(IOState.ok, None)\\n lgr.log(\\n 5,\\n \\\"%s (%s) exiting (exit_requested: %s, last data: %s)\\\",\\n self.identifier,\\n self,\\n self.exit_requested, data)\\n\\n\\nclass ReadThread(TransportThread):\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]],\\n user_info: Any,\\n source: IO,\\n destination_queue: Queue[tuple[Any, IOState, bytes]],\\n length: int = COPY_BUFSIZE\\n ) -> None:\\n\\n super().__init__(identifier, signal_queues, user_info)\\n self.source = source\\n self.destination_queue = destination_queue\\n self.length = length\\n\\n def read(self) -> Optional[bytes]:\\n try:\\n data = os.read(self.source.fileno(), self.length)\\n except (ValueError, OSError):\\n # The destination was most likely closed, nevertheless,\\n # try to close it and indicate EOF.\\n _try_close(self.source)\\n return None\\n return data or None\\n\\n def write(self,\\n data: bytes\\n ) -> bool:\\n\\n # We write to an unlimited queue, no need for timeout checking.\\n self.destination_queue.put((self.user_info, IOState.ok, data))\\n return True\\n\\n\\nclass WriteThread(TransportThread):\\n def __init__(self,\\n identifier: str,\\n signal_queues: list[Queue[tuple[Any, IOState, Optional[bytes]]]],\\n user_info: Any,\\n source_queue: Queue[Optional[bytes]],\\n destination: IO\\n ) -> None:\\n\\n super().__init__(identifier, signal_queues, user_info)\\n self.source_queue = source_queue\\n self.destination = destination\\n\\n def read(self) -> Optional[bytes]:\\n data = self.source_queue.get()\\n if data is None:\\n # Close stdin file descriptor here, since we know that no more\\n # data will be sent to stdin.\\n _try_close(self.destination)\\n return data\\n\\n def write(self,\\n data: bytes,\\n ) -> bool:\\n try:\\n written = 0\\n while written < len(data):\\n written += os.write(\\n self.destination.fileno(),\\n data[written:])\\n if self.exit_requested:\\n return written == len(data)\\n except (BrokenPipeError, OSError, ValueError):\\n # The destination was most likely closed, nevertheless,\\n # try to close it and indicate EOF.\\n _try_close(self.destination)\\n return False\\n return True\\n\"\n },\n {\n \"alpha_fraction\": 0.7488971948623657,\n \"alphanum_fraction\": 0.7697658538818359,\n \"avg_line_length\": 46.15999984741211,\n \"blob_id\": \"45c86625701b49397391a61555edcd82a15234ac\",\n \"content_id\": \"eda104eaa60a1968a0a91736a1336e040895eca0\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"reStructuredText\",\n \"length_bytes\": 5894,\n \"license_type\": \"permissive\",\n \"max_line_length\": 143,\n \"num_lines\": 125,\n \"path\": \"/docs/source/design/user_messaging.rst\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \".. -*- mode: rst -*-\\n.. vi: set ft=rst sts=4 ts=4 sw=4 et tw=79:\\n\\n.. _chap_design_user_messaging:\\n\\n*******************************************************\\nUser messaging: result records vs exceptions vs logging\\n*******************************************************\\n\\n.. topic:: Specification scope and status\\n\\n This specification provides a partial overview of the implementation goal.\\n\\nMotivation\\n==========\\n\\nThis specification delineates the applicable contexts for using\\n:ref:`result records `, :ref:`exceptions `,\\n:ref:`progress reporting `, specific :ref:`log levels `,\\nor other types of user messaging processes.\\n\\n\\nSpecification\\n=============\\n\\nResult records\\n--------------\\n\\n**Result records are the only return value format** for all DataLad interfaces.\\n\\nContrasting with classic Python interfaces that return specific non-annotated values,\\nDataLad interfaces (i.e. subclasses of :py:class:`datalad.interface.base.Interface`)\\nimplement message passing by yielding :ref:`result records `\\nthat are associated with individual operations. Result records are routinely inspected throughout\\nthe code base and their annotations are used to inform general program flow and error handling.\\n\\nDataLad interface calls can include an ``on_failure`` parameterization to specify how to\\nproceed with a particular operation if a returned result record is\\n:ref:`classified as a failure result `. DataLad interface calls can\\nalso include a ``result_renderer`` parameterization to explicitly enable or\\ndisable the rendering of result records.\\n\\nDevelopers should be aware that external callers will use DataLad interface call parameterizations\\nthat can selectively ignore or act on result records, and that the process should therefore\\nyield meaningful result records. If, in turn, the process itself receives a set of result\\nrecords from a sub-process, these should be inspected individually in order to identify result\\nvalues that could require re-annotation or status re-classification.\\n\\nFor user messaging purposes, result records can also be enriched with additional human-readable\\ninformation on the nature of the result, via the ``message`` key, and human-readable hints to\\nthe user, via the ``hints`` key. Both of these are rendered via the `UI Module`_.\\n\\n\\nException handling\\n------------------\\n\\nIn general, **exceptions should be raised when there is no way to ignore or recover from\\nthe offending action**.\\n\\nMore specifically, raise an exception when:\\n\\n1. A DataLad interface's parameter specifications are violated\\n2. An additional requirement (beyond parameters) for the meaningful continuation of a\\n DataLad interface, function, or process is not met\\n\\nIt must be made clear to the user/caller what the exact cause of the exception\\nis, given the context within which the user/caller triggered the action.\\nThis is achieved directly via a (re)raised exception, as opposed to logging messages or\\nresults records which could be ignored or unseen by the user.\\n\\n.. note::\\n In the case of a complex set of dependent actions it could be expensive to\\n confirm parameter violations. In such cases, initial sub-routines might already generate\\n result records that have to be inspected by the caller, and it could be practically better\\n to yield a result record (with ``status=[error|impossible]``) to communicate the failure.\\n It would then be up to the upstream caller to decide whether to specify\\n ``on_failure='ignore'`` or whether to inspect individual result records and turn them\\n into exceptions or not.\\n\\n\\nLogging\\n-------\\n\\nLogging provides developers with additional means to describe steps in a process,\\nso as to **allow insight into the program flow during debugging** or analysis of e.g.\\nusage patterns. Logging can be turned off externally, filtered, and redirected. Apart from\\nthe :ref:`log-level ` and message, it is not inspectable and\\ncannot be used to control the logic or flow of a program.\\n\\nImportantly, logging should not be the primary user messaging method for command outcomes,\\nTherefore:\\n\\n1. No interface should rely solely on logging for user communication\\n2. Use logging for in-progress user communication via the mechanism for :ref:`progress reporting `\\n3. Use logging to inform debugging processes\\n\\n\\nUI Module\\n---------\\n\\nThe :mod:`~datalad.ui` module provides the means to communicate information\\nto the user in a user-interface-specific manner, e.g. via a console, dialog, or an iPython interface.\\nInternally, all DataLad results processed by the result renderer are passed through the UI module.\\n\\nTherefore: unless the criteria for logging apply, and unless the message to be delivered to the user\\nis specified via the ``message`` key of a result record, developers should let explicit user communication\\nhappen through the UI module as it provides the flexibility to adjust to the present UI.\\nSpecifically, :py:func:`datalad.ui.message` allows passing a simple message via the UI module.\\n\\n\\nExamples\\n========\\n\\nThe following links point to actual code implementations of the respective user\\nmessaging methods:\\n\\n- `Result yielding`_\\n- `Exception handling`_\\n- `Logging`_\\n- `UI messaging`_\\n\\n.. _Result yielding: https://github.com/datalad/datalad/blob/a8d7c63b763aacfbca15925bb1562a62b4448ea6/datalad/core/local/status.py#L402-L426\\n.. _Exception handling: https://github.com/datalad/datalad/blob/a8d7c63b763aacfbca15925bb1562a62b4448ea6/datalad/core/local/status.py#L149-L150\\n.. _Logging: https://github.com/datalad/datalad/blob/a8d7c63b763aacfbca15925bb1562a62b4448ea6/datalad/core/local/status.py#L158\\n.. _UI messaging: https://github.com/datalad/datalad/blob/a8d7c63b763aacfbca15925bb1562a62b4448ea6/datalad/core/local/status.py#L438-L457\"\n },\n {\n \"alpha_fraction\": 0.6641094088554382,\n \"alphanum_fraction\": 0.674449622631073,\n \"avg_line_length\": 26.504587173461914,\n \"blob_id\": \"93f8c0fc0f708136b607d2e85257d79b597eaa14\",\n \"content_id\": \"3efc01724ebfd29e22e3bc4e8d92f5ae4419fe3e\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 2998,\n \"license_type\": \"permissive\",\n \"max_line_length\": 89,\n \"num_lines\": 109,\n \"path\": \"/tools/mimic_merges\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\n#emacs: -*- mode: shell-script; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*- \\n#ex: set sts=4 ts=4 sw=4 noet:\\n#\\n#\\n# COPYRIGHT: Yaroslav Halchenko 2014\\n#\\n# LICENSE: MIT\\n#\\n# Permission is hereby granted, free of charge, to any person obtaining a copy\\n# of this software and associated documentation files (the \\\"Software\\\"), to deal\\n# in the Software without restriction, including without limitation the rights\\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n# copies of the Software, and to permit persons to whom the Software is\\n# furnished to do so, subject to the following conditions:\\n#\\n# The above copyright notice and this permission notice shall be included in\\n# all copies or substantial portions of the Software.\\n#\\n# THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\\n# THE SOFTWARE.\\n#\\n\\nset -eu\\n\\ndepth=5\\n# precreate associative array with directory names\\ndeclare -A dirs\\ndirs[\\\"0\\\"]='.'\\ndname=.\\nfor d in `eval echo {1..$depth}`; do\\n\\techo $dname\\n\\tdname+=\\\"/d$d\\\"\\n\\tdirs[\\\"$d\\\"]=$dname\\ndone\\n\\nfunction multi_branch {\\n\\tbranches=$1\\n\\tfiles_per_branch=$2\\n annex=$3\\n\\techo \\\"Creating $branches branches with $files_per_branch per branch. annex=$annex\\\"\\n\\ti=0\\n\\tfor b in `eval echo {1..$branches}`; do\\n\\t\\tgit co -b b$b master &> /dev/null\\n\\t\\tfor f in `eval echo {1..$files_per_branch}`; do\\n\\t\\t\\t#echo -ne \\\"\\\\rFile $f\\\"\\n\\t\\t\\tfdepth=$(python -c \\\"print $i%$depth\\\")\\n\\t\\t\\tdname=${dirs[\\\"$fdepth\\\"]}\\n\\t\\t\\t#[ -e $dname ] || mkdir -p $dname\\n\\t\\t\\tfname=$dname/f$i.dat\\n\\t\\t\\techo \\\"file $i\\\" > $fname;\\n\\t\\t\\ti=$(($i+1))\\n\\t\\tdone\\n if [ $annex=1 ]; then\\n git annex add * > /dev/null;\\n else\\n git add * > /dev/null\\n fi\\n\\t\\tgit commit -m \\\"commit in branch $b\\\" >/dev/null;\\n\\tdone\\n\\techo \\\"Merging\\\"\\n\\teval \\\"git merge -m 'merging $branches together' b{1..$branches}\\\" >/dev/null\\n}\\n\\nfunction init_repo {\\n\\ttdir_=$1\\n\\tif [ -e $tdir_ ]; then\\n\\t\\tchmod +w -R $tdir_\\n\\t\\trm -r $tdir_ || :\\n\\tfi\\n\\tmkdir -p $tdir_\\n\\tcd $tdir_\\n\\tgit init\\n\\tgit annex init\\n\\ttouch .empty\\n\\tgit add .empty; git commit -m \\\"initial commit just to avoid dances with empty branches\\\"\\n\\t# precreate directories\\n\\tfor d in ${dirs[*]}; do\\n\\t\\tmkdir -p $tdir_/$d\\n\\tdone\\n}\\n\\nif [ $# -lt 2 ]; then\\n\\techo \\\"Usage: $0 nfiles_per_branch nbranches [tempdir]\\\"\\n\\texit 1\\nfi\\n\\nfilespb=$1\\nbr=$2\\nfiles=$(python -c \\\"print $filespb*$br\\\")\\n\\nif [ $# -ge 3 ]; then\\n\\ttdir=$3\\nelse\\n\\ttdir=/tmp/testdir\\nfi\\n\\nannex=0\\necho \\\"Temp path $tdir\\\"\\ninit_repo $tdir/branches; cd $tdir/branches; time multi_branch $br $filespb $annex\\ninit_repo $tdir/nobranches; cd $tdir/nobranches; time multi_branch 1 $files $annex\\n\\n#init_repo\\n#time singe_branch\\n\"\n },\n {\n \"alpha_fraction\": 0.6345177888870239,\n \"alphanum_fraction\": 0.6598984599113464,\n \"avg_line_length\": 16.81818199157715,\n \"blob_id\": \"5a69ffcd9f21bd6264f9697664497ba47c5dfca5\",\n \"content_id\": \"b6ab9cf7be778b5a311675deaaed735c548f12c6\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 197,\n \"license_type\": \"permissive\",\n \"max_line_length\": 62,\n \"num_lines\": 11,\n \"path\": \"/tools/bisect-git-annex.scripts/bisect-git-annex-lock.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\nset -eu\\n\\nerr=\\\"thread blocked indefinitely\\\"\\n\\ncd ~/QA\\ntimeout 5 git annex get -J2 sub-* 2>&1 | tee annex-get-log.txt\\nif grep -q \\\"$err\\\" annex-get-log.txt; then\\n\\techo \\\"E: $err\\\"\\n\\texit 1\\nfi\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.7104895114898682,\n \"alphanum_fraction\": 0.7174825072288513,\n \"avg_line_length\": 36.6315803527832,\n \"blob_id\": \"92201b783c024544d73cce186aaa66b029e05d61\",\n \"content_id\": \"942d61603f4545a9ee5ef759937504981a95c445\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 715,\n \"license_type\": \"permissive\",\n \"max_line_length\": 151,\n \"num_lines\": 19,\n \"path\": \"/tools/ci/prep-travis-devel-annex.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/bin/bash\\n\\nset -e -u\\n\\n# configure\\nsed -e 's,/debian ,/debian-devel ,g' /etc/apt/sources.list.d/neurodebian.sources.list | sudo tee /etc/apt/sources.list.d/neurodebian-devel.sources.list\\nsudo apt-get update\\n\\n# check versions\\n# devel:\\ndevel_annex_version=$(apt-cache policy git-annex-standalone | grep -B1 '/debian-devel ' | awk '/ndall/{print $1;}')\\ncurrent_annex_version=$(apt-cache policy git-annex-standalone | awk '/\\\\*\\\\*\\\\*/{print $2}')\\n\\nif dpkg --compare-versions \\\"$devel_annex_version\\\" gt \\\"$current_annex_version\\\"; then\\n sudo apt-get install \\\"git-annex-standalone=$devel_annex_version\\\"\\nelse\\n echo \\\"I: devel version $devel_annex_version is not newer than installed $current_annex_version\\\"\\n exit 99\\nfi\\n\"\n },\n {\n \"alpha_fraction\": 0.5920093655586243,\n \"alphanum_fraction\": 0.5984733700752258,\n \"avg_line_length\": 40.430198669433594,\n \"blob_id\": \"768b165271f273d9795dfbb2134d50b2eb4683d8\",\n \"content_id\": \"f2c04d794272d37ceae4f56d093eacd0164721c0\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 14542,\n \"license_type\": \"permissive\",\n \"max_line_length\": 122,\n \"num_lines\": 351,\n \"path\": \"/datalad/distributed/tests/test_ria_git_remote.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\n\\nimport subprocess\\n\\nfrom datalad.api import (\\n Dataset,\\n clone,\\n)\\nfrom datalad.customremotes.ria_utils import (\\n create_ds_in_store,\\n create_store,\\n get_layout_locations,\\n)\\nfrom datalad.distributed.ora_remote import (\\n LocalIO,\\n SSHRemoteIO,\\n)\\nfrom datalad.distributed.tests.ria_utils import (\\n common_init_opts,\\n populate_dataset,\\n)\\nfrom datalad.interface.results import annexjson2result\\nfrom datalad.tests.utils_pytest import (\\n assert_result_count,\\n assert_status,\\n eq_,\\n known_failure_windows,\\n skip_ssh,\\n slow,\\n with_tempfile,\\n)\\nfrom datalad.utils import (\\n Path,\\n quote_cmdlinearg,\\n)\\n\\n\\n@known_failure_windows # see gh-4469\\n@with_tempfile()\\n@with_tempfile(mkdir=True)\\ndef _test_bare_git_version_1(host, dspath, store):\\n # This test should take a dataset and create a bare repository at the remote\\n # end from it.\\n # Given, that it is placed correctly within a tree of dataset, that remote\\n # thing should then be usable as an ora-remote as well as as a git-type\\n # remote.\\n # Note: Usability of git remote by annex depends on dataset layout version\\n # (dirhashlower vs. -mixed).\\n # For version 1 (lower) upload and consumption should be\\n # interchangeable. It doesn't matter which remote is used for what\\n # direction.\\n ds_path = Path(dspath)\\n store = Path(store)\\n ds = Dataset(ds_path).create()\\n populate_dataset(ds)\\n\\n bare_repo_path, _, objdir = get_layout_locations(1, store, ds.id)\\n # Use git to make sure the remote end is what git thinks a bare clone of it\\n # should look like\\n subprocess.run(['git', 'clone', '--bare',\\n quote_cmdlinearg(str(dspath)),\\n quote_cmdlinearg(str(bare_repo_path))\\n ])\\n\\n if host:\\n url = \\\"ria+ssh://{host}{path}\\\".format(host=host,\\n path=store)\\n else:\\n url = \\\"ria+{}\\\".format(store.as_uri())\\n init_opts = common_init_opts + ['url={}'.format(url)]\\n # set up store:\\n io = SSHRemoteIO(host) if host else LocalIO()\\n create_store(io, store, '1')\\n # set up the dataset location, too.\\n # Note: Dataset layout version 1 (dirhash lower):\\n create_ds_in_store(io, store, ds.id, '1', '1', init_obj_tree=False)\\n\\n # Now, let's have the bare repo as a git remote and use it with annex\\n git_url = \\\"ssh://{host}{path}\\\".format(host=host, path=bare_repo_path) \\\\\\n if host else bare_repo_path.as_uri()\\n ds.repo.add_remote('bare-git', git_url)\\n ds.repo.enable_remote('bare-git')\\n\\n # copy files to the remote\\n ds.push('.', to='bare-git')\\n eq_(len(ds.repo.whereis('one.txt')), 2)\\n\\n # now we can drop all content locally, reobtain it, and survive an\\n # fsck\\n ds.drop('.')\\n ds.get('.')\\n assert_status('ok', [annexjson2result(r, ds) for r in ds.repo.fsck()])\\n\\n # Now, add the ora remote:\\n ds.repo.init_remote('ora-remote', options=init_opts)\\n # fsck to make availability known\\n assert_status(\\n 'ok',\\n [annexjson2result(r, ds)\\n for r in ds.repo.fsck(remote='ora-remote', fast=True)])\\n eq_(len(ds.repo.whereis('one.txt')), 3)\\n\\n # Now move content from git-remote to local and see it not being available\\n # via bare-git anymore.\\n ds.repo.call_annex(['move', '--all', '--from=bare-git'])\\n # ora-remote doesn't know yet:\\n eq_(len(ds.repo.whereis('one.txt')), 2)\\n\\n # But after fsck it does:\\n fsck_res = [annexjson2result(r, ds)\\n for r in ds.repo.fsck(remote='ora-remote', fast=True)]\\n assert_result_count(fsck_res,\\n 1,\\n status='error',\\n error_message='** Based on the location log, one.txt\\\\n'\\n '** was expected to be present, '\\n 'but its content is missing.')\\n assert_result_count(fsck_res,\\n 1,\\n status='error',\\n error_message='** Based on the location log, subdir/two\\\\n'\\n '** was expected to be present, '\\n 'but its content is missing.')\\n eq_(len(ds.repo.whereis('one.txt')), 1)\\n # and the other way around: upload via ora-remote and have it available via\\n # git-remote:\\n ds.push('.', to='ora-remote')\\n # fsck to make availability known\\n assert_status(\\n 'ok',\\n [annexjson2result(r, ds)\\n for r in ds.repo.fsck(remote='bare-git', fast=True)])\\n eq_(len(ds.repo.whereis('one.txt')), 3)\\n\\n\\n@slow # 12sec + ? on travis\\ndef test_bare_git_version_1():\\n # TODO: Skipped due to gh-4436\\n known_failure_windows(skip_ssh(_test_bare_git_version_1))('datalad-test')\\n _test_bare_git_version_1(None)\\n\\n\\n@known_failure_windows # see gh-4469\\n@with_tempfile()\\n@with_tempfile(mkdir=True)\\ndef _test_bare_git_version_2(host, dspath, store):\\n # Similarly to test_bare_git_version_1, this should ensure a bare git repo\\n # at the store location for a dataset doesn't conflict with the ORA remote.\\n # Note: Usability of git remote by annex depends on dataset layout version\\n # (dirhashlower vs. -mixed).\\n # For version 2 (mixed) upload via ORA and consumption via git should\\n # work. But not the other way around, since git-annex uses\\n # dirhashlower with bare repos.\\n\\n ds_path = Path(dspath)\\n store = Path(store)\\n ds = Dataset(ds_path).create()\\n populate_dataset(ds)\\n\\n bare_repo_path, _, objdir = get_layout_locations(1, store, ds.id)\\n # Use git to make sure the remote end is what git thinks a bare clone of it\\n # should look like\\n subprocess.run(['git', 'clone', '--bare',\\n quote_cmdlinearg(str(dspath)),\\n quote_cmdlinearg(str(bare_repo_path))\\n ])\\n\\n if host:\\n url = \\\"ria+ssh://{host}{path}\\\".format(host=host,\\n path=store)\\n else:\\n url = \\\"ria+{}\\\".format(store.as_uri())\\n init_opts = common_init_opts + ['url={}'.format(url)]\\n # set up store:\\n io = SSHRemoteIO(host) if host else LocalIO()\\n create_store(io, store, '1')\\n # set up the dataset location, too.\\n # Note: Dataset layout version 2 (dirhash mixed):\\n create_ds_in_store(io, store, ds.id, '2', '1')\\n # Avoid triggering a git-annex safety check. See gh-5253.\\n assert objdir.is_absolute()\\n io.remove_dir(objdir)\\n\\n # Now, let's have the bare repo as a git remote\\n git_url = \\\"ssh://{host}{path}\\\".format(host=host, path=bare_repo_path) \\\\\\n if host else bare_repo_path.as_uri()\\n ds.repo.add_remote('bare-git', git_url)\\n ds.repo.enable_remote('bare-git')\\n # and the ORA remote in addition:\\n ds.repo.init_remote('ora-remote', options=init_opts)\\n # upload keys via ORA:\\n ds.push('.', to='ora-remote')\\n # bare-git doesn't know yet:\\n eq_(len(ds.repo.whereis('one.txt')), 2)\\n # fsck to make availability known\\n assert_status(\\n 'ok',\\n [annexjson2result(r, ds)\\n for r in ds.repo.fsck(remote='bare-git', fast=True)])\\n eq_(len(ds.repo.whereis('one.txt')), 3)\\n ds.drop('.')\\n eq_(len(ds.repo.whereis('one.txt')), 2)\\n # actually consumable via git remote:\\n ds.repo.call_annex(['move', 'one.txt', '--from', 'bare-git'])\\n eq_(len(ds.repo.whereis('one.txt')), 2)\\n # now, move back via git - shouldn't be consumable via ORA\\n ds.repo.call_annex(['move', 'one.txt', '--to', 'bare-git'])\\n # fsck to make availability known, but there's nothing from POV of ORA:\\n fsck_res = [annexjson2result(r, ds)\\n for r in ds.repo.fsck(remote='ora-remote', fast=True)]\\n assert_result_count(fsck_res,\\n 1,\\n status='error',\\n error_message='** Based on the location log, one.txt\\\\n'\\n '** was expected to be present, '\\n 'but its content is missing.')\\n assert_result_count(fsck_res, 3, status='ok')\\n eq_(len(fsck_res), 4)\\n eq_(len(ds.repo.whereis('one.txt')), 1)\\n\\n\\n@slow # 13sec + ? on travis\\ndef test_bare_git_version_2():\\n # TODO: Skipped due to gh-4436\\n known_failure_windows(skip_ssh(_test_bare_git_version_2))('datalad-test')\\n _test_bare_git_version_2(None)\\n\\n# TODO: Outcommented \\\"old\\\" test from git-annex-ria-remote. This one needs to be\\n# revisited after RF'ing to base ORA on proper command abstractions for\\n# remote execution\\n\\n# @skip_if_on_windows\\n# @with_tempfile\\n# @with_tempfile(mkdir=True)\\n# @serve_path_via_http\\n# @with_tempfile\\n# @with_tempfile\\n# @with_tempfile(mkdir=True)\\n# def test_create_as_bare(origin=None, remote_base_path=None, remote_base_url=None, public=None,\\n# consumer=None, tmp_location=None):\\n#\\n# # Note/TODO: Do we need things like:\\n# # git config receive.denyCurrentBranch updateInstead\\n# # mv .hooks/post-update.sample hooks/post-update\\n# # git update-server-info\\n#\\n# # Test how we build a riaremote from an existing dataset, that is a bare git repo and can be accessed as a git type\\n# # remote as well. This should basically outline how to publish to that kind of structure as a data store, that is\\n# # autoenabled, so we can publish to github/gitlab and make that storage known.\\n#\\n# remote_base_path = Path(remote_base_path)\\n#\\n# ds = create(origin)\\n# populate_dataset(ds)\\n# assert_repo_status(ds.path)\\n#\\n# # add the ria remote:\\n# # Note: For serve_path_via_http to work (which we need later), the directory needs to already exist.\\n# # But by default ORARemote will reject to create the remote structure in an already existing directory,\\n# # that wasn't created by itself (lacks as ria-layout-version file).\\n# # So, we can either configure force-write here or put a version file in it beforehand.\\n# # However, this is specific to the test environment!\\n# with open(str(remote_base_path / 'ria-layout-version'), 'w') as f:\\n# f.write('1')\\n# initexternalremote(ds.repo, 'riaremote', 'ora', config={'base-path': str(remote_base_path)})\\n# # pretty much any annex command that talks to that remote should now trigger the actual creation on the remote end:\\n# assert_status(\\n# 'ok',\\n# [annexjson2result(r, ds)\\n# for r in ds.repo.fsck(remote='riaremote', fast=True)])\\n#\\n# remote_dataset_path = remote_base_path / ds.id[:3] / ds.id[3:]\\n#\\n# assert remote_base_path.exists()\\n# assert remote_dataset_path.exists()\\n# ds.push('.', to='riaremote')\\n#\\n# # Now, let's make the remote end a valid, bare git repository\\n# eq_(subprocess.run(['git', 'init', '--bare'], cwd=str(remote_dataset_path)).returncode,\\n# 0)\\n#\\n# #subprocess.run(['mv', 'hooks/post-update.sample', 'hooks/post-update'], cwd=remote_dataset_path)\\n# #subprocess.run(['git', 'update-server-info'], cwd=remote_dataset_path)\\n#\\n# # TODO: we might need \\\"mv .hooks/post-update.sample hooks/post-update\\\", \\\"git update-server-info\\\" as well\\n# # add as git remote and push everything\\n# eq_(subprocess.run(['git', 'remote', 'add', 'bare-git', str(remote_dataset_path)], cwd=origin).returncode,\\n# 0)\\n# # Note: \\\"--mirror\\\" does the job for this test, while it might not be a good default some kind of\\n# # datalad-create-sibling. However those things need to be configurable for actual publish/creation routine anyway\\n# eq_(subprocess.run(['git', 'push', '--mirror', 'bare-git'], cwd=origin).returncode,\\n# 0)\\n#\\n# # annex doesn't know the bare-git remote yet:\\n# eq_(len(ds.repo.whereis('one.txt')), 2)\\n# # But after enableremote and a fsck it does:\\n# eq_(subprocess.run(['git', 'annex', 'enableremote', 'bare-git'], cwd=origin).returncode,\\n# 0)\\n# assert_status(\\n# 'ok',\\n# [annexjson2result(r, ds)\\n# for r in ds.repo.fsck(remote='bare-git', fast=True)])\\n# eq_(len(ds.repo.whereis('one.txt')), 3)\\n#\\n# # we can drop and get again via 'bare-git' remote:\\n# ds.drop('.')\\n# eq_(len(ds.repo.whereis('one.txt')), 2)\\n# eq_(subprocess.run(['git', 'annex', 'get', 'one.txt', '--from', 'bare-git'], cwd=origin).returncode,\\n# 0)\\n# eq_(len(ds.repo.whereis('one.txt')), 3)\\n# # let's get the other one from riaremote\\n# eq_(len(ds.repo.whereis(op.join('subdir', 'two'))), 2)\\n# eq_(subprocess.run(['git', 'annex', 'get', op.join('subdir', 'two'), '--from', 'riaremote'], cwd=origin).returncode,\\n# 0)\\n# eq_(len(ds.repo.whereis(op.join('subdir', 'two'))), 3)\\n#\\n# raise SkipTest(\\\"NOT YET DONE\\\")\\n# # TODO: Part below still doesn't work. \\\"'storage' is not available\\\" when trying to copy to it. May be the HTTP\\n# # Server is not available from within the context of the git-type special remote? Either way, still smells like an\\n# # issue with the f****** test setup.\\n#\\n#\\n#\\n# # Now, let's try make it a data store for datasets available from elsewhere (like github or gitlab):\\n# # For this test, we need a second git remote pointing to remote_dataset_path, but via HTTP.\\n# # This is because annex-initremote for a git-type special remote requires a git remote pointing to the same location\\n# # and it fails to match local paths. Also doesn't work with file:// scheme.\\n# #\\n# # TODO: Figure it out in detail. That issue is either a bug or not \\\"real\\\".\\n# #\\n# # ds.repo._allow_local_urls()\\n# # dataset_url = remote_base_url + ds.id[:3] + '/' + ds.id[3:] + '/'\\n# # eq_(subprocess.run(['git', 'remote', 'add', 'datasrc', dataset_url],\\n# # cwd=origin).returncode,\\n# # 0)\\n# # eq_(subprocess.run(['git', 'annex', 'initremote', 'storage', 'type=git',\\n# # 'location={}'.format(dataset_url), 'autoenable=true'],\\n# # cwd=origin).returncode,\\n# # 0)\\n# # assert_status(\\n# # 'ok',\\n# # [annexjson2result(r, ds)\\n# # for r in fsck(ds.repo, remote='storage', fast=True)])\\n\"\n },\n {\n \"alpha_fraction\": 0.6054096817970276,\n \"alphanum_fraction\": 0.6075311303138733,\n \"avg_line_length\": 37.479591369628906,\n \"blob_id\": \"bbe1685ed58288a093751b23257e12c19b17292d\",\n \"content_id\": \"739130044659bfec5aeec09d50877c0c68d4b95b\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 15084,\n \"license_type\": \"permissive\",\n \"max_line_length\": 92,\n \"num_lines\": 392,\n \"path\": \"/datalad/support/tests/test_fileinfo.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Test file info getters\\\"\\\"\\\"\\n\\n\\nimport os.path as op\\nfrom pathlib import Path\\n\\nimport datalad.utils as ut\\nfrom datalad.distribution.dataset import Dataset\\nfrom datalad.support.exceptions import NoSuchPathError\\nfrom datalad.support.gitrepo import GitRepo\\nfrom datalad.tests.utils_pytest import (\\n assert_dict_equal,\\n assert_equal,\\n assert_false,\\n assert_in,\\n assert_not_in,\\n assert_raises,\\n assert_repo_status,\\n get_annexstatus,\\n get_convoluted_situation,\\n known_failure_githubci_win,\\n on_nfs,\\n on_travis,\\n slow,\\n skip_if,\\n with_tempfile,\\n with_tree,\\n)\\n\\n\\n@slow # 10sec on travis\\n@known_failure_githubci_win\\n@with_tempfile\\ndef test_get_content_info(path=None):\\n repo = GitRepo(path)\\n assert_equal(repo.get_content_info(), {})\\n # an invalid reference causes an exception\\n assert_raises(ValueError, repo.get_content_info, ref='HEAD')\\n\\n ds = get_convoluted_situation(path)\\n repopath = ds.repo.pathobj\\n\\n assert_equal(ds.repo.pathobj, repopath)\\n assert_equal(ds.pathobj, ut.Path(path))\\n\\n # verify general rules on fused info records that are incrementally\\n # assembled: for git content info, amended with annex info on 'HEAD'\\n # (to get the last committed stage and with it possibly vanished\\n # content), and lastly annex info wrt to the present worktree, to\\n # also get info on added/staged content\\n # this fuses the info reported from\\n # - git ls-files\\n # - git annex findref HEAD\\n # - git annex find --include '*'\\n for f, r in get_annexstatus(ds.repo).items():\\n if f.match('*_untracked'):\\n assert(r.get('gitshasum', None) is None)\\n if f.match('*_deleted'):\\n assert(not f.exists() and not f.is_symlink() is None)\\n if f.match('subds_*'):\\n assert(r['type'] == 'dataset' if r.get('gitshasum', None) else 'directory')\\n if f.match('file_*'):\\n # which one exactly depends on many things\\n assert_in(r['type'], ('file', 'symlink'))\\n if f.match('file_ingit*'):\\n assert(r['type'] == 'file')\\n elif '.datalad' not in f.parts and not f.match('.git*') and \\\\\\n r.get('gitshasum', None) and not f.match('subds*'):\\n # this should be known to annex, one way or another\\n # regardless of whether things add deleted or staged\\n # or anything in between\\n assert_in('key', r, f)\\n assert_in('keyname', r, f)\\n assert_in('backend', r, f)\\n assert_in('bytesize', r, f)\\n # no duplication with path\\n assert_not_in('file', r, f)\\n\\n # query full untracked report\\n res = ds.repo.get_content_info()\\n assert_in(repopath.joinpath('dir_untracked', 'file_untracked'), res)\\n assert_not_in(repopath.joinpath('dir_untracked'), res)\\n # query for compact untracked report\\n res = ds.repo.get_content_info(untracked='normal')\\n assert_not_in(repopath.joinpath('dir_untracked', 'file_untracked'), res)\\n assert_in(repopath.joinpath('dir_untracked'), res)\\n # query no untracked report\\n res = ds.repo.get_content_info(untracked='no')\\n assert_not_in(repopath.joinpath('dir_untracked', 'file_untracked'), res)\\n assert_not_in(repopath.joinpath('dir_untracked'), res)\\n\\n # git status integrity\\n status = ds.repo.status()\\n for t in ('subds', 'file'):\\n for s in ('untracked', 'added', 'deleted', 'clean',\\n 'ingit_clean', 'dropped_clean', 'modified',\\n 'ingit_modified'):\\n for l in ('', ut.PurePosixPath('subdir', '')):\\n if t == 'subds' and 'ingit' in s or 'dropped' in s:\\n # invalid combination\\n continue\\n if t == 'subds' and s == 'deleted':\\n # same as subds_unavailable -> clean\\n continue\\n p = repopath.joinpath(l, '{}_{}'.format(t, s))\\n assert p.match('*_{}'.format(status[p]['state'])), p\\n if t == 'subds':\\n assert_in(status[p]['type'], ('dataset', 'directory'), p)\\n else:\\n assert_in(status[p]['type'], ('file', 'symlink'), p)\\n\\n # git annex status integrity\\n annexstatus = get_annexstatus(ds.repo)\\n for t in ('file',):\\n for s in ('untracked', 'added', 'deleted', 'clean',\\n 'ingit_clean', 'dropped_clean', 'modified',\\n 'ingit_modified'):\\n for l in ('', ut.PurePosixPath('subdir', '')):\\n p = repopath.joinpath(l, '{}_{}'.format(t, s))\\n if s in ('untracked', 'ingit_clean', 'ingit_modified'):\\n # annex knows nothing about these things\\n assert_not_in('key', annexstatus[p])\\n continue\\n assert_in('key', annexstatus[p])\\n # dear future,\\n # if the next one fails, git-annex might have changed the\\n # nature of the path that are being reported by\\n # `annex find --json`\\n # when this was written `hashir*` was a native path, but\\n # `file` was a POSIX path\\n assert_equal(annexstatus[p]['has_content'], 'dropped' not in s)\\n\\n # check the different subds evaluation modes\\n someds = Dataset(ds.pathobj / 'subds_modified' / 'someds')\\n dirtyds_path = someds.pathobj / 'dirtyds'\\n assert_not_in(\\n 'state',\\n someds.repo.status(eval_submodule_state='no')[dirtyds_path]\\n )\\n assert_equal(\\n 'clean',\\n someds.repo.status(eval_submodule_state='commit')[dirtyds_path]['state']\\n )\\n assert_equal(\\n 'modified',\\n someds.repo.status(eval_submodule_state='full')[dirtyds_path]['state']\\n )\\n\\n\\n\\n@with_tempfile\\ndef test_compare_content_info(path=None):\\n # TODO remove when `create` is RF to return the new Dataset\\n ds = Dataset(path).create()\\n assert_repo_status(path)\\n\\n # for a clean repo HEAD and worktree query should yield identical results\\n # minus a 'bytesize' report that is readily available for HEAD, but would\\n # not a stat call per file for the worktree, and is not done ATM\\n wt = ds.repo.get_content_info(ref=None)\\n assert_dict_equal(\\n wt,\\n {f: {k: v for k, v in p.items() if k != 'bytesize'}\\n for f, p in ds.repo.get_content_info(ref='HEAD').items()}\\n )\\n\\n\\n@with_tempfile\\ndef test_subds_path(path=None):\\n # a dataset with a subdataset with a file, all neatly tracked\\n ds = Dataset(path).create()\\n subds = ds.create('sub')\\n assert_repo_status(path)\\n with (subds.pathobj / 'some.txt').open('w') as f:\\n f.write(u'test')\\n ds.save(recursive=True)\\n assert_repo_status(path)\\n\\n # querying the toplevel dataset repo for a subdspath should\\n # report the subdataset record in the dataset\\n # (unlike `git status`, which is silent for subdataset paths),\\n # but definitely not report the subdataset as deleted\\n # https://github.com/datalad/datalad-revolution/issues/17\\n stat = ds.repo.status(paths=[op.join('sub', 'some.txt')])\\n assert_equal(list(stat.keys()), [subds.repo.pathobj])\\n assert_equal(stat[subds.repo.pathobj]['state'], 'clean')\\n\\n\\n@skip_if(on_travis and on_nfs) # TODO. stalls https://github.com/datalad/datalad/pull/7372\\n@with_tempfile\\ndef test_report_absent_keys(path=None):\\n ds = Dataset(path).create()\\n # create an annexed file\\n testfile = ds.pathobj / 'dummy'\\n testfile.write_text(u'nothing')\\n ds.save()\\n # present in a full report and in a partial report\\n # based on worktree of HEAD ref\\n for ai in (\\n ds.repo.get_content_annexinfo(eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n paths=['dummy'],\\n eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n ref='HEAD',\\n eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n ref='HEAD',\\n paths=['dummy'],\\n eval_availability=True)):\\n assert_in(testfile, ai)\\n assert_equal(ai[testfile]['has_content'], True)\\n # drop the key, not available anywhere else\\n ds.drop('dummy', reckless='kill')\\n # does not change a thing, except the key is gone\\n for ai in (\\n ds.repo.get_content_annexinfo(eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n paths=['dummy'],\\n eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n ref='HEAD',\\n eval_availability=True),\\n ds.repo.get_content_annexinfo(\\n ref='HEAD',\\n paths=['dummy'],\\n eval_availability=True)):\\n assert_in(testfile, ai)\\n assert_equal(ai[testfile]['has_content'], False)\\n # make sure files with URL keys are correctly reported:\\n from datalad.conftest import test_http_server\\n remote_file_name = 'imaremotefile.dat'\\n local_file_name = 'mehasurlkey'\\n (Path(test_http_server.path) / remote_file_name).write_text(\\\"weee\\\")\\n remote_file_url = f'{test_http_server.url}/{remote_file_name}'\\n # we need to get a file with a URL key and check its local availability\\n ds.repo.call_annex(['addurl', '--relaxed', remote_file_url, '--file',\\n local_file_name])\\n ds.save(\\\"URL keys!\\\")\\n # should not be there\\n res = ds.repo.get_file_annexinfo(local_file_name, eval_availability=True)\\n assert_equal(res['has_content'], False)\\n ds.get(local_file_name)\\n # should be there\\n res = ds.repo.get_file_annexinfo(local_file_name, eval_availability=True)\\n assert_equal(res['has_content'], True)\\n\\n\\n@with_tempfile\\ndef test_annexinfo_init(path=None):\\n ds = Dataset(path).create()\\n foo = ds.pathobj / \\\"foo\\\"\\n foo_cont = b\\\"foo content\\\"\\n foo.write_bytes(foo_cont)\\n bar = ds.pathobj / \\\"bar\\\"\\n bar.write_text(u\\\"bar content\\\")\\n ds.save()\\n\\n # Custom init limits report, with original dict getting updated.\\n cinfo_custom_init = ds.repo.get_content_annexinfo(\\n init={foo: {\\\"bytesize\\\": 0,\\n \\\"this-is-surely-only-here\\\": \\\"right?\\\"}})\\n assert_not_in(bar, cinfo_custom_init)\\n assert_in(foo, cinfo_custom_init)\\n assert_equal(cinfo_custom_init[foo][\\\"bytesize\\\"], len(foo_cont))\\n assert_equal(cinfo_custom_init[foo][\\\"this-is-surely-only-here\\\"],\\n \\\"right?\\\")\\n\\n # \\\"git\\\" injects get_content_info() values.\\n cinfo_init_git = ds.repo.get_content_annexinfo(init=\\\"git\\\")\\n assert_in(\\\"gitshasum\\\", cinfo_init_git[foo])\\n\\n # init=None, on the other hand, does not.\\n cinfo_init_none = ds.repo.get_content_annexinfo(init=None)\\n assert_in(foo, cinfo_init_none)\\n assert_in(bar, cinfo_init_none)\\n assert_not_in(\\\"gitshasum\\\", cinfo_init_none[foo])\\n\\n\\n@with_tempfile\\ndef test_info_path_inside_submodule(path=None):\\n ds = Dataset(path).create()\\n subds = ds.create(\\\"submod\\\")\\n foo = (subds.pathobj / \\\"foo\\\")\\n foo.write_text(\\\"foo\\\")\\n ds.save(recursive=True)\\n cinfo = ds.repo.get_content_info(\\n ref=\\\"HEAD\\\", paths=[foo.relative_to(ds.pathobj)])\\n assert_in(\\\"gitshasum\\\", cinfo[subds.pathobj])\\n\\n\\n@with_tempfile\\ndef test_get_content_info_dotgit(path=None):\\n ds = Dataset(path).create()\\n # Files in .git/ won't be reported, though this takes a kludge on our side\\n # before Git 2.25.\\n assert_false(ds.repo.get_content_info(paths=[op.join(\\\".git\\\", \\\"config\\\")]))\\n\\n\\n@with_tempfile\\ndef test_get_content_info_paths_empty_list(path=None):\\n ds = Dataset(path).create()\\n\\n # Unlike None, passing any empty list as paths to get_content_info() does\\n # not report on all content.\\n assert_false(ds.repo.get_content_info(paths=[]))\\n assert_false(ds.repo.get_content_info(paths=[], ref=\\\"HEAD\\\"))\\n\\n # Add annex content to make sure its not reported.\\n (ds.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n ds.save()\\n\\n # Same for get_content_annexinfo()...\\n assert_false(ds.repo.get_content_annexinfo(paths=[]))\\n assert_false(ds.repo.get_content_annexinfo(paths=[], init=None))\\n assert_false(ds.repo.get_content_annexinfo(paths=[], ref=\\\"HEAD\\\"))\\n assert_false(\\n ds.repo.get_content_annexinfo(paths=[], ref=\\\"HEAD\\\", init=None))\\n # ... where whatever was passed for init will be returned as is.\\n assert_equal(\\n ds.repo.get_content_annexinfo(\\n paths=[], ref=\\\"HEAD\\\", init={\\\"random\\\": {\\\"entry\\\": \\\"a\\\"}}),\\n {\\\"random\\\": {\\\"entry\\\": \\\"a\\\"}})\\n\\n\\n@with_tempfile\\ndef test_status_paths_empty_list(path=None):\\n ds = Dataset(path).create()\\n assert_equal(ds.repo.status(paths=[]), {})\\n\\n\\n@with_tree(tree=(('ingit.txt', 'ingit'),\\n ('inannex.txt', 'inannex'),\\n ('dir1', {'dropped': 'dropped'}),\\n ('dir2', {'d21': 'd21', 'd22': 'd22'})))\\ndef test_get_file_annexinfo(path=None):\\n ds = Dataset(path).create(force=True)\\n ds.save('ingit.txt', to_git=True)\\n ds.save()\\n # have some content-less component for testing\\n ds.drop(ds.pathobj / 'dir1', reckless='kill')\\n\\n repo = ds.repo\\n # only handles a single file at a time\\n assert_raises(ValueError, repo.get_file_annexinfo, repo.pathobj / 'dir2')\\n # however, it only functionally matters that there is only a single file to\\n # report on not that the exact query path matches, the matching path is in\\n # the report\\n assert_equal(\\n repo.pathobj / 'dir1' / 'dropped',\\n repo.get_file_annexinfo(repo.pathobj / 'dir1')['path'])\\n\\n # does not raise on a non-annex file, instead it returns no properties\\n assert_equal(repo.get_file_annexinfo('ingit.txt'), {})\\n\\n # but does raise on path that doesn exist\\n assert_raises(NoSuchPathError, repo.get_file_annexinfo, 'nothere')\\n\\n # check return properties for utility\\n props = repo.get_file_annexinfo('inannex.txt')\\n # to replace get_file_backend()\\n assert_equal(props['backend'], 'MD5E')\\n # to replace get_file_key()\\n assert_equal(props['key'], 'MD5E-s7--3b158c5b0a18c247ebad28c09fc3e180.txt')\\n # for size reporting\\n assert_equal(props['bytesize'], 7)\\n # all records have a pathobj\\n assert_equal(props['path'], repo.pathobj / 'inannex.txt')\\n # test if `eval_availability` has desired effect\\n assert_not_in('has_content', props)\\n\\n # extended set of properties, after more expensive availability check\\n props = repo.get_file_annexinfo('inannex.txt', eval_availability=True)\\n # to replace file_has_content()\\n assert_equal(props['has_content'], True)\\n # to replace get_contentlocation()\\n assert_equal(\\n Path(props['objloc']).read_text(),\\n 'inannex')\\n\\n # make sure has_content is not always True\\n props = repo.get_file_annexinfo(\\n ds.pathobj / 'dir1' / 'dropped', eval_availability=True)\\n assert_equal(props['has_content'], False)\\n assert_not_in('objloc', props)\\n\"\n },\n {\n \"alpha_fraction\": 0.6220777034759521,\n \"alphanum_fraction\": 0.6345899701118469,\n \"avg_line_length\": 34.929969787597656,\n \"blob_id\": \"605fef2763039c9ebec64a1401fd38c71004f434\",\n \"content_id\": \"df5c9b60bef06836f6e74f880612a6babeab582f\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 99023,\n \"license_type\": \"permissive\",\n \"max_line_length\": 194,\n \"num_lines\": 2756,\n \"path\": \"/datalad/support/tests/test_annexrepo.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Test implementation of class AnnexRepo\\n\\n\\\"\\\"\\\"\\n\\nimport gc\\nimport json\\nimport logging\\nimport os\\nimport re\\nimport sys\\nimport unittest.mock\\nfrom functools import partial\\nfrom glob import glob\\nfrom os import mkdir\\nfrom os.path import (\\n basename,\\n curdir,\\n exists,\\n)\\nfrom os.path import join as opj\\nfrom os.path import (\\n pardir,\\n relpath,\\n)\\nfrom queue import Queue\\nfrom shutil import copyfile\\nfrom unittest.mock import patch\\nfrom urllib.parse import (\\n urljoin,\\n urlsplit,\\n)\\n\\nimport pytest\\n\\nfrom datalad import cfg as dl_cfg\\nfrom datalad.api import clone\\nfrom datalad.cmd import GitWitlessRunner\\nfrom datalad.cmd import WitlessRunner as Runner\\nfrom datalad.consts import (\\n DATALAD_SPECIAL_REMOTE,\\n DATALAD_SPECIAL_REMOTES_UUIDS,\\n WEB_SPECIAL_REMOTE_UUID,\\n)\\nfrom datalad.distribution.dataset import Dataset\\nfrom datalad.runner.gitrunner import GitWitlessRunner\\nfrom datalad.support import path as op\\n# imports from same module:\\nfrom datalad.support.annexrepo import (\\n AnnexJsonProtocol,\\n AnnexRepo,\\n GeneratorAnnexJsonNoStderrProtocol,\\n GeneratorAnnexJsonProtocol,\\n)\\nfrom datalad.support.exceptions import (\\n AnnexBatchCommandError,\\n CommandError,\\n FileInGitError,\\n FileNotInAnnexError,\\n FileNotInRepositoryError,\\n IncompleteResultsError,\\n InsufficientArgumentsError,\\n MissingExternalDependency,\\n OutdatedExternalDependency,\\n OutOfSpaceError,\\n RemoteNotAvailableError,\\n)\\nfrom datalad.support.external_versions import external_versions\\nfrom datalad.support.gitrepo import GitRepo\\nfrom datalad.support.sshconnector import get_connection_hash\\nfrom datalad.tests.utils_pytest import (\\n DEFAULT_BRANCH,\\n DEFAULT_REMOTE,\\n OBSCURE_FILENAME,\\n SkipTest,\\n assert_cwd_unchanged,\\n)\\nfrom datalad.tests.utils_pytest import assert_dict_equal as deq_\\nfrom datalad.tests.utils_pytest import (\\n assert_equal,\\n assert_false,\\n assert_in,\\n assert_is_instance,\\n assert_not_equal,\\n assert_not_in,\\n assert_not_is_instance,\\n assert_raises,\\n assert_re_in,\\n assert_repo_status,\\n assert_result_count,\\n assert_true,\\n create_tree,\\n eq_,\\n find_files,\\n get_most_obscure_supported_name,\\n known_failure_githubci_win,\\n known_failure_windows,\\n maybe_adjust_repo,\\n ok_,\\n ok_annex_get,\\n ok_file_has_content,\\n ok_file_under_git,\\n ok_git_config_not_empty,\\n on_nfs,\\n on_travis,\\n serve_path_via_http,\\n set_annex_version,\\n skip_if,\\n skip_if_adjusted_branch,\\n skip_if_on_windows,\\n skip_if_root,\\n skip_nomultiplex_ssh,\\n slow,\\n swallow_logs,\\n swallow_outputs,\\n with_parametric_batch,\\n with_sameas_remote,\\n with_tempfile,\\n with_tree,\\n xfail_buggy_annex_info,\\n)\\nfrom datalad.utils import (\\n Path,\\n chpwd,\\n get_linux_distribution,\\n on_windows,\\n quote_cmdlinearg,\\n rmtree,\\n unlink,\\n)\\n\\n\\n_GIT_ANNEX_VERSIONS_INFO = AnnexRepo.check_repository_versions()\\n\\n\\n@assert_cwd_unchanged\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_instance_from_clone(src=None, dst=None):\\n\\n origin = AnnexRepo(src, create=True)\\n ar = AnnexRepo.clone(src, dst)\\n assert_is_instance(ar, AnnexRepo, \\\"AnnexRepo was not created.\\\")\\n ok_(os.path.exists(os.path.join(dst, '.git', 'annex')))\\n\\n # do it again should raise ValueError since git will notice\\n # there's already a git-repo at that path and therefore can't clone to `dst`\\n with swallow_logs(new_level=logging.WARN) as cm:\\n assert_raises(ValueError, AnnexRepo.clone, src, dst)\\n\\n\\n@assert_cwd_unchanged\\n@with_tempfile\\ndef test_AnnexRepo_instance_from_existing(path=None):\\n AnnexRepo(path, create=True)\\n\\n ar = AnnexRepo(path)\\n assert_is_instance(ar, AnnexRepo, \\\"AnnexRepo was not created.\\\")\\n ok_(os.path.exists(os.path.join(path, '.git')))\\n\\n\\n@assert_cwd_unchanged\\n@with_tempfile\\ndef test_AnnexRepo_instance_brand_new(path=None):\\n\\n GitRepo(path)\\n assert_raises(RuntimeError, AnnexRepo, path, create=False)\\n\\n ar = AnnexRepo(path)\\n assert_is_instance(ar, AnnexRepo, \\\"AnnexRepo was not created.\\\")\\n ok_(os.path.exists(os.path.join(path, '.git')))\\n\\n\\n@assert_cwd_unchanged\\n@with_tempfile\\ndef test_AnnexRepo_crippled_filesystem(dst=None):\\n\\n ar = AnnexRepo(dst)\\n\\n # fake git-annex entries in .git/config:\\n ar.config.set(\\n \\\"annex.crippledfilesystem\\\",\\n 'true',\\n scope='local')\\n ok_(ar.is_crippled_fs())\\n ar.config.set(\\n \\\"annex.crippledfilesystem\\\",\\n 'false',\\n scope='local')\\n assert_false(ar.is_crippled_fs())\\n # since we can't remove the entry, just rename it to fake its absence:\\n ar.config.rename_section(\\\"annex\\\", \\\"removed\\\", scope='local')\\n ar.config.set(\\\"annex.something\\\", \\\"value\\\", scope='local')\\n assert_false(ar.is_crippled_fs())\\n\\n\\n@known_failure_githubci_win\\n@with_tempfile\\n@assert_cwd_unchanged\\ndef test_AnnexRepo_is_direct_mode(path=None):\\n\\n ar = AnnexRepo(path)\\n eq_(ar.config.getbool(\\\"annex\\\", \\\"direct\\\", False),\\n ar.is_direct_mode())\\n\\n\\n@known_failure_githubci_win\\n@with_tempfile()\\ndef test_AnnexRepo_is_direct_mode_gitrepo(path=None):\\n repo = GitRepo(path, create=True)\\n # artificially make .git/annex so no annex section gets initialized\\n # in .git/config. We did manage somehow to make this happen (via publish)\\n # but didn't reproduce yet, so just creating manually\\n mkdir(opj(repo.path, '.git', 'annex'))\\n ar = AnnexRepo(path, init=False, create=False)\\n # It is unlikely though that annex would be in direct mode (requires explicit)\\n # annex magic, without having annex section under .git/config\\n dm = ar.is_direct_mode()\\n # no direct mode, ever\\n assert_false(dm)\\n\\n\\n# ignore warning since we are testing that function here. Remove upon full deprecation\\n@pytest.mark.filterwarnings(r\\\"ignore: AnnexRepo.get_file_key\\\\(\\\\) is deprecated\\\")\\n@assert_cwd_unchanged\\n@with_tempfile\\ndef test_AnnexRepo_get_file_key(annex_path=None):\\n\\n ar = AnnexRepo(annex_path)\\n (ar.pathobj / 'test.dat').write_text('123\\\\n')\\n ar.save('test.dat', git=True)\\n (ar.pathobj / 'test-annex.dat').write_text(\\n \\\"content to be annex-addurl'd\\\")\\n ar.save('some')\\n\\n # test-annex.dat should return the correct key:\\n test_annex_key = \\\\\\n 'SHA256E-s28' \\\\\\n '--2795fb26981c5a687b9bf44930cc220029223f472cea0f0b17274f4473181e7b.dat'\\n eq_(ar.get_file_key(\\\"test-annex.dat\\\"), test_annex_key)\\n\\n # and should take a list with an empty string as result, if a file wasn't\\n # in annex:\\n eq_(\\n ar.get_file_key([\\\"filenotpresent.wtf\\\", \\\"test-annex.dat\\\"]),\\n ['', test_annex_key]\\n )\\n\\n # test.dat is actually in git\\n # should raise Exception; also test for polymorphism\\n assert_raises(IOError, ar.get_file_key, \\\"test.dat\\\")\\n assert_raises(FileNotInAnnexError, ar.get_file_key, \\\"test.dat\\\")\\n assert_raises(FileInGitError, ar.get_file_key, \\\"test.dat\\\")\\n\\n # filenotpresent.wtf doesn't even exist\\n assert_raises(IOError, ar.get_file_key, \\\"filenotpresent.wtf\\\")\\n\\n # if we force batch mode, no failure for not present or not annexed files\\n eq_(ar.get_file_key(\\\"filenotpresent.wtf\\\", batch=True), '')\\n eq_(ar.get_file_key(\\\"test.dat\\\", batch=True), '')\\n eq_(ar.get_file_key(\\\"test-annex.dat\\\", batch=True), test_annex_key)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_AnnexRepo_get_outofspace(annex_path=None):\\n ar = AnnexRepo(annex_path, create=True)\\n\\n def raise_cmderror(*args, **kwargs):\\n raise CommandError(\\n cmd=\\\"whatever\\\",\\n stderr=\\\"junk around not enough free space, need 905.6 MB more and after\\\"\\n )\\n\\n with patch.object(GitWitlessRunner, 'run_on_filelist_chunks', raise_cmderror) as cma, \\\\\\n assert_raises(OutOfSpaceError) as cme:\\n ar.get(\\\"file\\\")\\n exc = cme.value\\n eq_(exc.sizemore_msg, '905.6 MB')\\n assert_re_in(\\\".*annex.*(find|get).*needs 905.6 MB more\\\", str(exc), re.DOTALL)\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get_remote_na(src=None, path=None):\\n origin = AnnexRepo(src, create=True)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save()\\n ar = AnnexRepo.clone(src, path)\\n\\n with assert_raises(RemoteNotAvailableError) as cme:\\n ar.get('test-annex.dat', options=[\\\"--from=NotExistingRemote\\\"])\\n eq_(cme.value.remote, \\\"NotExistingRemote\\\")\\n\\n # and similar one whenever invoking with remote parameter\\n with assert_raises(RemoteNotAvailableError) as cme:\\n ar.get('test-annex.dat', remote=\\\"NotExistingRemote\\\")\\n eq_(cme.value.remote, \\\"NotExistingRemote\\\")\\n\\n\\n@with_sameas_remote\\ndef test_annex_repo_sameas_special(repo=None):\\n remotes = repo.get_special_remotes()\\n eq_(len(remotes), 2)\\n rsync_info = [v for v in remotes.values()\\n if v.get(\\\"sameas-name\\\") == \\\"r_rsync\\\"]\\n eq_(len(rsync_info), 1)\\n # r_rsync is a sameas remote that points to r_dir. Its sameas-name value\\n # has been copied under \\\"name\\\".\\n eq_(rsync_info[0][\\\"name\\\"], rsync_info[0][\\\"sameas-name\\\"])\\n\\n\\n# 1 is enough to test file_has_content\\n@with_parametric_batch\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_file_has_content(src=None, annex_path=None, *, batch):\\n origin = AnnexRepo(src)\\n (origin.pathobj / 'test.dat').write_text('123\\\\n')\\n origin.save('test.dat', git=True)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save('some')\\n ar = AnnexRepo.clone(src, annex_path)\\n testfiles = [\\\"test-annex.dat\\\", \\\"test.dat\\\"]\\n\\n eq_(ar.file_has_content(testfiles), [False, False])\\n\\n ok_annex_get(ar, \\\"test-annex.dat\\\")\\n eq_(ar.file_has_content(testfiles, batch=batch), [True, False])\\n eq_(ar.file_has_content(testfiles[:1], batch=batch), [True])\\n\\n eq_(ar.file_has_content(testfiles + [\\\"bogus.txt\\\"], batch=batch),\\n [True, False, False])\\n\\n assert_false(ar.file_has_content(\\\"bogus.txt\\\", batch=batch))\\n ok_(ar.file_has_content(\\\"test-annex.dat\\\", batch=batch))\\n\\n ar.unlock([\\\"test-annex.dat\\\"])\\n eq_(ar.file_has_content([\\\"test-annex.dat\\\"], batch=batch),\\n [True])\\n with open(opj(annex_path, \\\"test-annex.dat\\\"), \\\"a\\\") as ofh:\\n ofh.write(\\\"more\\\")\\n eq_(ar.file_has_content([\\\"test-annex.dat\\\"], batch=batch),\\n [False])\\n\\n\\n# 1 is enough to test\\n@xfail_buggy_annex_info\\n@with_parametric_batch\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_is_under_annex(src=None, annex_path=None, *, batch):\\n origin = AnnexRepo(src)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save('some')\\n ar = AnnexRepo.clone(src, annex_path)\\n\\n with open(opj(annex_path, 'not-committed.txt'), 'w') as f:\\n f.write(\\\"aaa\\\")\\n\\n testfiles = [\\\"test-annex.dat\\\", \\\"not-committed.txt\\\", \\\"INFO.txt\\\"]\\n # wouldn't change\\n target_value = [True, False, False]\\n eq_(ar.is_under_annex(testfiles, batch=batch), target_value)\\n\\n ok_annex_get(ar, \\\"test-annex.dat\\\")\\n eq_(ar.is_under_annex(testfiles, batch=batch), target_value)\\n eq_(ar.is_under_annex(testfiles[:1], batch=batch), target_value[:1])\\n eq_(ar.is_under_annex(testfiles[1:], batch=batch), target_value[1:])\\n\\n eq_(ar.is_under_annex(testfiles + [\\\"bogus.txt\\\"], batch=batch),\\n target_value + [False])\\n\\n assert_false(ar.is_under_annex(\\\"bogus.txt\\\", batch=batch))\\n ok_(ar.is_under_annex(\\\"test-annex.dat\\\", batch=batch))\\n\\n ar.unlock([\\\"test-annex.dat\\\"])\\n eq_(ar.is_under_annex([\\\"test-annex.dat\\\"], batch=batch),\\n [True])\\n with open(opj(annex_path, \\\"test-annex.dat\\\"), \\\"a\\\") as ofh:\\n ofh.write(\\\"more\\\")\\n eq_(ar.is_under_annex([\\\"test-annex.dat\\\"], batch=batch),\\n [False])\\n\\n\\n@xfail_buggy_annex_info\\n@with_tree(tree=(('about.txt', 'Lots of abouts'),\\n ('about2.txt', 'more abouts'),\\n ('d', {'sub.txt': 'more stuff'})))\\n@serve_path_via_http()\\n@with_tempfile\\ndef test_AnnexRepo_web_remote(sitepath=None, siteurl=None, dst=None):\\n\\n ar = AnnexRepo(dst, create=True)\\n testurl = urljoin(siteurl, 'about.txt')\\n testurl2 = urljoin(siteurl, 'about2.txt')\\n testurl3 = urljoin(siteurl, 'd/sub.txt')\\n url_file_prefix = urlsplit(testurl).netloc.split(':')[0]\\n testfile = '%s_about.txt' % url_file_prefix\\n testfile2 = '%s_about2.txt' % url_file_prefix\\n testfile3 = opj('d', 'sub.txt')\\n\\n # get the file from remote\\n with swallow_outputs() as cmo:\\n ar.add_url_to_file(testfile, testurl)\\n l = ar.whereis(testfile)\\n assert_in(WEB_SPECIAL_REMOTE_UUID, l)\\n eq_(len(l), 2)\\n ok_(ar.file_has_content(testfile))\\n\\n # output='full'\\n lfull = ar.whereis(testfile, output='full')\\n eq_(set(lfull), set(l)) # the same entries\\n non_web_remote = l[1 - l.index(WEB_SPECIAL_REMOTE_UUID)]\\n assert_in('urls', lfull[non_web_remote])\\n eq_(lfull[non_web_remote]['urls'], [])\\n assert_not_in('uuid', lfull[WEB_SPECIAL_REMOTE_UUID]) # no uuid in the records\\n eq_(lfull[WEB_SPECIAL_REMOTE_UUID]['urls'], [testurl])\\n assert_equal(lfull[WEB_SPECIAL_REMOTE_UUID]['description'], 'web')\\n\\n # --all and --key are incompatible\\n assert_raises(CommandError, ar.whereis, [testfile], options='--all', output='full', key=True)\\n\\n # output='descriptions'\\n ldesc = ar.whereis(testfile, output='descriptions')\\n eq_(set(ldesc), set([v['description'] for v in lfull.values()]))\\n\\n # info w/ and w/o fast mode\\n for fast in [True, False]:\\n info = ar.info(testfile, fast=fast)\\n eq_(info['size'], 14)\\n assert(info['key']) # that it is there\\n info_batched = ar.info(testfile, batch=True, fast=fast)\\n eq_(info, info_batched)\\n # while at it ;)\\n with swallow_outputs() as cmo:\\n eq_(ar.info('nonexistent', batch=False), None)\\n eq_(ar.info('nonexistent-batch', batch=True), None)\\n eq_(cmo.out, '')\\n eq_(cmo.err, '')\\n ar.precommit() # to stop all the batched processes for swallow_outputs\\n\\n # annex repo info\\n repo_info = ar.repo_info(fast=False)\\n eq_(repo_info['local annex size'], 14)\\n eq_(repo_info['backend usage'], {'SHA256E': 1})\\n # annex repo info in fast mode\\n repo_info_fast = ar.repo_info(fast=True)\\n # doesn't give much testable info, so just comparing a subset for match with repo_info info\\n eq_(repo_info_fast['semitrusted repositories'], repo_info['semitrusted repositories'])\\n #import pprint; pprint.pprint(repo_info)\\n\\n # remove the remote\\n ar.rm_url(testfile, testurl)\\n l = ar.whereis(testfile)\\n assert_not_in(WEB_SPECIAL_REMOTE_UUID, l)\\n eq_(len(l), 1)\\n\\n # now only 1 copy; drop should fail\\n try:\\n res = ar.drop(testfile)\\n except CommandError as e:\\n # there should be at least one result that was captured\\n # TODO think about a more standard way of accessing such\\n # records in a CommandError, maybe having a more specialized\\n # exception derived from CommandError\\n res = e.kwargs['stdout_json'][0]\\n eq_(res['command'], 'drop')\\n eq_(res['success'], False)\\n assert_in('adjust numcopies', res['note'])\\n\\n # read the url using different method\\n ar.add_url_to_file(testfile, testurl)\\n l = ar.whereis(testfile)\\n assert_in(WEB_SPECIAL_REMOTE_UUID, l)\\n eq_(len(l), 2)\\n ok_(ar.file_has_content(testfile))\\n\\n # 2 known copies now; drop should succeed\\n ar.drop(testfile)\\n l = ar.whereis(testfile)\\n assert_in(WEB_SPECIAL_REMOTE_UUID, l)\\n eq_(len(l), 1)\\n assert_false(ar.file_has_content(testfile))\\n lfull = ar.whereis(testfile, output='full')\\n assert_not_in(non_web_remote, lfull) # not present -- so not even listed\\n\\n # multiple files/urls\\n # get the file from remote\\n with swallow_outputs() as cmo:\\n ar.add_url_to_file(testfile2, testurl2)\\n\\n # TODO: if we ask for whereis on all files, we should get for all files\\n lall = ar.whereis('.')\\n eq_(len(lall), 2)\\n for e in lall:\\n assert(isinstance(e, list))\\n # but we don't know which one for which file. need a 'full' one for that\\n lall_full = ar.whereis('.', output='full')\\n ok_(ar.file_has_content(testfile2))\\n ok_(lall_full[testfile2][non_web_remote]['here'])\\n eq_(set(lall_full), {testfile, testfile2})\\n\\n # add a bogus 2nd url to testfile\\n\\n someurl = \\\"http://example.com/someurl\\\"\\n ar.add_url_to_file(testfile, someurl, options=['--relaxed'])\\n lfull = ar.whereis(testfile, output='full')\\n eq_(set(lfull[WEB_SPECIAL_REMOTE_UUID]['urls']), {testurl, someurl})\\n\\n # and now test with a file in subdirectory\\n subdir = opj(dst, 'd')\\n os.mkdir(subdir)\\n with swallow_outputs() as cmo:\\n ar.add_url_to_file(testfile3, url=testurl3)\\n ok_file_has_content(opj(dst, testfile3), 'more stuff')\\n eq_(set(ar.whereis(testfile3)), {WEB_SPECIAL_REMOTE_UUID, non_web_remote})\\n eq_(set(ar.whereis(testfile3, output='full').keys()), {WEB_SPECIAL_REMOTE_UUID, non_web_remote})\\n\\n # and if we ask for both files\\n info2 = ar.info([testfile, testfile3])\\n eq_(set(info2), {testfile, testfile3})\\n eq_(info2[testfile3]['size'], 10)\\n\\n full = ar.whereis([], options='--all', output='full')\\n eq_(len(full.keys()), 3) # we asked for all files -- got 3 keys\\n assert_in(WEB_SPECIAL_REMOTE_UUID, full['SHA256E-s10--a978713ea759207f7a6f9ebc9eaebd1b40a69ae408410ddf544463f6d33a30e1.txt'])\\n\\n # which would work even if we cd to that subdir, but then we should use explicit curdir\\n with chpwd(subdir):\\n cur_subfile = opj(curdir, 'sub.txt')\\n eq_(set(ar.whereis(cur_subfile)), {WEB_SPECIAL_REMOTE_UUID, non_web_remote})\\n eq_(set(ar.whereis(cur_subfile, output='full').keys()), {WEB_SPECIAL_REMOTE_UUID, non_web_remote})\\n testfiles = [cur_subfile, opj(pardir, testfile)]\\n info2_ = ar.info(testfiles)\\n # Should maintain original relative file names\\n eq_(set(info2_), set(testfiles))\\n eq_(info2_[cur_subfile]['size'], 10)\\n\\n\\n@with_tree(tree={\\\"a.txt\\\": \\\"a\\\",\\n \\\"b\\\": \\\"b\\\",\\n OBSCURE_FILENAME: \\\"c\\\",\\n \\\"subdir\\\": {\\\"d\\\": \\\"d\\\", \\\"e\\\": \\\"e\\\"}})\\ndef test_find_batch_equivalence(path=None):\\n ar = AnnexRepo(path)\\n files = [\\\"a.txt\\\", \\\"b\\\", OBSCURE_FILENAME]\\n ar.add(files + [\\\"subdir\\\"])\\n ar.commit(\\\"add files\\\")\\n query = [\\\"not-there\\\"] + files\\n expected = {f: f for f in files}\\n expected.update({\\\"not-there\\\": \\\"\\\"})\\n eq_(expected, ar.find(query, batch=True))\\n eq_(expected, ar.find(query))\\n # If we give a subdirectory, we split that output.\\n eq_(set(ar.find([\\\"subdir\\\"])[\\\"subdir\\\"]), {\\\"subdir/d\\\", \\\"subdir/e\\\"})\\n eq_(ar.find([\\\"subdir\\\"]), ar.find([\\\"subdir\\\"], batch=True))\\n # manually ensure that no annex batch processes are around anymore\\n # that make the test cleanup break on windows.\\n # story at https://github.com/datalad/datalad/issues/4190\\n # even an explicit `del ar` does not get it done\\n ar._batched.close()\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_repo_info(path=None):\\n repo = AnnexRepo(path)\\n info = repo.repo_info() # works in empty repo without crashing\\n eq_(info['local annex size'], 0)\\n eq_(info['size of annexed files in working tree'], 0)\\n\\n def get_custom(custom={}):\\n \\\"\\\"\\\"Need a helper since repo_info modifies in place so we should generate\\n new each time\\n \\\"\\\"\\\"\\n custom_json = {\\n 'available local disk space': 'unknown',\\n 'size of annexed files in working tree': \\\"0\\\",\\n 'success': True,\\n 'command': 'info',\\n }\\n if custom:\\n custom_json.update(custom)\\n return [custom_json]\\n\\n with patch.object(\\n repo, '_call_annex_records',\\n return_value=get_custom()):\\n info = repo.repo_info()\\n eq_(info['available local disk space'], None)\\n\\n with patch.object(\\n repo, '_call_annex_records',\\n return_value=get_custom({\\n \\\"available local disk space\\\": \\\"19193986496 (+100000 reserved)\\\"})):\\n info = repo.repo_info()\\n eq_(info['available local disk space'], 19193986496)\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_migrating_backends(src=None, dst=None):\\n origin = AnnexRepo(src)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save('some')\\n ar = AnnexRepo.clone(src, dst, backend='MD5')\\n eq_(ar.default_backends, ['MD5'])\\n # GitPython has a bug which causes .git/config being wiped out\\n # under Python3, triggered by collecting its config instance I guess\\n gc.collect()\\n ok_git_config_not_empty(ar) # Must not blow, see https://github.com/gitpython-developers/GitPython/issues/333\\n\\n filename = get_most_obscure_supported_name()\\n filename_abs = os.path.join(dst, filename)\\n f = open(filename_abs, 'w')\\n f.write(\\\"What to write?\\\")\\n f.close()\\n\\n ar.add(filename, backend='MD5')\\n eq_(ar.get_file_backend(filename), 'MD5')\\n eq_(ar.get_file_backend('test-annex.dat'), 'SHA256E')\\n\\n # migrating will only do, if file is present\\n ok_annex_get(ar, 'test-annex.dat')\\n\\n eq_(ar.get_file_backend('test-annex.dat'), 'SHA256E')\\n ar.migrate_backend('test-annex.dat')\\n eq_(ar.get_file_backend('test-annex.dat'), 'MD5')\\n\\n ar.migrate_backend('', backend='SHA1')\\n eq_(ar.get_file_backend(filename), 'SHA1')\\n eq_(ar.get_file_backend('test-annex.dat'), 'SHA1')\\n\\n\\ntree1args = dict(\\n tree=(\\n ('firstfile', 'whatever'),\\n ('secondfile', 'something else'),\\n ('remotefile', 'pretends to be remote'),\\n ('faraway', 'incredibly remote')),\\n)\\n\\n# keys for files if above tree is generated and added to annex with MD5E backend\\ntree1_md5e_keys = {\\n 'firstfile': 'MD5E-s8--008c5926ca861023c1d2a36653fd88e2',\\n 'faraway': 'MD5E-s17--5b849ed02f914d3bbb5038fe4e3fead9',\\n 'secondfile': 'MD5E-s14--6c7ba9c5a141421e1c03cb9807c97c74',\\n 'remotefile': 'MD5E-s21--bf7654b3de20d5926d407ea7d913deb0'\\n}\\n\\n# this code is only here for documentation purposes\\n# @with_tree(**tree1args)\\n# def __test_get_md5s(path):\\n# # was used just to generate above dict\\n# annex = AnnexRepo(path, init=True, backend='MD5E')\\n# files = [basename(f) for f in find_files('.*', path)]\\n# annex.add(files)\\n# annex.commit()\\n# print({f: p['key'] for f, p in annex.get_content_annexinfo(files)})\\n\\n\\n@with_parametric_batch\\n@with_tree(**tree1args)\\ndef test_dropkey(path=None, *, batch):\\n kw = {'batch': batch}\\n annex = AnnexRepo(path, init=True, backend='MD5E')\\n files = list(tree1_md5e_keys)\\n annex.add(files)\\n annex.commit()\\n # drop one key\\n annex.drop_key(tree1_md5e_keys[files[0]], **kw)\\n # drop multiple\\n annex.drop_key([tree1_md5e_keys[f] for f in files[1:3]], **kw)\\n # drop already dropped -- should work as well atm\\n # https://git-annex.branchable.com/bugs/dropkey_--batch_--json_--force_is_always_succesfull\\n annex.drop_key(tree1_md5e_keys[files[0]], **kw)\\n # and a mix with already dropped or not\\n annex.drop_key(list(tree1_md5e_keys.values()), **kw)\\n # AnnexRepo is not able to guarantee that all batched processes are\\n # terminated when test cleanup code runs, avoid a crash (i.e. resource busy)\\n annex._batched.close()\\n\\n\\n@with_tree(**tree1args)\\n@serve_path_via_http()\\ndef test_AnnexRepo_backend_option(path=None, url=None):\\n ar = AnnexRepo(path, backend='MD5')\\n\\n # backend recorded in .gitattributes\\n eq_(ar.get_gitattributes('.')['.']['annex.backend'], 'MD5')\\n\\n ar.add('firstfile', backend='SHA1')\\n ar.add('secondfile')\\n eq_(ar.get_file_backend('firstfile'), 'SHA1')\\n eq_(ar.get_file_backend('secondfile'), 'MD5')\\n\\n with swallow_outputs() as cmo:\\n # must be added under different name since annex 20160114\\n ar.add_url_to_file('remotefile2', url + 'remotefile', backend='SHA1')\\n eq_(ar.get_file_backend('remotefile2'), 'SHA1')\\n\\n with swallow_outputs() as cmo:\\n ar.add_url_to_file('from_faraway', url + 'faraway', backend='SHA1')\\n eq_(ar.get_file_backend('from_faraway'), 'SHA1')\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get_file_backend(src=None, dst=None):\\n origin = AnnexRepo(src, create=True)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save()\\n\\n ar = AnnexRepo.clone(src, dst)\\n\\n eq_(ar.get_file_backend('test-annex.dat'), 'SHA256E')\\n # no migration\\n ok_annex_get(ar, 'test-annex.dat', network=False)\\n ar.migrate_backend('test-annex.dat', backend='SHA1')\\n eq_(ar.get_file_backend('test-annex.dat'), 'SHA1')\\n\\n\\n@skip_if_adjusted_branch\\n@with_tempfile\\ndef test_AnnexRepo_always_commit(path=None):\\n\\n repo = AnnexRepo(path)\\n\\n def get_annex_commit_counts():\\n return len(repo.get_revisions(\\\"git-annex\\\"))\\n\\n n_annex_commits_initial = get_annex_commit_counts()\\n\\n file1 = get_most_obscure_supported_name() + \\\"_1\\\"\\n file2 = get_most_obscure_supported_name() + \\\"_2\\\"\\n with open(opj(path, file1), 'w') as f:\\n f.write(\\\"First file.\\\")\\n with open(opj(path, file2), 'w') as f:\\n f.write(\\\"Second file.\\\")\\n\\n # always_commit == True is expected to be default\\n repo.add(file1)\\n\\n # Now git-annex log should show the addition:\\n out_list = list(repo.call_annex_items_(['log']))\\n eq_(len(out_list), 1)\\n\\n quote = lambda s: s.replace('\\\"', r'\\\\\\\"')\\n def assert_in_out(filename, out):\\n filename_quoted = quote(filename)\\n if repo._check_version_kludges('quotepath-respected') == \\\"no\\\":\\n assert_in(filename, out)\\n elif repo._check_version_kludges('quotepath-respected') == \\\"maybe\\\":\\n assert filename in out or filename_quoted in out\\n else:\\n assert_in(filename_quoted, out)\\n assert_in_out(file1, out_list[0])\\n\\n # check git log of git-annex branch:\\n # expected: initial creation, update (by annex add) and another\\n # update (by annex log)\\n eq_(get_annex_commit_counts(), n_annex_commits_initial + 1)\\n\\n with patch.object(repo, \\\"always_commit\\\", False):\\n repo.add(file2)\\n\\n # No additional git commit:\\n eq_(get_annex_commit_counts(), n_annex_commits_initial + 1)\\n\\n out = repo.call_annex(['log'])\\n\\n # And we see only the file before always_commit was set to false:\\n assert_in_out(file1, out)\\n assert_not_in(file2, out)\\n assert_not_in(quote(file2), out)\\n\\n # With always_commit back to True, do something that will trigger a commit\\n # on the annex branches.\\n repo.call_annex(['sync'])\\n\\n out = repo.call_annex(['log'])\\n assert_in_out(file1, out)\\n assert_in_out(file2, out)\\n\\n # Now git knows as well:\\n eq_(get_annex_commit_counts(), n_annex_commits_initial + 2)\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_on_uninited_annex(src=None, path=None):\\n origin = AnnexRepo(src, create=True)\\n (origin.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n origin.save()\\n # \\\"Manually\\\" clone to avoid initialization:\\n runner = Runner()\\n runner.run([\\\"git\\\", \\\"clone\\\", origin.path, path])\\n\\n assert_false(exists(opj(path, '.git', 'annex'))) # must not be there for this test to be valid\\n annex = AnnexRepo(path, create=False, init=False) # so we can initialize without\\n # and still can get our things\\n assert_false(annex.file_has_content('test-annex.dat'))\\n annex.get('test-annex.dat')\\n ok_(annex.file_has_content('test-annex.dat'))\\n\\n\\n@assert_cwd_unchanged\\n@with_tempfile\\ndef test_AnnexRepo_commit(path=None):\\n\\n ds = AnnexRepo(path, create=True)\\n filename = opj(path, get_most_obscure_supported_name())\\n with open(filename, 'w') as f:\\n f.write(\\\"File to add to git\\\")\\n ds.add(filename, git=True)\\n\\n assert_raises(AssertionError, assert_repo_status, path, annex=True)\\n\\n ds.commit(\\\"test _commit\\\")\\n assert_repo_status(path, annex=True)\\n\\n # nothing to commit doesn't raise by default:\\n ds.commit()\\n # but does with careless=False:\\n assert_raises(CommandError, ds.commit, careless=False)\\n\\n # committing untracked file raises:\\n with open(opj(path, \\\"untracked\\\"), \\\"w\\\") as f:\\n f.write(\\\"some\\\")\\n assert_raises(FileNotInRepositoryError, ds.commit, files=\\\"untracked\\\")\\n # not existing file as well:\\n assert_raises(FileNotInRepositoryError, ds.commit, files=\\\"not-existing\\\")\\n\\n\\n@with_tempfile\\ndef test_AnnexRepo_add_to_annex(path=None):\\n repo = AnnexRepo(path)\\n\\n assert_repo_status(repo, annex=True)\\n filename = get_most_obscure_supported_name()\\n filename_abs = opj(repo.path, filename)\\n with open(filename_abs, \\\"w\\\") as f:\\n f.write(\\\"some\\\")\\n\\n out_json = repo.add(filename)\\n # file is known to annex:\\n ok_(repo.is_under_annex(filename_abs),\\n \\\"Annexed file is not a link.\\\")\\n assert_in('key', out_json)\\n key = repo.get_file_annexinfo(filename)['key']\\n assert_false(key == '')\\n assert_equal(key, out_json['key'])\\n ok_(repo.file_has_content(filename))\\n\\n # uncommitted:\\n ok_(repo.dirty)\\n\\n repo.commit(\\\"Added file to annex.\\\")\\n assert_repo_status(repo, annex=True)\\n\\n # now using commit/msg options:\\n filename = \\\"another.txt\\\"\\n with open(opj(repo.path, filename), \\\"w\\\") as f:\\n f.write(\\\"something else\\\")\\n\\n repo.add(filename)\\n repo.commit(msg=\\\"Added another file to annex.\\\")\\n # known to annex:\\n fileprops = repo.get_file_annexinfo(filename, eval_availability=True)\\n ok_(fileprops['key'])\\n ok_(fileprops['has_content'])\\n\\n # and committed:\\n assert_repo_status(repo, annex=True)\\n\\n\\n@with_tempfile\\ndef test_AnnexRepo_add_to_git(path=None):\\n repo = AnnexRepo(path)\\n\\n assert_repo_status(repo, annex=True)\\n filename = get_most_obscure_supported_name()\\n with open(opj(repo.path, filename), \\\"w\\\") as f:\\n f.write(\\\"some\\\")\\n repo.add(filename, git=True)\\n\\n # not in annex, but in git:\\n eq_(repo.get_file_annexinfo(filename), {})\\n # uncommitted:\\n ok_(repo.dirty)\\n repo.commit(\\\"Added file to annex.\\\")\\n assert_repo_status(repo, annex=True)\\n\\n # now using commit/msg options:\\n filename = \\\"another.txt\\\"\\n with open(opj(repo.path, filename), \\\"w\\\") as f:\\n f.write(\\\"something else\\\")\\n\\n repo.add(filename, git=True)\\n repo.commit(msg=\\\"Added another file to annex.\\\")\\n # not in annex, but in git:\\n eq_(repo.get_file_annexinfo(filename), {})\\n\\n # and committed:\\n assert_repo_status(repo, annex=True)\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get(src=None, dst=None):\\n ar = AnnexRepo(src)\\n (ar.pathobj / 'test-annex.dat').write_text(\\n \\\"content to be annex-addurl'd\\\")\\n ar.save('some')\\n\\n annex = AnnexRepo.clone(src, dst)\\n assert_is_instance(annex, AnnexRepo, \\\"AnnexRepo was not created.\\\")\\n testfile = 'test-annex.dat'\\n testfile_abs = opj(dst, testfile)\\n assert_false(annex.file_has_content(\\\"test-annex.dat\\\"))\\n with swallow_outputs():\\n annex.get(testfile)\\n ok_(annex.file_has_content(\\\"test-annex.dat\\\"))\\n ok_file_has_content(testfile_abs, \\\"content to be annex-addurl'd\\\", strip=True)\\n\\n called = []\\n # for some reason yoh failed mock to properly just call original func\\n orig_run = annex._git_runner.run_on_filelist_chunks\\n\\n def check_run(cmd, files, **kwargs):\\n cmd_name = cmd[cmd.index('annex') + 1]\\n called.append(cmd_name)\\n if cmd_name == 'find':\\n assert_not_in('-J5', cmd)\\n elif cmd_name == 'get':\\n assert_in('-J5', cmd)\\n else:\\n raise AssertionError(\\n \\\"no other commands so far should be ran. Got %s\\\" % cmd\\n )\\n return orig_run(cmd, files, **kwargs)\\n\\n annex.drop(testfile)\\n with patch.object(GitWitlessRunner, 'run_on_filelist_chunks',\\n side_effect=check_run), \\\\\\n swallow_outputs():\\n annex.get(testfile, jobs=5)\\n eq_(called, ['find', 'get'])\\n ok_file_has_content(testfile_abs, \\\"content to be annex-addurl'd\\\", strip=True)\\n\\n\\n@with_tree(tree={'file.dat': 'content'})\\n@with_tempfile\\ndef test_v7_detached_get(opath=None, path=None):\\n # http://git-annex.branchable.com/bugs/get_fails_to_place_v7_unlocked_file_content_into_the_file_tree_in_v7_in_repo_with_detached_HEAD/\\n origin = AnnexRepo(opath, create=True, version=7)\\n GitRepo.add(origin, 'file.dat') # force direct `git add` invocation\\n origin.commit('added')\\n\\n AnnexRepo.clone(opath, path)\\n repo = AnnexRepo(path)\\n # test getting in a detached HEAD\\n repo.checkout('HEAD^{}')\\n repo.call_annex(['upgrade']) # TODO: .upgrade ?\\n\\n repo.get('file.dat')\\n ok_file_has_content(op.join(repo.path, 'file.dat'), \\\"content\\\")\\n\\n\\n# TODO:\\n#def init_remote(self, name, options):\\n#def enable_remote(self, name):\\n\\n@pytest.mark.parametrize(\\\"batch\\\", [False, True])\\n@with_tempfile\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get_contentlocation(src=None, path=None, work_dir_outside=None, *, batch):\\n ar = AnnexRepo(src)\\n (ar.pathobj / 'test-annex.dat').write_text(\\n \\\"content to be annex-addurl'd\\\")\\n ar.save('some')\\n\\n annex = AnnexRepo.clone(src, path)\\n fname = 'test-annex.dat'\\n key = annex.get_file_annexinfo(fname)['key']\\n # MIH at this point the whole test and get_contentlocation() itself\\n # is somewhat moot. The above call already has properties like\\n # 'hashdirmixed', 'hashdirlower', and 'key' from which the location\\n # could be built.\\n # with eval_availability=True, it also has 'objloc' with a absolute\\n # path to a verified annex key location\\n\\n # TODO: see if we can avoid this or specify custom exception\\n eq_(annex.get_contentlocation(key, batch=batch), '')\\n\\n with swallow_outputs() as cmo:\\n annex.get(fname)\\n key_location = annex.get_contentlocation(key, batch=batch)\\n assert(key_location)\\n\\n if annex.is_managed_branch():\\n # the rest of the test assumes annexed files being symlinks\\n return\\n\\n # they both should point to the same location eventually\\n eq_((annex.pathobj / fname).resolve(),\\n (annex.pathobj / key_location).resolve())\\n\\n # test how it would look if done under a subdir of the annex:\\n with chpwd(opj(annex.path, 'subdir'), mkdir=True):\\n key_location = annex.get_contentlocation(key, batch=batch)\\n # they both should point to the same location eventually\\n eq_((annex.pathobj / fname).resolve(),\\n (annex.pathobj / key_location).resolve())\\n\\n # test how it would look if done under a dir outside of the annex:\\n with chpwd(work_dir_outside, mkdir=True):\\n key_location = annex.get_contentlocation(key, batch=batch)\\n # they both should point to the same location eventually\\n eq_((annex.pathobj / fname).resolve(),\\n (annex.pathobj / key_location).resolve())\\n\\n\\n@known_failure_windows\\n@with_tree(tree=(('about.txt', 'Lots of abouts'),\\n ('about2.txt', 'more abouts'),\\n ('about2_.txt', 'more abouts_'),\\n ('d', {'sub.txt': 'more stuff'})))\\n@serve_path_via_http()\\n@with_tempfile\\ndef test_AnnexRepo_addurl_to_file_batched(sitepath=None, siteurl=None, dst=None):\\n\\n if dl_cfg.get('datalad.fake-dates'):\\n raise SkipTest(\\n \\\"Faked dates are enabled; skipping batched addurl tests\\\")\\n\\n ar = AnnexRepo(dst, create=True)\\n testurl = urljoin(siteurl, 'about.txt')\\n testurl2 = urljoin(siteurl, 'about2.txt')\\n testurl2_ = urljoin(siteurl, 'about2_.txt')\\n testurl3 = urljoin(siteurl, 'd/sub.txt')\\n url_file_prefix = urlsplit(testurl).netloc.split(':')[0]\\n testfile = 'about.txt'\\n testfile2 = 'about2.txt'\\n testfile2_ = 'about2_.txt'\\n testfile3 = opj('d', 'sub.txt')\\n\\n # add to an existing but not committed file\\n # TODO: __call__ of the BatchedAnnex must be checked to be called\\n copyfile(opj(sitepath, 'about.txt'), opj(dst, testfile))\\n # must crash sensibly since file exists, we shouldn't addurl to non-annexed files\\n with assert_raises(AnnexBatchCommandError):\\n ar.add_url_to_file(testfile, testurl, batch=True)\\n\\n # Remove it and re-add\\n unlink(opj(dst, testfile))\\n ar.add_url_to_file(testfile, testurl, batch=True)\\n\\n info = ar.info(testfile)\\n eq_(info['size'], 14)\\n assert(info['key'])\\n # not even added to index yet since we this repo is with default batch_size\\n assert_not_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile))\\n\\n # TODO: none of the below should re-initiate the batch process\\n\\n # add to an existing and staged annex file\\n copyfile(opj(sitepath, 'about2.txt'), opj(dst, testfile2))\\n ar.add(testfile2)\\n ar.add_url_to_file(testfile2, testurl2, batch=True)\\n assert(ar.info(testfile2))\\n # not committed yet\\n # assert_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile2))\\n\\n # add to an existing and committed annex file\\n copyfile(opj(sitepath, 'about2_.txt'), opj(dst, testfile2_))\\n ar.add(testfile2_)\\n if ar.is_direct_mode():\\n assert_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile))\\n else:\\n assert_not_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile))\\n ar.commit(\\\"added about2_.txt and there was about2.txt lingering around\\\")\\n # commit causes closing all batched annexes, so testfile gets committed\\n assert_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile))\\n assert(not ar.dirty)\\n ar.add_url_to_file(testfile2_, testurl2_, batch=True)\\n assert(ar.info(testfile2_))\\n assert_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(testfile2_))\\n\\n # add into a new file\\n # filename = 'newfile.dat'\\n filename = get_most_obscure_supported_name()\\n\\n # Note: The following line was necessary, since the test setup just\\n # doesn't work with singletons\\n # TODO: Singleton mechanic needs a general solution for this\\n AnnexRepo._unique_instances.clear()\\n ar2 = AnnexRepo(dst, batch_size=1)\\n\\n with swallow_outputs():\\n eq_(len(ar2._batched), 0)\\n ar2.add_url_to_file(filename, testurl, batch=True)\\n eq_(len(ar2._batched), 1) # we added one more with batch_size=1\\n ar2.precommit() # to possibly stop batch process occupying the stdout\\n ar2.commit(\\\"added new file\\\") # would do nothing ATM, but also doesn't fail\\n assert_in(filename, ar2.get_files())\\n assert_in(WEB_SPECIAL_REMOTE_UUID, ar2.whereis(filename))\\n\\n ar.commit(\\\"actually committing new files\\\")\\n assert_in(filename, ar.get_files())\\n assert_in(WEB_SPECIAL_REMOTE_UUID, ar.whereis(filename))\\n # this poor bugger still wasn't added since we used default batch_size=0 on him\\n\\n # and closing the pipes now shouldn't anyhow affect things\\n eq_(len(ar._batched), 1)\\n ar._batched.close()\\n eq_(len(ar._batched), 1) # doesn't remove them, just closes\\n assert(not ar.dirty)\\n\\n ar._batched.clear()\\n eq_(len(ar._batched), 0) # .clear also removes\\n\\n raise SkipTest(\\\"TODO: more, e.g. add with a custom backend\\\")\\n # TODO: also with different modes (relaxed, fast)\\n # TODO: verify that file is added with that backend and that we got a new batched process\\n\\n\\n@with_tree(tree={\\\"foo\\\": \\\"foo content\\\"})\\n@serve_path_via_http()\\n@with_tree(tree={\\\"bar\\\": \\\"bar content\\\"})\\ndef test_annexrepo_fake_dates_disables_batched(sitepath=None, siteurl=None, dst=None):\\n ar = AnnexRepo(dst, create=True, fake_dates=True)\\n\\n with swallow_logs(new_level=logging.DEBUG) as cml:\\n ar.add_url_to_file(\\\"foo-dst\\\", urljoin(siteurl, \\\"foo\\\"), batch=True)\\n cml.assert_logged(\\n msg=\\\"Not batching addurl call because fake dates are enabled\\\",\\n level=\\\"DEBUG\\\",\\n regex=False)\\n\\n ar.add(\\\"bar\\\")\\n ar.commit(\\\"add bar\\\")\\n key = ar.get_content_annexinfo([\\\"bar\\\"]).popitem()[1]['key']\\n\\n with swallow_logs(new_level=logging.DEBUG) as cml:\\n ar.drop_key(key, batch=True)\\n cml.assert_logged(\\n msg=\\\"Not batching drop_key call because fake dates are enabled\\\",\\n level=\\\"DEBUG\\\",\\n regex=False)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_annex_backends(path=None):\\n path = Path(path)\\n repo_default = AnnexRepo(path / \\\"r_default\\\")\\n eq_(repo_default.default_backends, None)\\n\\n repo_kw = AnnexRepo(path / \\\"repo_kw\\\", backend='MD5E')\\n eq_(repo_kw.default_backends, ['MD5E'])\\n\\n # persists\\n repo_kw = AnnexRepo(path / \\\"repo_kw\\\")\\n eq_(repo_kw.default_backends, ['MD5E'])\\n\\n repo_config = AnnexRepo(path / \\\"repo_config\\\")\\n repo_config.config.set(\\\"annex.backend\\\", \\\"MD5E\\\", reload=True)\\n eq_(repo_config.default_backends, [\\\"MD5E\\\"])\\n\\n repo_compat = AnnexRepo(path / \\\"repo_compat\\\")\\n repo_compat.config.set(\\\"annex.backends\\\", \\\"MD5E WORM\\\", reload=True)\\n eq_(repo_compat.default_backends, [\\\"MD5E\\\", \\\"WORM\\\"])\\n\\n\\n# ignore deprecation warnings since here we should not use high level\\n# interface like push\\n@pytest.mark.filterwarnings(r\\\"ignore: AnnexRepo.copy_to\\\\(\\\\) is deprecated\\\")\\n@skip_nomultiplex_ssh # too much of \\\"multiplex\\\" testing\\n@with_tempfile(mkdir=True)\\ndef test_annex_ssh(topdir=None):\\n # On Xenial, this hangs with a recent git-annex. It bisects to git-annex's\\n # 7.20191230-142-g75059c9f3. This is likely due to an interaction with an\\n # older openssh version. See\\n # https://git-annex.branchable.com/bugs/SSH-based_git-annex-init_hang_on_older_systems___40__Xenial__44___Jessie__41__/\\n if external_versions['cmd:system-ssh'] < '7.4' and \\\\\\n external_versions['cmd:annex'] <= '8.20200720.1':\\n raise SkipTest(\\\"Test known to hang\\\")\\n\\n topdir = Path(topdir)\\n rm1 = AnnexRepo(topdir / \\\"remote1\\\", create=True)\\n rm2 = AnnexRepo.clone(rm1.path, str(topdir / \\\"remote2\\\"))\\n rm2.remove_remote(DEFAULT_REMOTE)\\n\\n main_tmp = AnnexRepo.clone(rm1.path, str(topdir / \\\"main\\\"))\\n main_tmp.remove_remote(DEFAULT_REMOTE)\\n repo_path = main_tmp.path\\n del main_tmp\\n remote_1_path = rm1.path\\n remote_2_path = rm2.path\\n\\n from datalad import ssh_manager\\n\\n # check whether we are the first to use these sockets:\\n hash_1 = get_connection_hash('datalad-test')\\n socket_1 = opj(str(ssh_manager.socket_dir), hash_1)\\n hash_2 = get_connection_hash('datalad-test2')\\n socket_2 = opj(str(ssh_manager.socket_dir), hash_2)\\n datalad_test_was_open = exists(socket_1)\\n datalad_test2_was_open = exists(socket_2)\\n\\n # repo to test:AnnexRepo(repo_path)\\n # At first, directly use git to add the remote, which should be recognized\\n # by AnnexRepo's constructor\\n gr = GitRepo(repo_path, create=True)\\n gr.add_remote(\\\"ssh-remote-1\\\", \\\"ssh://datalad-test\\\" + remote_1_path)\\n\\n ar = AnnexRepo(repo_path, create=False)\\n\\n # socket was not touched:\\n if datalad_test_was_open:\\n ok_(exists(socket_1))\\n else:\\n ok_(not exists(socket_1))\\n\\n # remote interaction causes socket to be created:\\n (ar.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n (ar.pathobj / \\\"bar\\\").write_text(\\\"bar\\\")\\n ar.add(\\\"foo\\\")\\n ar.add(\\\"bar\\\")\\n ar.commit(\\\"add files\\\")\\n\\n ar.copy_to([\\\"foo\\\"], remote=\\\"ssh-remote-1\\\")\\n # copy_to() opens it if needed.\\n #\\n # Note: This isn't racy because datalad-sshrun should not close this itself\\n # because the connection was either already open before this test or\\n # copy_to(), not the underlying git-annex/datalad-sshrun call, opens it.\\n ok_(exists(socket_1))\\n\\n # add another remote:\\n ar.add_remote('ssh-remote-2', \\\"ssh://datalad-test2\\\" + remote_2_path)\\n\\n # socket was not touched:\\n if datalad_test2_was_open:\\n # FIXME: occasionally(?) fails in V6:\\n # ok_(exists(socket_2))\\n pass\\n else:\\n ok_(not exists(socket_2))\\n\\n # copy to the new remote:\\n #\\n # Same racy note as the copy_to() call above.\\n ar.copy_to([\\\"foo\\\"], remote=\\\"ssh-remote-2\\\")\\n\\n if not exists(socket_2): # pragma: no cover\\n # @known_failure (marked for grep)\\n raise SkipTest(\\\"test_annex_ssh hit known failure (gh-4781)\\\")\\n\\n # Check that git-annex is actually using datalad-sshrun.\\n fail_cmd = quote_cmdlinearg(sys.executable) + \\\"-c 'assert 0'\\\"\\n with patch.dict('os.environ', {'GIT_SSH_COMMAND': fail_cmd}):\\n with assert_raises(CommandError):\\n ar.copy_to([\\\"bar\\\"], remote=\\\"ssh-remote-2\\\")\\n ar.copy_to([\\\"bar\\\"], remote=\\\"ssh-remote-2\\\")\\n\\n ssh_manager.close(ctrl_path=[socket_1, socket_2])\\n\\n\\n@with_tempfile\\ndef test_annex_remove(path=None):\\n ar = AnnexRepo(path)\\n (ar.pathobj / 'test-annex.dat').write_text(\\n \\\"content to be annex-addurl'd\\\")\\n ar.save('some')\\n\\n repo = AnnexRepo(path, create=False)\\n\\n file_list = list(repo.get_content_annexinfo(init=None))\\n assert len(file_list) >= 1\\n # remove a single file\\n out = repo.remove(str(file_list[0]))\\n assert_not_in(file_list[0], repo.get_content_annexinfo(init=None))\\n eq_(out[0], str(file_list[0].relative_to(repo.pathobj)))\\n\\n with open(opj(repo.path, \\\"rm-test.dat\\\"), \\\"w\\\") as f:\\n f.write(\\\"whatever\\\")\\n\\n # add it\\n repo.add(\\\"rm-test.dat\\\")\\n\\n # remove without '--force' should fail, due to staged changes:\\n assert_raises(CommandError, repo.remove, \\\"rm-test.dat\\\")\\n assert_in(\\\"rm-test.dat\\\", repo.get_annexed_files())\\n\\n # now force:\\n out = repo.remove(\\\"rm-test.dat\\\", force=True)\\n assert_not_in(\\\"rm-test.dat\\\", repo.get_annexed_files())\\n eq_(out[0], \\\"rm-test.dat\\\")\\n\\n\\n@with_tempfile\\n@with_tempfile\\n@with_tempfile\\ndef test_repo_version_upgrade(path1=None, path2=None, path3=None):\\n with swallow_logs(new_level=logging.INFO) as cm:\\n # Since git-annex 7.20181031, v6 repos upgrade to v7.\\n # Future proofing: We will test on v6 as long as it is upgradeable,\\n # but would switch to first upgradeable after\\n Uversion = 6 if 6 in _GIT_ANNEX_VERSIONS_INFO[\\\"upgradable\\\"] \\\\\\n else _GIT_ANNEX_VERSIONS_INFO[\\\"upgradeable\\\"][0]\\n v_first_supported = next(i for i in _GIT_ANNEX_VERSIONS_INFO[\\\"supported\\\"] if i >= Uversion)\\n annex = AnnexRepo(path1, create=True, version=Uversion)\\n assert_repo_status(path1, annex=True)\\n v_upgraded_to = int(annex.config.get('annex.version'))\\n\\n if external_versions['cmd:annex'] <= '10.20220724':\\n eq_(v_upgraded_to, v_first_supported)\\n assert_in(\\\"will be upgraded to 8\\\", cm.out)\\n else:\\n # 10.20220724-5-g63cef2ae0 started to auto-upgrade to 10, although 8 was the\\n # lowest supported. In general we can only assert that we upgrade into one\\n # of the supported\\n assert_in(v_upgraded_to, _GIT_ANNEX_VERSIONS_INFO[\\\"supported\\\"])\\n assert_in(\\\"will be upgraded to %s or later version\\\" % v_first_supported, cm.out)\\n\\n # default from config item (via env var):\\n with patch.dict('os.environ', {'DATALAD_REPO_VERSION': str(Uversion)}):\\n # and check consistency of upgrading to the default version:\\n annex = AnnexRepo(path2, create=True)\\n version = int(annex.config.get('annex.version'))\\n eq_(version, v_upgraded_to)\\n\\n\\n@pytest.mark.parametrize(\\\"version\\\", _GIT_ANNEX_VERSIONS_INFO[\\\"supported\\\"])\\ndef test_repo_version_supported(version, tmp_path):\\n # default from config item (via env var):\\n Uversion = _GIT_ANNEX_VERSIONS_INFO[\\\"upgradable\\\"][0]\\n with patch.dict('os.environ', {'DATALAD_REPO_VERSION': str(Uversion)}):\\n # ...parameter `version` still has priority over default config:\\n annex = AnnexRepo(str(tmp_path), create=True, version=version)\\n annex_version = int(annex.config.get('annex.version'))\\n if not annex.is_managed_branch():\\n # There is no \\\"upgrade\\\" for any of the supported versions.\\n # if we are not in adjusted branch\\n eq_(annex_version, version)\\n else:\\n print(\\\"HERE\\\")\\n # some annex command might have ran to trigger the update\\n assert annex_version in {v for v in _GIT_ANNEX_VERSIONS_INFO[\\\"supported\\\"] if v >= version}\\n\\n\\n@skip_if(external_versions['cmd:annex'] > '8.20210428', \\\"Stopped showing if too quick\\\")\\n@with_tempfile\\ndef test_init_scanning_message(path=None):\\n with swallow_logs(new_level=logging.INFO) as cml:\\n AnnexRepo(path, create=True, version=7)\\n # somewhere around 8.20210428-186-g428c91606 git annex changed\\n # handling of scanning for unlocked files upon init and started to report\\n # \\\"scanning for annexed\\\" instead of \\\"scanning for unlocked\\\".\\n # Could be a line among many (as on Windows) so match=False so we search\\n assert_re_in(\\\".*scanning for .* files\\\", cml.out, flags=re.IGNORECASE, match=False)\\n\\n\\n# ignore deprecation warnings since that is the test testing that functionality\\n@pytest.mark.filterwarnings(r\\\"ignore: AnnexRepo.copy_to\\\\(\\\\) is deprecated\\\")\\n@with_tempfile\\n@with_tempfile\\n@with_tempfile\\ndef test_annex_copy_to(src=None, origin=None, clone=None):\\n ar = AnnexRepo(src)\\n (ar.pathobj / 'test.dat').write_text(\\\"123\\\\n\\\")\\n ar.save('some', git=True)\\n (ar.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n ar.save('some')\\n\\n repo = AnnexRepo.clone(src, origin)\\n remote = AnnexRepo.clone(origin, clone)\\n repo.add_remote(\\\"target\\\", clone)\\n\\n assert_raises(IOError, repo.copy_to, \\\"doesnt_exist.dat\\\", \\\"target\\\")\\n assert_raises(FileInGitError, repo.copy_to, \\\"test.dat\\\", \\\"target\\\")\\n assert_raises(ValueError, repo.copy_to, \\\"test-annex.dat\\\", \\\"invalid_target\\\")\\n\\n # see #3102\\n # \\\"copying\\\" a dir shouldn't do anything and not raise.\\n os.mkdir(opj(repo.path, \\\"subdir\\\"))\\n repo.copy_to(\\\"subdir\\\", \\\"target\\\")\\n\\n # test-annex.dat has no content to copy yet:\\n eq_(repo.copy_to(\\\"test-annex.dat\\\", \\\"target\\\"), [])\\n\\n repo.get(\\\"test-annex.dat\\\")\\n # now it has:\\n eq_(repo.copy_to(\\\"test-annex.dat\\\", \\\"target\\\"), [\\\"test-annex.dat\\\"])\\n # and will not be copied again since it was already copied\\n eq_(repo.copy_to([\\\"test.dat\\\", \\\"test-annex.dat\\\"], \\\"target\\\"), [])\\n\\n # Test that if we pass a list of items and annex processes them nicely,\\n # we would obtain a list back. To not stress our tests even more -- let's mock\\n def ok_copy(command, **kwargs):\\n # Check that we do pass to annex call only the list of files which we\\n # asked to be copied\\n assert_in('copied1', kwargs['files'])\\n assert_in('copied2', kwargs['files'])\\n assert_in('existed', kwargs['files'])\\n return [\\n {\\\"command\\\":\\\"copy\\\",\\\"note\\\":\\\"to target ...\\\", \\\"success\\\":True,\\n \\\"key\\\":\\\"akey1\\\", \\\"file\\\":\\\"copied1\\\"},\\n {\\\"command\\\":\\\"copy\\\",\\\"note\\\":\\\"to target ...\\\", \\\"success\\\":True,\\n \\\"key\\\":\\\"akey2\\\", \\\"file\\\":\\\"copied2\\\"},\\n {\\\"command\\\":\\\"copy\\\",\\\"note\\\":\\\"checking target ...\\\", \\\"success\\\":True,\\n \\\"key\\\":\\\"akey3\\\", \\\"file\\\":\\\"existed\\\"},\\n ]\\n # Note that we patch _call_annex_records,\\n # which is in turn invoked first by copy_to for \\\"find\\\" operation.\\n # TODO: provide a dedicated handling within above ok_copy for 'find' command\\n with patch.object(repo, '_call_annex_records', ok_copy):\\n eq_(repo.copy_to([\\\"copied2\\\", \\\"copied1\\\", \\\"existed\\\"], \\\"target\\\"),\\n [\\\"copied1\\\", \\\"copied2\\\"])\\n\\n # now let's test that we are correctly raising the exception in case if\\n # git-annex execution fails\\n orig_run = repo._call_annex\\n\\n # Kinda a bit off the reality since no nonex* would not be returned/handled\\n # by _get_expected_files, so in real life -- wouldn't get report about Incomplete!?\\n def fail_to_copy(command, **kwargs):\\n if command[0] == 'copy':\\n # That is not how annex behaves\\n # http://git-annex.branchable.com/bugs/copy_does_not_reflect_some_failed_copies_in_--json_output/\\n # for non-existing files output goes into stderr\\n #\\n # stderr output depends on config+version of annex, though:\\n if not dl_cfg.getbool(\\n section=\\\"annex\\\", option=\\\"skipunknown\\\",\\n # git-annex switched default for this config:\\n default=bool(\\n external_versions['cmd:annex'] < '10.20220222')):\\n\\n stderr = \\\"error: pathspec 'nonex1' did not match any file(s) \\\" \\\\\\n \\\"known to git\\\\n\\\" \\\\\\n \\\"error: pathspec 'nonex2' did not match any file(s) \\\" \\\\\\n \\\"known to git\\\\n\\\"\\n else:\\n stderr = \\\"git-annex: nonex1 not found\\\\n\\\" \\\\\\n \\\"git-annex: nonex2 not found\\\\n\\\"\\n\\n raise CommandError(\\n \\\"Failed to run ...\\\",\\n stdout_json=[\\n {\\\"command\\\":\\\"copy\\\",\\\"note\\\":\\\"to target ...\\\", \\\"success\\\":True,\\n \\\"key\\\":\\\"akey1\\\", \\\"file\\\":\\\"copied\\\"},\\n {\\\"command\\\":\\\"copy\\\",\\\"note\\\":\\\"checking target ...\\\",\\n \\\"success\\\":True, \\\"key\\\":\\\"akey2\\\", \\\"file\\\":\\\"existed\\\"},\\n ],\\n stderr=stderr\\n )\\n else:\\n return orig_run(command, **kwargs)\\n\\n def fail_to_copy_get_expected(files, expr):\\n assert files == [\\\"copied\\\", \\\"existed\\\", \\\"nonex1\\\", \\\"nonex2\\\"]\\n return {'akey1': 10}, [\\\"copied\\\"]\\n\\n with patch.object(repo, '_call_annex', fail_to_copy), \\\\\\n patch.object(repo, '_get_expected_files', fail_to_copy_get_expected):\\n with assert_raises(IncompleteResultsError) as cme:\\n repo.copy_to([\\\"copied\\\", \\\"existed\\\", \\\"nonex1\\\", \\\"nonex2\\\"], \\\"target\\\")\\n eq_(cme.value.results, [\\\"copied\\\"])\\n eq_(cme.value.failed, ['nonex1', 'nonex2'])\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_annex_drop(src=None, dst=None):\\n ar = AnnexRepo(src)\\n (ar.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n ar.save('some')\\n\\n ar = AnnexRepo.clone(src, dst)\\n testfile = 'test-annex.dat'\\n assert_false(ar.file_has_content(testfile))\\n ar.get(testfile)\\n ok_(ar.file_has_content(testfile))\\n eq_(len([f for f in ar.fsck(fast=True) if f['file'] == testfile]), 1)\\n\\n # drop file by name:\\n result = ar.drop([testfile])\\n assert_false(ar.file_has_content(testfile))\\n ok_(isinstance(result, list))\\n eq_(len(result), 1)\\n eq_(result[0]['command'], 'drop')\\n eq_(result[0]['success'], True)\\n eq_(result[0]['file'], testfile)\\n\\n ar.get(testfile)\\n\\n # drop file by key:\\n testkey = ar.get_file_annexinfo(testfile)['key']\\n result = ar.drop([testkey], key=True)\\n assert_false(ar.file_has_content(testfile))\\n ok_(isinstance(result, list))\\n eq_(len(result), 1)\\n eq_(result[0]['command'], 'drop')\\n eq_(result[0]['success'], True)\\n eq_(result[0]['key'], testkey)\\n\\n # insufficient arguments:\\n assert_raises(TypeError, ar.drop)\\n assert_raises(InsufficientArgumentsError, ar.drop, [], options=[\\\"--jobs=5\\\"])\\n assert_raises(InsufficientArgumentsError, ar.drop, [])\\n\\n # too much arguments:\\n assert_raises(CommandError, ar.drop, ['.'], options=['--all'])\\n\\n (ar.pathobj / 'somefile.txt').write_text('this')\\n ar.save()\\n with assert_raises(CommandError) as e:\\n ar.drop('somefile.txt')\\n # CommandError has to pull the errors from the JSON record 'note'\\n assert_in('necessary cop', str(e.value))\\n\\n with assert_raises(CommandError) as e:\\n ar._call_annex_records(['fsck', '-N', '3'])\\n # CommandError has to pull the errors from the JSON record 'error-messages'\\n assert_in('1 of 3 trustworthy copies', str(e.value))\\n\\n\\n@with_tree({\\\"a.txt\\\": \\\"a\\\", \\\"b.txt\\\": \\\"b\\\", \\\"c.py\\\": \\\"c\\\", \\\"d\\\": \\\"d\\\"})\\ndef test_annex_get_annexed_files(path=None):\\n repo = AnnexRepo(path)\\n repo.add(\\\".\\\")\\n repo.commit()\\n eq_(set(repo.get_annexed_files()), {\\\"a.txt\\\", \\\"b.txt\\\", \\\"c.py\\\", \\\"d\\\"})\\n\\n repo.drop(\\\"a.txt\\\", options=[\\\"--force\\\"])\\n eq_(set(repo.get_annexed_files()), {\\\"a.txt\\\", \\\"b.txt\\\", \\\"c.py\\\", \\\"d\\\"})\\n eq_(set(repo.get_annexed_files(with_content_only=True)),\\n {\\\"b.txt\\\", \\\"c.py\\\", \\\"d\\\"})\\n\\n eq_(set(repo.get_annexed_files(patterns=[\\\"*.txt\\\"])),\\n {\\\"a.txt\\\", \\\"b.txt\\\"})\\n eq_(set(repo.get_annexed_files(with_content_only=True,\\n patterns=[\\\"*.txt\\\"])),\\n {\\\"b.txt\\\"})\\n\\n eq_(set(repo.get_annexed_files(patterns=[\\\"*.txt\\\", \\\"*.py\\\"])),\\n {\\\"a.txt\\\", \\\"b.txt\\\", \\\"c.py\\\"})\\n\\n eq_(set(repo.get_annexed_files()),\\n set(repo.get_annexed_files(patterns=[\\\"*\\\"])))\\n\\n eq_(set(repo.get_annexed_files(with_content_only=True)),\\n set(repo.get_annexed_files(with_content_only=True, patterns=[\\\"*\\\"])))\\n\\n\\n@pytest.mark.parametrize(\\\"batch\\\", [True, False])\\n@with_tree(tree={\\\"test-annex.dat\\\": \\\"content\\\"})\\n@serve_path_via_http()\\n@with_tempfile()\\n@with_tempfile()\\ndef test_is_available(_=None, content_url=None, origpath=None, path=None, *,\\n batch):\\n\\n fname = \\\"test-annex.dat\\\"\\n content_url += \\\"/\\\" + fname\\n origds = Dataset(origpath).create()\\n origds.repo.add_url_to_file(fname, content_url)\\n origds.save()\\n origds.drop(fname)\\n annex = clone(origpath, path).repo\\n\\n # bkw = {'batch': batch}\\n if batch:\\n is_available = partial(annex.is_available, batch=batch)\\n else:\\n is_available = annex.is_available\\n\\n key = annex.get_content_annexinfo([fname]).popitem()[1]['key']\\n\\n # explicit is to verify data type etc\\n assert is_available(key, key=True) is True\\n assert is_available(fname) is True\\n\\n # known remote but doesn't have it\\n assert is_available(fname, remote=DEFAULT_REMOTE) is False\\n\\n # If the 'datalad' special remote is present, it will claim fname's URL.\\n if DATALAD_SPECIAL_REMOTE in annex.get_remotes():\\n remote = DATALAD_SPECIAL_REMOTE\\n uuid = DATALAD_SPECIAL_REMOTES_UUIDS[DATALAD_SPECIAL_REMOTE]\\n else:\\n remote = \\\"web\\\"\\n uuid = WEB_SPECIAL_REMOTE_UUID\\n\\n # it is on the 'web'\\n assert is_available(fname, remote=remote) is True\\n # not effective somehow :-/ may be the process already running or smth\\n # with swallow_logs(), swallow_outputs(): # it will complain!\\n assert is_available(fname, remote='unknown') is False\\n assert_false(is_available(\\\"boguskey\\\", key=True))\\n\\n # remove url\\n urls = annex.whereis(fname, output=\\\"full\\\").get(uuid, {}).get(\\\"urls\\\", [])\\n\\n assert(len(urls) == 1)\\n eq_(urls,\\n annex.whereis(key, key=True, output=\\\"full\\\")\\n .get(uuid, {}).get(\\\"urls\\\"))\\n annex.rm_url(fname, urls[0])\\n\\n assert is_available(key, key=True) is False\\n assert is_available(fname) is False\\n assert is_available(fname, remote=remote) is False\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_get_urls_none(path=None):\\n ar = AnnexRepo(path, create=True)\\n with open(opj(ar.path, \\\"afile\\\"), \\\"w\\\") as f:\\n f.write(\\\"content\\\")\\n eq_(ar.get_urls(\\\"afile\\\"), [])\\n\\n\\n@xfail_buggy_annex_info\\n@with_tempfile(mkdir=True)\\ndef test_annex_add_no_dotfiles(path=None):\\n ar = AnnexRepo(path, create=True)\\n print(ar.path)\\n assert_true(os.path.exists(ar.path))\\n assert_false(ar.dirty)\\n os.makedirs(opj(ar.path, '.datalad'))\\n # we don't care about empty directories\\n assert_false(ar.dirty)\\n with open(opj(ar.path, '.datalad', 'somefile'), 'w') as f:\\n f.write('some content')\\n # make sure the repo is considered dirty now\\n assert_true(ar.dirty) # TODO: has been more detailed assertion (untracked file)\\n # now add to git, and it should work\\n ar.add('.', git=True)\\n # all in index\\n assert_true(ar.dirty)\\n # TODO: has been more specific:\\n # assert_false(ar.repo.is_dirty(\\n # index=False, working_tree=True, untracked_files=True, submodules=True))\\n ar.commit(msg=\\\"some\\\")\\n # all committed\\n assert_false(ar.dirty)\\n # not known to annex\\n assert_false(ar.is_under_annex(opj(ar.path, '.datalad', 'somefile')))\\n\\n\\n@with_tempfile\\ndef test_annex_version_handling_at_min_version(path=None):\\n with set_annex_version(AnnexRepo.GIT_ANNEX_MIN_VERSION):\\n po = patch.object(AnnexRepo, '_check_git_annex_version',\\n side_effect=AnnexRepo._check_git_annex_version)\\n with po as cmpc:\\n eq_(AnnexRepo.git_annex_version, None)\\n ar1 = AnnexRepo(path, create=True)\\n assert(ar1)\\n eq_(AnnexRepo.git_annex_version, AnnexRepo.GIT_ANNEX_MIN_VERSION)\\n eq_(cmpc.call_count, 1)\\n # 2nd time must not be called\\n try:\\n # Note: Remove to cause creation of a new instance\\n rmtree(path)\\n except OSError:\\n pass\\n ar2 = AnnexRepo(path)\\n assert(ar2)\\n eq_(AnnexRepo.git_annex_version, AnnexRepo.GIT_ANNEX_MIN_VERSION)\\n eq_(cmpc.call_count, 1)\\n\\n\\n@with_tempfile\\ndef test_annex_version_handling_bad_git_annex(path=None):\\n with set_annex_version(None):\\n eq_(AnnexRepo.git_annex_version, None)\\n with assert_raises(MissingExternalDependency) as cme:\\n AnnexRepo(path)\\n linux_distribution_name = get_linux_distribution()[0]\\n if linux_distribution_name == 'debian':\\n assert_in(\\\"handbook.datalad.org\\\", str(cme.value))\\n eq_(AnnexRepo.git_annex_version, None)\\n\\n with set_annex_version('6.20160505'):\\n eq_(AnnexRepo.git_annex_version, None)\\n try:\\n # Note: Remove to cause creation of a new instance\\n rmtree(path)\\n except OSError:\\n pass\\n assert_raises(OutdatedExternalDependency, AnnexRepo, path)\\n # and we don't assign it\\n eq_(AnnexRepo.git_annex_version, None)\\n # so we could still fail\\n try:\\n # Note: Remove to cause creation of a new instance\\n rmtree(path)\\n except OSError:\\n pass\\n assert_raises(OutdatedExternalDependency, AnnexRepo, path)\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_get_description(path1=None, path2=None):\\n annex1 = AnnexRepo(path1, create=True)\\n # some content for git-annex branch\\n create_tree(path1, {'1.dat': 'content'})\\n annex1.add('1.dat', git=False)\\n annex1.commit(\\\"msg\\\")\\n annex1_description = annex1.get_description()\\n assert_not_equal(annex1_description, path1)\\n\\n annex2 = AnnexRepo(path2, create=True, description='custom 2')\\n eq_(annex2.get_description(), 'custom 2')\\n # not yet known\\n eq_(annex2.get_description(uuid=annex1.uuid), None)\\n\\n annex2.add_remote('annex1', path1)\\n annex2.fetch('annex1')\\n # it will match the remote name\\n eq_(annex2.get_description(uuid=annex1.uuid),\\n annex1_description + ' [annex1]')\\n # add a little probe file to make sure it stays untracked\\n create_tree(path1, {'probe': 'probe'})\\n assert_not_in('probe', annex2.get_indexed_files())\\n annex2.localsync('annex1')\\n assert_not_in('probe', annex2.get_indexed_files())\\n # but let's remove the remote\\n annex2.remove_remote('annex1')\\n eq_(annex2.get_description(uuid=annex1.uuid), annex1_description)\\n\\n\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\ndef test_AnnexRepo_flyweight(path1=None, path2=None):\\n\\n import sys\\n\\n repo1 = AnnexRepo(path1, create=True)\\n assert_is_instance(repo1, AnnexRepo)\\n\\n # Due to issue 4862, we currently still require gc.collect() under unclear\\n # circumstances to get rid of an exception traceback when creating in an\\n # existing directory. That traceback references the respective function\\n # frames which in turn reference the repo instance (they are methods).\\n # Doesn't happen on all systems, though. Eventually we need to figure that\\n # out.\\n # However, still test for the refcount after gc.collect() to ensure we don't\\n # introduce new circular references and make the issue worse!\\n gc.collect()\\n\\n # As long as we don't reintroduce any circular references or produce\\n # garbage during instantiation that isn't picked up immediately, `repo1`\\n # should be the only counted reference to this instance.\\n # Note, that sys.getrefcount reports its own argument and therefore one\\n # reference too much.\\n assert_equal(1, sys.getrefcount(repo1) - 1)\\n\\n # instantiate again:\\n repo2 = AnnexRepo(path1, create=False)\\n assert_is_instance(repo2, AnnexRepo)\\n # the very same object:\\n ok_(repo1 is repo2)\\n\\n # reference the same in an different way:\\n with chpwd(path1):\\n repo3 = AnnexRepo(relpath(path1, start=path2), create=False)\\n assert_is_instance(repo3, AnnexRepo)\\n # it's the same object:\\n ok_(repo1 is repo3)\\n\\n # but path attribute is absolute, so they are still equal:\\n ok_(repo1 == repo3)\\n\\n # Now, let's try to get a GitRepo instance from a path, we already have an\\n # AnnexRepo of\\n repo4 = GitRepo(path1)\\n assert_is_instance(repo4, GitRepo)\\n assert_not_is_instance(repo4, AnnexRepo)\\n\\n orig_id = id(repo1)\\n\\n # Be sure we have exactly one object in memory:\\n assert_equal(1, len([o for o in gc.get_objects()\\n if isinstance(o, AnnexRepo) and o.path == path1]))\\n\\n\\n # But we have two GitRepos in memory (the AnnexRepo and repo4):\\n assert_equal(2, len([o for o in gc.get_objects()\\n if isinstance(o, GitRepo) and o.path == path1]))\\n\\n # deleting one reference doesn't change anything - we still get the same\\n # thing:\\n del repo1\\n gc.collect() # TODO: see first comment above\\n ok_(repo2 is not None)\\n ok_(repo2 is repo3)\\n ok_(repo2 == repo3)\\n\\n repo1 = AnnexRepo(path1)\\n eq_(orig_id, id(repo1))\\n\\n del repo1\\n del repo2\\n\\n # for testing that destroying the object calls close() on BatchedAnnex:\\n class Dummy:\\n def __init__(self, *args, **kwargs):\\n self.close_called = False\\n\\n def close(self):\\n self.close_called = True\\n\\n fake_batch = Dummy()\\n\\n # Killing last reference will lead to garbage collection which will call\\n # AnnexRepo's finalizer:\\n with patch.object(repo3._batched, 'close', fake_batch.close):\\n with swallow_logs(new_level=1) as cml:\\n del repo3\\n gc.collect() # TODO: see first comment above\\n cml.assert_logged(msg=\\\"Finalizer called on: AnnexRepo(%s)\\\" % path1,\\n level=\\\"Level 1\\\",\\n regex=False)\\n # finalizer called close() on BatchedAnnex:\\n assert_true(fake_batch.close_called)\\n\\n # Flyweight is gone:\\n assert_not_in(path1, AnnexRepo._unique_instances.keys())\\n\\n # gc doesn't know any instance anymore:\\n assert_equal([], [o for o in gc.get_objects()\\n if isinstance(o, AnnexRepo) and o.path == path1])\\n # GitRepo is unaffected:\\n assert_equal(1, len([o for o in gc.get_objects()\\n if isinstance(o, GitRepo) and o.path == path1]))\\n\\n # new object is created on re-request:\\n repo1 = AnnexRepo(path1)\\n assert_equal(1, len([o for o in gc.get_objects()\\n if isinstance(o, AnnexRepo) and o.path == path1]))\\n\\n\\n@with_tempfile\\n@with_tempfile(mkdir=True)\\n@with_tempfile\\ndef test_AnnexRepo_get_toppath(repo=None, tempdir=None, repo2=None):\\n AnnexRepo(repo, create=True)\\n\\n reporeal = str(Path(repo).resolve())\\n eq_(AnnexRepo.get_toppath(repo, follow_up=False), reporeal)\\n eq_(AnnexRepo.get_toppath(repo), repo)\\n # Generate some nested directory\\n AnnexRepo(repo2, create=True)\\n repo2real = str(Path(repo2).resolve())\\n nested = opj(repo2, \\\"d1\\\", \\\"d2\\\")\\n os.makedirs(nested)\\n eq_(AnnexRepo.get_toppath(nested, follow_up=False), repo2real)\\n eq_(AnnexRepo.get_toppath(nested), repo2)\\n # and if not under git, should return None\\n eq_(AnnexRepo.get_toppath(tempdir), None)\\n\\n\\ndef test_AnnexRepo_get_submodules():\\n raise SkipTest(\\\"TODO\\\")\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_AnnexRepo_dirty(path=None):\\n\\n repo = AnnexRepo(path, create=True)\\n ok_(not repo.dirty)\\n\\n # pure git operations:\\n # untracked file\\n with open(opj(path, 'file1.txt'), 'w') as f:\\n f.write('whatever')\\n ok_(repo.dirty)\\n # staged file\\n repo.add('file1.txt', git=True)\\n ok_(repo.dirty)\\n # clean again\\n repo.commit(\\\"file1.txt added\\\")\\n ok_(not repo.dirty)\\n # modify to be the same\\n with open(opj(path, 'file1.txt'), 'w') as f:\\n f.write('whatever')\\n ok_(not repo.dirty)\\n # modified file\\n with open(opj(path, 'file1.txt'), 'w') as f:\\n f.write('something else')\\n ok_(repo.dirty)\\n # clean again\\n repo.add('file1.txt', git=True)\\n repo.commit(\\\"file1.txt modified\\\")\\n ok_(not repo.dirty)\\n\\n # annex operations:\\n # untracked file\\n with open(opj(path, 'file2.txt'), 'w') as f:\\n f.write('different content')\\n ok_(repo.dirty)\\n # annexed file\\n repo.add('file2.txt', git=False)\\n ok_(repo.dirty)\\n # commit\\n repo.commit(\\\"file2.txt annexed\\\")\\n\\n ok_(not repo.dirty)\\n\\n repo.unlock(\\\"file2.txt\\\")\\n # Unlocking the file is seen as a modification when we're not already in an\\n # adjusted branch (for this test, that would be the case if we're on a\\n # crippled filesystem).\\n ok_(repo.dirty ^ repo.is_managed_branch())\\n repo.save()\\n ok_(not repo.dirty)\\n\\n subm = AnnexRepo(repo.pathobj / \\\"subm\\\", create=True)\\n (subm.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n subm.save()\\n ok_(repo.dirty)\\n repo.save()\\n assert_false(repo.dirty)\\n maybe_adjust_repo(subm)\\n assert_false(repo.dirty)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_AnnexRepo_set_remote_url(path=None):\\n\\n ar = AnnexRepo(path, create=True)\\n ar.add_remote('some', 'http://example.com/.git')\\n assert_equal(ar.config['remote.some.url'],\\n 'http://example.com/.git')\\n assert_not_in('remote.some.annexurl', ar.config.keys())\\n # change url:\\n ar.set_remote_url('some', 'http://believe.it')\\n assert_equal(ar.config['remote.some.url'],\\n 'http://believe.it')\\n assert_not_in('remote.some.annexurl', ar.config.keys())\\n\\n # set push url:\\n ar.set_remote_url('some', 'ssh://whatever.ru', push=True)\\n assert_equal(ar.config['remote.some.pushurl'],\\n 'ssh://whatever.ru')\\n assert_in('remote.some.annexurl', ar.config.keys())\\n assert_equal(ar.config['remote.some.annexurl'],\\n 'ssh://whatever.ru')\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_wanted(path=None):\\n ar = AnnexRepo(path, create=True)\\n eq_(ar.get_preferred_content('wanted'), None)\\n # test samples with increasing \\\"trickiness\\\"\\n for v in (\\\"standard\\\",\\n \\\"include=*.nii.gz or include=*.nii\\\",\\n \\\"exclude=archive/* and (include=*.dat or smallerthan=2b)\\\"\\n ):\\n ar.set_preferred_content('wanted', expr=v)\\n eq_(ar.get_preferred_content('wanted'), v)\\n # give it some file so clone/checkout works without hiccups\\n create_tree(ar.path, {'1.dat': 'content'})\\n ar.add('1.dat')\\n ar.commit(msg=\\\"blah\\\")\\n # make a clone and see if all cool there\\n # intentionally clone as pure Git and do not annex init so to see if we\\n # are ignoring crummy log msgs\\n ar1_path = ar.path + '_1'\\n GitRepo.clone(ar.path, ar1_path)\\n ar1 = AnnexRepo(ar1_path, init=False)\\n eq_(ar1.get_preferred_content('wanted'), None)\\n eq_(ar1.get_preferred_content('wanted', DEFAULT_REMOTE), v)\\n ar1.set_preferred_content('wanted', expr='standard')\\n eq_(ar1.get_preferred_content('wanted'), 'standard')\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_AnnexRepo_metadata(path=None):\\n # prelude\\n obscure_name = get_most_obscure_supported_name()\\n\\n ar = AnnexRepo(path, create=True)\\n create_tree(\\n path,\\n {\\n 'up.dat': 'content',\\n obscure_name: {\\n obscure_name + '.dat': 'lowcontent'\\n }\\n })\\n ar.add('.', git=False)\\n ar.commit('content')\\n assert_repo_status(path)\\n # fugue\\n # doesn't do anything if there is nothing to do\\n ar.set_metadata('up.dat')\\n eq_([], list(ar.get_metadata(None)))\\n eq_([], list(ar.get_metadata('')))\\n eq_([], list(ar.get_metadata([])))\\n eq_({'up.dat': {}}, dict(ar.get_metadata('up.dat')))\\n # basic invocation\\n eq_(1, len(ar.set_metadata(\\n 'up.dat',\\n reset={'mike': 'awesome'},\\n add={'tag': 'awesome'},\\n remove={'tag': 'awesome'}, # cancels prev, just to use it\\n init={'virgin': 'true'},\\n purge=['nothere'])))\\n # no timestamps by default\\n md = dict(ar.get_metadata('up.dat'))\\n deq_({'up.dat': {\\n 'virgin': ['true'],\\n 'mike': ['awesome']}},\\n md)\\n # matching timestamp entries for all keys\\n md_ts = dict(ar.get_metadata('up.dat', timestamps=True))\\n for k in md['up.dat']:\\n assert_in('{}-lastchanged'.format(k), md_ts['up.dat'])\\n assert_in('lastchanged', md_ts['up.dat'])\\n # recursive needs a flag\\n assert_raises(CommandError, ar.set_metadata, '.', purge=['virgin'])\\n ar.set_metadata('.', purge=['virgin'], recursive=True)\\n deq_({'up.dat': {\\n 'mike': ['awesome']}},\\n dict(ar.get_metadata('up.dat')))\\n # Use trickier tags (spaces, =)\\n ar.set_metadata('.', reset={'tag': 'one and= '}, purge=['mike'], recursive=True)\\n playfile = opj(obscure_name, obscure_name + '.dat')\\n target = {\\n 'up.dat': {\\n 'tag': ['one and= ']},\\n playfile: {\\n 'tag': ['one and= ']}}\\n deq_(target, dict(ar.get_metadata('.')))\\n for batch in (True, False):\\n # no difference in reporting between modes\\n deq_(target, dict(ar.get_metadata(['up.dat', playfile], batch=batch)))\\n # incremental work like a set\\n ar.set_metadata(playfile, add={'tag': 'one and= '})\\n deq_(target, dict(ar.get_metadata('.')))\\n ar.set_metadata(playfile, add={'tag': ' two'})\\n # returned values are sorted\\n eq_([' two', 'one and= '], dict(ar.get_metadata(playfile))[playfile]['tag'])\\n # init honor prior values\\n ar.set_metadata(playfile, init={'tag': 'three'})\\n eq_([' two', 'one and= '], dict(ar.get_metadata(playfile))[playfile]['tag'])\\n ar.set_metadata(playfile, remove={'tag': ' two'})\\n deq_(target, dict(ar.get_metadata('.')))\\n # remove non-existing doesn't error and doesn't change anything\\n ar.set_metadata(playfile, remove={'ether': 'best'})\\n deq_(target, dict(ar.get_metadata('.')))\\n # add works without prior existence\\n ar.set_metadata(playfile, add={'novel': 'best'})\\n eq_(['best'], dict(ar.get_metadata(playfile))[playfile]['novel'])\\n\\n\\n@with_tree(tree={'file.txt': 'content'})\\n@serve_path_via_http()\\n@with_tempfile\\ndef test_AnnexRepo_addurl_batched_and_set_metadata(path=None, url=None, dest=None):\\n ar = AnnexRepo(dest, create=True)\\n fname = \\\"file.txt\\\"\\n ar.add_url_to_file(fname, urljoin(url, fname), batch=True)\\n ar.set_metadata(fname, init={\\\"number\\\": \\\"one\\\"})\\n eq_([\\\"one\\\"], dict(ar.get_metadata(fname))[fname][\\\"number\\\"])\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_change_description(path=None):\\n # prelude\\n ar = AnnexRepo(path, create=True, description='some')\\n eq_(ar.get_description(), 'some')\\n # try change it\\n ar = AnnexRepo(path, create=False, init=True, description='someother')\\n # this doesn't cut the mustard, still old\\n eq_(ar.get_description(), 'some')\\n # need to resort to \\\"internal\\\" helper\\n ar._init(description='someother')\\n eq_(ar.get_description(), 'someother')\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get_corresponding_branch(src_path=None, path=None):\\n src = AnnexRepo(src_path, create=True)\\n (src.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n src.save('some')\\n\\n ar = AnnexRepo.clone(src_path, path)\\n\\n # we should be on the default branch.\\n eq_(DEFAULT_BRANCH,\\n ar.get_corresponding_branch() or ar.get_active_branch())\\n\\n # special case v6 adjusted branch is not provided by a dedicated build:\\n ar.adjust()\\n # as above, we still want to get the default branch, while being on\\n # 'adjusted/(unlocked)'\\n eq_('adjusted/{}(unlocked)'.format(DEFAULT_BRANCH),\\n ar.get_active_branch())\\n eq_(DEFAULT_BRANCH, ar.get_corresponding_branch())\\n\\n\\n@with_tempfile\\n@with_tempfile\\ndef test_AnnexRepo_get_tracking_branch(src_path=None, path=None):\\n src = AnnexRepo(src_path, create=True)\\n (src.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n src.save('some')\\n\\n ar = AnnexRepo.clone(src_path, path)\\n\\n # we want the relation to original branch, e.g. in v6+ adjusted branch\\n eq_((DEFAULT_REMOTE, 'refs/heads/' + DEFAULT_BRANCH),\\n ar.get_tracking_branch())\\n\\n\\n@skip_if_adjusted_branch\\n@with_tempfile\\ndef test_AnnexRepo_is_managed_branch(path=None):\\n ar = AnnexRepo(path, create=True)\\n (ar.pathobj / 'test-annex.dat').write_text(\\\"content\\\")\\n ar.save('some')\\n\\n ar.adjust()\\n ok_(ar.is_managed_branch())\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_fake_is_not_special(path=None):\\n ar = AnnexRepo(path, create=True)\\n # doesn't exist -- we fail by default\\n assert_raises(RemoteNotAvailableError, ar.is_special_annex_remote, \\\"fake\\\")\\n assert_false(ar.is_special_annex_remote(\\\"fake\\\", check_if_known=False))\\n\\n\\n@with_tree(tree={\\\"remote\\\": {}, \\\"main\\\": {}, \\\"special\\\": {}})\\ndef test_is_special(path=None):\\n rem = AnnexRepo(op.join(path, \\\"remote\\\"), create=True)\\n dir_arg = \\\"directory={}\\\".format(op.join(path, \\\"special\\\"))\\n rem.init_remote(\\\"imspecial\\\",\\n [\\\"type=directory\\\", \\\"encryption=none\\\", dir_arg])\\n ok_(rem.is_special_annex_remote(\\\"imspecial\\\"))\\n\\n ar = AnnexRepo.clone(rem.path, op.join(path, \\\"main\\\"))\\n assert_false(ar.is_special_annex_remote(DEFAULT_REMOTE))\\n\\n assert_false(ar.is_special_annex_remote(\\\"imspecial\\\",\\n check_if_known=False))\\n ar.enable_remote(\\\"imspecial\\\", options=[dir_arg])\\n ok_(ar.is_special_annex_remote(\\\"imspecial\\\"))\\n\\n # With a mis-configured remote, give warning and return false.\\n ar.config.unset(f\\\"remote.{DEFAULT_REMOTE}.url\\\", scope=\\\"local\\\")\\n with swallow_logs(new_level=logging.WARNING) as cml:\\n assert_false(ar.is_special_annex_remote(DEFAULT_REMOTE))\\n cml.assert_logged(msg=\\\".*no URL.*\\\", level=\\\"WARNING\\\", regex=True)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_fake_dates(path=None):\\n ar = AnnexRepo(path, create=True, fake_dates=True)\\n timestamp = ar.config.obtain(\\\"datalad.fake-dates-start\\\") + 1\\n # Commits from the \\\"git annex init\\\" call are one second ahead.\\n for commit in ar.get_branch_commits_(\\\"git-annex\\\"):\\n eq_(timestamp, int(ar.format_commit('%ct', commit)))\\n assert_in(\\\"timestamp={}s\\\".format(timestamp),\\n ar.call_git([\\\"cat-file\\\", \\\"blob\\\", \\\"git-annex:uuid.log\\\"], read_only=True))\\n\\n\\n# to prevent regression\\n# http://git-annex.branchable.com/bugs/v6_-_under_subdir__58___git_add___34__whines__34____44___git_commit___34__blows__34__/\\n# It is disabled because is not per se relevant to DataLad since we do not\\n# Since we invoke from the top of the repo, we do not hit it,\\n# but thought to leave it around if we want to enforce/test system-wide git being\\n# compatible with annex for v6 mode\\n@with_tempfile(mkdir=True)\\ndef _test_add_under_subdir(path):\\n ar = AnnexRepo(path, create=True, version=6)\\n gr = GitRepo(path) # \\\"Git\\\" view over the repository, so we force \\\"git add\\\"\\n subdir = opj(path, 'sub')\\n subfile = opj('sub', 'empty')\\n # os.mkdir(subdir)\\n create_tree(subdir, {'empty': ''})\\n runner = Runner(cwd=subdir)\\n with chpwd(subdir):\\n runner.run(['git', 'add', 'empty']) # should add successfully\\n # gr.commit('important') #\\n runner.run(['git', 'commit', '-m', 'important'])\\n ar.is_under_annex(subfile)\\n\\n\\n# https://github.com/datalad/datalad/issues/2892\\n@with_tempfile(mkdir=True)\\ndef test_error_reporting(path=None):\\n ar = AnnexRepo(path, create=True)\\n res = ar.call_annex_records(['add'], files='gl\\\\\\\\orious BS')\\n target = {\\n 'command': 'add',\\n # whole thing, despite space, properly quotes backslash\\n 'file': 'gl\\\\\\\\orious BS',\\n 'note': 'not found',\\n 'success': False\\n }\\n assert len(res) >= 1\\n if 'message-id' in res[0]:\\n # new since ~ 10.20230407-99-gbe36e208c2\\n target['message-id'] = 'FileNotFound'\\n target['input'] = ['gl\\\\\\\\orious BS']\\n target['error-messages'] = ['git-annex: gl\\\\\\\\orious BS not found']\\n else:\\n # our own produced record\\n target['error-messages'] = ['File unknown to git']\\n eq_(res, [target])\\n\\n\\n@with_tree(tree={\\n 'file1': \\\"content1\\\",\\n 'dir1': {'file2': 'content2'},\\n})\\ndef test_annexjson_protocol(path=None):\\n ar = AnnexRepo(path, create=True)\\n ar.save()\\n assert_repo_status(path)\\n # first an orderly execution\\n res = ar._call_annex(\\n ['find', '.', '--json'],\\n protocol=AnnexJsonProtocol)\\n for k in ('stdout', 'stdout_json', 'stderr'):\\n assert_in(k, res)\\n orig_j = res['stdout_json']\\n eq_(len(orig_j), 2)\\n # not meant as an exhaustive check for output structure,\\n # just some assurance that it is not totally alien\\n ok_(all(j['file'] for j in orig_j))\\n # no complaints, unless git-annex is triggered to run in debug mode\\n if logging.getLogger('datalad.annex').getEffectiveLevel() > 8:\\n eq_(res['stderr'], '')\\n\\n # Note: git-annex-find does not error with all annex\\n # versions. Fixed in annex commit\\n # ce91f10132805d11448896304821b0aa9c6d9845 (Feb 28, 2022).\\n if '10.20220222' < external_versions['cmd:annex'] < '10.20220322':\\n raise SkipTest(\\\"zero-exit annex-find bug\\\")\\n\\n # now the same, but with a forced error\\n with assert_raises(CommandError) as e:\\n ar._call_annex(['find', '.', 'error', '--json'],\\n protocol=AnnexJsonProtocol)\\n # normal operation is not impaired\\n eq_(e.value.kwargs['stdout_json'], orig_j)\\n # we get a clue what went wrong,\\n # but reporting depends on config + version (default changed):\\n msg = \\\"pathspec 'error' did not match\\\" if not dl_cfg.getbool(\\n section=\\\"annex\\\", option=\\\"skipunknown\\\",\\n # git-annex switched default for this config:\\n default=bool(external_versions['cmd:annex'] < '10.20220222')) else \\\\\\n \\\"error not found\\\"\\n assert_in(msg, e.value.stderr)\\n # there should be no errors reported in an individual records\\n # hence also no pointless statement in the str()\\n assert_not_in('errors from JSON records', str(e.value))\\n\\n\\n@with_tempfile\\ndef test_annexjson_protocol_long(path=None, *, caplog):\\n records = [\\n {\\\"k\\\": \\\"v\\\" * 20},\\n # Value based off of\\n # Lib.asyncio.unix_events._UnixReadPipeTransport.max_size.\\n {\\\"k\\\": \\\"v\\\" * 256 * 1024},\\n # and tiny ones in between should not be lost\\n {\\\"k\\\": \\\"v\\\"},\\n # even a much larger one - we should handle as well\\n {\\\"k\\\": \\\"v\\\" * 256 * 1024 * 5},\\n ]\\n with open(path, 'w') as f:\\n for record in records:\\n print(\\\"print(%r);\\\" % json.dumps(record), file=f)\\n runner = GitWitlessRunner()\\n with caplog.at_level(logging.ERROR), \\\\\\n swallow_logs(new_level=logging.ERROR):\\n res = runner.run(\\n [sys.executable, path],\\n protocol=AnnexJsonProtocol\\n )\\n eq_(res['stdout'], '')\\n eq_(res['stderr'], '')\\n eq_(res['stdout_json'], records)\\n\\n\\n@pytest.mark.parametrize(\\\"print_opt\\\", ['', ', end=\\\"\\\"'])\\n@with_tempfile\\ndef test_annexjson_protocol_incorrect(path=None, *, print_opt, caplog):\\n # Test that we still log some incorrectly formed JSON record\\n bad_json = '{\\\"I\\\": \\\"am wrong,}'\\n with open(path, 'w') as f:\\n print(\\\"print(%r%s);\\\" % (bad_json, print_opt), file=f)\\n runner = GitWitlessRunner()\\n # caplog only to not cause memory error in case of heavy debugging\\n # Unfortunately it lacks similar .assert_logged with a regex matching\\n # to be just used instead\\n with caplog.at_level(logging.ERROR), \\\\\\n swallow_logs(new_level=logging.ERROR) as cml:\\n res = runner.run(\\n [sys.executable, path],\\n protocol=AnnexJsonProtocol\\n )\\n cml.assert_logged(\\n msg=\\\".*[rR]eceived undecodable JSON output\\\",\\n level=\\\"ERROR\\\",\\n regex=True)\\n # only error logged and nothing returned\\n eq_(res['stdout'], '')\\n eq_(res['stderr'], '')\\n eq_(res['stdout_json'], [])\\n\\n# see https://github.com/datalad/datalad/pull/5400 for troubleshooting\\n# for stalling with unlock=False, and then with unlock=True it took >= 300 sec\\n# https://github.com/datalad/datalad/pull/5433#issuecomment-784470028\\n@skip_if(on_travis and on_nfs) # TODO. stalls\\n# http://git-annex.branchable.com/bugs/cannot_commit___34__annex_add__34__ed_modified_file_which_switched_its_largefile_status_to_be_committed_to_git_now/#comment-bf70dd0071de1bfdae9fd4f736fd1ec\\n# https://github.com/datalad/datalad/issues/1651\\n@known_failure_githubci_win\\n@pytest.mark.parametrize(\\\"unlock\\\", [True, False])\\n@with_tree(tree={\\n '.gitattributes': \\\"** annex.largefiles=(largerthan=4b)\\\",\\n 'alwaysbig': 'a'*10,\\n 'willgetshort': 'b'*10,\\n 'tobechanged-git': 'a',\\n 'tobechanged-annex': 'a'*10,\\n})\\ndef test_commit_annex_commit_changed(path=None, *, unlock):\\n # Here we test commit working correctly if file was just removed\\n # (not unlocked), edited and committed back\\n\\n # TODO: an additional possible interaction to check/solidify - if files\\n # first get unannexed (after being optionally unlocked first)\\n unannex = False\\n\\n ar = AnnexRepo(path, create=True)\\n ar.save(paths=[\\\".gitattributes\\\"], git=True)\\n ar.save(\\\"initial commit\\\")\\n assert_repo_status(path)\\n # Now let's change all but commit only some\\n files = [op.basename(p) for p in glob(op.join(path, '*'))]\\n if unlock:\\n ar.unlock(files)\\n if unannex:\\n ar.unannex(files)\\n create_tree(\\n path\\n , {\\n 'alwaysbig': 'a'*11,\\n 'willgetshort': 'b',\\n 'tobechanged-git': 'aa',\\n 'tobechanged-annex': 'a'*11,\\n 'untracked': 'unique'\\n }\\n , remove_existing=True\\n )\\n assert_repo_status(\\n path\\n , modified=files if not unannex else ['tobechanged-git']\\n , untracked=['untracked'] if not unannex else\\n # all but the one in git now\\n ['alwaysbig', 'tobechanged-annex', 'untracked', 'willgetshort']\\n )\\n\\n ar.save(\\\"message\\\", paths=['alwaysbig', 'willgetshort'])\\n assert_repo_status(\\n path\\n , modified=['tobechanged-git', 'tobechanged-annex']\\n , untracked=['untracked']\\n )\\n ok_file_under_git(path, 'alwaysbig', annexed=True)\\n ok_file_under_git(path, 'willgetshort', annexed=False)\\n\\n ar.save(\\\"message2\\\", untracked='no') # commit all changed\\n assert_repo_status(\\n path\\n , untracked=['untracked']\\n )\\n ok_file_under_git(path, 'tobechanged-git', annexed=False)\\n ok_file_under_git(path, 'tobechanged-annex', annexed=True)\\n\\n\\n_test_unannex_tree = {\\n OBSCURE_FILENAME: 'content1',\\n OBSCURE_FILENAME + \\\".dat\\\": 'content2',\\n}\\nif not on_windows and (\\n external_versions['cmd:annex'] <= '10.20230407' or external_versions['cmd:annex'] >= '10.20230408'\\n):\\n # Only whenever we are not within the development versions of the 10.20230407\\n # where we cannot do version comparison relibalye,\\n # the case where we have entire filename within \\\"\\\"\\n _test_unannex_tree[f'\\\"{OBSCURE_FILENAME}\\\"'] = 'content3'\\n\\n\\n@with_tree(tree=_test_unannex_tree)\\ndef test_unannex_etc(path=None):\\n # Primarily to test if quote/unquote/not-quote'ing work for tricky\\n # filenames. Ref: https://github.com/datalad/datalad/pull/7372\\n repo = AnnexRepo(path)\\n files = list(_test_unannex_tree)\\n # here it is through json so kinda guaranteed to work but let's check too\\n assert files == [x['file'] for x in repo.add(files)]\\n assert sorted(files) == sorted(repo.get_annexed_files())\\n assert files == repo.unannex(files)\\n\\n\\n@slow # 15 + 17sec on travis\\n@pytest.mark.parametrize(\\\"cls\\\", [GitRepo, AnnexRepo])\\n@with_tempfile(mkdir=True)\\ndef test_files_split_exc(topdir=None, *, cls):\\n r = cls(topdir)\\n # absent files -- should not crash with \\\"too long\\\" but some other more\\n # meaningful exception\\n files = [\\\"f\\\" * 100 + \\\"%04d\\\" % f for f in range(100000)]\\n if isinstance(r, AnnexRepo):\\n # Annex'es add first checks for what is being added and does not fail\\n # for non existing files either ATM :-/ TODO: make consistent etc\\n r.add(files)\\n else:\\n with assert_raises(Exception) as ecm:\\n r.add(files)\\n assert_not_in('too long', str(ecm.value))\\n assert_not_in('too many', str(ecm.value))\\n\\n\\n# with 204 (/ + (98+3)*2 + /) chars guaranteed, we hit \\\"filename too long\\\" quickly on windows\\n# so we are doomed to shorten the filepath for testing on windows. Since the limits are smaller\\n# on windows (16k vs e.g. 1m on linux in CMD_MAX_ARG), it would already be a \\\"struggle\\\" for it,\\n# we also reduce number of dirs/files\\n_ht_len, _ht_n = (48, 20) if on_windows else (98, 100)\\n\\n_HEAVY_TREE = {\\n # might already run into 'filename too long' on windows probably\\n \\\"d\\\" * _ht_len + '%03d' % d: {\\n # populate with not entirely unique but still not all identical (empty) keys.\\n # With content unique to that filename we would still get 100 identical\\n # files for each key, thus possibly hitting regressions in annex like\\n # https://git-annex.branchable.com/bugs/significant_performance_regression_impacting_datal/\\n # but also would not hit filesystem as hard as if we had all the keys unique.\\n 'f' * _ht_len + '%03d' % f: str(f)\\n for f in range(_ht_n)\\n }\\n for d in range(_ht_n)\\n}\\n\\n# @known_failure_windows # might fail with some older annex `cp` failing to set permissions\\n@slow # 313s well -- if errors out - only 3 sec\\n@pytest.mark.parametrize(\\\"cls\\\", [GitRepo, AnnexRepo])\\n@with_tree(tree=_HEAVY_TREE)\\ndef test_files_split(topdir=None, *, cls):\\n from glob import glob\\n r = cls(topdir)\\n dirs = glob(op.join(topdir, '*'))\\n files = glob(op.join(topdir, '*', '*'))\\n\\n r.add(files)\\n r.commit(files=files)\\n\\n # Let's modify and do dl.add for even a heavier test\\n # Now do for real on some heavy directory\\n import datalad.api as dl\\n for f in files:\\n os.unlink(f)\\n with open(f, 'w') as f:\\n f.write('1')\\n dl.save(dataset=r.path, path=dirs, result_renderer=\\\"disabled\\\")\\n\\n\\n@skip_if_on_windows\\n@skip_if_root\\n@with_tree({\\n 'repo': {\\n 'file1': 'file1',\\n 'file2': 'file2'\\n }\\n})\\ndef test_ro_operations(path=None):\\n # This test would function only if there is a way to run sudo\\n # non-interactively, e.g. on Travis or on your local (watchout!) system\\n # after you ran sudo command recently.\\n run = Runner().run\\n sudochown = lambda cmd: run(['sudo', '-n', 'chown'] + cmd)\\n\\n repo = AnnexRepo(op.join(path, 'repo'), init=True)\\n repo.add('file1')\\n repo.commit()\\n\\n # make a clone\\n repo2 = repo.clone(repo.path, op.join(path, 'clone'))\\n repo2.get('file1')\\n\\n # progress forward original repo and fetch (but nothing else) it into repo2\\n repo.add('file2')\\n repo.commit()\\n repo2.fetch(DEFAULT_REMOTE)\\n\\n # Assure that regardless of umask everyone could read it all\\n run(['chmod', '-R', 'a+rX', repo2.path])\\n try:\\n # To assure that git/git-annex really cannot acquire a lock and do\\n # any changes (e.g. merge git-annex branch), we make this repo owned by root\\n sudochown(['-R', 'root', repo2.path])\\n except Exception as exc:\\n # Exception could be CommandError or IOError when there is no sudo\\n raise SkipTest(\\\"Cannot run sudo chown non-interactively: %s\\\" % exc)\\n\\n # recent git would refuse to run git status in repository owned by someone else\\n # which could lead to odd git-annex errors before 10.20220504-55-gaf0d85446 AKA 10.20220525~13\\n # see https://github.com/datalad/datalad/issues/5665 and after an informative error\\n # https://github.com/datalad/datalad/issues/6708\\n # To overcome - explicitly add the path into allowed\\n dl_cfg.add('safe.directory', repo2.path, scope='global')\\n\\n try:\\n assert not repo2.get('file1') # should work since file is here already\\n repo2.status() # should be Ok as well\\n # and we should get info on the file just fine\\n assert repo2.info('file1')\\n # The tricky part is the repo_info which might need to update\\n # remotes UUID -- by default it should fail!\\n # Oh well -- not raised on travis... whatever for now\\n #with assert_raises(CommandError):\\n # repo2.repo_info()\\n # but should succeed if we disallow merges\\n repo2.repo_info(merge_annex_branches=False)\\n # and ultimately the ls which uses it\\n try:\\n from datalad.api import ls\\n ls(repo2.path, all_=True, long_=True)\\n except ImportError:\\n raise SkipTest(\\n \\\"No `ls` command available (provided by -deprecated extension)\\\")\\n finally:\\n sudochown(['-R', str(os.geteuid()), repo2.path])\\n\\n # just check that all is good again\\n repo2.repo_info()\\n\\n\\n@skip_if_on_windows\\n@skip_if_root\\n@with_tree({\\n 'file1': 'file1',\\n})\\ndef test_save_noperms(path=None):\\n # check that we do report annex error messages\\n\\n # This test would function only if there is a way to run sudo\\n # non-interactively, e.g. on Travis or on your local (watchout!) system\\n # after you ran sudo command recently.\\n repo = AnnexRepo(path, init=True)\\n\\n run = Runner().run\\n sudochown = lambda cmd: run(['sudo', '-n', 'chown'] + cmd)\\n\\n try:\\n # To assure that git/git-annex really cannot acquire a lock and do\\n # any changes (e.g. merge git-annex branch), we make this repo owned by root\\n sudochown(['-R', 'root:root', str(repo.pathobj / 'file1')])\\n except Exception as exc:\\n # Exception could be CommandError or IOError when there is no sudo\\n raise SkipTest(\\\"Cannot run sudo chown non-interactively: %s\\\" % exc)\\n\\n try:\\n repo.save(paths=['file1'])\\n except CommandError as exc:\\n res = exc.kwargs[\\\"stdout_json\\\"]\\n assert_result_count(res, 1)\\n assert_result_count(res, 1, file='file1',\\n command='add', success=False)\\n assert_in('permission denied', res[0]['error-messages'][0])\\n finally:\\n sudochown(['-R', str(os.geteuid()), repo.path])\\n\\n\\ndef test_get_size_from_key():\\n\\n # see https://git-annex.branchable.com/internals/key_format/\\n # BACKEND[-sNNNN][-mNNNN][-SNNNN-CNNNN]--NAME\\n\\n test_keys = {\\\"ANYBACKEND--NAME\\\": None,\\n \\\"ANYBACKEND-s123-m1234--NAME-WITH-DASHES.ext\\\": 123,\\n \\\"MD5E-s100-S10-C1--somen.ame\\\": 10,\\n \\\"SHA256-s99-S10-C10--name\\\": 9,\\n \\\"SHA256E-sNaN--name\\\": None, # debatable: None or raise?\\n }\\n\\n invalid = [\\\"ANYBACKEND-S10-C30--missing-total\\\",\\n \\\"s99-S10-C10--NOBACKEND\\\",\\n \\\"MD5-s100-S5--no-chunk-number\\\"]\\n\\n for key in invalid:\\n assert_raises(ValueError, AnnexRepo.get_size_from_key, key)\\n\\n for key, value in test_keys.items():\\n eq_(AnnexRepo.get_size_from_key(key), value)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_call_annex(path=None):\\n ar = AnnexRepo(path, create=True)\\n # we raise on mistakes\\n with assert_raises(CommandError):\\n ar._call_annex(['not-an-annex-command'])\\n # and we get to know why\\n try:\\n ar._call_annex(['not-an-annex-command'])\\n except CommandError as e:\\n assert_in('Invalid argument', e.stderr)\\n\\n\\n@with_tempfile\\ndef test_whereis_zero_copies(path=None):\\n repo = AnnexRepo(path, create=True)\\n (repo.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n repo.save()\\n repo.drop([\\\"foo\\\"], options=[\\\"--force\\\"])\\n\\n for output in \\\"full\\\", \\\"uuids\\\", \\\"descriptions\\\":\\n res = repo.whereis(files=[\\\"foo\\\"], output=output)\\n if output == \\\"full\\\":\\n assert_equal(res[\\\"foo\\\"], {})\\n else:\\n assert_equal(res, [[]])\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_whereis_batch_eqv(path=None):\\n path = Path(path)\\n\\n repo_a = AnnexRepo(path / \\\"a\\\", create=True)\\n (repo_a.pathobj / \\\"foo\\\").write_text(\\\"foo\\\")\\n (repo_a.pathobj / \\\"bar\\\").write_text(\\\"bar\\\")\\n (repo_a.pathobj / \\\"baz\\\").write_text(\\\"baz\\\")\\n repo_a.save()\\n\\n repo_b = repo_a.clone(repo_a.path, str(path / \\\"b\\\"))\\n repo_b.drop([\\\"bar\\\"])\\n repo_b.drop([\\\"baz\\\"])\\n repo_b.drop([\\\"baz\\\"], options=[\\\"--from=\\\" + DEFAULT_REMOTE, \\\"--force\\\"])\\n\\n files = [\\\"foo\\\", \\\"bar\\\", \\\"baz\\\"]\\n info = repo_b.get_content_annexinfo(files)\\n keys = [info[repo_b.pathobj / f]['key'] for f in files]\\n\\n for output in \\\"full\\\", \\\"uuids\\\", \\\"descriptions\\\":\\n out_non_batch = repo_b.whereis(files=files, batch=False, output=output)\\n assert_equal(out_non_batch,\\n repo_b.whereis(files=files, batch=True, output=output))\\n out_non_batch_keys = repo_b.whereis(files=keys, batch=False, key=True, output=output)\\n # should be identical\\n if output == 'full':\\n # we need to map files to keys though\\n assert_equal(out_non_batch_keys,\\n {k: out_non_batch[f] for f, k in zip(files, keys)})\\n else:\\n assert_equal(out_non_batch, out_non_batch_keys)\\n\\n if external_versions['cmd:annex'] >= '8.20210903':\\n # --batch-keys support was introduced\\n assert_equal(out_non_batch_keys,\\n repo_b.whereis(files=keys, batch=True, key=True, output=output))\\n\\n if external_versions['cmd:annex'] < '8.20210903':\\n # --key= and --batch are incompatible.\\n with assert_raises(ValueError):\\n repo_b.whereis(files=files, batch=True, key=True)\\n\\n\\ndef test_done_deprecation():\\n with unittest.mock.patch(\\\"datalad.cmd.warnings.warn\\\") as warn_mock:\\n _ = AnnexJsonProtocol(\\\"done\\\")\\n warn_mock.assert_called_once()\\n\\n with unittest.mock.patch(\\\"datalad.cmd.warnings.warn\\\") as warn_mock:\\n _ = AnnexJsonProtocol()\\n warn_mock.assert_not_called()\\n\\n\\ndef test_generator_annex_json_protocol():\\n\\n runner = Runner()\\n stdin_queue = Queue()\\n\\n def json_object(count: int):\\n json_template = '{{\\\"id\\\": \\\"some-id\\\", \\\"count\\\": {count}}}'\\n return json_template.format(count=count).encode()\\n\\n count = 123\\n stdin_queue.put(json_object(count=count))\\n for result in runner.run(cmd=\\\"cat\\\", protocol=GeneratorAnnexJsonProtocol, stdin=stdin_queue):\\n assert_equal(\\n result,\\n {\\n \\\"id\\\": \\\"some-id\\\",\\n \\\"count\\\": count,\\n }\\n )\\n if count == 133:\\n break\\n count += 1\\n stdin_queue.put(json_object(count=count))\\n\\n\\ndef test_captured_exception():\\n class RaiseMock:\\n def add_(self, *args, **kwargs):\\n raise CommandError(\\\"RaiseMock.add_\\\")\\n\\n with patch(\\\"datalad.support.annexrepo.super\\\") as repl_super:\\n repl_super.return_value = RaiseMock()\\n gen = AnnexRepo.add_(object(), [])\\n assert_raises(CommandError, gen.send, None)\\n\\n\\n@skip_if_on_windows\\ndef test_stderr_rejecting_protocol_trigger():\\n result_generator = GitWitlessRunner().run(\\n \\\"echo ssss >&2\\\",\\n protocol=GeneratorAnnexJsonNoStderrProtocol)\\n\\n try:\\n tuple(result_generator)\\n except CommandError as e:\\n assert_in(\\\"ssss\\\", e.stderr)\\n return\\n assert_true(False)\\n\\n\\n@skip_if_on_windows\\ndef test_stderr_rejecting_protocol_ignore():\\n\\n result_generator = GitWitlessRunner().run(\\n ['echo', '{\\\"status\\\": \\\"ok\\\"}'],\\n protocol=GeneratorAnnexJsonNoStderrProtocol)\\n assert_equal(tuple(result_generator), ({\\\"status\\\": \\\"ok\\\"},))\\n\"\n },\n {\n \"alpha_fraction\": 0.5895057320594788,\n \"alphanum_fraction\": 0.5954243540763855,\n \"avg_line_length\": 35.899105072021484,\n \"blob_id\": \"0c0324fc2efc74b88aa06935287c2e8f28e45e41\",\n \"content_id\": \"e73e9ac1f607cc14a9753b16651843ae16b409f6\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 28900,\n \"license_type\": \"permissive\",\n \"max_line_length\": 209,\n \"num_lines\": 783,\n \"path\": \"/datalad/core/local/tests/test_run.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-; coding: utf-8 -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Partial testing of `run` commands.\\n\\nNote: Tests of `run` that involve `rerun` are in interface.tests.test_run.\\n\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\nimport logging\\nimport os\\nimport os.path as op\\nimport sys\\nfrom os import (\\n mkdir,\\n remove,\\n)\\nfrom unittest.mock import patch\\n\\nfrom datalad.api import (\\n clone,\\n run,\\n)\\nfrom datalad.cli.main import main\\nfrom datalad.core.local.run import (\\n _format_iospecs,\\n _get_substitutions,\\n format_command,\\n run_command,\\n)\\nfrom datalad.distribution.dataset import Dataset\\nfrom datalad.support.exceptions import (\\n CommandError,\\n IncompleteResultsError,\\n NoDatasetFound,\\n)\\nfrom datalad.tests.utils_pytest import (\\n DEFAULT_BRANCH,\\n OBSCURE_FILENAME,\\n assert_false,\\n assert_in,\\n assert_in_results,\\n assert_not_in,\\n assert_not_in_results,\\n assert_raises,\\n assert_repo_status,\\n assert_result_count,\\n assert_status,\\n create_tree,\\n eq_,\\n known_failure_windows,\\n neq_,\\n ok_,\\n ok_exists,\\n ok_file_has_content,\\n patch_config,\\n swallow_logs,\\n swallow_outputs,\\n with_tempfile,\\n with_tree,\\n)\\nfrom datalad.utils import (\\n chpwd,\\n ensure_unicode,\\n on_windows,\\n)\\n\\ncat_command = 'cat' if not on_windows else 'type'\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_invalid_call(path=None):\\n with chpwd(path):\\n # no dataset, no luck\\n assert_raises(NoDatasetFound, run, 'doesntmatter')\\n # dirty dataset\\n ds = Dataset(path).create()\\n create_tree(ds.path, {'this': 'dirty'})\\n assert_status('impossible', run('doesntmatter', on_failure='ignore'))\\n\\n\\ndef last_commit_msg(repo):\\n # ATTN: Pass branch explicitly so that this check works when we're on an\\n # adjusted branch too (e.g., when this test is executed under Windows).\\n return repo.format_commit(\\\"%B\\\", DEFAULT_BRANCH)\\n\\n\\n@with_tempfile(mkdir=True)\\n@with_tempfile(mkdir=True)\\ndef test_basics(path=None, nodspath=None):\\n ds = Dataset(path).create()\\n last_state = ds.repo.get_hexsha()\\n # run inside the dataset\\n with chpwd(path), \\\\\\n swallow_outputs():\\n # provoke command failure\\n res = ds.run('7i3amhmuch9invalid', on_failure=\\\"ignore\\\",\\n result_renderer=None)\\n assert_result_count(res, 1, action=\\\"run\\\", status=\\\"error\\\")\\n run_res = [r for r in res if r[\\\"action\\\"] == \\\"run\\\"][0]\\n # let's not speculate that the exit code is always 127\\n ok_(run_res[\\\"run_info\\\"][\\\"exit\\\"] > 0)\\n eq_(last_state, ds.repo.get_hexsha())\\n # now one that must work\\n res = ds.run('cd .> empty', message='TEST')\\n assert_repo_status(ds.path)\\n assert_result_count(res, 3)\\n # TODO 'state' is still untracked!!!\\n assert_result_count(res, 1, action='add',\\n path=op.join(ds.path, 'empty'), type='file')\\n assert_result_count(res, 1, action='save', path=ds.path)\\n commit_msg = last_commit_msg(ds.repo)\\n ok_(commit_msg.startswith('[DATALAD RUNCMD] TEST'))\\n # crude test that we have a record for the PWD\\n assert_in('\\\"pwd\\\": \\\".\\\"', commit_msg)\\n last_state = ds.repo.get_hexsha()\\n # now run a command that will not alter the dataset\\n noop_cmd = ':'\\n res = ds.run(noop_cmd, message='NOOP_TEST')\\n assert_result_count(res, 1, action='save', status='notneeded')\\n eq_(last_state, ds.repo.get_hexsha())\\n # We can also run the command via a single-item list because this is\\n # what the CLI interface passes in for quoted commands.\\n res = ds.run([noop_cmd], message='NOOP_TEST')\\n assert_result_count(res, 1, action='save', status='notneeded')\\n\\n # run outside the dataset, should still work but with limitations\\n with chpwd(nodspath), \\\\\\n swallow_outputs():\\n res = ds.run('cd . > empty2', message='TEST')\\n assert_result_count(res, 1, action='add',\\n path=op.join(ds.path, 'empty2'),\\n type='file', status='ok')\\n assert_result_count(res, 1, action='save', status='ok')\\n\\n # running without a command is a noop\\n with chpwd(path):\\n with swallow_logs(new_level=logging.WARN) as cml:\\n ds.run()\\n assert_in(\\\"No command given\\\", cml.out)\\n\\n # running without a command is a noop\\n with chpwd(path):\\n with swallow_logs(new_level=logging.INFO) as cml:\\n assert_raises(\\n IncompleteResultsError,\\n ds.run,\\n '7i3amhmuch9invalid',\\n # this is on_failure=stop by default\\n )\\n # must give recovery hint in Python notation\\n assert_in(\\\"can save the changes with \\\\\\\"Dataset(\\\", cml.out)\\n\\n with chpwd(path):\\n # make sure that an invalid input declaration prevents command\\n # execution by default\\n assert_raises(\\n IncompleteResultsError,\\n ds.run, 'cd .> dummy0', inputs=['not-here'])\\n ok_(not (ds.pathobj / 'dummy0').exists())\\n # but the default behavior can be changed\\n assert_raises(\\n IncompleteResultsError,\\n ds.run, 'cd .> dummy0', inputs=['not-here'],\\n on_failure='continue')\\n # it has stilled failed, but the command got executed nevertheless\\n ok_((ds.pathobj / 'dummy0').exists())\\n\\n\\n@known_failure_windows\\n# ^ For an unknown reason, appveyor started failing after we removed\\n# receive.autogc=0 and gc.auto=0 from our common git options (gh-3482).\\n# moreover the usage of unicode in the file names also breaks this on windows\\n@with_tempfile(mkdir=True)\\ndef test_py2_unicode_command(path=None):\\n # Avoid OBSCURE_FILENAME to avoid windows-breakage (gh-2929).\\n ds = Dataset(path).create()\\n touch_cmd = \\\"import sys; open(sys.argv[1], 'w').write('')\\\"\\n cmd_str = u\\\"{} -c \\\\\\\"{}\\\\\\\" {}\\\".format(sys.executable,\\n touch_cmd,\\n u\\\"bβ0.dat\\\")\\n ds.run(cmd_str)\\n assert_repo_status(ds.path)\\n ok_exists(op.join(path, u\\\"bβ0.dat\\\"))\\n\\n # somewhat desperate attempt to detect our own Github CI tests on a\\n # crippled filesystem (VFAT) that is so crippled that it doesn't handle\\n # what is needed here. It just goes mad with encoded bytestrings:\\n # CommandError: ''python -c '\\\"'\\\"'import sys; open(sys.argv[1], '\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'w'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"').write('\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"''\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"'\\\"')'\\\"'\\\"' '\\\"'\\\"' β1 '\\\"'\\\"''' failed with exitcode 1 under /crippledfs/\\n if not on_windows and os.environ.get('TMPDIR', None) != '/crippledfs': # FIXME\\n ds.run([sys.executable, \\\"-c\\\", touch_cmd, u\\\"bβ1.dat\\\"])\\n assert_repo_status(ds.path)\\n ok_exists(op.join(path, u\\\"bβ1.dat\\\"))\\n\\n # Send in a list of byte-strings to mimic a py2 command-line\\n # invocation.\\n ds.run([s.encode(\\\"utf-8\\\")\\n for s in [sys.executable, \\\"-c\\\", touch_cmd, u\\\" β1 \\\"]])\\n assert_repo_status(ds.path)\\n ok_exists(op.join(path, u\\\" β1 \\\"))\\n\\n assert_in_results(\\n ds.run(u\\\"bβ2.dat\\\", result_renderer=None, on_failure=\\\"ignore\\\"),\\n status=\\\"error\\\", action=\\\"run\\\")\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_sidecar(path=None):\\n ds = Dataset(path).create()\\n # Simple sidecar message checks.\\n ds.run(\\\"cd .> dummy0\\\", message=\\\"sidecar arg\\\", sidecar=True)\\n assert_not_in('\\\"cmd\\\":', ds.repo.format_commit(\\\"%B\\\"))\\n\\n ds.config.set(\\\"datalad.run.record-sidecar\\\", \\\"false\\\", scope=\\\"local\\\")\\n ds.run(\\\"cd .> dummy1\\\", message=\\\"sidecar config\\\")\\n\\n assert_in('\\\"cmd\\\":', last_commit_msg(ds.repo))\\n\\n ds.config.set(\\\"datalad.run.record-sidecar\\\", \\\"true\\\", scope=\\\"local\\\")\\n ds.run(\\\"cd .> dummy2\\\", message=\\\"sidecar config\\\")\\n assert_not_in('\\\"cmd\\\":', last_commit_msg(ds.repo))\\n\\n # Don't break when config.get() returns multiple values. Here it's two\\n # values in .gitconfig, but a more realistic scenario is a value in\\n # $repo/.git/config that overrides a setting in ~/.config/git/config.\\n ds.config.add(\\\"datalad.run.record-sidecar\\\", \\\"false\\\", scope=\\\"local\\\")\\n ds.run(\\\"cd .> dummy3\\\", message=\\\"sidecar config\\\")\\n assert_in('\\\"cmd\\\":', last_commit_msg(ds.repo))\\n\\n\\n # make sure sidecar file is committed when explicitly specifying outputs\\n ds.run(\\\"cd .> dummy4\\\",\\n outputs=[\\\"dummy4\\\"],\\n sidecar=True,\\n explicit=True,\\n message=\\\"sidecar + specified outputs\\\")\\n assert_not_in('\\\"cmd\\\":', last_commit_msg(ds.repo))\\n assert_repo_status(ds.path)\\n\\n\\n\\n\\n@with_tree(tree={\\\"to_remove\\\": \\\"abc\\\"})\\ndef test_run_save_deletion(path=None):\\n ds = Dataset(path).create(force=True)\\n ds.save()\\n ds.run(\\\"{} to_remove\\\".format(\\\"del\\\" if on_windows else \\\"rm\\\"))\\n assert_repo_status(ds.path)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_from_subds(path=None):\\n subds = Dataset(path).create().create(\\\"sub\\\")\\n subds.run(\\\"cd .> foo\\\")\\n assert_repo_status(subds.path)\\n\\n\\n@with_tree(tree={\\\"sub\\\": {\\\"input\\\": \\\"\\\"}})\\ndef test_run_from_subds_gh3551(path=None):\\n ds = Dataset(path).create(force=True)\\n ds.save()\\n ds.create(\\\"output\\\")\\n with chpwd(op.join(ds.path, \\\"sub\\\")):\\n assert_in_results(\\n run(\\\"echo\\\",\\n inputs=[op.join(op.pardir, \\\"sub\\\", \\\"input\\\")],\\n outputs=[op.join(op.pardir, \\\"output\\\")],\\n return_type=\\\"list\\\", result_filter=None, result_xfm=None),\\n action=\\\"get\\\",\\n status=\\\"notneeded\\\")\\n assert_repo_status(ds.path)\\n\\n subds_path = op.join(\\\"output\\\", \\\"subds\\\")\\n ds.create(subds_path)\\n with chpwd(op.join(ds.path, \\\"sub\\\")):\\n output_dir = op.join(op.pardir, \\\"output\\\", \\\"subds\\\")\\n # The below command is trying to be compatible. It could be made better\\n # (e.g., actually using the input file) by someone that knows something\\n # about Windows.\\n assert_in_results(\\n run(\\\"cd .> {}\\\".format(op.join(output_dir, \\\"f\\\")),\\n inputs=[op.join(op.pardir, \\\"sub\\\", \\\"input\\\")],\\n outputs=[output_dir],\\n return_type=\\\"list\\\", result_filter=None, result_xfm=None),\\n action=\\\"save\\\",\\n status=\\\"ok\\\")\\n assert_repo_status(ds.path)\\n subds = Dataset(op.join(ds.path, subds_path))\\n ok_exists(op.join(subds.path, \\\"f\\\"))\\n if not ds.repo.is_managed_branch(): # FIXME\\n # This check fails on Windows:\\n # https://github.com/datalad/datalad/pull/3747/checks?check_run_id=248506560#step:8:254\\n ok_(subds.repo.file_has_content(\\\"f\\\"))\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_assume_ready(path=None):\\n ds = Dataset(path).create()\\n repo = ds.repo\\n adjusted = repo.is_managed_branch()\\n\\n # --assume-ready=inputs\\n\\n (repo.pathobj / \\\"f1\\\").write_text(\\\"f1\\\")\\n ds.save()\\n\\n def cat_cmd(fname):\\n return [sys.executable, \\\"-c\\\",\\n \\\"import sys; print(open(sys.argv[-1]).read())\\\",\\n fname]\\n\\n assert_in_results(\\n ds.run(cat_cmd(\\\"f1\\\"), inputs=[\\\"f1\\\"]),\\n action=\\\"get\\\", type=\\\"file\\\")\\n # Same thing, but without the get() call.\\n assert_not_in_results(\\n ds.run(cat_cmd(\\\"f1\\\"), inputs=[\\\"f1\\\"], assume_ready=\\\"inputs\\\"),\\n action=\\\"get\\\", type=\\\"file\\\")\\n\\n ds.drop(\\\"f1\\\", reckless='kill')\\n if not adjusted:\\n # If the input is not actually ready, the command will fail.\\n assert_in_results(\\n ds.run(cat_cmd(\\\"f1\\\"), inputs=[\\\"f1\\\"], assume_ready=\\\"inputs\\\",\\n on_failure=\\\"ignore\\\", result_renderer=None),\\n action=\\\"run\\\", status=\\\"error\\\")\\n\\n # --assume-ready=outputs\\n\\n def unlink_and_write_cmd(fname):\\n # This command doesn't care whether the output file is unlocked because\\n # it removes it ahead of time anyway.\\n return [sys.executable, \\\"-c\\\",\\n \\\"import sys; import os; import os.path as op; \\\"\\n \\\"f = sys.argv[-1]; op.lexists(f) and os.unlink(f); \\\"\\n \\\"open(f, mode='w').write(str(sys.argv))\\\",\\n fname]\\n\\n (repo.pathobj / \\\"f2\\\").write_text(\\\"f2\\\")\\n ds.save()\\n\\n res = ds.run(unlink_and_write_cmd(\\\"f2\\\"), outputs=[\\\"f2\\\"])\\n if not adjusted:\\n assert_in_results(res, action=\\\"unlock\\\", type=\\\"file\\\")\\n # Same thing, but without the unlock() call.\\n res = ds.run(unlink_and_write_cmd(\\\"f2\\\"), outputs=[\\\"f2\\\"],\\n assume_ready=\\\"outputs\\\")\\n assert_not_in_results(res, action=\\\"unlock\\\", type=\\\"file\\\")\\n\\n # --assume-ready=both\\n\\n res = ds.run(unlink_and_write_cmd(\\\"f2\\\"),\\n outputs=[\\\"f2\\\"], inputs=[\\\"f2\\\"])\\n assert_in_results(res, action=\\\"get\\\", type=\\\"file\\\")\\n if not adjusted:\\n assert_in_results(res, action=\\\"unlock\\\", type=\\\"file\\\")\\n\\n res = ds.run(unlink_and_write_cmd(\\\"f2\\\"),\\n outputs=[\\\"f2\\\"], inputs=[\\\"f2\\\"],\\n assume_ready=\\\"both\\\")\\n assert_not_in_results(res, action=\\\"get\\\", type=\\\"file\\\")\\n assert_not_in_results(res, action=\\\"unlock\\\", type=\\\"file\\\")\\n\\n\\n@with_tempfile()\\n@with_tempfile()\\ndef test_run_explicit(origpath=None, path=None):\\n origds = Dataset(origpath).create()\\n (origds.pathobj / \\\"test-annex.dat\\\").write_text('content')\\n origds.save()\\n ds = clone(origpath, path)\\n\\n assert_false(ds.repo.file_has_content(\\\"test-annex.dat\\\"))\\n\\n create_tree(ds.path, {\\\"dirt_untracked\\\": \\\"untracked\\\",\\n \\\"dirt_modified\\\": \\\"modified\\\"})\\n ds.save(\\\"dirt_modified\\\", to_git=True)\\n with open(op.join(path, \\\"dirt_modified\\\"), \\\"a\\\") as ofh:\\n ofh.write(\\\", more\\\")\\n\\n # We need explicit=True to run with dirty repo.\\n assert_status(\\n \\\"impossible\\\",\\n ds.run(f\\\"{cat_command} test-annex.dat test-annex.dat >doubled.dat\\\",\\n inputs=[\\\"test-annex.dat\\\"],\\n on_failure=\\\"ignore\\\"))\\n\\n hexsha_initial = ds.repo.get_hexsha()\\n # If we specify test-annex.dat as an input, it will be retrieved before the\\n # run.\\n ds.run(f\\\"{cat_command} test-annex.dat test-annex.dat >doubled.dat\\\",\\n inputs=[\\\"test-annex.dat\\\"], explicit=True,\\n result_renderer='disabled')\\n ok_(ds.repo.file_has_content(\\\"test-annex.dat\\\"))\\n # We didn't commit anything because outputs weren't specified.\\n assert_false(ds.repo.file_has_content(\\\"doubled.dat\\\"))\\n eq_(hexsha_initial, ds.repo.get_hexsha())\\n\\n # If an input doesn't exist, we just show the standard warning.\\n with assert_raises(IncompleteResultsError):\\n ds.run(\\\"ls\\\", inputs=[\\\"not-there\\\"], explicit=True,\\n on_failure=\\\"stop\\\", result_renderer='disabled')\\n\\n remove(op.join(path, \\\"doubled.dat\\\"))\\n\\n hexsha_initial = ds.repo.get_hexsha()\\n ds.run(f\\\"{cat_command} test-annex.dat test-annex.dat >doubled.dat\\\",\\n inputs=[\\\"test-annex.dat\\\"], outputs=[\\\"doubled.dat\\\"],\\n explicit=True, result_renderer='disabled')\\n ok_(ds.repo.file_has_content(\\\"doubled.dat\\\"))\\n assert_repo_status(ds.path, modified=[\\\"dirt_modified\\\"],\\n untracked=['dirt_untracked'])\\n neq_(hexsha_initial, ds.repo.get_hexsha())\\n\\n # Saving explicit outputs works from subdirectories.\\n subdir = op.join(path, \\\"subdir\\\")\\n mkdir(subdir)\\n with chpwd(subdir):\\n run(\\\"echo insubdir >foo\\\", explicit=True, outputs=[\\\"foo\\\"],\\n result_renderer='disabled')\\n ok_(ds.repo.file_has_content(op.join(\\\"subdir\\\", \\\"foo\\\")))\\n\\n\\n@with_tree(tree={OBSCURE_FILENAME + u\\\".t\\\": \\\"obscure\\\",\\n \\\"bar.txt\\\": \\\"b\\\",\\n \\\"foo blah.txt\\\": \\\"f\\\"})\\ndef test_inputs_quotes_needed(path=None):\\n ds = Dataset(path).create(force=True)\\n ds.save()\\n cmd = \\\"import sys; open(sys.argv[-1], 'w').write('!'.join(sys.argv[1:]))\\\"\\n # The string form of a command works fine when the inputs/outputs have\\n # spaces ...\\n cmd_str = \\\"{} -c \\\\\\\"{}\\\\\\\" {{inputs}} {{outputs[0]}}\\\".format(\\n sys.executable, cmd)\\n ds.run(cmd_str, inputs=[\\\"*.t*\\\"], outputs=[\\\"out0\\\"], expand=\\\"inputs\\\")\\n expected = u\\\"!\\\".join(\\n list(sorted([OBSCURE_FILENAME + u\\\".t\\\", \\\"bar.txt\\\", \\\"foo blah.txt\\\"])) +\\n [\\\"out0\\\"])\\n with open(op.join(path, \\\"out0\\\")) as ifh:\\n eq_(ensure_unicode(ifh.read()), expected)\\n # ... but the list form of a command does not. (Don't test this failure\\n # with the obscure file name because we'd need to know its composition to\\n # predict the failure.)\\n cmd_list = [sys.executable, \\\"-c\\\", cmd, \\\"{inputs}\\\", \\\"{outputs[0]}\\\"]\\n ds.run(cmd_list, inputs=[\\\"*.txt\\\"], outputs=[\\\"out0\\\"])\\n ok_file_has_content(op.join(path, \\\"out0\\\"), \\\"bar.txt foo!blah.txt!out0\\\")\\n\\n\\n@with_tree(tree={\\\"foo\\\": \\\"f\\\", \\\"bar\\\": \\\"b\\\"})\\ndef test_inject(path=None):\\n ds = Dataset(path).create(force=True)\\n assert_repo_status(ds.path, untracked=['foo', 'bar'])\\n list(run_command(\\\"nonsense command\\\",\\n dataset=ds,\\n inject=True,\\n extra_info={\\\"custom_key\\\": \\\"custom_field\\\"}))\\n msg = last_commit_msg(ds.repo)\\n assert_in(\\\"custom_key\\\", msg)\\n assert_in(\\\"nonsense command\\\", msg)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_format_command_strip_leading_dashes(path=None):\\n ds = Dataset(path).create()\\n eq_(format_command(ds, [\\\"--\\\", \\\"cmd\\\", \\\"--opt\\\"]),\\n '\\\"cmd\\\" \\\"--opt\\\"' if on_windows else \\\"cmd --opt\\\")\\n eq_(format_command(ds, [\\\"--\\\"]), \\\"\\\")\\n # Can repeat to escape.\\n eq_(format_command(ds, [\\\"--\\\", \\\"--\\\", \\\"ok\\\"]),\\n '\\\"--\\\" \\\"ok\\\"' if on_windows else \\\"-- ok\\\")\\n # String stays as is.\\n eq_(format_command(ds, \\\"--\\\"), \\\"--\\\")\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_cmdline_disambiguation(path=None):\\n Dataset(path).create()\\n with chpwd(path):\\n # Without a positional argument starting a command, any option is\\n # treated as an option to 'datalad run'.\\n with swallow_outputs() as cmo:\\n with patch(\\\"datalad.core.local.run._execute_command\\\") as exec_cmd:\\n with assert_raises(SystemExit):\\n main([\\\"datalad\\\", \\\"run\\\", \\\"--message\\\"])\\n exec_cmd.assert_not_called()\\n assert_in(\\\"message: expected one\\\", cmo.err)\\n # If we want to pass an option as the first value of a command (e.g.,\\n # because we are using a runscript with containers-run), we can do this\\n # with \\\"--\\\".\\n with patch(\\\"datalad.core.local.run._execute_command\\\") as exec_cmd:\\n with assert_raises(SystemExit):\\n main([\\\"datalad\\\", \\\"run\\\", \\\"--\\\", \\\"--message\\\"])\\n exec_cmd.assert_called_once_with(\\n '\\\"--message\\\"' if on_windows else \\\"--message\\\",\\n path)\\n\\n # Our parser used to mishandle --version (gh-3067),\\n # treating 'datalad run CMD --version' as 'datalad --version'.\\n # but that is no longer the case and echo --version should work with or\\n # without explicit \\\"--\\\" separator\\n for sep in [[], ['--']]:\\n with patch(\\\"datalad.core.local.run._execute_command\\\") as exec_cmd:\\n with assert_raises(SystemExit):\\n main([\\\"datalad\\\", \\\"run\\\"] + sep + [\\\"echo\\\", \\\"--version\\\"])\\n exec_cmd.assert_called_once_with(\\n '\\\"echo\\\" \\\"--version\\\"' if on_windows else \\\"echo --version\\\",\\n path)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_path_semantics(path=None):\\n # Test that we follow path resolution from gh-3435: paths are relative to\\n # dataset if a dataset instance is given and relative to the current\\n # working directory otherwise.\\n\\n ds0 = Dataset(op.join(path, \\\"ds0\\\")).create()\\n ds0_subdir = op.join(ds0.path, \\\"s0\\\")\\n os.mkdir(ds0_subdir)\\n\\n # Although not useful, we can specify `dataset` as a string that lines up\\n # with the one from the current directory.\\n with chpwd(ds0_subdir):\\n run(\\\"cd .> one\\\", dataset=\\\"..\\\")\\n run(\\\"cd .> one\\\", outputs=[\\\"one\\\"], dataset=ds0.path)\\n ok_exists(op.join(ds0_subdir, \\\"one\\\"))\\n assert_repo_status(ds0.path)\\n\\n # Specify string dataset argument, running from another dataset ...\\n\\n ds1 = Dataset(op.join(path, \\\"ds1\\\")).create()\\n ds1_subdir = op.join(ds1.path, \\\"s1\\\")\\n os.mkdir(ds1_subdir)\\n\\n # ... producing output file in specified dataset\\n with chpwd(ds1_subdir):\\n run(\\\"cd .> {}\\\".format(op.join(ds0.path, \\\"two\\\")),\\n dataset=ds0.path)\\n ok_exists(op.join(ds0.path, \\\"two\\\"))\\n assert_repo_status(ds0.path)\\n\\n # ... producing output file in specified dataset and passing output file as\\n # relative to current directory\\n with chpwd(ds1_subdir):\\n out = op.join(ds0.path, \\\"three\\\")\\n run(\\\"cd .> {}\\\".format(out), dataset=ds0.path, explicit=True,\\n outputs=[op.relpath(out, ds1_subdir)])\\n ok_exists(op.join(ds0.path, \\\"three\\\"))\\n assert_repo_status(ds0.path)\\n\\n # ... producing output file outside of specified dataset, leaving it\\n # untracked in the other dataset\\n assert_repo_status(ds1.path)\\n with chpwd(ds1_subdir):\\n run(\\\"cd .> four\\\", dataset=ds0.path)\\n assert_repo_status(ds1.path, untracked=[ds1_subdir])\\n\\n # If we repeat above with an instance instead of the string, the directory\\n # for the run is the specified dataset.\\n with chpwd(ds1_subdir):\\n run(\\\"cd .> five\\\", dataset=ds0)\\n ok_exists(op.join(ds0.path, \\\"five\\\"))\\n assert_repo_status(ds0.path)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_remove_keeps_leading_directory(path=None):\\n ds = Dataset(op.join(path, \\\"ds\\\")).create()\\n repo = ds.repo\\n\\n (ds.pathobj / \\\"d\\\").mkdir()\\n output = (ds.pathobj / \\\"d\\\" / \\\"foo\\\")\\n output.write_text(\\\"foo\\\")\\n ds.save()\\n\\n output_rel = str(output.relative_to(ds.pathobj))\\n repo.drop(output_rel, options=[\\\"--force\\\"])\\n\\n assert_in_results(\\n ds.run(\\\"cd .> {}\\\".format(output_rel), outputs=[output_rel],\\n result_renderer='disabled'),\\n action=\\\"run.remove\\\", status=\\\"ok\\\")\\n\\n assert_repo_status(ds.path)\\n\\n # Remove still gets saved() if command doesn't generate the output (just as\\n # it would if git-rm were used instead of unlink).\\n repo.drop(output_rel, options=[\\\"--force\\\"])\\n assert_in_results(\\n ds.run(\\\"cd .> something-else\\\", outputs=[output_rel],\\n result_renderer='disabled'),\\n action=\\\"run.remove\\\", status=\\\"ok\\\")\\n assert_repo_status(ds.path)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_reglob_outputs(path=None):\\n ds = Dataset(path).create()\\n repo = ds.repo\\n (ds.pathobj / \\\"write_text.py\\\").write_text(\\\"\\\"\\\"\\nimport sys\\nassert len(sys.argv) == 2\\nname = sys.argv[1]\\nwith open(name + \\\".txt\\\", \\\"w\\\") as fh:\\n fh.write(name)\\n\\\"\\\"\\\")\\n ds.save(to_git=True)\\n cmd = [sys.executable, \\\"write_text.py\\\"]\\n\\n ds.run(cmd + [\\\"foo\\\"], outputs=[\\\"*.txt\\\"], expand=\\\"outputs\\\")\\n assert_in(\\\"foo.txt\\\", last_commit_msg(repo))\\n\\n ds.run(cmd + [\\\"bar\\\"], outputs=[\\\"*.txt\\\"], explicit=True)\\n ok_exists(str(ds.pathobj / \\\"bar.txt\\\"))\\n assert_repo_status(ds.path)\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_unexpanded_placeholders(path=None):\\n ds = Dataset(path).create()\\n cmd = [sys.executable, \\\"-c\\\",\\n \\\"import sys; open(sys.argv[1], 'w').write(' '.join(sys.argv[2:]))\\\"]\\n\\n # It's weird, but for lack of better options, inputs and outputs that don't\\n # have matches are available unexpanded.\\n\\n with assert_raises(IncompleteResultsError):\\n ds.run(cmd + [\\\"arg1\\\", \\\"{inputs}\\\"], inputs=[\\\"foo*\\\"],\\n on_failure=\\\"continue\\\")\\n assert_repo_status(ds.path)\\n ok_file_has_content(op.join(path, \\\"arg1\\\"), \\\"foo*\\\")\\n\\n ds.run(cmd + [\\\"arg2\\\", \\\"{outputs}\\\"], outputs=[\\\"bar*\\\"])\\n assert_repo_status(ds.path)\\n ok_file_has_content(op.join(path, \\\"arg2\\\"), \\\"bar*\\\")\\n\\n ds.run(cmd + [\\\"arg3\\\", \\\"{outputs[1]}\\\"], outputs=[\\\"foo*\\\", \\\"bar\\\"])\\n ok_file_has_content(op.join(path, \\\"arg3\\\"), \\\"bar\\\")\\n\\n\\n@with_tempfile(mkdir=True)\\ndef test_run_empty_repo(path=None):\\n ds = Dataset(path).create()\\n cmd = [sys.executable, \\\"-c\\\", \\\"open('foo', 'w').write('')\\\"]\\n # Using \\\"*\\\" in a completely empty repo will fail.\\n with assert_raises(IncompleteResultsError):\\n ds.run(cmd, inputs=[\\\"*\\\"], on_failure=\\\"stop\\\")\\n assert_repo_status(ds.path)\\n # \\\".\\\" will work okay, though.\\n assert_status(\\\"ok\\\", ds.run(cmd, inputs=[\\\".\\\"]))\\n assert_repo_status(ds.path)\\n ok_exists(str(ds.pathobj / \\\"foo\\\"))\\n\\n\\n@with_tree(tree={\\\"foo\\\": \\\"f\\\", \\\"bar\\\": \\\"b\\\"})\\ndef test_dry_run(path=None):\\n ds = Dataset(path).create(force=True)\\n\\n # The dataset is reported as dirty, and the custom result render relays\\n # that to the default renderer.\\n with swallow_outputs() as cmo:\\n with assert_raises(IncompleteResultsError):\\n ds.run(\\\"blah \\\", dry_run=\\\"basic\\\")\\n assert_in(\\\"run(impossible)\\\", cmo.out)\\n assert_not_in(\\\"blah\\\", cmo.out)\\n\\n ds.save()\\n\\n # unknown dry-run mode\\n assert_raises(ValueError, ds.run, 'blah', dry_run='absurd')\\n\\n with swallow_outputs() as cmo:\\n ds.run(\\\"blah \\\", dry_run=\\\"basic\\\")\\n assert_in(\\\"Dry run\\\", cmo.out)\\n assert_in(\\\"location\\\", cmo.out)\\n assert_in(\\\"blah\\\", cmo.out)\\n assert_not_in(\\\"expanded inputs\\\", cmo.out)\\n assert_not_in(\\\"expanded outputs\\\", cmo.out)\\n\\n with swallow_outputs() as cmo:\\n ds.run(\\\"blah {inputs} {outputs}\\\", dry_run=\\\"basic\\\",\\n inputs=[\\\"fo*\\\"], outputs=[\\\"b*r\\\"])\\n assert_in(\\n 'blah \\\"foo\\\" \\\"bar\\\"' if on_windows else \\\"blah foo bar\\\",\\n cmo.out)\\n assert_in(\\\"expanded inputs\\\", cmo.out)\\n assert_in(\\\"['foo']\\\", cmo.out)\\n assert_in(\\\"expanded outputs\\\", cmo.out)\\n assert_in(\\\"['bar']\\\", cmo.out)\\n\\n # Just the command.\\n with swallow_outputs() as cmo:\\n ds.run(\\\"blah \\\", dry_run=\\\"command\\\")\\n assert_not_in(\\\"Dry run\\\", cmo.out)\\n assert_in(\\\"blah\\\", cmo.out)\\n assert_not_in(\\\"inputs\\\", cmo.out)\\n\\n # The output file wasn't unlocked.\\n assert_repo_status(ds.path)\\n\\n # Subdaset handling\\n\\n subds = ds.create(\\\"sub\\\")\\n (subds.pathobj / \\\"baz\\\").write_text(\\\"z\\\")\\n ds.save(recursive=True)\\n\\n # If a subdataset is installed, it works as usual.\\n with swallow_outputs() as cmo:\\n ds.run(\\\"blah {inputs}\\\", dry_run=\\\"basic\\\", inputs=[\\\"sub/b*\\\"])\\n assert_in(\\n 'blah \\\"sub\\\\\\\\baz\\\"' if on_windows else 'blah sub/baz',\\n cmo.out)\\n\\n # However, a dry run will not do the install/reglob procedure.\\n ds.drop(\\\"sub\\\", what='all', reckless='kill', recursive=True)\\n with swallow_outputs() as cmo:\\n ds.run(\\\"blah {inputs}\\\", dry_run=\\\"basic\\\", inputs=[\\\"sub/b*\\\"])\\n assert_in(\\\"sub/b*\\\", cmo.out)\\n assert_not_in(\\\"baz\\\", cmo.out)\\n\\n\\n@with_tree(tree={OBSCURE_FILENAME + \\\".t\\\": \\\"obscure\\\",\\n \\\"normal.txt\\\": \\\"normal\\\"})\\ndef test_io_substitution(path=None):\\n files = [OBSCURE_FILENAME + \\\".t\\\", \\\"normal.txt\\\"]\\n ds = Dataset(path).create(force=True)\\n ds.save()\\n # prefix the content of any given file with 'mod::'\\n cmd = \\\"import sys; from pathlib import Path; t = [(Path(p), 'mod::' + Path(p).read_text()) for p in sys.argv[1:]]; [k.write_text(v) for k, v in t]\\\"\\n cmd_str = \\\"{} -c \\\\\\\"{}\\\\\\\" {{inputs}}\\\".format(sys.executable, cmd)\\n # this should run and not crash with permission denied\\n ds.run(cmd_str, inputs=[\\\"{outputs}\\\"], outputs=[\\\"*.t*\\\"],\\n result_renderer='disabled')\\n # all filecontent got the prefix\\n for f in files:\\n ok_((ds.pathobj / f).read_text().startswith('mod::'))\\n\\n # we could just ds.rerun() now, and it should work, but this would make\\n # rerun be a dependency of a core test\\n # instead just double-run, but with a non-list input-spec.\\n # should have same outcome\\n ds.run(cmd_str, inputs=\\\"{outputs}\\\", outputs=\\\"*.t*\\\",\\n result_renderer='disabled')\\n for f in files:\\n ok_((ds.pathobj / f).read_text().startswith('mod::mod::'))\\n\\n\\ndef test_format_iospecs():\\n seq = ['one', 'two']\\n eq_(seq, _format_iospecs(['{dummy}'], dummy=seq))\\n # garbage when combined with longer spec-sequences\\n # but this is unavoidable without introducing a whitelist\\n # of supported value types -- which would limit flexibility\\n eq_([\\\"['one', 'two']\\\", 'other'],\\n _format_iospecs(['{dummy}', 'other'], dummy=seq))\\n\\n\\ndef test_substitution_config():\\n # use a shim to avoid having to create an actual dataset\\n # the tested function only needs a `ds.config` to be a ConfigManager\\n from datalad import cfg\\n\\n class dset:\\n config = cfg\\n\\n # empty be default\\n eq_(_get_substitutions(dset), {})\\n # basic access\\n with patch_config({\\\"datalad.run.substitutions.dummy\\\": 'ork'}):\\n eq_(_get_substitutions(dset), dict(dummy='ork'))\\n # can report multi-value\\n with patch_config({\\\"datalad.run.substitutions.dummy\\\": ['a', 'b']}):\\n eq_(_get_substitutions(dset), dict(dummy=['a', 'b']))\\n\\n # verify combo with iospec formatting\\n eq_(_format_iospecs(['{dummy}'],\\n **_get_substitutions(dset)),\\n ['a', 'b'])\\n\"\n },\n {\n \"alpha_fraction\": 0.7093862891197205,\n \"alphanum_fraction\": 0.7129963636398315,\n \"avg_line_length\": 31.58823585510254,\n \"blob_id\": \"33a294ab0185f02155de3e3303344f48719cd4c7\",\n \"content_id\": \"6a99e51ae803a30b505b3c72b7e460bb01ca5c5c\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"reStructuredText\",\n \"length_bytes\": 2216,\n \"license_type\": \"permissive\",\n \"max_line_length\": 131,\n \"num_lines\": 68,\n \"path\": \"/docs/source/index.rst\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"DataLad |---| data management and publication multitool\\n*******************************************************\\n\\nWelcome to DataLad's **technical documentation**. Information here is targeting\\nsoftware developers and is focused on the Python API and :term:`CLI`, as well\\nas software design, employed technologies, and key features. Comprehensive\\n**user documentation** with information on installation, basic operation,\\nsupport, and (advanced) use case descriptions is available in the `DataLad\\nhandbook `_.\\n\\nContent\\n^^^^^^^\\n\\n.. toctree::\\n :maxdepth: 1\\n\\n changelog\\n acknowledgements\\n publications\\n\\nConcepts and technologies\\n=========================\\n\\n.. toctree::\\n :maxdepth: 2\\n\\n background\\n related\\n basics\\n credentials\\n customization\\n design/index\\n glossary\\n\\nCommands and API\\n================\\n\\n.. toctree::\\n :maxdepth: 2\\n\\n cmdline\\n modref\\n config\\n\\nExtension packages\\n==================\\n\\nDataLad can be customized and additional functionality can be integrated via\\nextensions. Each extension provides its own documentation:\\n\\n- `Crawling web resources and automated data distributions `_\\n- `Neuroimaging data and workflows `_\\n- `Containerized computational environments `_\\n- `Advanced metadata tooling with JSON-LD reporting and additional metadata extractors `_\\n- `Staged additions, performance and user experience improvements for DataLad `_\\n- `Resources for working with the UKBiobank as a DataLad dataset `_\\n- `Deposit and retrieve DataLad datasets via the Open Science Framework `_\\n- `Functionality that has been phased out of the core package `_\\n- `Special interest functionality or drafts of future additions to DataLad proper `_\\n\\nIndices and tables\\n==================\\n\\n* :ref:`genindex`\\n* :ref:`modindex`\\n* :ref:`search`\\n\\n.. |---| unicode:: U+02014 .. em dash\\n\"\n },\n {\n \"alpha_fraction\": 0.6223336458206177,\n \"alphanum_fraction\": 0.6250462532043457,\n \"avg_line_length\": 39.15016555786133,\n \"blob_id\": \"9b39861ef5932b3ade87eda32c39f765743ec9d7\",\n \"content_id\": \"b3c44026ca29644c749a1e625e9385a3b3a598ea\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 24331,\n \"license_type\": \"permissive\",\n \"max_line_length\": 79,\n \"num_lines\": 606,\n \"path\": \"/datalad/cli/parser.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"\\\"\\\"\\\"Components to build the parser instance for the CLI\\n\\nThis module must import (and run) really fast for a responsive CLI.\\nIt is unconditionally imported by the main() entrypoint.\\n\\\"\\\"\\\"\\n\\n# ATTN!\\n# All top-imports are limited to functionality that is necessary for the\\n# non-error case of constructing of a single target command parser only.\\n# For speed reasons, all other imports necessary for special cases,\\n# like error handling, must be done conditionally in-line.\\n\\nimport argparse\\nimport logging\\nimport sys\\nfrom collections import defaultdict\\nfrom functools import partial\\n\\nfrom datalad import __version__\\nfrom datalad.interface.base import (\\n get_cmd_doc,\\n get_interface_groups,\\n is_api_arg,\\n load_interface,\\n)\\nfrom datalad.support.constraints import EnsureChoice\\nfrom datalad.utils import getargspec\\n\\nfrom .common_args import common_args\\nfrom .exec import call_from_parser\\nfrom .helpers import get_commands_from_groups\\nfrom .interface import (\\n alter_interface_docs_for_cmdline,\\n get_cmd_ex,\\n get_cmdline_command_name,\\n)\\n\\n# special case imports\\n# .helpers import add_entrypoints_to_interface_groups\\n# .helpers.get_description_with_cmd_summary\\n# .helpers.get_commands_from_groups\\n# .utils.get_suggestions_msg,\\n# .interface._known_extension_commands\\n# .interface._deprecated_commands\\n\\nlgr = logging.getLogger('datalad.cli.parser')\\n\\n\\nhelp_gist = \\\"\\\"\\\"\\\\\\nComprehensive data management solution\\n\\nDataLad provides a unified data distribution system built on the Git\\nand Git-annex. DataLad command line tools allow to manipulate (obtain,\\ncreate, update, publish, etc.) datasets and provide a comprehensive\\ntoolbox for joint management of data and code. Compared to Git/annex\\nit primarily extends their functionality to transparently and\\nsimultaneously work with multiple inter-related repositories.\\\"\\\"\\\"\\n\\n\\n# TODO: OPT look into making setup_parser smarter to become faster\\n# Now it seems to take up to 200ms to do all the parser setup\\n# even though it might not be necessary to know about all the commands etc.\\n# I wondered if it could somehow decide on what commands to worry about etc\\n# by going through sys.args first\\ndef setup_parser(\\n cmdlineargs,\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n return_subparsers=False,\\n completing=False,\\n help_ignore_extensions=False):\\n \\\"\\\"\\\"\\n The holy grail of establishing CLI for DataLad's Interfaces\\n\\n Parameters\\n ----------\\n cmdlineargs: sys.argv\\n Used to make some shortcuts when construction of a full parser can be\\n avoided.\\n formatter_class:\\n Passed to argparse\\n return_subparsers: bool, optional\\n is used ATM only by BuildManPage in _datalad_build_support\\n completing: bool, optional\\n Flag to indicate whether the process was invoked by argcomplete\\n help_ignore_extensions: bool, optional\\n Prevent loading of extension entrypoints when --help is requested.\\n This is enabled when building docs to avoid pollution of generated\\n manpages with extensions commands (that should appear in their own\\n docs, but not in the core datalad package docs)\\n \\\"\\\"\\\"\\n lgr.log(5, \\\"Starting to setup_parser\\\")\\n\\n # main parser\\n parser = ArgumentParserDisableAbbrev(\\n fromfile_prefix_chars=None,\\n prog='datalad',\\n # usage=\\\"%(prog)s ...\\\",\\n description=help_gist,\\n formatter_class=formatter_class,\\n add_help=False,\\n # TODO: when dropping support for Python 3.8: uncomment below\\n # and use parse_known_args instead of _parse_known_args:\\n # # set to False so parse_known_args does not add its error handling\\n # # Added while RFing from using _parse_known_args to parse_known_args.\\n # exit_on_error=False,\\n )\\n\\n # common options\\n parser_add_common_options(parser)\\n\\n # get all interface definitions from datalad-core\\n interface_groups = get_interface_groups()\\n\\n # try to figure out whether the parser construction can be limited to\\n # a single (sub)command -- don't even try to do this, when we are in\\n # any of the doc-building capacities -- timing is not relevant there\\n status, parseinfo = single_subparser_possible(\\n cmdlineargs,\\n parser,\\n completing,\\n ) if not return_subparsers else ('allparsers', None)\\n\\n command_provider = 'core'\\n\\n if status == 'allparsers' and not help_ignore_extensions:\\n from .helpers import add_entrypoints_to_interface_groups\\n add_entrypoints_to_interface_groups(interface_groups)\\n\\n # when completing and we have no incomplete option or parameter\\n # we still need to offer all commands for completion\\n if (completing and status == 'allknown') or (\\n status == 'subcommand' and parseinfo not in\\n get_commands_from_groups(interface_groups)):\\n # we know the command is not in the core package\\n # still a chance it could be in an extension\\n command_provider = 'extension'\\n # we need the full help, or we have a potential command that\\n # lives in an extension, must load all extension, expensive\\n from .helpers import add_entrypoints_to_interface_groups\\n\\n # need to load all the extensions and try again\\n # TODO load extensions one-by-one and stop when a command was found\\n add_entrypoints_to_interface_groups(interface_groups)\\n\\n if status == 'subcommand':\\n known_commands = get_commands_from_groups(interface_groups)\\n if parseinfo not in known_commands:\\n # certainly not possible to identify a single parser that\\n # could be constructed, but we can be helpful\\n # will sys.exit() unless we are completing\\n try_suggest_extension_with_command(\\n parser, parseinfo, completing, known_commands)\\n # in completion mode we can get here, even for a command\\n # that does not exist at all!\\n command_provider = None\\n\\n # TODO check if not needed elsewhere\\n if status == 'help' or completing and status in ('allknown', 'unknownopt'):\\n # --help specification was delayed since it causes immediate\\n # printout of\\n # --help output before we setup --help for each command\\n parser_add_common_opt(parser, 'help')\\n\\n all_parsers = {} # name: (sub)parser\\n\\n if (completing and status == 'allknown') or status \\\\\\n in ('allparsers', 'subcommand', 'error'):\\n # parseinfo could be None here, when we could not identify\\n # a subcommand, but need to locate matching ones for\\n # completion\\n # create subparser, use module suffix as cmd name\\n subparsers = parser.add_subparsers()\\n for _, _, _interfaces \\\\\\n in sorted(interface_groups, key=lambda x: x[1]):\\n for _intfspec in _interfaces:\\n cmd_name = get_cmdline_command_name(_intfspec)\\n if status == 'subcommand':\\n # in case only a subcommand is desired, we could\\n # skip some processing\\n if command_provider and cmd_name != parseinfo:\\n # a known command, but know what we are looking for\\n continue\\n if command_provider is None and not cmd_name.startswith(\\n parseinfo):\\n # an unknown command, and has no common prefix with\\n # the current command candidate, not even good\\n # for completion\\n continue\\n subparser = add_subparser(\\n _intfspec,\\n subparsers,\\n cmd_name,\\n formatter_class,\\n completing=completing,\\n )\\n if subparser: # interface can fail to load\\n all_parsers[cmd_name] = subparser\\n\\n # \\\"main\\\" parser is under \\\"datalad\\\" name\\n all_parsers['datalad'] = parser\\n lgr.log(5, \\\"Finished setup_parser\\\")\\n if return_subparsers:\\n # TODO why not pull the subparsers from the main parser?\\n return all_parsers\\n else:\\n return parser\\n\\n\\ndef setup_parser_for_interface(parser, cls, completing=False):\\n # XXX needs safety check for name collisions\\n # XXX allow for parser kwargs customization\\n # get the signature, order of arguments is taken from it\\n ndefaults = 0\\n args, varargs, varkw, defaults = getargspec(\\n cls.__call__, include_kwonlyargs=True)\\n if defaults is not None:\\n ndefaults = len(defaults)\\n default_offset = ndefaults - len(args)\\n prefix_chars = parser.prefix_chars\\n for i, arg in enumerate(args):\\n if not is_api_arg(arg):\\n continue\\n\\n param = cls._params_[arg]\\n defaults_idx = default_offset + i\\n if param.cmd_args == tuple():\\n # explicitly provided an empty sequence of argument names\\n # this shall not appear in the parser\\n continue\\n\\n # set up the parameter\\n setup_parserarg_for_interface(\\n parser, arg, param, defaults_idx, prefix_chars, defaults,\\n completing=completing)\\n\\n\\ndef setup_parserarg_for_interface(parser, param_name, param, defaults_idx,\\n prefix_chars, defaults, completing=False):\\n cmd_args = param.cmd_args\\n parser_kwargs = param.cmd_kwargs\\n has_default = defaults_idx >= 0\\n if cmd_args:\\n if cmd_args[0][0] in prefix_chars:\\n # TODO: All the Parameter(args=...) values in this code\\n # base use hyphens, so there is no point in the below\\n # conversion. If it looks like no extensions rely on this\\n # behavior either, this could be dropped.\\n parser_args = [c.replace('_', '-') for c in cmd_args]\\n else:\\n # Argparse will not convert dashes to underscores for\\n # arguments that don't start with a prefix character, so\\n # the above substitution must be avoided so that\\n # call_from_parser() can find the corresponding parameter.\\n parser_args = cmd_args\\n elif has_default:\\n # Construct the option from the Python parameter name.\\n parser_args = (\\\"--{}\\\".format(param_name.replace(\\\"_\\\", \\\"-\\\")),)\\n else:\\n # If args= wasn't given and its a positional argument in the\\n # function, add a positional argument to argparse. If `dest` is\\n # specified, we need to remove it from the keyword arguments\\n # because add_argument() expects it as the first argument. Note\\n # that `arg` shouldn't have a dash here, but `metavar` can be\\n # used if a dash is preferred for the command-line help.\\n parser_args = (parser_kwargs.pop(\\\"dest\\\", param_name),)\\n\\n if has_default:\\n parser_kwargs['default'] = defaults[defaults_idx]\\n if param.constraints is not None:\\n parser_kwargs['type'] = param.constraints\\n if completing:\\n help = None\\n # if possible, define choices to enable their completion\\n if 'choices' not in parser_kwargs and \\\\\\n isinstance(param.constraints, EnsureChoice):\\n parser_kwargs['choices'] = [\\n c for c in param.constraints._allowed if c is not None]\\n else:\\n help = _amend_param_parser_kwargs_for_help(\\n parser_kwargs, param,\\n defaults[defaults_idx] if defaults_idx >= 0 else None)\\n # create the parameter, using the constraint instance for type\\n # conversion\\n parser.add_argument(*parser_args, help=help,\\n **parser_kwargs)\\n\\n\\ndef _amend_param_parser_kwargs_for_help(parser_kwargs, param, default=None):\\n if 'metavar' not in parser_kwargs and \\\\\\n isinstance(param.constraints, EnsureChoice):\\n parser_kwargs['metavar'] = \\\\\\n '{%s}' % '|'.join(\\n # don't use short_description(), because\\n # it also needs to give valid output for\\n # Python syntax (quotes...), but here we\\n # can simplify to shell syntax where everything\\n # is a string\\n p for p in param.constraints._allowed\\n # in the cmdline None pretty much means\\n # don't give the options, so listing it\\n # doesn't make sense. Moreover, any non-string\\n # value cannot be given and very likely only\\n # serves a special purpose in the Python API\\n # or implementation details\\n if isinstance(p, str))\\n help = alter_interface_docs_for_cmdline(param._doc)\\n if help:\\n help = help.rstrip()\\n if help[-1] != '.':\\n help += '.'\\n if param.constraints is not None:\\n help += _get_help_for_parameter_constraint(param)\\n if default is not None and \\\\\\n not parser_kwargs.get('action', '').startswith('store_'):\\n # if it is a flag, in commandline it makes little sense to show\\n # showing the Default: (likely boolean).\\n # See https://github.com/datalad/datalad/issues/3203\\n help += \\\" [Default: %r]\\\" % (default,)\\n return help\\n\\n\\ndef _get_help_for_parameter_constraint(param):\\n # include value constraint description and default\\n # into the help string\\n cdoc = alter_interface_docs_for_cmdline(\\n param.constraints.long_description())\\n if cdoc[0] == '(' and cdoc[-1] == ')':\\n cdoc = cdoc[1:-1]\\n return ' Constraints: %s' % cdoc\\n\\n\\ndef single_subparser_possible(cmdlineargs, parser, completing):\\n \\\"\\\"\\\"Performs early analysis of the cmdline\\n\\n Looks at the first unparsed argument and if a known command,\\n would return only that one.\\n\\n When a plain command invocation with `--version` is detected, it will be\\n acted on directly (until sys.exit(0) to avoid wasting time on unnecessary\\n further processing.\\n\\n Returns\\n -------\\n {'error', 'allknown', 'help', 'unknownopt', 'subcommand'}, None or str\\n Returns a status label and a parameter for this status.\\n 'error': parsing failed, 'allknown': the parser successfully\\n identified all arguments, 'help': a help request option was found,\\n 'unknownopt': an unknown or incomplete option was found,\\n 'subcommand': a potential subcommand name was found. For the latter\\n two modes the second return value is the option or command name.\\n For all other modes the second return value is None.\\n \\\"\\\"\\\"\\n # Before doing anything additional and possibly expensive see may be that\\n # we have got the command already\\n try:\\n parsed_args, unparsed_args = parser._parse_known_args(\\n cmdlineargs[1:], argparse.Namespace())\\n # before anything handle possible datalad --version\\n if not unparsed_args and getattr(parsed_args, 'version', None):\\n parsed_args.version() # will exit with 0\\n if not (completing or unparsed_args):\\n # there was nothing that could be a command\\n fail_with_short_help(\\n parser,\\n msg=\\\"too few arguments, \\\"\\n \\\"run with --help or visit https://handbook.datalad.org\\\",\\n exit_code=2)\\n lgr.debug(\\\"Command line args 1st pass for DataLad %s. \\\"\\n \\\"Parsed: %s Unparsed: %s\\\",\\n __version__, parsed_args, unparsed_args)\\n except Exception as exc:\\n # this did not work out\\n from datalad.support.exceptions import CapturedException\\n ce = CapturedException(exc)\\n lgr.debug(\\\"Early parsing failed with %s\\\", ce)\\n return 'error', None\\n\\n if not unparsed_args:\\n # cannot possibly be a subcommand\\n return 'allknown', None\\n\\n unparsed_arg = unparsed_args[0]\\n\\n # First unparsed could be either unknown option to top level \\\"datalad\\\"\\n # or a command. Among unknown could be --help/--help-np which would\\n # need to be dealt with\\n if unparsed_arg in ('--help', '--help-np', '-h'):\\n # not need to try to tune things, all these will result in everything\\n # to be imported and parsed\\n return 'help', None\\n elif unparsed_arg.startswith('-'): # unknown or incomplete option\\n if completing:\\n return 'unknownopt', unparsed_arg\\n # will sys.exit\\n fail_with_short_help(parser,\\n msg=f\\\"unrecognized argument {unparsed_arg}\\\",\\n # matches exit code of InsufficientArgumentsError\\n exit_code=2)\\n else: # potential command to handle\\n return 'subcommand', unparsed_arg\\n\\n\\ndef try_suggest_extension_with_command(parser, cmd, completing, known_cmds):\\n \\\"\\\"\\\"If completing=False, this function will trigger sys.exit()\\\"\\\"\\\"\\n # check if might be coming from known extensions\\n from .interface import (\\n _deprecated_commands,\\n _known_extension_commands,\\n )\\n extension_commands = {\\n c: e\\n for e, commands in _known_extension_commands.items()\\n for c in commands\\n }\\n hint = None\\n if cmd in extension_commands:\\n hint = \\\"Command %s is provided by (not installed) extension %s.\\\" \\\\\\n % (cmd, extension_commands[cmd])\\n elif cmd in _deprecated_commands:\\n hint_cmd = _deprecated_commands[cmd]\\n hint = \\\"Command %r was deprecated\\\" % cmd\\n hint += (\\\" in favor of %r command.\\\" % hint_cmd) if hint_cmd else '.'\\n if not completing:\\n fail_with_short_help(\\n parser,\\n hint=hint,\\n provided=cmd,\\n known=list(known_cmds.keys()) + list(extension_commands.keys())\\n )\\n\\n\\ndef add_subparser(_intfspec, subparsers, cmd_name, formatter_class,\\n completing=False):\\n \\\"\\\"\\\"Given an interface spec, add a subparser to subparsers under cmd_name\\n \\\"\\\"\\\"\\n _intf = load_interface(_intfspec)\\n if _intf is None:\\n # failed to load, error was already logged\\n return\\n\\n # compose argparse.add_parser() arguments, focused on docs\\n parser_args = dict(formatter_class=formatter_class)\\n # use class description, if no explicit description is available\\n intf_doc = get_cmd_doc(_intf)\\n if not completing:\\n parser_args['description'] = alter_interface_docs_for_cmdline(\\n intf_doc)\\n if hasattr(_intf, '_examples_'):\\n intf_ex = alter_interface_docs_for_cmdline(get_cmd_ex(_intf))\\n parser_args['description'] += intf_ex\\n\\n # create the sub-parser\\n subparser = subparsers.add_parser(cmd_name, add_help=False, **parser_args)\\n # our own custom help for all commands, we must do it here\\n # (not in setup_parser_for_interface()) because the top-level parser must\\n # not unconditionally have it available initially\\n parser_add_common_opt(subparser, 'help')\\n # let module configure the parser\\n setup_parser_for_interface(subparser, _intf, completing=completing)\\n # and we would add custom handler for --version\\n parser_add_version_opt(\\n subparser, _intf.__module__.split('.', 1)[0], include_name=True)\\n # logger for command\\n # configure 'run' function for this command\\n plumbing_args = dict(\\n # this is the key execution handler\\n func=partial(call_from_parser, _intf),\\n # use the logger of the module that defined the interface\\n logger=logging.getLogger(_intf.__module__),\\n subparser=subparser)\\n if hasattr(_intf, 'result_renderer_cmdline'):\\n plumbing_args['result_renderer'] = _intf.result_renderer_cmdline\\n subparser.set_defaults(**plumbing_args)\\n return subparser\\n\\n\\nclass ArgumentParserDisableAbbrev(argparse.ArgumentParser):\\n # Don't accept abbreviations for long options. This kludge was originally\\n # added at a time when our minimum required Python version was below 3.5,\\n # preventing us from using allow_abbrev=False. Now our minimum Python\\n # version is high enough, but we still can't use allow_abbrev=False because\\n # it suffers from the problem described in 6b3f2fffe (BF: cmdline: Restore\\n # handling of short options, 2018-07-23).\\n #\\n # Modified from the solution posted at\\n # https://bugs.python.org/issue14910#msg204678\\n def _get_option_tuples(self, option_string):\\n chars = self.prefix_chars\\n if option_string[0] in chars and option_string[1] in chars:\\n # option_string is a long flag. Disable abbreviation.\\n return []\\n return super(ArgumentParserDisableAbbrev, self)._get_option_tuples(\\n option_string)\\n\\n\\ndef parser_add_common_opt(parser, opt, names=None, **kwargs):\\n opt_tmpl = common_args[opt]\\n opt_kwargs = opt_tmpl[1].copy()\\n opt_kwargs.update(kwargs)\\n if names is None:\\n parser.add_argument(*opt_tmpl[0], **opt_kwargs)\\n else:\\n parser.add_argument(*names, **opt_kwargs)\\n\\n\\ndef parser_add_common_options(parser, version=None):\\n \\\"\\\"\\\"Add all options defined in common_args, but excludes 'help'\\\"\\\"\\\"\\n # populate with standard options\\n for arg in common_args:\\n if arg == 'help':\\n continue\\n parser_add_common_opt(parser, arg)\\n # special case version arg\\n if version is not None:\\n import warnings\\n warnings.warn(\\\"Passing 'version' to parser_add_common_options \\\"\\n \\\"no longer has an effect \\\"\\n \\\"and will be removed in a future release.\\\",\\n DeprecationWarning)\\n parser_add_version_opt(parser, 'datalad', include_name=True, delay=True)\\n\\n\\ndef parser_add_version_opt(parser, mod_name, include_name=False, delay=False):\\n \\\"\\\"\\\"Setup --version option\\n\\n Parameters\\n ----------\\n parser:\\n mod_name: str, optional\\n include_name: bool, optional\\n delay: bool, optional\\n If set to True, no action is taken immediately, and rather\\n we assign the function which would print the version. Necessary for\\n early pre-parsing of the cmdline\\n \\\"\\\"\\\"\\n\\n def print_version():\\n mod = sys.modules.get(mod_name, None)\\n version = getattr(mod, '__version__', None)\\n if version is None:\\n # Let's use the standard Python mechanism if underlying module\\n # did not provide __version__\\n try:\\n if sys.version_info < (3, 10):\\n import importlib_metadata as im\\n else:\\n import importlib.metadata as im\\n\\n pkg = im.packages_distributions()[mod_name][0]\\n version = im.version(pkg)\\n except Exception:\\n version = \\\"unknown\\\"\\n if include_name:\\n print(\\\"%s %s\\\" % (mod_name, version))\\n else:\\n print(version)\\n sys.exit(0)\\n\\n class versionAction(argparse.Action):\\n def __call__(self, parser, args, values, option_string=None):\\n if delay:\\n setattr(args, self.dest, print_version)\\n else:\\n print_version()\\n\\n parser.add_argument(\\n \\\"--version\\\",\\n nargs=0,\\n action=versionAction,\\n help=(\\n \\\"show the program's version\\\"\\n if not mod_name\\n else \\\"show the module and its version which provides the command\\\")\\n )\\n\\n\\ndef fail_with_short_help(parser=None,\\n msg=None,\\n known=None, provided=None,\\n hint=None,\\n exit_code=1,\\n what=\\\"command\\\",\\n out=None):\\n \\\"\\\"\\\"Generic helper to fail\\n with short help possibly hinting on what was intended if `known`\\n were provided\\n \\\"\\\"\\\"\\n out = out or sys.stderr\\n if msg:\\n out.write(\\\"error: %s\\\\n\\\" % msg)\\n if not known:\\n if parser:\\n parser_add_common_opt(parser, 'help')\\n # just to appear in print_usage also consistent with --help output\\n parser.add_argument(\\\"command [command-opts]\\\")\\n parser.print_usage(file=out)\\n else:\\n out.write(\\n \\\"datalad: Unknown %s %r. See 'datalad --help'.\\\\n\\\\n\\\"\\n % (what, provided,))\\n if provided not in known:\\n from datalad.utils import get_suggestions_msg\\n out.write(get_suggestions_msg(provided, known))\\n if hint:\\n out.write(\\\"Hint: %s\\\\n\\\" % hint)\\n raise SystemExit(exit_code)\\n\"\n },\n {\n \"alpha_fraction\": 0.5875251293182373,\n \"alphanum_fraction\": 0.5900402665138245,\n \"avg_line_length\": 30.55555534362793,\n \"blob_id\": \"3a9cb38862607f87ab7c88fc6656034dd069b011\",\n \"content_id\": \"5f7084ca07d564c00cc8cbb366feb87b7fefe3c1\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1988,\n \"license_type\": \"permissive\",\n \"max_line_length\": 87,\n \"num_lines\": 63,\n \"path\": \"/datalad/downloaders/tests/test_shub.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Tests for shub:// downloader\\\"\\\"\\\"\\n\\nfrom datalad.downloaders.shub import SHubDownloader\\nfrom datalad.support.exceptions import DownloadError\\nfrom datalad.tests.utils_pytest import (\\n assert_raises,\\n ok_file_has_content,\\n serve_path_via_http,\\n with_tempfile,\\n)\\nfrom datalad.utils import (\\n Path,\\n create_tree,\\n)\\n\\n\\n@with_tempfile(mkdir=True)\\n@serve_path_via_http\\ndef test_downloader_bad_query(urlpath=None, url=None):\\n downloader = SHubDownloader()\\n downloader.api_url = url\\n with assert_raises(DownloadError):\\n downloader.download(\\\"shub://org/repo\\\", urlpath)\\n\\n\\n@with_tempfile(mkdir=True)\\n@serve_path_via_http\\ndef test_downloader_bad_json(urlpath=None, url=None):\\n downloader = SHubDownloader()\\n downloader.api_url = url\\n create_tree(urlpath,\\n tree={\\\"org\\\": {\\\"repo\\\": ''}})\\n with assert_raises(DownloadError):\\n downloader.download(\\\"shub://org/repo\\\", urlpath)\\n\\n\\n@with_tempfile(mkdir=True)\\n@serve_path_via_http\\n@with_tempfile(mkdir=True)\\ndef test_downloader_download(urlpath=None, url=None, path=None):\\n path = Path(path)\\n downloader = SHubDownloader()\\n downloader.api_url = url\\n create_tree(urlpath,\\n tree={\\\"data\\\": \\\"foo\\\",\\n \\\"org\\\": {\\\"repo\\\":\\n '{{\\\"name\\\":\\\"org/repo\\\",\\\"image\\\":\\\"{}\\\"}}'\\n .format(url + \\\"data\\\")}})\\n\\n target = str(path / \\\"target\\\")\\n downloader.download(\\\"shub://org/repo\\\", target)\\n ok_file_has_content(target, \\\"foo\\\")\\n\\n other_target = str(path / \\\"other-target\\\")\\n downloader.download(\\\"shub://org/repo\\\", other_target)\\n\"\n },\n {\n \"alpha_fraction\": 0.5500293374061584,\n \"alphanum_fraction\": 0.5510432720184326,\n \"avg_line_length\": 40.36644744873047,\n \"blob_id\": \"64fd3438efef51964e073c2d5048394716d064ff\",\n \"content_id\": \"23418a977f4d649bb61408eed6f57e3deb5da17d\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\",\n \"LicenseRef-scancode-unknown-license-reference\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 18739,\n \"license_type\": \"permissive\",\n \"max_line_length\": 116,\n \"num_lines\": 453,\n \"path\": \"/datalad/local/foreach_dataset.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 noet:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Plumbing command for running a command on each (sub)dataset\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\n\\nimport inspect\\nimport logging\\nimport os.path as op\\nimport sys\\nfrom typing import Union\\n\\nfrom argparse import REMAINDER\\nfrom itertools import chain\\nfrom tempfile import mkdtemp\\n\\nfrom datalad.cmd import NoCapture, StdOutErrCapture\\nfrom datalad.core.local.run import normalize_command\\n\\nfrom datalad.distribution.dataset import (\\n Dataset,\\n EnsureDataset,\\n datasetmethod,\\n require_dataset,\\n)\\nfrom datalad.interface.base import (\\n Interface,\\n build_doc,\\n eval_results,\\n)\\nfrom datalad.interface.common_opts import (\\n contains,\\n dataset_state,\\n jobs_opt,\\n recursion_flag,\\n recursion_limit,\\n)\\nfrom datalad.interface.results import get_status_dict\\nfrom datalad.support.constraints import (\\n EnsureBool,\\n EnsureChoice,\\n EnsureNone,\\n)\\nfrom datalad.support.exceptions import InsufficientArgumentsError\\nfrom datalad.support.parallel import (\\n ProducerConsumer,\\n ProducerConsumerProgressLog,\\n no_parentds_in_futures,\\n no_subds_in_futures,\\n)\\nfrom datalad.support.param import Parameter\\nfrom datalad.utils import (\\n SequenceFormatter,\\n chpwd as chpwd_cm,\\n getpwd,\\n nothing_cm,\\n shortened_repr,\\n swallow_outputs,\\n)\\n\\nlgr = logging.getLogger('datalad.local.foreach_dataset')\\n\\n\\n_PYTHON_CMDS = {\\n 'exec': exec,\\n 'eval': eval\\n}\\n\\n# Centralize definition with delayed assignment for 'auto' for each case\\n_SAFE_TO_CONSUME_MAP = {\\n 'auto': lambda: 1/0, # must be defined based on bottomup\\\"\\n 'all-subds-done': no_subds_in_futures,\\n 'superds-done': no_parentds_in_futures,\\n 'always': None\\n}\\n\\n@build_doc\\nclass ForEachDataset(Interface):\\n r\\\"\\\"\\\"Run a command or Python code on the dataset and/or each of its sub-datasets.\\n\\n This command provides a convenience for the cases were no dedicated DataLad command\\n is provided to operate across the hierarchy of datasets. It is very similar to\\n `git submodule foreach` command with the following major differences\\n\\n - by default (unless [CMD: --subdatasets-only CMD][PY: `subdatasets_only=True` PY]) it would\\n include operation on the original dataset as well,\\n - subdatasets could be traversed in bottom-up order,\\n - can execute commands in parallel (see `jobs` option), but would account for the order,\\n e.g. in bottom-up order command is executed in super-dataset only after it is executed\\n in all subdatasets.\\n\\n Additional notes:\\n\\n - for execution of \\\"external\\\" commands we use the environment used to execute external\\n git and git-annex commands.\\n\\n *Command format*\\n\\n || REFLOW >>\\n [CMD: --cmd-type external CMD][PY: cmd_type='external' PY]: A few placeholders are\\n supported in the command via Python format specification:\\n << REFLOW ||\\n\\n\\n - \\\"{pwd}\\\" will be replaced with the full path of the current working directory.\\n - \\\"{ds}\\\" and \\\"{refds}\\\" will provide instances of the dataset currently\\n operated on and the reference \\\"context\\\" dataset which was provided via ``dataset``\\n argument.\\n - \\\"{tmpdir}\\\" will be replaced with the full path of a temporary directory.\\n \\\"\\\"\\\"\\n _examples_ = [\\n dict(text=\\\"Aggressively git clean all datasets, running 5 parallel jobs\\\",\\n code_py=\\\"foreach_dataset(['git', 'clean', '-dfx'], recursive=True, jobs=5)\\\",\\n code_cmd=\\\"datalad foreach-dataset -r -J 5 git clean -dfx\\\"),\\n ]\\n\\n _params_ = dict(\\n cmd=Parameter(\\n args=(\\\"cmd\\\",),\\n nargs=REMAINDER,\\n metavar='COMMAND',\\n doc=\\\"\\\"\\\"command for execution. [CMD: A leading '--' can be used to\\n disambiguate this command from the preceding options to DataLad.\\n For --cmd-type exec or eval only a single\\n command argument (Python code) is supported. CMD]\\n [PY: For `cmd_type='exec'` or `cmd_type='eval'` (Python code) should\\n be either a string or a list with only a single item. If 'eval', the\\n actual function can be passed, which will be provided all placeholders\\n as keyword arguments. PY]\\n \\\"\\\"\\\"),\\n cmd_type=Parameter(\\n args=(\\\"--cmd-type\\\",),\\n constraints=EnsureChoice('auto', 'external', 'exec', 'eval'),\\n doc=\\\"\\\"\\\"type of the command. `external`: to be run in a child process using dataset's runner;\\n 'exec': Python source code to execute using 'exec(), no value returned;\\n 'eval': Python source code to evaluate using 'eval()', return value is placed into 'result' field.\\n 'auto': If used via Python API, and `cmd` is a Python function, it will use 'eval', and\\n otherwise would assume 'external'.\\\"\\\"\\\"),\\n # Following options are taken from subdatasets\\n dataset=Parameter(\\n args=(\\\"-d\\\", \\\"--dataset\\\"),\\n doc=\\\"\\\"\\\"specify the dataset to operate on. If\\n no dataset is given, an attempt is made to identify the dataset\\n based on the input and/or the current working directory\\\"\\\"\\\",\\n constraints=EnsureDataset() | EnsureNone()),\\n state=dataset_state,\\n recursive=recursion_flag,\\n recursion_limit=recursion_limit,\\n contains=contains,\\n bottomup=Parameter(\\n args=(\\\"--bottomup\\\",),\\n action=\\\"store_true\\\",\\n doc=\\\"\\\"\\\"whether to report subdatasets in bottom-up order along\\n each branch in the dataset tree, and not top-down.\\\"\\\"\\\"),\\n # Possible extra options to be introduced if use-case/demand comes\\n # TODO: --diff to provide `diff` record so any arbitrary git reset --hard etc desire could be fulfilled\\n # TODO: --lower-recursion-limit aka --mindepth of find to replace subdatasets-only.\\n # or may be recursion_limit could be made more sophisticated to be able to specify range\\n subdatasets_only=Parameter(\\n args=(\\\"-s\\\", \\\"--subdatasets-only\\\"),\\n action=\\\"store_true\\\",\\n doc=\\\"\\\"\\\"whether to exclude top level dataset. It is implied if a non-empty\\n `contains` is used\\\"\\\"\\\"),\\n output_streams=Parameter(\\n args=(\\\"--output-streams\\\", \\\"--o-s\\\"),\\n constraints=EnsureChoice('capture', 'pass-through', 'relpath'),\\n doc=\\\"\\\"\\\"ways to handle outputs. 'capture' and return outputs from 'cmd' in the record ('stdout',\\n 'stderr'); 'pass-through' to the screen (and thus absent from returned record); prefix with 'relpath'\\n captured output (similar to like grep does) and write to stdout and stderr. In 'relpath', relative path\\n is relative to the top of the dataset if `dataset` is specified, and if not - relative to current\\n directory.\\\"\\\"\\\"),\\n chpwd=Parameter(\\n args=(\\\"--chpwd\\\",),\\n constraints=EnsureChoice('ds', 'pwd'),\\n doc=\\\"\\\"\\\"'ds' will change working directory to the top of the corresponding dataset. With 'pwd'\\n no change of working directory will happen.\\n Note that for Python commands, due to use of threads, we do not allow chdir=ds to be used\\n with jobs > 1. Hint: use 'ds' and 'refds' objects' methods to execute commands in the context\\n of those datasets.\\n \\\"\\\"\\\"),\\n safe_to_consume=Parameter(\\n args=(\\\"--safe-to-consume\\\",),\\n constraints=EnsureChoice(*_SAFE_TO_CONSUME_MAP),\\n doc=\\\"\\\"\\\"Important only in the case of parallel (jobs greater than 1) execution.\\n 'all-subds-done' instructs to not consider superdataset until command finished execution\\n in all subdatasets (it is the value in case of 'auto' if traversal is bottomup).\\n 'superds-done' instructs to not process subdatasets until command finished in the super-dataset\\n (it is the value in case of 'auto' in traversal is not bottom up, which is the default). With\\n 'always' there is no constraint on either to execute in sub or super dataset.\\n \\\"\\\"\\\"),\\n jobs=jobs_opt,\\n )\\n\\n @staticmethod\\n @datasetmethod(name='foreach_dataset')\\n @eval_results\\n def __call__(\\n cmd,\\n *,\\n cmd_type=\\\"auto\\\",\\n dataset=None,\\n state='present',\\n recursive=False,\\n recursion_limit=None,\\n contains=None,\\n bottomup=False,\\n subdatasets_only=False,\\n output_streams='pass-through',\\n chpwd='ds', # as the most common case/scenario\\n safe_to_consume='auto',\\n jobs=None\\n ):\\n if not cmd:\\n raise InsufficientArgumentsError(\\\"No command given\\\")\\n\\n if safe_to_consume not in _SAFE_TO_CONSUME_MAP:\\n raise ValueError(f\\\"safe_to_consume - Unknown value {safe_to_consume!r}. \\\"\\n f\\\"Known are: {', '.join(_SAFE_TO_CONSUME_MAP)}\\\")\\n if safe_to_consume == 'auto':\\n safe_to_consume_func = no_subds_in_futures if bottomup else no_parentds_in_futures\\n else:\\n safe_to_consume_func = _SAFE_TO_CONSUME_MAP[safe_to_consume]\\n\\n if cmd_type == 'auto':\\n cmd_type = 'eval' if _is_callable(cmd) else 'external'\\n\\n python = cmd_type in _PYTHON_CMDS\\n\\n if python:\\n if _is_callable(cmd):\\n if cmd_type != 'eval':\\n raise ValueError(f\\\"Can invoke provided function only in 'eval' mode. {cmd_type!r} was provided\\\")\\n else:\\n # yoh decided to avoid unnecessary complication/inhomogeneity with support\\n # of multiple Python commands for now; and also allow for a single string command\\n # in Python interface\\n if isinstance(cmd, (list, tuple)):\\n if len(cmd) > 1:\\n raise ValueError(f\\\"Please provide a single Python expression. Got {len(cmd)}: {cmd!r}\\\")\\n cmd = cmd[0]\\n\\n if not isinstance(cmd, str):\\n raise ValueError(f\\\"Please provide a single Python expression or a function. Got {cmd!r}\\\")\\n else:\\n if _is_callable(cmd):\\n raise ValueError(f\\\"cmd_type={cmd_type} but a function {cmd} was provided\\\")\\n protocol = NoCapture if output_streams == 'pass-through' else StdOutErrCapture\\n\\n refds = require_dataset(\\n dataset, check_installed=True, purpose='foreach-dataset execution')\\n pwd = getpwd() # Note: 'run' has some more elaborate logic for this\\n\\n #\\n # Producer -- datasets to act on\\n #\\n subdatasets_it = refds.subdatasets(\\n state=state,\\n recursive=recursive, recursion_limit=recursion_limit,\\n contains=contains,\\n bottomup=bottomup,\\n result_xfm='paths',\\n result_renderer='disabled',\\n return_type='generator',\\n )\\n\\n if subdatasets_only or contains:\\n datasets_it = subdatasets_it\\n else:\\n if bottomup:\\n datasets_it = chain(subdatasets_it, [refds.path])\\n else:\\n datasets_it = chain([refds.path], subdatasets_it)\\n\\n #\\n # Consumer - one for all cmd_type's\\n #\\n def run_cmd(dspath):\\n ds = Dataset(dspath)\\n status_rec = get_status_dict(\\n 'foreach-dataset',\\n ds=ds,\\n path=ds.path,\\n command=cmd\\n )\\n if not ds.is_installed():\\n yield dict(\\n status_rec,\\n status=\\\"impossible\\\",\\n message=\\\"not installed\\\"\\n )\\n return\\n # For consistent environment (Python) and formatting (command) similar to `run` one\\n # But for Python command we provide actual ds and refds not paths\\n placeholders = dict(\\n pwd=pwd,\\n # pass actual instances so .format could access attributes even for external commands\\n ds=ds, # if python else ds.path,\\n dspath=ds.path, # just for consistency with `run`\\n refds=refds, # if python else refds.path,\\n # Check if the command contains \\\"tmpdir\\\" to avoid creating an\\n # unnecessary temporary directory in most but not all cases.\\n # Note: different from 'run' - not wrapping match within {} and doing str\\n tmpdir=mkdtemp(prefix=\\\"datalad-run-\\\") if \\\"tmpdir\\\" in str(cmd) else \\\"\\\")\\n try:\\n if python:\\n if isinstance(cmd, str):\\n cmd_f, cmd_a, cmd_kw = _PYTHON_CMDS[cmd_type], (cmd, placeholders), {}\\n else:\\n assert _is_callable(cmd)\\n # all placeholders are passed as kwargs to the function\\n cmd_f, cmd_a, cmd_kw = cmd, [], placeholders\\n\\n cm = chpwd_cm(ds.path) if chpwd == 'ds' else nothing_cm()\\n with cm:\\n if output_streams == 'pass-through':\\n res = cmd_f(*cmd_a, **cmd_kw)\\n out = {}\\n elif output_streams in ('capture', 'relpath'):\\n with swallow_outputs() as cmo:\\n res = cmd_f(*cmd_a, **cmd_kw)\\n out = {\\n 'stdout': cmo.out,\\n 'stderr': cmo.err,\\n }\\n else:\\n raise RuntimeError(output_streams)\\n if cmd_type == 'eval':\\n status_rec['result'] = res\\n else:\\n assert res is None\\n else:\\n try:\\n cmd_expanded = format_command(cmd, **placeholders)\\n except KeyError as exc:\\n yield dict(\\n status_rec,\\n status='impossible',\\n message=('command has an unrecognized placeholder: %s', exc))\\n return\\n out = ds.repo._git_runner.run(\\n cmd_expanded,\\n cwd=ds.path if chpwd == 'ds' else pwd,\\n protocol=protocol)\\n if output_streams in ('capture', 'relpath'):\\n status_rec.update(out)\\n # provide some feedback to user in default rendering\\n if any(out.values()):\\n status_rec['message'] = shortened_repr(out, 100)\\n status_rec['status'] = 'ok'\\n yield status_rec\\n except Exception as exc:\\n # get a better version with exception handling redoing the whole\\n # status dict from scratch\\n yield get_status_dict(\\n 'foreach-dataset',\\n ds=ds,\\n path=ds.path,\\n command=cmd,\\n exception=exc,\\n status='error',\\n message=str(exc)\\n )\\n\\n if output_streams == 'pass-through':\\n pc_class = ProducerConsumer\\n pc_kw = {}\\n else:\\n pc_class = ProducerConsumerProgressLog\\n pc_kw = dict(lgr=lgr, label=\\\"foreach-dataset\\\", unit=\\\"datasets\\\")\\n\\n if python:\\n effective_jobs = pc_class.get_effective_jobs(jobs)\\n if effective_jobs > 1:\\n warning = \\\"\\\"\\n if chpwd == 'ds':\\n warning += \\\\\\n \\\"Execution of Python commands in parallel threads while changing directory \\\" \\\\\\n \\\"is not thread-safe. \\\"\\n if output_streams in ('capture', 'relpath'):\\n warning += \\\\\\n \\\"Execution of Python commands in parallel while capturing output is not possible.\\\"\\n if warning:\\n lgr.warning(\\\"Got jobs=%d. %s We will execute without parallelization\\\", jobs, warning)\\n jobs = 0 # no threading even between producer/consumer\\n\\n yield from pc_class(\\n producer=datasets_it,\\n consumer=run_cmd,\\n # probably not needed\\n # It is ok to start with subdatasets since top dataset already exists\\n safe_to_consume=safe_to_consume_func,\\n # or vice versa\\n jobs=jobs,\\n **pc_kw\\n )\\n\\n @staticmethod\\n def custom_result_renderer(res, **kwargs):\\n from datalad.interface.utils import generic_result_renderer\\n if kwargs.get('output_streams') == 'relpath':\\n from datalad.log import no_progress\\n with no_progress():\\n ds: Union[str, Dataset] = kwargs.get('dataset')\\n if ds:\\n if not isinstance(ds, Dataset):\\n ds = Dataset(ds) # so all ///, ^ etc get treated\\n refpath = ds.path\\n else:\\n refpath = getpwd()\\n for k in ('stdout', 'stderr'):\\n v = res.get(k)\\n if v:\\n path = res.get('path')\\n relpath = op.relpath(path, refpath) if path else ''\\n if relpath == op.curdir:\\n relpath = ''\\n if relpath and not relpath.endswith(op.sep):\\n relpath += op.sep\\n out = getattr(sys, k)\\n for l in v.splitlines():\\n out.write(f\\\"{relpath}{l}\\\\n\\\")\\n else:\\n generic_result_renderer(res)\\n\\n# Reduced version from run\\ndef format_command(command, **kwds):\\n \\\"\\\"\\\"Plug in placeholders in `command`.\\n\\n Parameters\\n ----------\\n dset : Dataset\\n command : str or list\\n\\n `kwds` is passed to the `format` call.\\n\\n Returns\\n -------\\n formatted command (str)\\n \\\"\\\"\\\"\\n command = normalize_command(command)\\n sfmt = SequenceFormatter()\\n return sfmt.format(command, **kwds)\\n\\n\\ndef _is_callable(f):\\n return inspect.isfunction(f) or inspect.isbuiltin(f)\\n\"\n },\n {\n \"alpha_fraction\": 0.76932293176651,\n \"alphanum_fraction\": 0.776512861251831,\n \"avg_line_length\": 37.8139533996582,\n \"blob_id\": \"f59356e737a8434cca3f920c26e2831b823c9df3\",\n \"content_id\": \"0849c6dbfa4b650df1fd8301be1086e0e6856371\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Shell\",\n \"length_bytes\": 1669,\n \"license_type\": \"permissive\",\n \"max_line_length\": 144,\n \"num_lines\": 43,\n \"path\": \"/docs/casts/seamless_nested_repos.sh\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"say \\\"DataLad makes a tree of nested Git repositories feel like a big monorepo...\\\"\\n\\nsay \\\"Let's create a root dataset\\\"\\nrun \\\"datalad create demo\\\"\\nrun \\\"cd demo\\\"\\nsay \\\"Any DataLad dataset is just a Git repo with some initial configuration\\\"\\nrun \\\"git log --oneline\\\"\\n\\nsay \\\"We can nest datasets, by telling DataLad to register a new dataset in a parent dataset\\\"\\nrun \\\"datalad create -d . sub1\\\"\\nsay \\\"A subdataset is a regular Git submodule\\\"\\nrun \\\"git submodule\\\"\\n\\nsay \\\"Datasets can be nested arbitrarily deep\\\"\\nrun \\\"datalad create -d . sub1/justadir/sub2\\\"\\n\\nsay \\\"Unlike Git, DataLad automatically takes care of committing all changes associated with the added subdataset up to the given parent dataset\\\"\\nrun \\\"datalad status\\\"\\n\\nsay \\\"Let's create some content in the deepest subdataset\\\"\\nrun \\\"mkdir sub1/justadir/sub2/anotherdir\\\"\\nrun \\\"touch sub1/justadir/sub2/anotherdir/afile\\\"\\n\\nsay \\\"Git only reports changes within a repository, in the case the whole subdataset\\\"\\nrun \\\"git status\\\"\\n\\nsay \\\"DataLad considers the entire tree\\\"\\nrun \\\"datalad status -r\\\"\\n\\nsay \\\"Like Git, it can report individual untracked files, but also across repository boundaries\\\"\\nrun \\\"datalad status -r --untracked all\\\"\\n\\nsay \\\"Adding this new content with Git or git-annex would be an exercise\\\"\\nrun_expfail \\\"git add sub1/justadir/sub2/anotherdir/afile\\\"\\n\\nsay \\\"Again, DataLad does not require users to determine the correct repository\\\"\\nrun \\\"datalad save -d . sub1/justadir/sub2/anotherdir/afile\\\"\\n\\nsay \\\"All associated changes in the entire dataset tree were committed\\\"\\nrun \\\"datalad status\\\"\\n\\nsay \\\"DataLad's 'diff' is able to report the changes from these related commits throughout the repository tree\\\"\\nrun \\\"datalad diff -r -f @~1\\\"\\n\"\n },\n {\n \"alpha_fraction\": 0.7143410444259644,\n \"alphanum_fraction\": 0.7155027985572815,\n \"avg_line_length\": 36.97549057006836,\n \"blob_id\": \"12833308bacbbc1f13e555cd0f51d8b5ccdd11b8\",\n \"content_id\": \"412c6227fe08e3cdd8f45fc6bde450139ff59a6a\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"reStructuredText\",\n \"length_bytes\": 7747,\n \"license_type\": \"permissive\",\n \"max_line_length\": 84,\n \"num_lines\": 204,\n \"path\": \"/docs/source/design/progress_reporting.rst\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \".. -*- mode: rst -*-\\n.. vi: set ft=rst sts=4 ts=4 sw=4 et tw=79:\\n\\n.. _chap_design_progress_reporting:\\n\\n******************\\nProgress reporting\\n******************\\n\\n.. topic:: Specification scope and status\\n\\n This specification describes the current implementation.\\n\\n\\nProgress reporting is implemented via the logging system. A dedicated function\\n:py:func:`datalad.log.log_progress` represents the main API for progress\\nreporting. For some standard use cases, the utilities\\n:py:func:`datalad.log.with_progress` and\\n:py:func:`datalad.log.with_result_progress` can simplify result reporting\\nfurther.\\n\\n\\nDesign and implementation\\n=========================\\n\\nThis basic idea is to use an instance of datalad's loggers to emit log messages\\nwith particular attributes that are picked up by\\n:py:class:`datalad.log.ProgressHandler` (derived from\\n:py:class:`logging.Handler`), and are acted on differently, depending on\\nconfiguration and conditions of a session (e.g., interactive terminal sessions\\nvs. non-interactive usage in scripts). This variable behavior is implemented\\nvia the use of :py:mod:`logging` standard library log filters and handlers.\\nRoughly speaking, :py:class:`datalad.log.ProgressHandler` will only be used for\\ninteractive sessions. In non-interactive cases, progress log messages are\\ninspected by :py:func:`datalad.log.filter_noninteractive_progress`, and are\\neither discarded or treated like any other log message (see\\n:py:meth:`datalad.log.LoggerHelper.get_initialized_logger` for details on the\\nhandler and filter setup).\\n\\n:py:class:`datalad.log.ProgressHandler` inspects incoming log records for\\nattributes with names starting with `dlm_progress`. It will only process such\\nrecords and pass others on to the underlying original log handler otherwise.\\n\\n:py:class:`datalad.log.ProgressHandler` takes care of creating, updating and\\ndestroying any number of simultaneously running progress bars. Progress reports\\nmust identify the respective process via an arbitrary string ID. It is the\\ncaller's responsibility to ensure that this ID is unique to the target\\nprocess/activity.\\n\\n\\nReporting progress with `log_progress()`\\n========================================\\n\\nTypical progress reporting via :py:func:`datalad.log.log_progress` involves\\nthree types of calls.\\n\\n1. Start reporting progress about a process\\n-------------------------------------------\\n\\nA typical call to start of progress reporting looks like this\\n\\n.. code-block:: python\\n\\n log_progress(\\n # the callable used to emit log messages\\n lgr.info,\\n # a unique identifiers of the activity progress is reported for\\n identifier,\\n # main message\\n 'Unlocking files',\\n # optional unit string for a progress bar\\n unit=' Files',\\n # optional label to be displayed in a progress bar\\n label='Unlocking',\\n # maximum value for a progress bar\\n total=nfiles,\\n )\\n\\nA new progress bar will be created automatically for any report with a previously\\nunseen activity ``identifier``. It can be configured via the specification of\\na number of arguments, most notably a target ``total`` for the progress bar.\\nSee :py:func:`datalad.log.log_progress` for a complete overview.\\n\\nStarting a progress report must be done with a dedicated call. It cannot be combined\\nwith a progress update.\\n\\n\\n2. Update progress information about a process\\n----------------------------------------------\\n\\nAny subsequent call to :py:func:`datalad.log.log_progress` with an activity\\nidentifier that has already been seen either updates, or finishes the progress\\nreporting for an activity. Updates must contain an ``update`` key which either\\nspecifies a new value (if `increment=False`, the default) or an increment to\\npreviously known value (if `increment=True`):\\n\\n.. code-block:: python\\n\\n log_progress(\\n lgr.info,\\n # must match the identier used to start the progress reporting\\n identifier,\\n # arbitrary message content, string expansion supported just like\\n # regular log messages\\n \\\"Files to unlock %i\\\", nfiles,\\n # critical key for report updates\\n update=1,\\n # ``update`` could be an absolute value or an increment\\n increment=True\\n )\\n\\nUpdating a progress report can only be done after a progress reporting was\\ninitialized (see above).\\n\\n\\n3. Report completion of a process\\n---------------------------------\\n\\nA progress bar will remain active until it is explicitly taken down, even if an\\ninitially declared ``total`` value may have been reached. Finishing a progress\\nreport requires a final log message with the corresponding identifiers which,\\nlike the first initializing message, does NOT contain an ``update`` key.\\n\\n.. code-block:: python\\n\\n log_progress(\\n lgr.info,\\n identifier,\\n # closing log message\\n \\\"Completed unlocking files\\\",\\n )\\n\\n\\nProgress reporting in non-interactive sessions\\n----------------------------------------------\\n\\n:py:func:`datalad.log.log_progress` takes a `noninteractive_level` argument\\nthat can be used to specify a log level at which progress is logged when no\\nprogress bars can be used, but actual log messages are produced.\\n\\n.. code-block:: python\\n\\n import logging\\n\\n log_progress(\\n lgr.info,\\n identifier,\\n \\\"Completed unlocking files\\\",\\n noninteractive_level=logging.INFO\\n )\\n\\nEach call to :py:func:`~datalad.log.log_progress` can be given a different\\nlog level, in order to control the verbosity of the reporting in such a scenario.\\nFor example, it is possible to log the start or end of an activity at a higher\\nlevel than intermediate updates. It is also possible to single out particular\\nintermediate events, and report them at a higher level.\\n\\nIf no `noninteractive_level` is specified, the progress update is unconditionally\\nlogged at the level implied by the given logger callable. \\n\\n\\nReporting progress with `with_(result_)progress()`\\n==================================================\\n\\nFor cases were a list of items needs to be processes sequentially, and progress\\nshall be communicated, two additional helpers could be used: the decorators\\n:py:func:`datalad.log.with_progress` and\\n:py:func:`datalad.log.with_result_progress`. They require a callable that takes\\na list (or more generally a sequence) of items to be processed as the first\\npositional argument. They both set up and perform all necessary calls to\\n:py:func:`~datalad.log.log_progress`.\\n\\nThe difference between these helpers is that\\n:py:func:`datalad.log.with_result_progress` expects a callable to produce\\nDataLad result records, and supports customs filters to decide which particular\\nresult records to consider for progress reporting (e.g., only records for a\\nparticular `action` and `type`).\\n\\n\\nOutput non-progress information without interfering with progress bars\\n======================================================================\\n\\n:py:func:`~datalad.log.log_progress` can also be useful when not reporting\\nprogress, but ensuring that no other output is interfering with progress bars,\\nand vice versa. The argument `maint` can be used in this case, with no\\nparticular activity identifier (it always impacts all active progress bars):\\n\\n\\n.. code-block:: python\\n\\n log_progress(\\n lgr.info,\\n None,\\n 'Clear progress bars',\\n maint='clear',\\n )\\n\\n\\nThis call will trigger a temporary discontinuation of any progress bar display.\\nProgress bars can either be re-enabled all at once, by an analog message with\\n``maint='refresh'``, or will re-show themselves automatically when the next\\nupdate is received. A :py:func:`~datalad.log.no_progress` context manager helper\\ncan be used to surround your context with those two calls to prevent progress\\nbars from interfering.\\n\"\n },\n {\n \"alpha_fraction\": 0.6125584244728088,\n \"alphanum_fraction\": 0.6359385251998901,\n \"avg_line_length\": 41.771427154541016,\n \"blob_id\": \"d9917beac18bb872bcb24ebcdf7298b3069776c9\",\n \"content_id\": \"31e53f819964347673bbfca0775957424d39e391\",\n \"detected_licenses\": [\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1497,\n \"license_type\": \"permissive\",\n \"max_line_length\": 87,\n \"num_lines\": 35,\n \"path\": \"/datalad/support/tests/test_status.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\nfrom datalad.tests.utils_pytest import (\\n assert_equal,\\n assert_not_equal,\\n)\\n\\nfrom ..status import FileStatus\\n\\n\\ndef test_FileStatus_basic():\\n assert_equal(FileStatus(size=0), FileStatus(size=0))\\n assert_not_equal(FileStatus(size=0), FileStatus(size=1))\\n # mtimes allow trimming if one is int\\n assert_equal(FileStatus(mtime=0), FileStatus(mtime=0.9999))\\n assert_equal(FileStatus(mtime=0), FileStatus(mtime=0.0001))\\n assert_not_equal(FileStatus(mtime=0.2), FileStatus(mtime=0.1))\\n assert_not_equal(FileStatus(mtime=0.2), FileStatus(mtime=None))\\n assert_not_equal(FileStatus(mtime=1), FileStatus(mtime=None))\\n # And with None should be False\\n assert_not_equal(FileStatus(mtime=1), None)\\n assert_not_equal(None, FileStatus(mtime=1))\\n # adding more information would result in not-equal\\n assert_not_equal(FileStatus(size=0), FileStatus(size=0, mtime=123))\\n # empty ones can't be compared\\n # TODO: actually not clear why that NotImplemented singleton is not returned\\n assert_not_equal(FileStatus(), FileStatus())\\n #assert_false(FileStatus() != FileStatus())\\n\"\n },\n {\n \"alpha_fraction\": 0.542140781879425,\n \"alphanum_fraction\": 0.5561943650245667,\n \"avg_line_length\": 37.415645599365234,\n \"blob_id\": \"1ec4260f07e55ad537e8b6fc1ffe10b23c435f8f\",\n \"content_id\": \"8a7b92e0f8c3bf11d173ec8b0ef9271980183aba\",\n \"detected_licenses\": [\n \"LicenseRef-scancode-unknown-license-reference\",\n \"BSD-3-Clause\",\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 25047,\n \"license_type\": \"permissive\",\n \"max_line_length\": 116,\n \"num_lines\": 652,\n \"path\": \"/datalad/local/tests/test_add_archive_content.py\",\n \"repo_name\": \"datalad/datalad\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# emacs: -*- mode: python; py-indent-offset: 4; tab-width: 4; indent-tabs-mode: nil -*-\\n# ex: set sts=4 ts=4 sw=4 et:\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n#\\n# See COPYING file distributed along with the datalad package for the\\n# copyright and license terms.\\n#\\n# ## ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##\\n\\\"\\\"\\\"Tests for add-archive-content command\\n\\n\\\"\\\"\\\"\\n\\n__docformat__ = 'restructuredtext'\\n\\nimport os\\nimport tempfile\\nfrom glob import glob\\nfrom os import unlink\\nfrom os.path import (\\n basename,\\n exists,\\n)\\nfrom os.path import join as opj\\nfrom os.path import (\\n lexists,\\n pardir,\\n)\\nfrom pathlib import Path\\n\\nfrom datalad.api import (\\n Dataset,\\n add_archive_content,\\n clean,\\n)\\nfrom datalad.consts import (\\n ARCHIVES_SPECIAL_REMOTE,\\n DATALAD_SPECIAL_REMOTES_UUIDS,\\n)\\nfrom datalad.support.exceptions import (\\n CommandError,\\n NoDatasetFound,\\n)\\nfrom datalad.support.external_versions import external_versions\\nfrom datalad.tests.utils_pytest import (\\n assert_cwd_unchanged,\\n assert_equal,\\n assert_false,\\n assert_in,\\n assert_in_results,\\n assert_not_in,\\n assert_raises,\\n assert_repo_status,\\n assert_result_values_cond,\\n assert_true,\\n create_tree,\\n eq_,\\n integration,\\n known_failure_windows,\\n ok_,\\n ok_archives_caches,\\n ok_file_has_content,\\n ok_file_under_git,\\n serve_path_via_http,\\n skip_if,\\n skip_if_adjusted_branch,\\n swallow_outputs,\\n with_tempfile,\\n with_tree,\\n xfail_buggy_annex_info,\\n)\\nfrom datalad.utils import (\\n chpwd,\\n find_files,\\n get_tempfile_kwargs,\\n getpwd,\\n on_windows,\\n rmtemp,\\n)\\n\\ntreeargs = dict(\\n tree=(\\n ('1.tar.gz', (\\n ('crcns_pfc-1_data', (('CR24A', (\\n ('behaving1', {'1 f.txt': '1 f load'}),)),)),\\n ('crcns_pfc-1_data', (('CR24C', (\\n ('behaving3', {'3 f.txt': '3 f load'}),)),)),\\n ('crcns_pfc-1_data', (('CR24D', (\\n ('behaving2', {'2 f.txt': '2 f load'}),)),)),\\n ('__MACOSX', (('crcns_pfc-2_data', (\\n ('CR24B', (\\n ('behaving2', {'2 f.txt': '2 f load'}),)),)\\n ),)),\\n ('crcns_pfc-2_data', (('__MACOSX', (\\n ('CR24E', (\\n ('behaving2', {'2 f.txt': '2 f load'}),)),)\\n ),)),\\n\\n )),\\n )\\n)\\n\\n\\n@assert_cwd_unchanged(ok_to_chdir=True)\\n@with_tree(**treeargs)\\n@serve_path_via_http()\\n@with_tempfile(mkdir=True)\\ndef test_add_archive_dirs(path_orig=None, url=None, repo_path=None):\\n # change to repo_path\\n with chpwd(repo_path):\\n # create annex repo\\n ds = Dataset(repo_path).create(force=True)\\n repo = ds.repo\\n # add archive to the repo so we could test\\n with swallow_outputs():\\n repo.add_url_to_file('1.tar.gz', opj(url, '1.tar.gz'))\\n repo.commit(\\\"added 1.tar.gz\\\")\\n\\n # test with excludes and annex options\\n add_archive_content('1.tar.gz',\\n existing='archive-suffix',\\n # Since inconsistent and seems in many cases no\\n # leading dirs to strip, keep them as provided\\n strip_leading_dirs=True,\\n delete=True,\\n leading_dirs_consider=['crcns.*', '1'],\\n leading_dirs_depth=2,\\n use_current_dir=False,\\n exclude='.*__MACOSX.*') # some junk penetrates\\n\\n eq_(repo.get_description(\\n uuid=DATALAD_SPECIAL_REMOTES_UUIDS[ARCHIVES_SPECIAL_REMOTE]),\\n '[%s]' % ARCHIVES_SPECIAL_REMOTE)\\n\\n all_files = sorted(find_files('.'))\\n # posixify paths to make it work on Windows as well\\n all_files = [Path(file).as_posix() for file in all_files]\\n target_files = {\\n 'CR24A/behaving1/1 f.txt',\\n 'CR24C/behaving3/3 f.txt',\\n 'CR24D/behaving2/2 f.txt',\\n '.datalad/config',\\n }\\n eq_(set(all_files), target_files)\\n\\n # regression test: the subdir in MACOSX wasn't excluded and its name was\\n # getting stripped by leading_dir_len\\n # if stripping and exclude didn't work this fails\\n assert_false(exists('__MACOSX'))\\n # if exclude doesn't work then name of subdir gets stripped by\\n # leading_dir_len\\n assert_false(exists('c-1_data'))\\n # if exclude doesn't work but everything else works this fails\\n assert_false(exists('CR24B'))\\n\\n# within top directory\\n# archive is in subdirectory -- adding in the same (or different) directory\\n\\ntree1args = dict(\\n tree=(\\n ('1.tar.gz', (\\n ('1 f.txt', '1 f load'),\\n ('d', (('1d', ''),)), )),\\n ('1u', {\\n '1.tar.gz': { # updated file content\\n '1 f.txt': '1 f load1'\\n }}),\\n ('2u', { # updated file content\\n '1.tar.gz': {\\n '1 f.txt': '1 f load2'\\n }}),\\n ('3u', { # updated file content\\n '1.tar.gz': {\\n '1 f.txt': '1 f load3'\\n }}),\\n ('4u', { # updated file content\\n '1.tar.gz': {\\n '1 f.txt': '1 f load4'\\n }}),\\n ('d1', (('1.tar.gz', (\\n ('2 f.txt', '2 f load'),\\n ('d2', (\\n ('2d', ''),)\\n )),),),),\\n )\\n)\\n\\ntree4uargs = dict(\\n tree=(\\n ('4u', { # updated file content\\n '1.tar.gz': {\\n '1 f.txt': '1 f load4',\\n 'sub.tar.gz': {\\n '2 f.txt': '2 f'\\n }\\n }}),\\n )\\n)\\n\\n\\n@xfail_buggy_annex_info\\n@known_failure_windows\\n# apparently fails only sometimes in PY3, but in a way that's common in V6\\n@assert_cwd_unchanged(ok_to_chdir=True)\\n@with_tree(**tree1args)\\n@serve_path_via_http()\\n@with_tempfile(mkdir=True)\\ndef test_add_archive_content(path_orig=None, url=None, repo_path=None):\\n with chpwd(repo_path):\\n # TODO we need to be able to pass path into add_archive_content\\n # We could mock but I mean for the API\\n\\n # no repo yet\\n assert_raises(NoDatasetFound, add_archive_content, \\\"nonexisting.tar.gz\\\")\\n ds = Dataset(repo_path).create()\\n res = ds.add_archive_content(\\\"nonexisting.tar.gz\\\", on_failure='ignore')\\n assert_in_results(res, action='add-archive-content',\\n status='impossible')\\n repo = ds.repo\\n\\n # we can't add a file from outside the repo ATM\\n res = ds.add_archive_content(Path(path_orig) / '1.tar.gz',\\n on_failure='ignore')\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n status='impossible',\\n type=\\\"dataset\\\",\\n message=\\\"Can not add archive outside of the dataset\\\"\\n )\\n\\n # Let's add first archive to the repo so we could test\\n with swallow_outputs():\\n repo.add_url_to_file('1.tar.gz', opj(url, '1.tar.gz'))\\n for s in range(1, 5):\\n repo.add_url_to_file('%du/1.tar.gz' % s,\\n opj(url, '%du/1.tar.gz' % s))\\n repo.commit(\\\"added 1.tar.gz\\\")\\n\\n key_1tar = repo.get_file_annexinfo('1.tar.gz')['key'] # will be used in the test later\\n\\n def d1_basic_checks():\\n ok_(exists('1'))\\n ok_file_under_git('1', '1 f.txt', annexed=True)\\n ok_file_under_git(opj('1', 'd', '1d'), annexed=True)\\n ok_archives_caches(repo_path, 0)\\n\\n # and by default it just does it, everything goes to annex\\n res = add_archive_content('1.tar.gz')\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n status='ok'\\n )\\n d1_basic_checks()\\n\\n # If ran again, should proceed just fine since the content is the same\\n # so no changes would be made really\\n res = add_archive_content('1.tar.gz')\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n status='ok'\\n )\\n\\n # But that other one carries updated file, so should fail due to\\n # overwrite\\n res = add_archive_content(Path('1u') / '1.tar.gz',\\n use_current_dir=True, on_failure='ignore')\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n status='error',\\n )\\n assert_in('exists, but would be overwritten by new file',\\n res[0]['message'])\\n # but should do fine if overrides are allowed\\n add_archive_content(Path('1u') / '1.tar.gz', existing='overwrite',\\n use_current_dir=True)\\n add_archive_content(Path('2u') / '1.tar.gz',\\n existing='archive-suffix', use_current_dir=True)\\n add_archive_content(Path('3u') / '1.tar.gz',\\n existing='archive-suffix', use_current_dir=True)\\n add_archive_content(Path('4u') / '1.tar.gz',\\n existing='archive-suffix', use_current_dir=True)\\n\\n # rudimentary test\\n assert_equal(sorted(map(basename, glob(opj(repo_path, '1', '1*')))),\\n ['1 f-1.1.txt', '1 f-1.2.txt', '1 f-1.txt', '1 f.txt'])\\n whereis = repo.whereis(glob(opj(repo_path, '1', '1*')))\\n # they all must be the same\\n assert(all([x == whereis[0] for x in whereis[1:]]))\\n\\n # and we should be able to reference it while under subdirectory\\n subdir = opj(repo_path, 'subdir')\\n with chpwd(subdir, mkdir=True):\\n add_archive_content(opj(pardir, '1.tar.gz'), dataset=ds.path,\\n use_current_dir=True)\\n d1_basic_checks()\\n # or we could keep relative path and also demand to keep the archive prefix\\n # while extracting under original (annex root) dir\\n add_archive_content(opj(pardir, '1.tar.gz'),\\n dataset=ds.path,\\n add_archive_leading_dir=True)\\n\\n with chpwd(opj(repo_path, '1')):\\n d1_basic_checks()\\n\\n with chpwd(repo_path):\\n # test with excludes and renames and annex options\\n ds.add_archive_content(\\n '1.tar.gz', exclude=['d'], rename=['/ /_', '/^1/2'],\\n annex_options=\\\"-c annex.largefiles=exclude=*.txt\\\",\\n delete=True)\\n # no conflicts since new name\\n ok_file_under_git('2', '1_f.txt', annexed=False)\\n assert_false(exists(opj('2', 'd')))\\n assert_false(exists('1.tar.gz')) # delete was in effect\\n\\n # now test ability to extract within subdir\\n with chpwd(opj(repo_path, 'd1'), mkdir=True):\\n # Let's add first archive to the repo so we could test\\n # named the same way but different content\\n with swallow_outputs():\\n repo.add_url_to_file('d1/1.tar.gz', opj(url, 'd1', '1.tar.gz'))\\n repo.commit(\\\"added 1.tar.gz in d1\\\")\\n\\n def d2_basic_checks():\\n ok_(exists('1'))\\n ok_file_under_git('1', '2 f.txt', annexed=True)\\n ok_file_under_git(opj('1', 'd2', '2d'), annexed=True)\\n ok_archives_caches(repo.path, 0)\\n add_archive_content('1.tar.gz', dataset=ds.path)\\n d2_basic_checks()\\n\\n # in manual tests ran into the situation of inability to obtain on a single run\\n # a file from an archive which was coming from a dropped key. I thought it was\\n # tested in custom remote tests, but I guess not sufficiently well enough\\n repo.drop(opj('1', '1 f.txt')) # should be all kosher\\n repo.get(opj('1', '1 f.txt'))\\n ok_archives_caches(repo.path, 1, persistent=True)\\n ok_archives_caches(repo.path, 0, persistent=False)\\n\\n repo.drop(opj('1', '1 f.txt')) # should be all kosher\\n repo.drop(key_1tar, key=True) # is available from the URL -- should be kosher\\n repo.get(opj('1', '1 f.txt')) # that what managed to not work\\n\\n # TODO: check if persistent archive is there for the 1.tar.gz\\n\\n # We should be able to drop everything since available online\\n with swallow_outputs():\\n clean(dataset=ds)\\n repo.drop(key_1tar, key=True) # is available from the URL -- should be kosher\\n\\n ds.drop(opj('1', '1 f.txt')) # should be all kosher\\n ds.get(opj('1', '1 f.txt')) # and should be able to get it again\\n\\n # bug was that dropping didn't work since archive was dropped first\\n repo.call_annex([\\\"drop\\\", \\\"--all\\\"])\\n\\n # verify that we can't drop a file if archive key was dropped and online archive was removed or changed size! ;)\\n repo.get(key_1tar, key=True)\\n unlink(opj(path_orig, '1.tar.gz'))\\n with assert_raises(CommandError) as e:\\n repo.drop(key_1tar, key=True)\\n assert_equal(e.kwargs['stdout_json'][0]['success'], False)\\n assert_result_values_cond(\\n e.kwargs['stdout_json'], 'note',\\n lambda x: '(Use --force to override this check, or adjust numcopies.)' in x\\n )\\n assert exists(opj(repo.path, repo.get_contentlocation(key_1tar)))\\n\\n\\n@integration\\n@assert_cwd_unchanged(ok_to_chdir=True)\\n@with_tree(**tree1args)\\n@serve_path_via_http()\\n@with_tempfile(mkdir=True)\\ndef test_add_archive_content_strip_leading(path_orig=None, url=None, repo_path=None):\\n with chpwd(repo_path):\\n ds = Dataset(repo_path).create(force=True)\\n repo = ds.repo\\n # Let's add first archive to the repo so we could test\\n with swallow_outputs():\\n repo.add_url_to_file('1.tar.gz', opj(url, '1.tar.gz'))\\n repo.commit(\\\"added 1.tar.gz\\\")\\n\\n add_archive_content('1.tar.gz', strip_leading_dirs=True)\\n ok_(not exists('1'))\\n ok_file_under_git(ds.path, '1 f.txt', annexed=True)\\n ok_file_under_git('d', '1d', annexed=True)\\n ok_archives_caches(ds.path, 0)\\n\\n\\n@assert_cwd_unchanged(ok_to_chdir=True)\\n@with_tree(tree={\\\"1.zip\\\": {\\\"dir\\\": {\\\"bar\\\": \\\"blah\\\"}, \\\"foo\\\": \\\"blahhhhh\\\"}})\\ndef test_add_archive_content_zip(repo_path=None):\\n ds = Dataset(repo_path).create(force=True)\\n with chpwd(repo_path):\\n with swallow_outputs():\\n ds.save(\\\"1.zip\\\", message=\\\"add 1.zip\\\")\\n add_archive_content(\\\"1.zip\\\")\\n ok_file_under_git(ds.pathobj / \\\"1\\\" / \\\"foo\\\", annexed=True)\\n ok_file_under_git(ds.pathobj / \\\"1\\\" / \\\"dir\\\" / \\\"bar\\\", annexed=True)\\n ok_archives_caches(ds.path, 0)\\n\\n\\n@with_tree(tree={\\\"ds\\\": {\\\"1.tar.gz\\\": {\\\"foo\\\": \\\"abc\\\"}},\\n \\\"notds\\\": {\\\"2.tar.gz\\\": {\\\"bar\\\": \\\"def\\\"}}})\\ndef test_add_archive_content_absolute_path(path=None):\\n ds = Dataset(opj(path, \\\"ds\\\")).create(force=True)\\n repo = ds.repo\\n ds.save(\\\"1.tar.gz\\\", message=\\\"1.tar.gz\\\")\\n abs_tar_gz = opj(path, \\\"ds\\\", \\\"1.tar.gz\\\")\\n add_archive_content(abs_tar_gz, dataset=ds)\\n ok_file_under_git(opj(path, \\\"ds\\\", \\\"1\\\", \\\"foo\\\"), annexed=True)\\n commit_msg = repo.format_commit(\\\"%B\\\")\\n # The commit message uses relative paths.\\n assert_not_in(abs_tar_gz, commit_msg)\\n assert_in(\\\"1.tar.gz\\\", commit_msg)\\n res = add_archive_content(opj(path, \\\"notds\\\", \\\"2.tar.gz\\\"),\\n dataset=ds, on_failure='ignore')\\n\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n status='impossible',\\n message='Can not add archive outside of the dataset',\\n )\\n\\n\\n@assert_cwd_unchanged(ok_to_chdir=True)\\n@with_tree(**tree4uargs)\\ndef test_add_archive_use_archive_dir(repo_path=None):\\n ds = Dataset(repo_path).create(force=True)\\n with chpwd(repo_path):\\n # Let's add first archive to the repo with default setting\\n archive_path = opj('4u', '1.tar.gz')\\n # check it gives informative error if archive is not already added\\n res = add_archive_content(archive_path, on_failure='ignore')\\n message = \\\\\\n \\\"Can not add an untracked archive. Run 'datalad save 4u\\\\\\\\1.tar.gz'\\\"\\\\\\n if on_windows else \\\\\\n \\\"Can not add an untracked archive. Run 'datalad save 4u/1.tar.gz'\\\"\\n assert_in_results(\\n res,\\n action='add-archive-content',\\n message=message,\\n status='impossible')\\n\\n with swallow_outputs():\\n ds.save(archive_path)\\n\\n ok_archives_caches(ds.path, 0)\\n add_archive_content(archive_path, strip_leading_dirs=True,\\n use_current_dir=True)\\n ok_(not exists(opj('4u', '1 f.txt')))\\n ok_file_under_git(ds.path, '1 f.txt', annexed=True)\\n ok_archives_caches(ds.path, 0)\\n\\n # and now let's extract under archive dir\\n add_archive_content(archive_path, strip_leading_dirs=True)\\n ok_file_under_git(ds.path, opj('4u', '1 f.txt'), annexed=True)\\n ok_archives_caches(ds.path, 0)\\n\\n add_archive_content(opj('4u', 'sub.tar.gz'))\\n ok_file_under_git(ds.path, opj('4u', 'sub', '2 f.txt'), annexed=True)\\n ok_archives_caches(ds.path, 0)\\n\\n\\n@with_tree(\\n tree={\\n 'archives': {\\n '1.gz': '1',\\n '2.xz': '2',\\n '3.lzma': '3',\\n # TODO: add any other stream compression we might be supporting via 7zip or patool?\\n },\\n }\\n)\\ndef test_add_archive_single_file(repo_path=None):\\n ds = Dataset(repo_path).create(force=True)\\n with chpwd(repo_path):\\n archives = glob('archives/*')\\n ds.save(archives, message='Added archives')\\n\\n for archive in archives:\\n archive_name = os.path.splitext(archive)[0]\\n archive_content = os.path.basename(archive_name)\\n ds.add_archive_content(archive)\\n ok_file_has_content(archive_name, archive_content)\\n\\n\\nclass TestAddArchiveOptions():\\n # few tests bundled with a common setup/teardown to minimize boiler plate\\n # nothing here works on windows, no even teardown(), prevent failure at the\\n # origin\\n def setup(self):\\n repo_path = tempfile.mkdtemp(**get_tempfile_kwargs(prefix=\\\"tree\\\"))\\n create_tree(\\n repo_path,\\n {'1.tar': {'file.txt': 'load',\\n '1.dat': 'load2'}})\\n self.ds = ds = Dataset(repo_path)\\n ds.create(force=True)\\n self.annex = ds.repo\\n # Let's add first archive to the annex so we could test\\n ds.save('1.tar', message=\\\"added 1.tar\\\")\\n\\n def teardown(self):\\n # so we close any outstanding batch process etc\\n self.annex.precommit()\\n rmtemp(self.ds.path)\\n\\n def test_add_delete(self):\\n # To test that .tar gets removed\\n self.ds.add_archive_content('1.tar', strip_leading_dirs=True,\\n delete=True)\\n assert_false(lexists(self.ds.pathobj / '1.tar'))\\n\\n # git-annex regression\\n # https://git-annex.branchable.com/bugs/regression__58___annex_add_of_moved_file_errors_out/\\n @skip_if(\\n '10.20220525' <= external_versions['cmd:annex'] < '10.20220706', # approx when was fixed\\n msg=\\\"buggy git-annex release\\\"\\n )\\n def test_add_archive_leading_dir(self):\\n import os\\n os.mkdir(self.ds.pathobj / 'sub')\\n f123 = Path('sub') / '123.tar'\\n Path(self.ds.pathobj / '1.tar').rename(self.ds.pathobj / Path(f123))\\n self.annex.remove('1.tar', force=True)\\n self.ds.save(message=\\\"renamed\\\")\\n\\n self.ds.add_archive_content(\\n f123,\\n add_archive_leading_dir=True,\\n strip_leading_dirs=True\\n )\\n\\n ok_file_under_git(self.ds.path,\\n str(Path('sub') / '123' / 'file.txt'),\\n annexed=True)\\n\\n # https://github.com/datalad/datalad/issues/6187\\n @skip_if_adjusted_branch\\n def test_add_delete_after_and_drop(self):\\n # To test that .tar gets removed\\n # but that new stuff was added to annex repo. We know the key since\\n # default backend and content remain the same\\n key1 = 'MD5E-s5--db87ebcba59a8c9f34b68e713c08a718.dat'\\n repo = self.ds.repo\\n # previous state of things:\\n prev_files = list(find_files('.*', self.ds.path))\\n assert_equal(repo.whereis(key1, key=True, output='full'), {})\\n\\n commits_prior = list(repo.get_branch_commits_('git-annex'))\\n self.ds.add_archive_content('1.tar',\\n strip_leading_dirs=True, delete_after=True)\\n commits_after = list(repo.get_branch_commits_('git-annex'))\\n # There should be a single commit for all additions +1 to initiate\\n # datalad-archives gh-1258\\n # If faking dates, there should be another +1 because\\n # annex.alwayscommit isn't set to false.\\n assert_equal(len(commits_after),\\n # We expect one more when faking dates because\\n # annex.alwayscommit isn't set to false.\\n len(commits_prior) + 2 + repo.fake_dates_enabled)\\n assert_equal(prev_files, list(find_files('.*', self.ds.path)))\\n w = repo.whereis(key1, key=True, output='full')\\n assert_equal(len(w), 2) # in archive, and locally since we didn't drop\\n\\n # Let's now do the same but also drop content\\n self.ds.add_archive_content('1.tar',\\n strip_leading_dirs=True, delete_after=True,\\n drop_after=True)\\n assert_equal(prev_files, list(find_files('.*', self.ds.path)))\\n w = repo.whereis(key1, key=True, output='full')\\n assert_equal(len(w), 1) # in archive\\n\\n # there should be no .datalad temporary files hanging around\\n self.assert_no_trash_left_behind()\\n\\n def test_add_delete_after_and_drop_subdir(self=None):\\n os.mkdir(opj(self.annex.path, 'subdir'))\\n mv_out = self.annex.call_git(\\n ['mv', '1.tar', 'subdir']\\n )\\n self.annex.commit(\\\"moved into subdir\\\")\\n with chpwd(self.annex.path):\\n # was failing since deleting without considering if tarball\\n # was extracted in that tarball directory\\n commits_prior_master = list(self.annex.get_branch_commits_())\\n commits_prior = list(self.annex.get_branch_commits_('git-annex'))\\n add_out = self.ds.add_archive_content(\\n opj('subdir', '1.tar'),\\n delete_after=True,\\n drop_after=True)\\n assert_repo_status(self.annex.path)\\n if not self.annex.is_managed_branch():\\n # whole counting logic here is ignorant of adjusted branches\\n commits_after_master = list(self.annex.get_branch_commits_())\\n commits_after = list(self.annex.get_branch_commits_('git-annex'))\\n # There should be a single commit for all additions +1 to\\n # initiate datalad-archives gh-1258. If faking dates,\\n # there should be another +1 because annex.alwayscommit\\n # isn't set to false.\\n assert_equal(len(commits_after),\\n len(commits_prior) + 2 + self.annex.fake_dates_enabled)\\n assert_equal(len(commits_after_master), len(commits_prior_master))\\n # there should be no .datalad temporary files hanging around\\n self.assert_no_trash_left_behind()\\n\\n # and if we add some untracked file, redo, there should be no changes\\n # to master and file should remain not committed\\n create_tree(self.annex.path, {'dummy.txt': '123'})\\n assert_true(self.annex.dirty) # untracked file\\n add_out = add_archive_content(\\n opj('subdir', '1.tar'),\\n delete_after=True,\\n drop_after=True,\\n allow_dirty=True)\\n assert_repo_status(self.annex.path, untracked=['dummy.txt'])\\n assert_equal(len(list(self.annex.get_branch_commits_())),\\n len(commits_prior_master))\\n\\n # there should be no .datalad temporary files hanging around\\n self.assert_no_trash_left_behind()\\n\\n def assert_no_trash_left_behind(self):\\n assert_equal(\\n list(find_files(r'\\\\.datalad..*', self.annex.path, exclude=\\\"config\\\",\\n dirs=True)),\\n []\\n )\\n\\n @xfail_buggy_annex_info\\n def test_override_existing_under_git(self):\\n create_tree(self.ds.path, {'1.dat': 'load2'})\\n self.ds.save('1.dat', to_git=True, message='added to git')\\n self.ds.add_archive_content(\\n '1.tar', strip_leading_dirs=True,\\n )\\n # and we did not bother adding it to annex (for now) -- just skipped\\n # since we have it and it is the same\\n ok_file_under_git(self.ds.path, '1.dat', annexed=False)\\n\\n # but if we say 'overwrite' -- we would remove and replace\\n self.ds.add_archive_content(\\n '1.tar', strip_leading_dirs=True, delete=True\\n , existing='overwrite'\\n )\\n ok_file_under_git(self.ds.path, '1.dat', annexed=True)\\n\"\n }\n]"},"num_files":{"kind":"number","value":390,"string":"390"}}},{"rowIdx":2978313,"cells":{"repo_name":{"kind":"string","value":"jim-bo/scafathon"},"repo_url":{"kind":"string","value":"https://github.com/jim-bo/scafathon"},"snapshot_id":{"kind":"string","value":"313b35b1d36ec5623f931f9e74f34745f428e040"},"revision_id":{"kind":"string","value":"9e5e059ee9ae74a2d16dc8b9356cf6e2bb8472fe"},"directory_id":{"kind":"string","value":"6a33f68ca49d7c3ff95aadabd2b9fb7980fd950a"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2021-01-01T16:25:00.712869","string":"2021-01-01T16:25:00.712869"},"revision_date":{"kind":"timestamp","value":"2014-02-25T17:33:59","string":"2014-02-25T17:33:59"},"committer_date":{"kind":"timestamp","value":"2014-02-25T17:33:59","string":"2014-02-25T17:33:59"},"github_id":{"kind":"null"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.5037604570388794,"alphanum_fraction":0.5210442543029785,"avg_line_length":23.13263511657715,"blob_id":"ff878cc9510ef048b68b1a742c6a9967b68a4f8b","content_id":"11be2c7d435fa5f3cdd2beda3049169f4b149460","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":13828,"license_type":"permissive","max_line_length":117,"num_lines":573,"path":"/utils/eval.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"import os\nimport sys\nimport math\nimport numpy as np\nimport logging\nimport subprocess\nimport networkx as nx\n\n### definitions ###\nagp_dt = np.dtype([\\\n ('scaf_name', 'S255'),\\\n ('scaf_start', np.long),\\\n ('scaf_stop', np.long),\\\n ('scaf_idx', np.long),\\\n ('comp_type', 'S50'),\\\n ('comp_name', 'S255'),\\\n ('comp_start', np.long),\\\n ('comp_stop', np.long),\\\n ('comp_orien', np.long),\\\n ('comp_linkage', np.long),\\\n])\n\n### private functions ###\n\ndef _load_agp(fpath):\n ''' read agp file into array.'''\n\n # read in agp.\n fin = open(fpath, \"rb\")\n lines = fin.readlines()\n fin.close()\n\n # count number of lines minus comments.\n cnt = 0\n for line in lines:\n if line[0] != \"#\" and len(line) != 0 and line.strip().split()[0] != \"RUNTIME:\":\n cnt += 1\n\n # instantiate array.\n agp_edges = np.zeros(cnt, dtype=agp_dt)\n\n # parse agp.\n idx = 0\n for line in lines:\n # tokenize.\n if line[0] == \"#\": continue\n tmp = line.strip().split()\n if len(tmp) == 0: continue\n if tmp[0] == \"RUNTIME:\": continue\n\n # get general tokenize.\n agp_edges[idx]['scaf_name'] = tmp[0]\n agp_edges[idx]['scaf_start'] = int(float(tmp[1]))\n agp_edges[idx]['scaf_stop'] = int(float(tmp[2]))\n agp_edges[idx]['scaf_idx'] = int(float(tmp[3]))\n agp_edges[idx]['comp_type'] = tmp[4]\n\n # contig.\n if tmp[4] == \"W\":\n # get parts.\n agp_edges[idx]['comp_name'] = tmp[5]\n agp_edges[idx]['comp_start'] = int(tmp[6])\n agp_edges[idx]['comp_stop'] = int(tmp[7])\n if tmp[8] == \"+\":\n agp_edges[idx]['comp_orien'] = 0\n else:\n agp_edges[idx]['comp_orien'] = 1\n\n else:\n\n # save entry.\n agp_edges[idx]['comp_name'] = tmp[6]\n agp_edges[idx]['comp_start'] = 1\n agp_edges[idx]['comp_stop'] = int(tmp[5])\n if tmp[7] != \"yes\":\n agp_edges[idx]['comp_linkage'] = 0\n else:\n agp_edges[idx]['comp_linkage'] = 1\n\n\n # update index.\n idx += 1\n\n # shirnk array.\n agp_edges.resize(idx)\n\n return agp_edges\n\ndef _agp_graph(fpath, RG=None):\n ''' returns agp graph '''\n\n # load agp array.\n agp_edges = _load_agp(fpath)\n\n # make digraph.\n G = nx.DiGraph()\n\n # add nodes.\n for i in range(agp_edges.size):\n\n # skip contigs themselves.\n if agp_edges[i]['comp_type'] != 'W': continue\n\n # add node info.\n name = agp_edges[i]['comp_name']\n width = agp_edges[i]['comp_stop']\n orien = agp_edges[i]['comp_orien']\n start = agp_edges[i]['scaf_start']\n stop = agp_edges[i]['scaf_stop']\n scaf = agp_edges[i]['scaf_name']\n G.add_node(agp_edges[i]['comp_name'], {'width':width, 'orien':orien, 'start':start, 'stop':stop,'scaf':scaf})\n\n # add edges.\n for i in range(agp_edges.size):\n\n # skip contigs themselves.\n if agp_edges[i]['comp_type'] != 'N': continue\n if i == agp_edges.shape[0] - 1: continue\n\n # add sorted edges.\n ctg1 = agp_edges[i-1]['comp_name']\n ctg2 = agp_edges[i+1]['comp_name']\n gap = agp_edges[i]['comp_stop']\n\n G.add_edge(ctg1, ctg2, {'gap':gap})\n\n # if RG is supplied ensure all contigs exist.\n if RG != None:\n for n in RG.nodes():\n if G.has_node(n) == False:\n G.add_node(n, RG.node[n])\n\n # done.\n return G\n\ndef _uconn_N50(RG, TG):\n \"\"\" calcultes UCONN N50s\"\"\"\n\n # flip TG to be most consistent with RG.\n TG = _dag_flip(RG, TG)\n\n # calculate teh TPN50\n min_size = 1\n WG_REFN50 = _calculate_n50(RG, gap=True, min_size=min_size)\n NG_REFN50 = _calculate_n50(RG, gap=False, min_size=min_size)\n\n # calculate reported n50\n WG_N50 = _calculate_n50(TG, gap=True, min_size=min_size)\n NG_N50 = _calculate_n50(TG, gap=False, min_size=min_size)\n\n # remove edges not in TG.\n TG = _remove_difference(RG, TG)\n\n # calculate teh TPN50\n WG_TPN50 = _calculate_n50(TG, gap=True, min_size=min_size)\n NG_TPN50 = _calculate_n50(TG, gap=False, min_size=min_size)\n\n # yield results.\n return WG_N50, WG_TPN50, TG\n\ndef _compute_formula(true_adj, test_adj, n):\n ''' computes statistics when TG is already oriented. This\n method computes A and B exactly, but uses formulas\n to find C and D.'''\n\n # set vars.\n m = len(true_adj)\n N = n * (n-1)\n\n # compute the A statistic set.\n A = true_adj.intersection(test_adj)\n\n # compute the B statistic set.\n B = test_adj.difference(true_adj)\n\n # compute the C statistic set.\n C = m - len(A)\n\n # compute the D statistic set.\n D = N - m - len(B)\n\n # return categories.\n return len(A), len(B), C, D, A\n\n\ndef _gap_deviation(RG, TG):\n ''' calculate MAPE '''\n\n # find true edges.\n radj = set(RG.edges())\n tadj = set(TG.edges())\n edges = tadj.intersection(radj)\n\n # calculate MAPE.\n s = 0.0\n for e0, e1 in edges:\n At = RG[e0][e1]['gap']\n Ft = TG[e0][e1]['gap']\n if At != 0.0:\n s += abs(float(At - Ft) / float(At))\n\n # return it.\n try:\n return (100.0 / float(len(edges))) * s\n except:\n return -1.0\n\ndef _get_runtime(agp_file):\n\n # read in agp.\n fin = open(agp_file, \"rb\")\n lines = fin.readlines()\n fin.close()\n\n if len(lines) == 0:\n return -1.0\n\n if lines[-1].count(\"RUNTIME\") == 0:\n return -1.0\n\n # parse last line.\n tmp = lines[-1].strip().split()\n\n return float(tmp[1])\n\n\ndef _sanity_check(RG, TG, A, B, C, D):\n ''' make sure these parameter make sense '''\n\n # set vars.\n n = RG.number_of_nodes()\n m = RG.number_of_edges()\n N = n * (n-1)\n\n # run check 1: m = A + C.\n check1 = m == A + C\n\n # run check 2: N - m = B + D.\n check2 = N - m == B + D\n\n # run report.\n fail = False\n\n if check1 == False:\n logging.error(\"failed check 1: m = A + C, %i = %i + %i: %i\" % (m, A, C, m == A + C))\n fail = True\n\n if check2 == False:\n logging.error(\"failed check 2: N-m = B + D, %i - %i = %i + %i: %i\" % (N, m, B, D, N-m==B+D))\n fail = True\n\n if fail == True:\n sys.exit()\n\n\ndef _dag_flip(RG, TG):\n ''' flip to make most consistant '''\n\n # check it.\n _graph_check(RG)\n _graph_check(TG)\n\n # make set of reference.\n rset = set(RG.edges())\n\n # loop over each component.\n NG = nx.DiGraph()\n for comp in nx.weakly_connected_components(TG):\n\n # turn to subgraph.\n subg = TG.subgraph(comp)\n\n # make sets.\n tset1 = set(subg.edges())\n tset2 = set([(e1, e0) for e0, e1 in tset1])\n\n # check version.\n s1 = len(rset.intersection(tset1))\n s2 = len(rset.intersection(tset2))\n\n # add to nodes to new graph.\n for n in subg.nodes():\n NG.add_node(n, subg.node[n])\n\n # add the best matching orientation.\n for e0, e1 in subg.edges():\n if s1 >= s2:\n NG.add_edge(e0, e1, subg[e0][e1])\n else:\n NG.add_edge(e1, e0, subg[e0][e1])\n\n # return it.\n return NG\n\ndef _graph_check(G):\n ''' makes sure its linear and a DAG '''\n\n # path check.\n for n in G.nodes():\n if G.number_of_edges(n) > 2:\n logging.error(\"bad scaffold graph 1 \")\n sys.exit(1)\n\n # DAG check.\n if nx.is_directed_acyclic_graph(G) == False:\n logging.error(\"bad scaffold graph 2\")\n sys.exit(1)\n\ndef _calculate_n50(G, min_size=False, gap=False):\n ''' calculates scaffold N50 given scaffold graph'''\n\n # compute the scaffold sizes.\n sizes = _calc_sizes(G, min_size,gap)\n\n # calculate n50.\n sizes.sort(reverse = True)\n s = sum(sizes)\n limit = s * 0.5\n for l in sizes:\n s -= l\n if s <= limit:\n return int(l)\n \ndef _fasta_n50(fasta_file, min_size=False, gap=False):\n ''' calculates scaffold N50 given fasta file'''\n\n # load fasta.\n seqs = _load_fasta(fasta_file)\n\n # compute the scaffold sizes.\n sizes = [len(seqs[x]) for x in seqs]\n\n # calculate n50.\n sizes.sort(reverse = True)\n s = sum(sizes)\n limit = s * 0.5\n for l in sizes:\n s -= l\n if s <= limit:\n return int(l)\n\n\ndef _calc_sizes(G, min_size, gap, scaf_only=False):\n sizes = list()\n for comp in nx.weakly_connected_components(G):\n\n # skip non scaffolds.\n if scaf_only == True:\n if len(comp) < 2:\n continue\n\n # add contig size.\n size = 0\n for n in comp:\n size += G.node[n]['width']\n\n # add gap size.\n if gap != False:\n for p,q in G.edges(comp):\n size += G[p][q]['gap']\n\n # skip this.\n if min_size != False and size < min_size:\n continue\n\n # save the size.\n sizes.append(size)\n return sizes\n\n\ndef _calc_counts(G, min_size, gap, scaf_only=False):\n sizes = list()\n for comp in nx.weakly_connected_components(G):\n\n # skip non scaffolds.\n if scaf_only == True:\n if len(comp) < 2:\n continue\n\n # add contig size.\n size = 0\n for n in comp:\n size += G.node[n]['width']\n\n # add gap size.\n if gap != False:\n for p,q in G.edges(comp):\n size += G[p][q]['gap']\n\n # skip this.\n if min_size != False and size < min_size:\n continue\n\n # save the size.\n sizes.append(len(comp))\n\n return sizes\n\ndef _remove_difference(RG, TG):\n ''' removes edges not in RG'''\n\n # make edge sets.\n rset = set(RG.edges())\n tset = set(TG.edges())\n\n # identify edges in test that shouldn't be there\n to_remove = tset.difference(rset)\n\n # remove them.\n TG.remove_edges_from(to_remove)\n\n # return modified graph.\n return TG\n\ndef _load_fasta(file_path):\n ''' loads fasta file into dictionary'''\n\n # read file into memory.\n fin = open(file_path)\n lines = fin.readlines()\n fin.close()\n\n # build dictionary.\n data = dict()\n seq = \"\"\n for line in lines:\n\n # Skip blanks.\n if len(line) < 2: continue\n if line[0] == \"#\": continue\n\n # remove blanks.\n line = line.strip()\n\n # Check for ids.\n if line.count(\">\") > 0:\n\n # Check if ending seq.\n if len(seq) > 0:\n\n # save.\n data[head] = seq.upper()\n\n # reset head.\n head = line.replace(\">\",\"\")\n seq = \"\"\n\n # skip to next line.\n continue\n\n # Filter chars.\n seq += line\n\n # save the last one.\n data[head] = seq.upper()\n\n # return dictionary.\n return data\n\n### public functions ###\n\ndef simulation_evaluation(ref_fasta, ctg_fasta, scf_fasta, ref_agp, scf_agp):\n \"\"\" evaluates the simulated dataset \"\"\"\n\n # load the reference and test graph from AGP files.\n RG = _agp_graph(ref_agp)\n TG = _agp_graph(scf_agp, RG=RG)\n\n # calculate referece and ctg n50/\n ref_N50 = _fasta_n50(ref_fasta, gap=True)\n ctg_N50 = _fasta_n50(ctg_fasta, gap=True)\n scf_N50 = _fasta_n50(scf_fasta, gap=True)\n\n # ensure we have all contigs accounted for.\n assert set(TG.nodes()) == set(RG.nodes()),\\\n 'not all contigs accounted for'\n\n # compute the exact N50\n scf_N50_2, tp_N50, LG = _uconn_N50(RG, TG)\n\n # make edge sets.\n radj = set(RG.edges())\n tadj = set(TG.edges())\n\n # calculate 4 parameters.\n n = RG.number_of_nodes()\n A, B, C, D, A_SET = _compute_formula(radj, tadj, n)\n\n # compute derivativ stats.\n sensitivity = (100*(float(A) / float(A+C)))\n ppv = (100*(float(A) / float(A+B)))\n if float(math.sqrt((A+B)*(A+C)*(D+B)*(D+C))) != 0.0:\n mcc = (100*(float((A*D)-(B*C)) / float(math.sqrt((A+B)*(A+C)*(D+B)*(D+C)))))\n else:\n mcc = 0.0\n\n # get gap deviation.\n gap_dev = _gap_deviation(RG, TG)\n\n # get the runtime.\n runtime = _get_runtime(scf_agp)\n\n # print results.\n # A B C D gapMape runtime sensitivity ppv mcc REFN50 TPN50 REPN50\n return A, B, C, D, ppv, mcc, gap_dev, runtime, ref_N50, ctg_N50, scf_N50, tp_N50\n\n\n\ndef quast_evaluation(ref, ctgs, scf, sdir, threads):\n\n # note that we are running it.\n logging.info(\"running quast %s %s %s\" % (ref, ctgs, scf))\n\n # run the comparison script.\n x = ref.split(\"/\")\n #z = '/'.join(x[0:-1] + [\"genes.gff\"])\n\n cmd = [\\\n 'python',\\\n '/opt/quast/quast.py',\\\n \"-e\",\n \"-f\",\n # \"-G\", z,\\\n \"-o\", \"./\",\\\n \"-R\", ref,\\\n \"-T\", str(threads),\\\n scf\\\n ]\n\n '''\n # remove dir.\n if os.path.isdir(sdir) == True:\n subprocess.call([\"rm\", \"-rf\", sdir])\n\n # make dir.\n if os.path.isdir(sdir) == False:\n subprocess.call(['mkdir', '-p', sdir])\n\n # make log file.\n lfile = \"%s/log.txt\" % sdir\n\n # capture output.\n with open(lfile, 'w') as fout:\n #if subprocess.call(cmd, stdout=fout, stderr=fout, cwd=sdir) != 0:\n if subprocess.call(cmd, cwd=sdir) != 0:\n logging.error('error running quast')\n return -1, -1\n '''\n # open the output.\n with open(\"%s/report.tsv\" % sdir) as fin:\n results = fin.readlines()\n tmp = list()\n for result in results:\n tmp.append(result.strip())\n results = tmp\n\n # extract results.\n lbls = list()\n res1 = list()\n res2 = list()\n cnt = 0\n for x in results:\n tmp = x.split(\"\\t\")\n lbls.append(tmp[0])\n res1.append(tmp[1])\n #res2.append(tmp[2])\n res2.append(\"\")\n #print cnt, tmp\n cnt += 1\n\n res = np.array([lbls,res1,res2])\n\n return res\n"},{"alpha_fraction":0.6042157411575317,"alphanum_fraction":0.6186079382896423,"avg_line_length":40.2152214050293,"blob_id":"48689949114dc873eecf41293abc4fd75d21d7a3","content_id":"4183ebc78fad20ceccd2fc1d6a3f8427a87a7c28","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":15703,"license_type":"permissive","max_line_length":159,"num_lines":381,"path":"/scafathon.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"#!/usr/bin/python\n'''\nstandalone adapter for scripts outside of the directory structure.\n'''\n### imports ###\n\n# system\nimport time\nimport subprocess\nimport warnings\nimport argparse\nimport logging\nimport time\nimport sys\nimport os\nimport numpy as np\n\nlogging.basicConfig(level=logging.DEBUG, format='[%(levelname)s] %(message)s', )\n\n# local\nfrom utils.align import create_idx, create_aln, pair_sam, pair_sam2\nfrom utils.prep import prep_silp, prep_opera, prep_mip\nfrom utils.run import run_silp, run_opera, run_mip\nfrom utils.eval import simulation_evaluation, quast_evaluation\n\n# hack to silence argparser.\nwarnings.filterwarnings('ignore', category=DeprecationWarning)\n\n### classes ###\n\n### functions ###\n\ndef align(args):\n ''' aligns reads against reference '''\n\n # validate parameters.\n assert os.path.isdir(args.base_dir), 'base_dir'\n assert os.path.isfile(args.ctg_fasta), 'ctg_fasta'\n assert os.path.isfile(args.read1_fastq), 'read1_fastq'\n assert os.path.isfile(args.read2_fastq), 'read2_fastq'\n assert os.path.isfile(args.size_file), 'size_file'\n\n # relavent files.\n base_dir = os.path.abspath(args.base_dir)\n\n size_file = os.path.abspath(args.size_file)\n ctg_fasta = os.path.abspath(args.ctg_fasta)\n read1_fastq = os.path.abspath(args.read1_fastq)\n read2_fastq = os.path.abspath(args.read2_fastq)\n\n tmp1_sam = os.path.abspath('%s/tmp1.sam' % base_dir)\n tmp2_sam = os.path.abspath('%s/tmp2.sam' % base_dir)\n\n read1_sam = os.path.abspath('%s/read1.sam' % base_dir)\n read2_sam = os.path.abspath('%s/read2.sam' % base_dir)\n\n ant_dir = '%s/ant' % base_dir\n idx_dir = '%s/index' % base_dir\n idx_file = '%s/index' % idx_dir\n\n # build index if not present.\n if os.path.isdir(idx_dir) == False:\n subprocess.call([\"mkdir\", \"-p\", idx_dir])\n create_idx(ctg_fasta, idx_file)\n\n # remove annotation dir if present.\n if os.path.isdir(ant_dir) == True:\n subprocess.call([\"rm\", \"-rf\", ant_dir])\n subprocess.call([\"mkdir\", \"-p\", ant_dir])\n\n # perform alignment.\n create_aln(size_file, idx_file, read1_fastq, tmp1_sam, ant_dir, args.num_cpu)\n create_aln(size_file, idx_file, read2_fastq, tmp2_sam, ant_dir, args.num_cpu)\n\n # pair the alignment.\n pair_sam2(tmp1_sam, tmp2_sam, read1_sam, read2_sam, args.key_size)\n\ndef pair(args):\n ''' pairs two same files '''\n\n # validate parameters.\n assert os.path.isdir(args.base_dir), 'base_dir'\n assert os.path.isfile(args.tmp1_sam), 'tmp1_sam'\n assert os.path.isfile(args.tmp2_sam), 'tmp2_sam'\n\n # relavent files.\n base_dir = os.path.abspath(args.base_dir)\n tmp1_sam = os.path.abspath(args.tmp1_sam)\n tmp2_sam = os.path.abspath(args.tmp2_sam)\n read1_sam = os.path.abspath('%s/read1.sam' % base_dir)\n read2_sam = os.path.abspath('%s/read2.sam' % base_dir)\n\n # pair the alignment.\n pair_sam2(tmp1_sam, tmp2_sam, read1_sam, read2_sam, args.key_size)\n\ndef meta_combine(args):\n \"\"\" combines two seperate alignments\"\"\"\n\n # validate parameters.\n assert os.path.isdir(args.base_dir), 'base_dir'\n assert os.path.isdir(args.work1_dir), 'w1_dir'\n assert os.path.isdir(args.work2_dir), 'w2_dir'\n\n # switch based on subset.\n if args.subsample == None:\n\n # combine reads.\n with open(\"%s/read1.sam\" % args.base_dir, \"wb\") as fout:\n subprocess.call([\"cat\",\"%s/read1.sam\" % args.work1_dir, \"%s/read1.sam\" % args.work2_dir], stdout=fout)\n\n with open(\"%s/read2.sam\" % args.base_dir, \"wb\") as fout:\n subprocess.call([\"cat\",\"%s/read2.sam\" % args.work1_dir, \"%s/read2.sam\" % args.work2_dir], stdout=fout)\n\n else:\n\n # count number of lines.\n cnt = 0\n with open(\"%s/read1.sam\" % args.work1_dir, \"r\") as fin:\n for line in fin:\n cnt += 1\n \n # only output a percentage of them.\n outp = float(cnt) * float(args.subsample)\n \n # first one.\n with open(\"%s/read1.sam\" % args.base_dir, \"wb\") as fout:\n cnt = 0\n with open(\"%s/read1.sam\" % args.work1_dir, \"r\") as fin:\n for line in fin:\n if cnt > outp: break\n fout.write(line)\n cnt += 1\n with open(\"%s/read1.sam\" % args.work2_dir, \"r\") as fin:\n for line in fin:\n fout.write(line)\n \n # second one.\n with open(\"%s/read2.sam\" % args.base_dir, \"wb\") as fout:\n cnt = 0\n with open(\"%s/read2.sam\" % args.work1_dir, \"r\") as fin:\n for line in fin:\n if cnt > outp: break\n fout.write(line)\n cnt += 1\n with open(\"%s/read2.sam\" % args.work2_dir, \"r\") as fin:\n for line in fin:\n fout.write(line)\n\n # copy one annotation.\n subprocess.call([\"cp\", \"%s/ant\" % args.work1_dir, \"%s/ant\" % args.base_dir, \"-R\"])\n subprocess.call([\"chmod\", \"u+w\", \"%s/ant\" % args.base_dir, \"-R\"])\n\n # combine the rest.\n tmp1_dir = \"%s/ant\" % args.base_dir\n tmp2_dir = \"%s/ant\" % args.work2_dir\n for x in os.listdir(tmp2_dir):\n\n # simplify.\n tmp1_x = \"%s/%s\" % (tmp1_dir,x)\n tmp2_x = \"%s/%s\" % (tmp2_dir,x)\n \n # copy it if no problem.\n if os.path.isfile(tmp1_x) == False:\n subprocess.call([\"cp\", tmp2_x, tmp1_x])\n\n else:\n # combine it.\n tmp1_n = np.load(tmp1_x)\n tmp2_n = np.load(tmp2_x)\n np.save(tmp1_x, tmp1_n+tmp2_n)\n\ndef prepare(args):\n \"\"\" prepares alignment given scaffolding method\"\"\"\n\n # extract information.\n work_dir = os.path.abspath(args.base_dir)\n align_dir = os.path.abspath(args.align_dir)\n ant_dir = '%s/ant' % align_dir\n\n read1_sam = '%s/read1.sam' % align_dir\n read2_sam = '%s/read2.sam' % align_dir\n ctg_fasta = os.path.abspath(args.ctg_fasta)\n prep_sh = '%s/prep.sh' % work_dir\n\n # translate pairmode.\n if args.pair_mode == 0:\n pair_mode = 'ff'\n elif args.pair_mode == 1:\n pair_mode = 'fr'\n elif args.pair_mode == 2:\n pair_mode = 'rf'\n\n # run the right prepare.\n cmd_args = (work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, args.ins_size, args.std_dev, args.bundle_size, pair_mode, args)\n if args.meth_mode == 0:\n prep_silp(*cmd_args)\n elif args.meth_mode == 1:\n prep_opera(*cmd_args)\n elif args.meth_mode == 2:\n prep_mip(*cmd_args)\n\n\ndef run(args):\n \"\"\" extracts information for scaffolding\"\"\"\n\n # extract information.\n work_dir = os.path.abspath(args.base_dir)\n align_dir = os.path.abspath(args.align_dir)\n ant_dir = '%s/ant' % align_dir\n\n read1_sam = '%s/read1.sam' % align_dir\n read2_sam = '%s/read2.sam' % align_dir\n ctg_fasta = os.path.abspath(args.ctg_fasta)\n ctg_agp = '%s/scf.agp' % work_dir\n scf_fasta = '%s/scf.fasta' % work_dir\n run_sh = '%s/run.sh' % work_dir\n\n # translate pairmode.\n if args.pair_mode == 0:\n pair_mode = 'ff'\n elif args.pair_mode == 1:\n pair_mode = 'fr'\n elif args.pair_mode == 2:\n pair_mode = 'rf'\n\n # run the right prepare.\n cmd_args = (work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, args.ins_size, args.std_dev, args.bundle_size, pair_mode, args)\n if args.meth_mode == 0:\n run_silp(*cmd_args)\n elif args.meth_mode == 1:\n run_opera(*cmd_args)\n elif args.meth_mode == 2:\n run_mip(*cmd_args)\n\ndef sim_eval(args):\n \"\"\"evaluates scaffold\"\"\"\n\n # simplify data.\n ref_fasta = os.path.abspath(args.ref_fasta)\n ctg_fasta = os.path.abspath(args.ctg_fasta)\n scf_fasta = os.path.abspath(args.scf_fasta)\n ref_agp = os.path.abspath(args.ref_agp)\n scf_agp = os.path.abspath(args.scf_agp)\n\n # call evaluation code.\n A, B, C, D, ppv, mcc, gap_dev, runtime, ref_N50, ctg_N50, scf_N50, tp_N50 = simulation_evaluation(ref_fasta, ctg_fasta, scf_fasta, ref_agp, scf_agp)\n\n # format and return.\n txt = list()\n txt.append('%d %d %d %d' % (A, B, C, D))\n txt.append('%.2f %.2f' % (ppv, mcc))\n txt.append('%.2f %.2f' % (gap_dev, runtime))\n txt.append('%d %d %d %d' % (ref_N50, ctg_N50, scf_N50, tp_N50))\n print ' '.join(txt)\n\ndef real_eval(args):\n \"\"\"evaluates scaffold using alignme\"\"\"\n\n # simplify data.\n ref_fasta = os.path.abspath(args.ref_fasta)\n ctg_fasta = os.path.abspath(args.ctg_fasta)\n scf_fasta = os.path.abspath(args.scf_fasta)\n #ref_agp = os.path.abspath(args.ref_agp)\n #scf_agp = os.path.abspath(args.scf_agp)\n\n # call quast\n res = quast_evaluation(ref_fasta, ctg_fasta, scf_fasta, args.wd, args.threads)\n\n\n # quast specific.\n try: N50 = int(float(res[1,np.where(res[0,:] == \"N50\")[0][0]]))\n except: N50 = 0\n try: NG50 = int(float(res[1,np.where(res[0,:] == \"NG50\")[0][0]]))\n except: NG50 = 0\n try: GFRAC = float(res[1,np.where(res[0,:] == \"Genome fraction (%)\")[0][0]])\n except: GFRAC = 0.0\n try: NA50 = int(float(res[1,np.where(res[0,:] == \"NA50\")[0][0]]))\n except: NA50 = 0\n try: NGA50 = int(float(res[1,np.where(res[0,:] == \"NGA50\")[0][0]]))\n except: NGA50 = 0\n\n # format and return.\n txt = list()\n txt.append(\"%d %d %.2f %d %d\" % (N50, NG50, GFRAC, NA50, NGA50))\n\n print ' '.join(txt)\n\n### script ###\n\nif __name__ == '__main__':\n\n # mode parser.\n main_p = argparse.ArgumentParser()\n subp = main_p.add_subparsers(help='sub-command help')\n\n ### data preparation ###\n # import reference into working directory.\n subp_p = subp.add_parser('align', help='aligns reads against contigs.')\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\n subp_p.add_argument('-p', dest='num_cpu', type=int, required=True, help='number of threads for bowtie2')\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\n subp_p.add_argument('-q1', dest='read1_fastq', required=True, help='read first file')\n subp_p.add_argument('-q2', dest='read2_fastq', required=True, help='read second file')\n subp_p.add_argument('-s', dest='size_file', required=True, help='size file')\n subp_p.add_argument('-k', dest='key_size', type=int, required=True, help='size of PE key at end of each read')\n subp_p.set_defaults(func=align)\n\n subp_p = subp.add_parser('pair', help='pairs 2 SAM files')\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\n subp_p.add_argument('-s1', dest='tmp1_sam', required=True, help='read first file')\n subp_p.add_argument('-s2', dest='tmp2_sam', required=True, help='read second file')\n subp_p.add_argument('-k', dest='key_size', type=int, required=True, help='size of PE key at end of each read')\n subp_p.set_defaults(func=pair)\n\n # combines two seperate alignments.\n subp_p = subp.add_parser('meta_combine', help='combines two seperate alignments. Used for meta scaffold testing.')\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\n subp_p.add_argument('-w1', dest='work1_dir', required=True, help='working directory')\n subp_p.add_argument('-w2', dest='work2_dir', required=True, help='working directory')\n subp_p.add_argument('-s', dest='subsample', type=float, required=False, help='subsample first directory')\n subp_p.set_defaults(func=meta_combine)\n\n # prepare the reference for scaffolding.\n subp_p = subp.add_parser('prep', help='runs pre-processing stage.')\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\n subp_p.add_argument('-w', dest='base_dir', required=True, help='scaffolding directory')\n subp_p.add_argument('-a', dest='align_dir', required=True, help='alignment directory')\n subp_p.add_argument('-i', dest='ins_size', type=int, required=True, help='insert size')\n subp_p.add_argument('-s', dest='std_dev', type=int, required=True, help='std_devition')\n subp_p.add_argument('-b', dest='bundle_size', type=int, required=True, help='bundle size')\n me_g = subp_p.add_mutually_exclusive_group(required=True)\n me_g.add_argument('-ff', dest='pair_mode', action='store_const', const=0, help='SOLiD style -> ->')\n me_g.add_argument('-fr', dest='pair_mode', action='store_const', const=1, help='innie style -> <-')\n me_g.add_argument('-rf', dest='pair_mode', action='store_const', const=2, help='outtie style <- ->')\n me_g = subp_p.add_mutually_exclusive_group(required=True)\n me_g.add_argument('-silp', dest='meth_mode', action='store_const', const=0, help='SILP')\n me_g.add_argument('-opera', dest='meth_mode', action='store_const', const=1, help='OPERA')\n me_g.add_argument('-mip', dest='meth_mode', action='store_const', const=2, help='MIP')\n subp_p.set_defaults(func=prepare)\n\n # run the scaffolding.\n subp_p = subp.add_parser('run', help='runs the actual scaffolding')\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\n subp_p.add_argument('-w', dest='base_dir', required=True, help='scaffolding directory')\n subp_p.add_argument('-a', dest='align_dir', required=True, help='alignment directory')\n subp_p.add_argument('-i', dest='ins_size', type=int, required=True, help='insert size')\n subp_p.add_argument('-s', dest='std_dev', type=int, required=True, help='std_devition')\n subp_p.add_argument('-b', dest='bundle_size', type=int, required=True, help='bundle size')\n me_g = subp_p.add_mutually_exclusive_group(required=True)\n me_g.add_argument('-ff', dest='pair_mode', action='store_const', const=0, help='SOLiD style -> ->')\n me_g.add_argument('-fr', dest='pair_mode', action='store_const', const=1, help='innie style -> <-')\n me_g.add_argument('-rf', dest='pair_mode', action='store_const', const=2, help='outtie style <- ->')\n me_g = subp_p.add_mutually_exclusive_group(required=True)\n me_g.add_argument('-silp', dest='meth_mode', action='store_const', const=0, help='SILP')\n me_g.add_argument('-opera', dest='meth_mode', action='store_const', const=1, help='OPERA')\n me_g.add_argument('-mip', dest='meth_mode', action='store_const', const=2, help='MIP')\n # SILP2 arguments.\n subp_p.add_argument('-z', dest='weight_mode', type=int, default=0, help='SILP2: weight mode')\n subp_p.set_defaults(func=run)\n\n # evaluate the scaffolding.\n subp_p = subp.add_parser('sim_eval', help='evaluates scaffolding if there is a true AGP')\n subp_p.add_argument('-r', dest='ref_fasta', required=True, help='reference fasta')\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\n subp_p.add_argument('-s', dest='scf_fasta', required=True, help='scaffold fasta')\n subp_p.add_argument('-a', dest='ref_agp', required=True, help='reference agp')\n subp_p.add_argument('-y', dest='scf_agp', required=True, help='predicted agp')\n subp_p.set_defaults(func=sim_eval)\n\n # evaluate the scaffolding.\n subp_p = subp.add_parser('real_eval', help='alignment based scaffold evaluation.')\n subp_p.add_argument('-r', dest='ref_fasta', required=True, help='reference fasta')\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\n subp_p.add_argument('-s', dest='scf_fasta', required=True, help='scaffold fasta')\n subp_p.add_argument('-y', dest='scf_agp', required=True, help='predicted agp')\n subp_p.add_argument('-wd', dest='wd', required=True, help='alignment working directory')\n subp_p.add_argument('-p', dest='threads', type=int, required=True, help='number of threads to align')\n subp_p.set_defaults(func=real_eval)\n\n args = main_p.parse_args()\n args.func(args)\n"},{"alpha_fraction":0.492044597864151,"alphanum_fraction":0.5010282397270203,"avg_line_length":28.996753692626953,"blob_id":"4b73b226cb70b797a4d76f19ced2424522dc0848","content_id":"7c8f300d3e7e1ca4a613c8ea4663795fedce5b01","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":9239,"license_type":"permissive","max_line_length":143,"num_lines":308,"path":"/utils/run.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"'''\ndrivers to prepare the data for scaffolding\n'''\nimport subprocess\nimport os\nimport time\nimport numpy as np\n\nfrom utils.misc import *\n\n## private functions ##\n\n## public functions ##\ndef run_silp(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \"\"\" SILP scaffolder \"\"\"\n\n # create command base.\n cmd_base = ['python', '/home/jrl03001/code/SILP2/silp.py']\n\n # scaffolding/\n job = list()\n job.append('#!/bin/bash')\n job.append('# scaffolding')\n job.append('# start time')\n job.append('start=$(date +%s)')\n job.append('%s orient -w %s -z %s ' % (' '.join(cmd_base), work_dir, args.weight_mode))\n job.append('%s order -w %s ' % (' '.join(cmd_base), work_dir))\n job.append('%s gap -w %s ' % (' '.join(cmd_base), work_dir))\n job.append('%s write -w %s -a %s' % (' '.join(cmd_base), work_dir, ctg_agp))\n job.append('%s fasta -w %s -a %s -c %s -f %s' % (' '.join(cmd_base), work_dir, ctg_agp, ctg_fasta, scf_fasta))\n job.append('# stop time')\n job.append('stop=$(date +%s)')\n job.append('echo RUNTIME: $(expr $stop - $start) >> %s' % ctg_agp)\n job.append('')\n runit(job, run_sh)\n\n\ndef run_opera(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \"\"\" OPERA scaffolder \"\"\"\n\n # opera specific directories.\n input_dir = '%s/input' % work_dir\n results_dir = '%s/results' % work_dir\n script_dir = '%s/script' % work_dir\n output_dir = '%s/output' % work_dir\n log_dir = '%s/log' % work_dir\n for x in [input_dir, results_dir, script_dir, output_dir, log_dir]:\n create_dir(x)\n\n # opera sepecific files.\n edge_file = '%s/opera_raw.txt' % input_dir\n config_file = '%s/opera.cfg' % input_dir\n script_file = '%s/opera.sh' % input_dir\n tout_file = '%s/scaffolds.scaf' % results_dir\n tscf_file = '%s/scaffoldSeq.fasta' % results_dir\n log_file = '%s/opera.log' % log_dir\n\n # write execution script.\n job = list()\n job.append('#!/bin/bash')\n job.append('# scaffolding')\n job.append('# start time')\n job.append('start=$(date +%s)')\n job.append('# run the job')\n job.append('/opt/opera/bin/opera %s &> %s' % (config_file, log_file))\n job.append('# stop time')\n job.append('stop=$(date +%s)')\n job.append('echo RUNTIME: $(expr $stop - $start) >> %s' % ctg_agp)\n job.append('')\n runit(job, run_sh)\n\n # load results.\n fin = open(tout_file, \"rb\")\n lines = fin.readlines()\n fin.close()\n\n # load the runtime string.\n with open(ctg_agp, 'rb') as fin:\n time_info = fin.readline().strip()\n\n # create an AGP.\n fout = open(ctg_agp, \"wb\")\n for lidx in range(len(lines)):\n\n # setup line.\n line = lines[lidx]\n\n # check header.\n if line[0] == \">\":\n header = line.strip().replace(\">\",\"\").split()[0]\n #header = line.strip().replace(\">\",\"\")\n part = 1\n scaf_start = 1\n scaf_stop = 0\n continue\n\n # tokenize.\n tmp = line.strip().split()\n\n # get ctgid.\n ctgid = tmp[0]\n\n if tmp[1] == \"BE\":\n orien = \"+\"\n else:\n orien = \"-\"\n\n ctglen = int(tmp[2])\n gaplen = int(tmp[3])\n\n # make indexs.\n scaf_stop = scaf_start + ctglen\n\n # write out AGP.\n fout.write(\"%s\\t%i\\t%i\\t%i\\t%s\\t%s\\t%i\\t%i\\t%s\\n\" % \\\n (header, scaf_start, scaf_stop, part, \"W\", ctgid, 1, ctglen, orien))\n #print \"write\"\n # increment pointers.\n scaf_start = scaf_stop + 1\n part += 1\n\n # add gap if size is not 0\n if gaplen != 0:\n\n # make indexs.\n scaf_stop = scaf_start + gaplen\n\n # add gap.\n fout.write(\"%s\\t%i\\t%i\\t%i\\t%s\\t%i\\t%s\\t%s\\n\" % \\\n (header, scaf_start, scaf_stop, part, \"N\", gaplen, \"fragment\", \"no\"))\n #print \"write\"\n # increment pointers.\n scaf_start = scaf_stop + 1\n part += 1\n\n # otherwise.\n else:\n # check if we can peak.\n if lidx+1 >= len(lines):\n continue\n\n\n # check if new scaffold.\n if lines[lidx+1][0] != \">\":\n # make fake gap.\n scaf_stop = scaf_start + 10\n\n # add gap.\n fout.write(\"%s\\t%i\\t%i\\t%i\\t%s\\t%i\\t%s\\t%s\\n\" % \\\n (header, scaf_start, scaf_stop, part, \"N\", gaplen, \"fragment\", \"no\"))\n #print \"write\"\n # increment pointers.\n scaf_start = scaf_stop + 1\n part += 1\n continue\n\n # write the timer.\n fout.write(time_info + '\\n')\n\n # close AGP file.\n fout.close()\n\n # move the output files to standard locations.\n subprocess.call(['cp', tscf_file, scf_fasta])\n\n\ndef run_mip(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \n # simplify files.\n ant_dir = '/dev/null'\n\n contig_file = ctg_fasta\n test1 = read1_sam\n test2 = read2_sam\n \n # mip specific files.\n SAM_1_MOD = \"%s/sam_1.sam\" % work_dir\n SAM_2_MOD = \"%s/sam_2.sam\" % work_dir\n MERGED_FILE = \"%s/merged\" % work_dir\n MERGED1_FILE = \"%s/merged.sorted1\" % work_dir\n MERGED2_FILE = \"%s/merged.sorted2\" % work_dir\n FILTERED_FILE = \"%s/filtered.txt\" % work_dir\n COV_FILE = \"%s/coverage.txt\" % work_dir\n PARAM_FILE = \"%s/parameters.txt\" % work_dir\n MIP_FILE = \"%s/scaffolds2.txt\" % work_dir\n OUT_FILE = \"%s/scaffolds.fasta\" % work_dir\n\n \n # execute mip.\n tstart = time.time()\n cmd = list()\n cmd.append(\"/opt/mip/scripts/mip-scaffolder.pl\")\n cmd.append(PARAM_FILE)\n cmd.append(contig_file)\n cmd.append(COV_FILE)\n cmd.append(work_dir)\n \n with open(run_sh, \"wb\") as fout:\n fout.write('#!/bin/bash\\n')\n fout.write(' '.join(cmd) + '\\n')\n \n subprocess.call([\"chmod\", \"u+x\", run_sh])\n if subprocess.call([run_sh], cwd=work_dir) != 0:\n logging.warning(\"couldn't run mip\")\n sys.exit(1)\n tstop = time.time()\n \n # compute time.\n trun = tstop - tstart\n \n # load MIP results into dictionary.\n fin = open(MIP_FILE, \"rb\")\n lines = fin.readlines()\n fin.close()\n mip = {}\n for line in lines:\n \n # tokenize.\n tmp = line.split()\n \n # set current scaffold.\n if tmp[0].count(\"scaffold\") > 0:\n # set current.\n curs = tmp[0]\n \n # set default.\n mip[curs] = []\n continue\n \n # append.\n mip[curs].append(tmp)\n \n # count the number of rows for agp file.\n size = 0\n for scafid in mip:\n size += len(mip[scafid]) + len(mip[scafid]) - 1\n\n # allocate the array.\n agps = np.zeros(size, dtype=agp_dt)\n\n # begin copying data.\n idx = 0\n for scafid in mip:\n scaf_start = 1\n scaf_idx = 1\n for i in range(len(mip[scafid])):\n \n # tokenize.\n entry = mip[scafid][i]\n ctg_name = entry[1]\n if entry[2] == \"F\":\n orien = 0\n else:\n orien = 1\n start = int(entry[3])\n stop = int(entry[4])\n \n # add to agp.\n agps[idx]['scaf_name'] = scafid\n agps[idx]['scaf_start'] = scaf_start\n agps[idx]['scaf_stop'] = scaf_start + abs(stop - start)\n agps[idx]['scaf_idx'] = scaf_idx\n agps[idx]['comp_type'] = \"W\"\n agps[idx]['comp_name'] = ctg_name\n agps[idx]['comp_start'] = 1\n agps[idx]['comp_stop'] = abs(stop - start)\n agps[idx]['comp_orien'] = orien\n agps[idx]['comp_linkage'] = 0\n\n # move up counts.\n scaf_start = agps[idx]['scaf_stop'] + 1\n scaf_idx += 1\n idx += 1\n \n # do gap.\n if entry[1] != mip[scafid][-1][1]:\n \n # add gap.\n agps[idx]['scaf_name'] = scafid\n agps[idx]['scaf_start'] = scaf_start\n agps[idx]['scaf_stop'] = int(mip[scafid][i+1][3]) - 1\n agps[idx]['scaf_idx'] = scaf_idx\n agps[idx]['comp_type'] = \"N\"\n agps[idx]['comp_name'] = \"fragment\"\n agps[idx]['comp_start'] = 1\n agps[idx]['comp_stop'] = abs(agps[idx]['scaf_stop'] - agps[idx]['scaf_start'])\n agps[idx]['comp_orien'] = 0\n agps[idx]['comp_linkage'] = 0 \n \n # move up counts.\n scaf_start = int(mip[scafid][i+1][3])\n scaf_idx += 1\n idx += 1\n\n # copy results.\n subprocess.call(['cp', OUT_FILE, scf_fasta])\n\n # save the agp.\n save_agps(ctg_agp, agps)\n\n # add time.\n with open(ctg_agp, 'rb') as fin:\n lines = fin.read()\n lines += 'RUNTIME: %.2f' % trun\n with open(ctg_agp, 'wb') as fout:\n fout.write(lines)\n \n # move the results.\n"},{"alpha_fraction":0.5634479522705078,"alphanum_fraction":0.5879085659980774,"avg_line_length":28.347963333129883,"blob_id":"23fb19e71a1584efb496e8b0dceba6961f3c1cfb","content_id":"825f69eff1e75df7cb3760926609f855d9f39086","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":9362,"license_type":"permissive","max_line_length":167,"num_lines":319,"path":"/utils/prep.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"'''\ndrivers to prepare the data for scaffolding\n'''\nimport sys\nimport logging\nimport string\nimport subprocess\nimport os\n\nfrom utils.misc import *\n\n## private functions ##\n\n## public functions ##\ndef prep_silp(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \"\"\" SILP scaffolder \"\"\"\n\n # create command base.\n cmd_base = ['python', '/home/jrl03001/code/SILP2/silp.py']\n\n # preprocess.\n job = list()\n job.append('#!/bin/bash')\n job.append('# preprocess')\n job.append('%s nodes -w %s -c %s' % (' '.join(cmd_base), work_dir, ctg_fasta))\n job.append('%s edges -w %s -i %i -s %i -%s -s1 %s -s2 %s' %\n (' '.join(cmd_base), work_dir, ins_size, std_dev, pair_mode, read1_sam, read2_sam))\n job.append('%s bundles -w %s -b %i -p 90 -bup 1 -r %s -i %i -s %i' % (' '.join(cmd_base), work_dir, bundle_size, ant_dir, ins_size, std_dev))\n job.append('%s decompose -w %s -m 2500' % (' '.join(cmd_base), work_dir))\n job.append('')\n runit(job, prep_sh)\n\ndef prep_opera(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \"\"\" opera scaffolder \"\"\"\n\n # opera specific directories.\n input_dir = '%s/input' % work_dir\n results_dir = '%s/results' % work_dir\n script_dir = '%s/script' % work_dir\n output_dir = '%s/output' % work_dir\n log_dir = '%s/log' % work_dir\n for x in [input_dir, results_dir, script_dir, output_dir, log_dir]:\n create_dir(x)\n\n # opera sepecific files.\n edge_file = '%s/opera_raw.txt' % input_dir\n config_file = '%s/opera.cfg' % input_dir\n script_file = '%s/opera.sh' % input_dir\n tout_file = '%s/scaffolds.scaf' % results_dir\n log_file = '%s/opera.log' % log_dir\n\n # open pair of sam files.\n fin1 = open(read1_sam, \"rb\")\n fin2 = open(read2_sam, \"rb\")\n fout = open(edge_file, 'wb')\n\n # create the edge file from paired sam.\n idx = 1\n for line1 in fin1:\n line2 = fin2.readline()\n\n # skip headers.\n if line1[0] == \"@\" or line2[0] == \"@\":\n continue\n\n # tokenize.\n tokens1 = line1.strip().split(\"\\t\")\n tokens2 = line2.strip().split(\"\\t\")\n\n # get data.\n rname1 = tokens1[2]\n rname2 = tokens2[2]\n\n qname1 = tokens1[0]\n qname2 = tokens2[0]\n\n pos1 = int(tokens1[3])\n pos2 = int(tokens2[3])\n\n szseq1 = len(tokens1[9])\n szseq2 = len(tokens2[9])\n\n seq1 = tokens1[9]\n seq2 = tokens2[9]\n\n # prepare orientation.\n if tokens1[1] == \"0\":\n orien1 = \"+\"\n else:\n orien1 = \"-\"\n if tokens2[1] == \"0\":\n orien2 = \"+\"\n else:\n orien2 = \"-\"\n\n # save names.\n nm1 = \"%i.1\" % idx\n nm2 = \"%i.2\" % idx\n idx += 1\n\n # create txt.\n line1 = \"%s\\t%s\\t%s\\t%i\\t%s\\t%s\\t%s\\n\" % (nm1, orien1, rname1, pos1, tokens1[9], tokens1[10], \"0\")\n line2 = \"%s\\t%s\\t%s\\t%i\\t%s\\t%s\\t%s\\n\" % (nm2, orien2, rname2, pos2, tokens2[9], tokens2[10], \"0\")\n\n # write to file.\n fout.write(line1)\n fout.write(line2)\n\n # close up shop.\n fin1.close()\n fin2.close()\n fout.close()\n\n # prepare config script\n txt = \"\"\"#\n# Essential Parameters\n#\n\n# Please always supply absolute path of each file,\n# Because relative path may not work all the time.\n\n# Output folder for final results\noutput_folder=${opera_results_dir}\n\n# Contig file\ncontig_file=${opera_node_file}\n\n#----------------------------------------------------------------------------------------------\n# Advanced Parameters\n\n#\n# Scaffolding related parameters\n#\n\n# Scaffold name in result file\nscaffold_name=scaffold\n\n# PET cluster threshold (default=5) (Opera will discard all clusters\n\n# Should Opera abort when running time for specific subgraph is longer\n# than 30 minutes (true or false, default=true)\nabort=false\n\n#----------------------------------------------------------------------------------------------\n#\n# Contig file related parameters\n#\n\n# Format of contig file (fasta or statistic, default=fasta)\nfile_format=fasta\n\n# Program name generating contig file (velvet or soap, default=velvet)\nfile_type=velvet\n\n# Should the repeat contigs be filtered (yes or no, default=true)\nfilter_repeat=yes\n\n# Repeat threshold (default=1.5): If the coverage of a contig is higher than\n# (repeat threshold * average coverage), then it is considered as repeat\nrepeat_threshold=1.5\n\n# Contig size threshold (default=500): Opera will not use the contigs whose length\n# is shorter than this value\ncontig_size_threshold=10\n\n#----------------------------------------------------------------------------------------------\n#\n# Library parameters.\n#\n\n[LIB]\ncalculate_ori=no\nread_ori=in\nmap_type=bowtie\ncalculate_lib=no\nlib_mean=${lib_mean}\nlib_std=${lib_std}\ncluster_threshold=${pet_size}\nmap_file=${opera_edge_file}\n\"\"\"\n txt = string.Template(txt)\n txt = txt.substitute(opera_results_dir=results_dir, opera_node_file=ctg_fasta, opera_edge_file=edge_file, pet_size=bundle_size, lib_mean=ins_size, lib_std=std_dev)\n\n # write to file.\n fout = open(config_file, \"wb\")\n fout.write(txt)\n fout.close()\n\n\ndef prep_mip(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\n \"\"\" mip scaffolder \"\"\"\n\n # simplify files.\n ant_dir = '/dev/null'\n pre_sh = prep_sh\n\n contig_file = ctg_fasta\n test1 = read1_sam\n test2 = read2_sam\n \n # sanity.\n if os.path.isfile(test1) == False or os.path.isfile(test2) == False:\n logging.error(\"missing file:\")\n logging.error(test1)\n logging.error(test2)\n \n # mip specific files.\n SAM_1_MOD = \"%s/sam_1.sam\" % work_dir\n SAM_2_MOD = \"%s/sam_2.sam\" % work_dir\n MERGED_FILE = \"%s/merged\" % work_dir\n MERGED1_FILE = \"%s/merged.sorted1\" % work_dir\n MERGED2_FILE = \"%s/merged.sorted2\" % work_dir\n FILTERED_FILE = \"%s/filtered.txt\" % work_dir\n COV_FILE = \"%s/coverage.txt\" % work_dir\n PARAM_FILE = \"%s/parameters.txt\" % work_dir\n MIP_FILE = \"%s/scaffolds2.txt\" % work_dir\n\n # modify SAM file to be happy with MIP.\n fin1 = open(test1, \"rb\")\n fin2 = open(test2, \"rb\")\n fout1 = open(SAM_1_MOD, \"wb\")\n fout2 = open(SAM_2_MOD, \"wb\")\n for line1 in fin1:\n line2 = fin2.readline()\n \n # tokenize.\n tokens1 = line1.strip().split(\"\\t\")\n tokens2 = line2.strip().split(\"\\t\")\n \n # change naming convention.\n tokens1[0] = tokens1[0].replace(\"/1\",\"_R3\")\n tokens2[0] = tokens2[0].replace(\"/2\",\"_F3\")\n \n # modify orientation.\n if pair_mode == 'rf':\n if tokens1[1] == \"0\":\n tokens1[1] = \"16\"\n else:\n tokens1[1] = \"0\"\n else:\n print pair_mode\n logging.error('un-written')\n sys.exit(1)\n \n \n # write it back out.\n fout1.write('\\t'.join(tokens1) + '\\n')\n fout2.write('\\t'.join(tokens2) + '\\n')\n\n fin1.close() \n fin2.close() \n fout1.close() \n fout2.close() \n\n PROG_1 = \"/opt/mip/scripts/merge.sh\"\n PROG_2 = \"/opt/mip/scripts/filter-mappings.sh\"\n PROG_3 = \"/home/jrl03001/code/ScafValidate/mip/contig_coverage.py\"\n #'''\n # merge data.\n with open(pre_sh, 'wb') as fout:\n \n # prepare.\n fout.write('#!/bin/bash\\n')\n cmd = [PROG_1, SAM_2_MOD, SAM_1_MOD, MERGED_FILE]\n fout.write(' '.join(cmd) + '\\n')\n cmd = [PROG_2, MERGED1_FILE, MERGED2_FILE, FILTERED_FILE]\n fout.write(' '.join(cmd) + '\\n')\n cmd = [\"python\", PROG_3, contig_file, COV_FILE, SAM_1_MOD, SAM_2_MOD]\n fout.write(' '.join(cmd) + '\\n')\n \n # run it.\n subprocess.call([\"chmod\", \"u+x\", pre_sh])\n if subprocess.call([pre_sh], cwd=work_dir) != 0:\n logging.error(\"couldn't prepare MIP\")\n sys.exit(1)\n\n #'''\n # write the config.\n txt = '''# Upper bound for genome length (required)\ngenome_length=5000000000\n\n#parameter specifications for the first stage\n[STAGE]\n# Maximum biconnected component size. (optional)\n#maximum_biconnected_component=50\n# Maximum allowed degree in scaffolding graph. (optional)\nmaximum_degree=50\n# Maximum coverage for nonrepetitive contig. (optional)\n#maximum_coverage=100\n# The maximum overlap between contigs that is allowed without checking for\n# sequence similarity. By default this is set based on the variablility in\n# insert size lengths of each library. (optional)\n#maximum_overlap=100\n# The minimum support for an edge. (optional)\nminimum_support=%i\n# Should edges with negative estimated distance be checked for sequence\n# similarity or removed automatically? (optional)\ncheck_negative_edges=1\n\n# library specification for the first stage\n[LIBRARY]\n# File in SAM format containing mappings for the mate pair reads\n# to the contigs\nmappings=%s\n# Orientation of the mate pairs (in current version must be SOLID)\norientation=SOLID\n# Insert length\ninsert_length=%i\n# Minimum insert length\nmin_insert_length=%i\n# Maximum insert length\nmax_insert_length=%i\n''' % (bundle_size, FILTERED_FILE, ins_size, (ins_size - (3*std_dev)), (ins_size + (3*std_dev)))\n\n \n # write to file.\n fout = open(PARAM_FILE, \"wb\")\n fout.write(txt)\n fout.close()\n"},{"alpha_fraction":0.7733333110809326,"alphanum_fraction":0.7787878513336182,"avg_line_length":48.93939208984375,"blob_id":"e3a5c0f43aac28f5cb51851c0920604634639204","content_id":"14d1bf9b18bb635859d30bb1b62a69d27e2d9e97","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Markdown","length_bytes":1650,"license_type":"permissive","max_line_length":233,"num_lines":33,"path":"/README.md","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"scafathon\n=========\n\n**Genome scaffolding comparison framework**\n\n\n## Overview\nScafathon is just a collection of scripts used to evaluate three genome scaffolding tools; SILP2, OPERA and MIP. It should be easy to extend this framework to add more tools. It relies on Quast for alignment based accuracy assesment.\n\n***Warning: This code is only intended for use by professionals. Modification of the source code is required to set proper paths to external executables. Furthermore adding additional scaffolding tools requires manual coding.***\n\n## Usage\nThe tool is divided up into several sub-programs which need to be run in-order. Use the \"-h\" argument after each of the following sub-commands for a description of their usage.\n```python\npython silp.py [sub-command] -h\n```\n1. *align:* aligns the paired reads (required bowtie2) installed\n2. *pair:* pairs two existing SAM files\n3. *meta_combine:* combines two pairs of SAM files at different percentages [metagenomic simulations]\n4. *prep:* prepares selected scaffold algorithm by running all preprocessing code\n5. *run:* runs scaffolding tool\n6. *sim_eval:* evaluates scaffold if there exists a reference AGP with locations of each contig\n7. *real_eval:* uses alignment based accuracy metrics\n\n## Installation\nThis is primarily a python program, it relies on several python packages:\n* numpy\n* networkx\n\nAlso several seperate packages are required. These include nucmer, quast and [parabio](https://github.com/jim-bo/parabio).\n\n## Disclaimer\nThis is a research tool written in a research enviroment. No support is offered and bugs may be present. Only one library size is support at this time. \n\n"},{"alpha_fraction":0.4289953410625458,"alphanum_fraction":0.4340822398662567,"avg_line_length":25.505617141723633,"blob_id":"b981c7a67de36752d838201660e7edad35900281","content_id":"fd5e0fa3b08a8602cfa93f7b9fc56904188bc8a3","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":2359,"license_type":"permissive","max_line_length":67,"num_lines":89,"path":"/utils/misc.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"import subprocess\nimport os\nimport numpy as np\n\nagp_dt = np.dtype([\\\n ('scaf_name', 'S255'),\\\n ('scaf_start', np.long),\\\n ('scaf_stop', np.long),\\\n ('scaf_idx', np.long),\\\n ('comp_type', 'S50'),\\\n ('comp_name', 'S255'),\\\n ('comp_start', np.long),\\\n ('comp_stop', np.long),\\\n ('comp_orien', np.long),\\\n ('comp_linkage', np.long),\\\n])\n\n\ndef runit(job, path):\n \"\"\" runs the job \"\"\"\n with open(path, 'wb') as fout:\n fout.write('\\n'.join(job))\n subprocess.call(['chmod', 'a+x', path])\n subprocess.call(['bash', path])\n\ndef create_dir(dir_path):\n ''' creates directory if necessary'''\n if os.path.isdir(dir_path) == False:\n if subprocess.call([\"mkdir\", dir_path]) != 0:\n logging.error(\"couldn't make dir\")\n sys.exit(1)\n\n\n\ndef save_agps(agp_file, agp):\n ''' saves agp to disk.'''\n\n # write to file.\n fout = open(agp_file, \"w\")\n\n # write each entry.\n z = len(agp_dt.names)\n for i in range(agp.size):\n\n # sanity skip.\n if agp[i]['scaf_name'] == \"\":\n continue\n\n # format result.\n tmp = agp[i]\n if tmp['comp_type'] == \"W\":\n # get orientation.\n if tmp[\"comp_orien\"] == 0:\n o = \"+\"\n else:\n o = \"-\"\n\n # write contig.\n txt = str(tmp['scaf_name']) + \"\\t\"\n txt += str(tmp['scaf_start']) + \"\\t\"\n txt += str(tmp['scaf_stop']) + \"\\t\"\n txt += str(tmp['scaf_idx']) + \"\\t\"\n txt += str(tmp['comp_type']) + \"\\t\"\n txt += str(tmp['comp_name']) + \"\\t\"\n txt += str(tmp['comp_start']) + \"\\t\"\n txt += str(tmp['comp_stop']) + \"\\t\"\n txt += o + \"\\n\"\n\n else:\n # get linkage.\n if tmp['comp_linkage'] == 0:\n o = \"no\"\n else:\n o = \"yes\"\n\n # write gap.\n txt = str(tmp['scaf_name']) + \"\\t\"\n txt += str(tmp['scaf_start']) + \"\\t\"\n txt += str(tmp['scaf_stop']) + \"\\t\"\n txt += str(tmp['scaf_idx']) + \"\\t\"\n txt += str(tmp['comp_type']) + \"\\t\"\n txt += str(tmp['comp_stop'] - tmp['comp_start']) + \"\\t\"\n txt += str(tmp['comp_name']) + \"\\t\"\n txt += o + \"\\n\"\n\n fout.write(txt)\n\n # close file.\n fout.close()\n"},{"alpha_fraction":0.5159717202186584,"alphanum_fraction":0.5442575216293335,"avg_line_length":23.1235294342041,"blob_id":"b480607bf84c02ee5083aaa1ddb0970b00cae73c","content_id":"d0f3285b47682ee4eb2c1e9f9ed79e596c539994","detected_licenses":["MIT"],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":8202,"license_type":"permissive","max_line_length":105,"num_lines":340,"path":"/utils/align.py","repo_name":"jim-bo/scafathon","src_encoding":"UTF-8","text":"'''\nalignment utility functions\n'''\nimport os\nimport sys\nimport subprocess\nimport logging\nimport mmap\nfrom operator import itemgetter\nimport numpy as np\n\n## public functions ##\ndef create_idx(asm_fasta, index_file):\n \"\"\" make bowtie2 index\n Parameters:\n -----------\n asm_fasta : str\n index_file : str\n \"\"\"\n\n # run the command.\n subprocess.call(['bowtie2-build', '-f', asm_fasta, index_file])\n\ndef create_aln(size_file, index_file, fastq_file, sam_file, ant_dir, num_cpu):\n \"\"\" make bowtie2 alignment and\n pull out multimappers/\n Parameters:\n -----------\n index_file : str\n fastq_file : str\n \"\"\"\n\n # create sizes.\n sizes = dict()\n with open(size_file, \"rb\") as fin:\n lines = fin.readlines()\n for line in lines:\n sz, name = line.strip().split()\n sz = int(sz)\n sizes[name] = sz\n\n # create the annotation arrays.\n annotes = dict()\n for ref in sizes:\n annotes[ref] = np.zeros(sizes[ref], dtype=np.int)\n\n # create alignment command.\n cmd = ['bowtie2','--reorder', '-k', '10', '-q','-p',str(num_cpu), '-x', index_file, '-U', fastq_file]\n\n # call the command and pipe output.\n output = subprocess.Popen(cmd, stdout=subprocess.PIPE)\n\n # open single-sam file.\n sam_out = open(sam_file, \"wb\")\n\n # loop over each alignment.\n for status, line in _extract_sam(output):\n\n # dump good ones.\n if status == True:\n sam_out.write(line)\n continue\n\n # record location of baduns.\n tokens = line.strip().split()\n start = int(tokens[3])\n stop = start + len(tokens[9])\n rname = tokens[2]\n\n # annotate that.\n annotes[rname][start:stop] += 1\n\n # close output.\n sam_out.close()\n\n # serialize multimap.\n for ref in annotes:\n\n # create name.\n fname = '%s/%s.npy' % (ant_dir, ref)\n\n # look for existing.\n if os.path.isfile(fname):\n tmp = np.load(fname)\n annotes[ref] = annotes[ref] + tmp\n\n # serialize it.\n np.save(fname, annotes[ref])\n\ndef pair_sam(sam_in_1, sam_in_2, sam_out_1, sam_out_2, key_size):\n \"\"\" pairs SAM files \"\"\"\n\n # memory map the SAM files1.\n fin1 = open(sam_in_1, \"r+\")\n fin2 = open(sam_in_2, \"r+\")\n\n map1 = mmap.mmap(fin1.fileno(), 0, access=mmap.ACCESS_COPY)\n map2 = mmap.mmap(fin2.fileno(), 0, access=mmap.ACCESS_COPY)\n\n # create lists from data.\n hitlist1 = list()\n hitlist2 = list()\n for p1, p2 in _sam_gen(map1, map2, key_size):\n hitlist1.append(p1)\n hitlist2.append(p2)\n\n # seek files bake to begining.\n map1.seek(0)\n map2.seek(0)\n\n # sort lists by name, reverse so we can pop from end.\n hitlist1.sort(key=itemgetter(1), reverse=True)\n hitlist2.sort(key=itemgetter(1), reverse=True)\n\n # open output files.\n fout1 = open(sam_out_1, \"wb\")\n fout2 = open(sam_out_2, \"wb\")\n\n # generator of pairs.\n for p1, p2 in _pair_gen(hitlist1, hitlist2):\n\n # load sam info from map.\n map1.seek(p1[0])\n map2.seek(p2[0])\n\n # write out info.\n fout1.write(map1.readline())\n fout2.write(map2.readline())\n\n # close output files.\n fout1.close()\n fout2.close()\n\n # close memmory mapped files.\n map1.close()\n map2.close()\n\n fin1.close()\n fin2.close()\n\n\ndef pair_sam2(sam_in_1, sam_in_2, sam_out_1, sam_out_2, key_size):\n \"\"\" pairs SAM files \"\"\"\n\n # memory map the first SAM file.\n logging.info(\"opening memory map files\")\n\n # build name arrays.\n logging.info(\"extracting name array 1\")\n id1 = _extract_names(sam_in_1, key_size)\n logging.info(\"extracting name array 2\")\n id2 = _extract_names(sam_in_2, key_size)\n\n # sort the names and copy.\n logging.info(\"sorting name array 1\")\n srt1 = np.sort(id1[:]['name'])\n logging.info(\"sorting name array 2\")\n srt2 = np.sort(id2[:]['name'])\n\n # compute unique in each pair.\n logging.info(\"unique 1\")\n uq1 = _numpy_unique(srt1)\n logging.info(\"unique 2\")\n uq2 = _numpy_unique(srt2)\n\n # compute the intersection of unique.\n logging.info(\"intersection\")\n valid_list = np.intersect1d(uq1, uq2, assume_unique=True)\n\n # sanity check.\n assert len(valid_list) != 0, 'cant have no valid stuff'\n\n # create a set.\n logging.info(\"set\")\n valid = set(list(valid_list))\n\n # write the entries.\n logging.info(\"writing\")\n _write_valid(sam_in_1, id1, valid, sam_out_1)\n _write_valid(sam_in_2, id2, valid, sam_out_2)\n logging.info(\"done\")\n\n\n## internal functions ##\n\ndef _write_valid(sam_in_1, id1, valid, sam_out_1):\n \"\"\" writes entries from valid set\"\"\"\n\n # open output.\n fout1 = open(sam_out_1, \"wb\")\n fin1 = open(sam_in_1, \"rb\")\n\n # generator of pairs.\n idx = 0\n for line in fin1:\n\n # operate.\n if id1[idx]['name'] in valid:\n fout1.write(line)\n\n # udpate\n idx += 1\n\n # close em.\n fout1.close()\n fin1.close()\n\ndef _numpy_unique(srt1):\n \"\"\" return unique subset\"\"\"\n\n # create mask.\n good = np.zeros(srt1.shape[0], dtype=np.bool)\n good[:] = False\n\n # iterate over non-boundry cases.\n for i in range(1, srt1.shape[0]-1):\n\n # must not match its neighbors.\n if srt1[i-1] != srt1[i] and srt1[i+1] != srt1[i]:\n good[i] = True\n\n # check the first one.\n if srt1[0] != srt1[1]:\n good[0] = True\n\n # check the last one.\n if srt1[-1] != srt1[-2]:\n good[-1] = True\n\n # return the subset slice.\n return srt1[good]\n\n\ndef _extract_names(file_name, key_size):\n \"\"\" builds numpy array of name hits\"\"\"\n\n # count lines.\n with open(file_name, \"rb\") as fin:\n line_cnt1 = 0\n for line in fin:\n line_cnt1 += 1\n\n # allocate array.\n id1 = np.zeros(line_cnt1, dtype=np.dtype([('name','S25'),('row',np.int)]))\n\n # copy data into array.\n with open(file_name, \"rb\") as fin:\n\n idx = 0\n for line1 in fin:\n # operate.\n if key_size == 0:\n id1[idx]['name'] = line1.split(\"\\t\")[0]\n else:\n id1[idx]['name'] = line1.split(\"\\t\")[0][0:-key_size]\n id1[idx]['row'] = idx\n\n # reset.\n idx += 1\n\n # return the array.\n return id1\n\ndef _extract_sam(output):\n ''' extracts output form SAM'''\n\n # extract unique to file, save multimap annotations.\n for line in iter(output.stdout.readline,''):\n\n # skip header.\n if line[0] == '@': continue\n\n # split.\n tokens = line.strip().split()\n\n # check for no align.\n if tokens[2] == '*':\n continue\n\n # check for MAPQ > 2:\n if int(tokens[4]) < 2:\n yield False, line\n else:\n # its good, yield it.\n yield True, line\n\n\ndef _sam_gen(map1, map2, key_size):\n '''yields the SAM name and the line index'''\n\n # loop till end of file.\n line1 = map1.readline()\n line2 = map2.readline()\n pos1 = 0\n pos2 = 0\n while line1 != '' and line2 != '':\n\n # process it.\n tok1 = line1.strip().split()\n tok2 = line2.strip().split()\n\n # remove to key.\n if key_size != 0:\n key1 = tok1[0][0:-key_size]\n key2 = tok2[0][0:-key_size]\n else:\n key1 = tok1[0]\n key2 = tok2[0]\n\n # yield the name and line number.\n yield (pos1, key1), (pos2, key2)\n\n # update info.\n pos1 += len(line1)\n pos2 += len(line2)\n line1 = map1.readline()\n line2 = map2.readline()\n\ndef _pair_gen(hitlist1, hitlist2):\n ''' does an in-order walk to find pairs '''\n\n # loop till each list is empty.\n while len(hitlist1) > 0 and len(hitlist2) > 0:\n\n # peek for a match.\n if hitlist1[-1][1] == hitlist2[-1][1]:\n\n # yield it.\n yield hitlist1[-1], hitlist2[-1]\n\n # change left.\n hitlist1.pop()\n\n else:\n\n # pop smaller.\n if hitlist1[-1][1] < hitlist2[-1][1]:\n hitlist1.pop()\n else:\n hitlist2.pop()\n"}],"string":"[\n {\n \"alpha_fraction\": 0.5037604570388794,\n \"alphanum_fraction\": 0.5210442543029785,\n \"avg_line_length\": 23.13263511657715,\n \"blob_id\": \"ff878cc9510ef048b68b1a742c6a9967b68a4f8b\",\n \"content_id\": \"11be2c7d435fa5f3cdd2beda3049169f4b149460\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 13828,\n \"license_type\": \"permissive\",\n \"max_line_length\": 117,\n \"num_lines\": 573,\n \"path\": \"/utils/eval.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import os\\nimport sys\\nimport math\\nimport numpy as np\\nimport logging\\nimport subprocess\\nimport networkx as nx\\n\\n### definitions ###\\nagp_dt = np.dtype([\\\\\\n ('scaf_name', 'S255'),\\\\\\n ('scaf_start', np.long),\\\\\\n ('scaf_stop', np.long),\\\\\\n ('scaf_idx', np.long),\\\\\\n ('comp_type', 'S50'),\\\\\\n ('comp_name', 'S255'),\\\\\\n ('comp_start', np.long),\\\\\\n ('comp_stop', np.long),\\\\\\n ('comp_orien', np.long),\\\\\\n ('comp_linkage', np.long),\\\\\\n])\\n\\n### private functions ###\\n\\ndef _load_agp(fpath):\\n ''' read agp file into array.'''\\n\\n # read in agp.\\n fin = open(fpath, \\\"rb\\\")\\n lines = fin.readlines()\\n fin.close()\\n\\n # count number of lines minus comments.\\n cnt = 0\\n for line in lines:\\n if line[0] != \\\"#\\\" and len(line) != 0 and line.strip().split()[0] != \\\"RUNTIME:\\\":\\n cnt += 1\\n\\n # instantiate array.\\n agp_edges = np.zeros(cnt, dtype=agp_dt)\\n\\n # parse agp.\\n idx = 0\\n for line in lines:\\n # tokenize.\\n if line[0] == \\\"#\\\": continue\\n tmp = line.strip().split()\\n if len(tmp) == 0: continue\\n if tmp[0] == \\\"RUNTIME:\\\": continue\\n\\n # get general tokenize.\\n agp_edges[idx]['scaf_name'] = tmp[0]\\n agp_edges[idx]['scaf_start'] = int(float(tmp[1]))\\n agp_edges[idx]['scaf_stop'] = int(float(tmp[2]))\\n agp_edges[idx]['scaf_idx'] = int(float(tmp[3]))\\n agp_edges[idx]['comp_type'] = tmp[4]\\n\\n # contig.\\n if tmp[4] == \\\"W\\\":\\n # get parts.\\n agp_edges[idx]['comp_name'] = tmp[5]\\n agp_edges[idx]['comp_start'] = int(tmp[6])\\n agp_edges[idx]['comp_stop'] = int(tmp[7])\\n if tmp[8] == \\\"+\\\":\\n agp_edges[idx]['comp_orien'] = 0\\n else:\\n agp_edges[idx]['comp_orien'] = 1\\n\\n else:\\n\\n # save entry.\\n agp_edges[idx]['comp_name'] = tmp[6]\\n agp_edges[idx]['comp_start'] = 1\\n agp_edges[idx]['comp_stop'] = int(tmp[5])\\n if tmp[7] != \\\"yes\\\":\\n agp_edges[idx]['comp_linkage'] = 0\\n else:\\n agp_edges[idx]['comp_linkage'] = 1\\n\\n\\n # update index.\\n idx += 1\\n\\n # shirnk array.\\n agp_edges.resize(idx)\\n\\n return agp_edges\\n\\ndef _agp_graph(fpath, RG=None):\\n ''' returns agp graph '''\\n\\n # load agp array.\\n agp_edges = _load_agp(fpath)\\n\\n # make digraph.\\n G = nx.DiGraph()\\n\\n # add nodes.\\n for i in range(agp_edges.size):\\n\\n # skip contigs themselves.\\n if agp_edges[i]['comp_type'] != 'W': continue\\n\\n # add node info.\\n name = agp_edges[i]['comp_name']\\n width = agp_edges[i]['comp_stop']\\n orien = agp_edges[i]['comp_orien']\\n start = agp_edges[i]['scaf_start']\\n stop = agp_edges[i]['scaf_stop']\\n scaf = agp_edges[i]['scaf_name']\\n G.add_node(agp_edges[i]['comp_name'], {'width':width, 'orien':orien, 'start':start, 'stop':stop,'scaf':scaf})\\n\\n # add edges.\\n for i in range(agp_edges.size):\\n\\n # skip contigs themselves.\\n if agp_edges[i]['comp_type'] != 'N': continue\\n if i == agp_edges.shape[0] - 1: continue\\n\\n # add sorted edges.\\n ctg1 = agp_edges[i-1]['comp_name']\\n ctg2 = agp_edges[i+1]['comp_name']\\n gap = agp_edges[i]['comp_stop']\\n\\n G.add_edge(ctg1, ctg2, {'gap':gap})\\n\\n # if RG is supplied ensure all contigs exist.\\n if RG != None:\\n for n in RG.nodes():\\n if G.has_node(n) == False:\\n G.add_node(n, RG.node[n])\\n\\n # done.\\n return G\\n\\ndef _uconn_N50(RG, TG):\\n \\\"\\\"\\\" calcultes UCONN N50s\\\"\\\"\\\"\\n\\n # flip TG to be most consistent with RG.\\n TG = _dag_flip(RG, TG)\\n\\n # calculate teh TPN50\\n min_size = 1\\n WG_REFN50 = _calculate_n50(RG, gap=True, min_size=min_size)\\n NG_REFN50 = _calculate_n50(RG, gap=False, min_size=min_size)\\n\\n # calculate reported n50\\n WG_N50 = _calculate_n50(TG, gap=True, min_size=min_size)\\n NG_N50 = _calculate_n50(TG, gap=False, min_size=min_size)\\n\\n # remove edges not in TG.\\n TG = _remove_difference(RG, TG)\\n\\n # calculate teh TPN50\\n WG_TPN50 = _calculate_n50(TG, gap=True, min_size=min_size)\\n NG_TPN50 = _calculate_n50(TG, gap=False, min_size=min_size)\\n\\n # yield results.\\n return WG_N50, WG_TPN50, TG\\n\\ndef _compute_formula(true_adj, test_adj, n):\\n ''' computes statistics when TG is already oriented. This\\n method computes A and B exactly, but uses formulas\\n to find C and D.'''\\n\\n # set vars.\\n m = len(true_adj)\\n N = n * (n-1)\\n\\n # compute the A statistic set.\\n A = true_adj.intersection(test_adj)\\n\\n # compute the B statistic set.\\n B = test_adj.difference(true_adj)\\n\\n # compute the C statistic set.\\n C = m - len(A)\\n\\n # compute the D statistic set.\\n D = N - m - len(B)\\n\\n # return categories.\\n return len(A), len(B), C, D, A\\n\\n\\ndef _gap_deviation(RG, TG):\\n ''' calculate MAPE '''\\n\\n # find true edges.\\n radj = set(RG.edges())\\n tadj = set(TG.edges())\\n edges = tadj.intersection(radj)\\n\\n # calculate MAPE.\\n s = 0.0\\n for e0, e1 in edges:\\n At = RG[e0][e1]['gap']\\n Ft = TG[e0][e1]['gap']\\n if At != 0.0:\\n s += abs(float(At - Ft) / float(At))\\n\\n # return it.\\n try:\\n return (100.0 / float(len(edges))) * s\\n except:\\n return -1.0\\n\\ndef _get_runtime(agp_file):\\n\\n # read in agp.\\n fin = open(agp_file, \\\"rb\\\")\\n lines = fin.readlines()\\n fin.close()\\n\\n if len(lines) == 0:\\n return -1.0\\n\\n if lines[-1].count(\\\"RUNTIME\\\") == 0:\\n return -1.0\\n\\n # parse last line.\\n tmp = lines[-1].strip().split()\\n\\n return float(tmp[1])\\n\\n\\ndef _sanity_check(RG, TG, A, B, C, D):\\n ''' make sure these parameter make sense '''\\n\\n # set vars.\\n n = RG.number_of_nodes()\\n m = RG.number_of_edges()\\n N = n * (n-1)\\n\\n # run check 1: m = A + C.\\n check1 = m == A + C\\n\\n # run check 2: N - m = B + D.\\n check2 = N - m == B + D\\n\\n # run report.\\n fail = False\\n\\n if check1 == False:\\n logging.error(\\\"failed check 1: m = A + C, %i = %i + %i: %i\\\" % (m, A, C, m == A + C))\\n fail = True\\n\\n if check2 == False:\\n logging.error(\\\"failed check 2: N-m = B + D, %i - %i = %i + %i: %i\\\" % (N, m, B, D, N-m==B+D))\\n fail = True\\n\\n if fail == True:\\n sys.exit()\\n\\n\\ndef _dag_flip(RG, TG):\\n ''' flip to make most consistant '''\\n\\n # check it.\\n _graph_check(RG)\\n _graph_check(TG)\\n\\n # make set of reference.\\n rset = set(RG.edges())\\n\\n # loop over each component.\\n NG = nx.DiGraph()\\n for comp in nx.weakly_connected_components(TG):\\n\\n # turn to subgraph.\\n subg = TG.subgraph(comp)\\n\\n # make sets.\\n tset1 = set(subg.edges())\\n tset2 = set([(e1, e0) for e0, e1 in tset1])\\n\\n # check version.\\n s1 = len(rset.intersection(tset1))\\n s2 = len(rset.intersection(tset2))\\n\\n # add to nodes to new graph.\\n for n in subg.nodes():\\n NG.add_node(n, subg.node[n])\\n\\n # add the best matching orientation.\\n for e0, e1 in subg.edges():\\n if s1 >= s2:\\n NG.add_edge(e0, e1, subg[e0][e1])\\n else:\\n NG.add_edge(e1, e0, subg[e0][e1])\\n\\n # return it.\\n return NG\\n\\ndef _graph_check(G):\\n ''' makes sure its linear and a DAG '''\\n\\n # path check.\\n for n in G.nodes():\\n if G.number_of_edges(n) > 2:\\n logging.error(\\\"bad scaffold graph 1 \\\")\\n sys.exit(1)\\n\\n # DAG check.\\n if nx.is_directed_acyclic_graph(G) == False:\\n logging.error(\\\"bad scaffold graph 2\\\")\\n sys.exit(1)\\n\\ndef _calculate_n50(G, min_size=False, gap=False):\\n ''' calculates scaffold N50 given scaffold graph'''\\n\\n # compute the scaffold sizes.\\n sizes = _calc_sizes(G, min_size,gap)\\n\\n # calculate n50.\\n sizes.sort(reverse = True)\\n s = sum(sizes)\\n limit = s * 0.5\\n for l in sizes:\\n s -= l\\n if s <= limit:\\n return int(l)\\n \\ndef _fasta_n50(fasta_file, min_size=False, gap=False):\\n ''' calculates scaffold N50 given fasta file'''\\n\\n # load fasta.\\n seqs = _load_fasta(fasta_file)\\n\\n # compute the scaffold sizes.\\n sizes = [len(seqs[x]) for x in seqs]\\n\\n # calculate n50.\\n sizes.sort(reverse = True)\\n s = sum(sizes)\\n limit = s * 0.5\\n for l in sizes:\\n s -= l\\n if s <= limit:\\n return int(l)\\n\\n\\ndef _calc_sizes(G, min_size, gap, scaf_only=False):\\n sizes = list()\\n for comp in nx.weakly_connected_components(G):\\n\\n # skip non scaffolds.\\n if scaf_only == True:\\n if len(comp) < 2:\\n continue\\n\\n # add contig size.\\n size = 0\\n for n in comp:\\n size += G.node[n]['width']\\n\\n # add gap size.\\n if gap != False:\\n for p,q in G.edges(comp):\\n size += G[p][q]['gap']\\n\\n # skip this.\\n if min_size != False and size < min_size:\\n continue\\n\\n # save the size.\\n sizes.append(size)\\n return sizes\\n\\n\\ndef _calc_counts(G, min_size, gap, scaf_only=False):\\n sizes = list()\\n for comp in nx.weakly_connected_components(G):\\n\\n # skip non scaffolds.\\n if scaf_only == True:\\n if len(comp) < 2:\\n continue\\n\\n # add contig size.\\n size = 0\\n for n in comp:\\n size += G.node[n]['width']\\n\\n # add gap size.\\n if gap != False:\\n for p,q in G.edges(comp):\\n size += G[p][q]['gap']\\n\\n # skip this.\\n if min_size != False and size < min_size:\\n continue\\n\\n # save the size.\\n sizes.append(len(comp))\\n\\n return sizes\\n\\ndef _remove_difference(RG, TG):\\n ''' removes edges not in RG'''\\n\\n # make edge sets.\\n rset = set(RG.edges())\\n tset = set(TG.edges())\\n\\n # identify edges in test that shouldn't be there\\n to_remove = tset.difference(rset)\\n\\n # remove them.\\n TG.remove_edges_from(to_remove)\\n\\n # return modified graph.\\n return TG\\n\\ndef _load_fasta(file_path):\\n ''' loads fasta file into dictionary'''\\n\\n # read file into memory.\\n fin = open(file_path)\\n lines = fin.readlines()\\n fin.close()\\n\\n # build dictionary.\\n data = dict()\\n seq = \\\"\\\"\\n for line in lines:\\n\\n # Skip blanks.\\n if len(line) < 2: continue\\n if line[0] == \\\"#\\\": continue\\n\\n # remove blanks.\\n line = line.strip()\\n\\n # Check for ids.\\n if line.count(\\\">\\\") > 0:\\n\\n # Check if ending seq.\\n if len(seq) > 0:\\n\\n # save.\\n data[head] = seq.upper()\\n\\n # reset head.\\n head = line.replace(\\\">\\\",\\\"\\\")\\n seq = \\\"\\\"\\n\\n # skip to next line.\\n continue\\n\\n # Filter chars.\\n seq += line\\n\\n # save the last one.\\n data[head] = seq.upper()\\n\\n # return dictionary.\\n return data\\n\\n### public functions ###\\n\\ndef simulation_evaluation(ref_fasta, ctg_fasta, scf_fasta, ref_agp, scf_agp):\\n \\\"\\\"\\\" evaluates the simulated dataset \\\"\\\"\\\"\\n\\n # load the reference and test graph from AGP files.\\n RG = _agp_graph(ref_agp)\\n TG = _agp_graph(scf_agp, RG=RG)\\n\\n # calculate referece and ctg n50/\\n ref_N50 = _fasta_n50(ref_fasta, gap=True)\\n ctg_N50 = _fasta_n50(ctg_fasta, gap=True)\\n scf_N50 = _fasta_n50(scf_fasta, gap=True)\\n\\n # ensure we have all contigs accounted for.\\n assert set(TG.nodes()) == set(RG.nodes()),\\\\\\n 'not all contigs accounted for'\\n\\n # compute the exact N50\\n scf_N50_2, tp_N50, LG = _uconn_N50(RG, TG)\\n\\n # make edge sets.\\n radj = set(RG.edges())\\n tadj = set(TG.edges())\\n\\n # calculate 4 parameters.\\n n = RG.number_of_nodes()\\n A, B, C, D, A_SET = _compute_formula(radj, tadj, n)\\n\\n # compute derivativ stats.\\n sensitivity = (100*(float(A) / float(A+C)))\\n ppv = (100*(float(A) / float(A+B)))\\n if float(math.sqrt((A+B)*(A+C)*(D+B)*(D+C))) != 0.0:\\n mcc = (100*(float((A*D)-(B*C)) / float(math.sqrt((A+B)*(A+C)*(D+B)*(D+C)))))\\n else:\\n mcc = 0.0\\n\\n # get gap deviation.\\n gap_dev = _gap_deviation(RG, TG)\\n\\n # get the runtime.\\n runtime = _get_runtime(scf_agp)\\n\\n # print results.\\n # A B C D gapMape runtime sensitivity ppv mcc REFN50 TPN50 REPN50\\n return A, B, C, D, ppv, mcc, gap_dev, runtime, ref_N50, ctg_N50, scf_N50, tp_N50\\n\\n\\n\\ndef quast_evaluation(ref, ctgs, scf, sdir, threads):\\n\\n # note that we are running it.\\n logging.info(\\\"running quast %s %s %s\\\" % (ref, ctgs, scf))\\n\\n # run the comparison script.\\n x = ref.split(\\\"/\\\")\\n #z = '/'.join(x[0:-1] + [\\\"genes.gff\\\"])\\n\\n cmd = [\\\\\\n 'python',\\\\\\n '/opt/quast/quast.py',\\\\\\n \\\"-e\\\",\\n \\\"-f\\\",\\n # \\\"-G\\\", z,\\\\\\n \\\"-o\\\", \\\"./\\\",\\\\\\n \\\"-R\\\", ref,\\\\\\n \\\"-T\\\", str(threads),\\\\\\n scf\\\\\\n ]\\n\\n '''\\n # remove dir.\\n if os.path.isdir(sdir) == True:\\n subprocess.call([\\\"rm\\\", \\\"-rf\\\", sdir])\\n\\n # make dir.\\n if os.path.isdir(sdir) == False:\\n subprocess.call(['mkdir', '-p', sdir])\\n\\n # make log file.\\n lfile = \\\"%s/log.txt\\\" % sdir\\n\\n # capture output.\\n with open(lfile, 'w') as fout:\\n #if subprocess.call(cmd, stdout=fout, stderr=fout, cwd=sdir) != 0:\\n if subprocess.call(cmd, cwd=sdir) != 0:\\n logging.error('error running quast')\\n return -1, -1\\n '''\\n # open the output.\\n with open(\\\"%s/report.tsv\\\" % sdir) as fin:\\n results = fin.readlines()\\n tmp = list()\\n for result in results:\\n tmp.append(result.strip())\\n results = tmp\\n\\n # extract results.\\n lbls = list()\\n res1 = list()\\n res2 = list()\\n cnt = 0\\n for x in results:\\n tmp = x.split(\\\"\\\\t\\\")\\n lbls.append(tmp[0])\\n res1.append(tmp[1])\\n #res2.append(tmp[2])\\n res2.append(\\\"\\\")\\n #print cnt, tmp\\n cnt += 1\\n\\n res = np.array([lbls,res1,res2])\\n\\n return res\\n\"\n },\n {\n \"alpha_fraction\": 0.6042157411575317,\n \"alphanum_fraction\": 0.6186079382896423,\n \"avg_line_length\": 40.2152214050293,\n \"blob_id\": \"48689949114dc873eecf41293abc4fd75d21d7a3\",\n \"content_id\": \"4183ebc78fad20ceccd2fc1d6a3f8427a87a7c28\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 15703,\n \"license_type\": \"permissive\",\n \"max_line_length\": 159,\n \"num_lines\": 381,\n \"path\": \"/scafathon.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#!/usr/bin/python\\n'''\\nstandalone adapter for scripts outside of the directory structure.\\n'''\\n### imports ###\\n\\n# system\\nimport time\\nimport subprocess\\nimport warnings\\nimport argparse\\nimport logging\\nimport time\\nimport sys\\nimport os\\nimport numpy as np\\n\\nlogging.basicConfig(level=logging.DEBUG, format='[%(levelname)s] %(message)s', )\\n\\n# local\\nfrom utils.align import create_idx, create_aln, pair_sam, pair_sam2\\nfrom utils.prep import prep_silp, prep_opera, prep_mip\\nfrom utils.run import run_silp, run_opera, run_mip\\nfrom utils.eval import simulation_evaluation, quast_evaluation\\n\\n# hack to silence argparser.\\nwarnings.filterwarnings('ignore', category=DeprecationWarning)\\n\\n### classes ###\\n\\n### functions ###\\n\\ndef align(args):\\n ''' aligns reads against reference '''\\n\\n # validate parameters.\\n assert os.path.isdir(args.base_dir), 'base_dir'\\n assert os.path.isfile(args.ctg_fasta), 'ctg_fasta'\\n assert os.path.isfile(args.read1_fastq), 'read1_fastq'\\n assert os.path.isfile(args.read2_fastq), 'read2_fastq'\\n assert os.path.isfile(args.size_file), 'size_file'\\n\\n # relavent files.\\n base_dir = os.path.abspath(args.base_dir)\\n\\n size_file = os.path.abspath(args.size_file)\\n ctg_fasta = os.path.abspath(args.ctg_fasta)\\n read1_fastq = os.path.abspath(args.read1_fastq)\\n read2_fastq = os.path.abspath(args.read2_fastq)\\n\\n tmp1_sam = os.path.abspath('%s/tmp1.sam' % base_dir)\\n tmp2_sam = os.path.abspath('%s/tmp2.sam' % base_dir)\\n\\n read1_sam = os.path.abspath('%s/read1.sam' % base_dir)\\n read2_sam = os.path.abspath('%s/read2.sam' % base_dir)\\n\\n ant_dir = '%s/ant' % base_dir\\n idx_dir = '%s/index' % base_dir\\n idx_file = '%s/index' % idx_dir\\n\\n # build index if not present.\\n if os.path.isdir(idx_dir) == False:\\n subprocess.call([\\\"mkdir\\\", \\\"-p\\\", idx_dir])\\n create_idx(ctg_fasta, idx_file)\\n\\n # remove annotation dir if present.\\n if os.path.isdir(ant_dir) == True:\\n subprocess.call([\\\"rm\\\", \\\"-rf\\\", ant_dir])\\n subprocess.call([\\\"mkdir\\\", \\\"-p\\\", ant_dir])\\n\\n # perform alignment.\\n create_aln(size_file, idx_file, read1_fastq, tmp1_sam, ant_dir, args.num_cpu)\\n create_aln(size_file, idx_file, read2_fastq, tmp2_sam, ant_dir, args.num_cpu)\\n\\n # pair the alignment.\\n pair_sam2(tmp1_sam, tmp2_sam, read1_sam, read2_sam, args.key_size)\\n\\ndef pair(args):\\n ''' pairs two same files '''\\n\\n # validate parameters.\\n assert os.path.isdir(args.base_dir), 'base_dir'\\n assert os.path.isfile(args.tmp1_sam), 'tmp1_sam'\\n assert os.path.isfile(args.tmp2_sam), 'tmp2_sam'\\n\\n # relavent files.\\n base_dir = os.path.abspath(args.base_dir)\\n tmp1_sam = os.path.abspath(args.tmp1_sam)\\n tmp2_sam = os.path.abspath(args.tmp2_sam)\\n read1_sam = os.path.abspath('%s/read1.sam' % base_dir)\\n read2_sam = os.path.abspath('%s/read2.sam' % base_dir)\\n\\n # pair the alignment.\\n pair_sam2(tmp1_sam, tmp2_sam, read1_sam, read2_sam, args.key_size)\\n\\ndef meta_combine(args):\\n \\\"\\\"\\\" combines two seperate alignments\\\"\\\"\\\"\\n\\n # validate parameters.\\n assert os.path.isdir(args.base_dir), 'base_dir'\\n assert os.path.isdir(args.work1_dir), 'w1_dir'\\n assert os.path.isdir(args.work2_dir), 'w2_dir'\\n\\n # switch based on subset.\\n if args.subsample == None:\\n\\n # combine reads.\\n with open(\\\"%s/read1.sam\\\" % args.base_dir, \\\"wb\\\") as fout:\\n subprocess.call([\\\"cat\\\",\\\"%s/read1.sam\\\" % args.work1_dir, \\\"%s/read1.sam\\\" % args.work2_dir], stdout=fout)\\n\\n with open(\\\"%s/read2.sam\\\" % args.base_dir, \\\"wb\\\") as fout:\\n subprocess.call([\\\"cat\\\",\\\"%s/read2.sam\\\" % args.work1_dir, \\\"%s/read2.sam\\\" % args.work2_dir], stdout=fout)\\n\\n else:\\n\\n # count number of lines.\\n cnt = 0\\n with open(\\\"%s/read1.sam\\\" % args.work1_dir, \\\"r\\\") as fin:\\n for line in fin:\\n cnt += 1\\n \\n # only output a percentage of them.\\n outp = float(cnt) * float(args.subsample)\\n \\n # first one.\\n with open(\\\"%s/read1.sam\\\" % args.base_dir, \\\"wb\\\") as fout:\\n cnt = 0\\n with open(\\\"%s/read1.sam\\\" % args.work1_dir, \\\"r\\\") as fin:\\n for line in fin:\\n if cnt > outp: break\\n fout.write(line)\\n cnt += 1\\n with open(\\\"%s/read1.sam\\\" % args.work2_dir, \\\"r\\\") as fin:\\n for line in fin:\\n fout.write(line)\\n \\n # second one.\\n with open(\\\"%s/read2.sam\\\" % args.base_dir, \\\"wb\\\") as fout:\\n cnt = 0\\n with open(\\\"%s/read2.sam\\\" % args.work1_dir, \\\"r\\\") as fin:\\n for line in fin:\\n if cnt > outp: break\\n fout.write(line)\\n cnt += 1\\n with open(\\\"%s/read2.sam\\\" % args.work2_dir, \\\"r\\\") as fin:\\n for line in fin:\\n fout.write(line)\\n\\n # copy one annotation.\\n subprocess.call([\\\"cp\\\", \\\"%s/ant\\\" % args.work1_dir, \\\"%s/ant\\\" % args.base_dir, \\\"-R\\\"])\\n subprocess.call([\\\"chmod\\\", \\\"u+w\\\", \\\"%s/ant\\\" % args.base_dir, \\\"-R\\\"])\\n\\n # combine the rest.\\n tmp1_dir = \\\"%s/ant\\\" % args.base_dir\\n tmp2_dir = \\\"%s/ant\\\" % args.work2_dir\\n for x in os.listdir(tmp2_dir):\\n\\n # simplify.\\n tmp1_x = \\\"%s/%s\\\" % (tmp1_dir,x)\\n tmp2_x = \\\"%s/%s\\\" % (tmp2_dir,x)\\n \\n # copy it if no problem.\\n if os.path.isfile(tmp1_x) == False:\\n subprocess.call([\\\"cp\\\", tmp2_x, tmp1_x])\\n\\n else:\\n # combine it.\\n tmp1_n = np.load(tmp1_x)\\n tmp2_n = np.load(tmp2_x)\\n np.save(tmp1_x, tmp1_n+tmp2_n)\\n\\ndef prepare(args):\\n \\\"\\\"\\\" prepares alignment given scaffolding method\\\"\\\"\\\"\\n\\n # extract information.\\n work_dir = os.path.abspath(args.base_dir)\\n align_dir = os.path.abspath(args.align_dir)\\n ant_dir = '%s/ant' % align_dir\\n\\n read1_sam = '%s/read1.sam' % align_dir\\n read2_sam = '%s/read2.sam' % align_dir\\n ctg_fasta = os.path.abspath(args.ctg_fasta)\\n prep_sh = '%s/prep.sh' % work_dir\\n\\n # translate pairmode.\\n if args.pair_mode == 0:\\n pair_mode = 'ff'\\n elif args.pair_mode == 1:\\n pair_mode = 'fr'\\n elif args.pair_mode == 2:\\n pair_mode = 'rf'\\n\\n # run the right prepare.\\n cmd_args = (work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, args.ins_size, args.std_dev, args.bundle_size, pair_mode, args)\\n if args.meth_mode == 0:\\n prep_silp(*cmd_args)\\n elif args.meth_mode == 1:\\n prep_opera(*cmd_args)\\n elif args.meth_mode == 2:\\n prep_mip(*cmd_args)\\n\\n\\ndef run(args):\\n \\\"\\\"\\\" extracts information for scaffolding\\\"\\\"\\\"\\n\\n # extract information.\\n work_dir = os.path.abspath(args.base_dir)\\n align_dir = os.path.abspath(args.align_dir)\\n ant_dir = '%s/ant' % align_dir\\n\\n read1_sam = '%s/read1.sam' % align_dir\\n read2_sam = '%s/read2.sam' % align_dir\\n ctg_fasta = os.path.abspath(args.ctg_fasta)\\n ctg_agp = '%s/scf.agp' % work_dir\\n scf_fasta = '%s/scf.fasta' % work_dir\\n run_sh = '%s/run.sh' % work_dir\\n\\n # translate pairmode.\\n if args.pair_mode == 0:\\n pair_mode = 'ff'\\n elif args.pair_mode == 1:\\n pair_mode = 'fr'\\n elif args.pair_mode == 2:\\n pair_mode = 'rf'\\n\\n # run the right prepare.\\n cmd_args = (work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, args.ins_size, args.std_dev, args.bundle_size, pair_mode, args)\\n if args.meth_mode == 0:\\n run_silp(*cmd_args)\\n elif args.meth_mode == 1:\\n run_opera(*cmd_args)\\n elif args.meth_mode == 2:\\n run_mip(*cmd_args)\\n\\ndef sim_eval(args):\\n \\\"\\\"\\\"evaluates scaffold\\\"\\\"\\\"\\n\\n # simplify data.\\n ref_fasta = os.path.abspath(args.ref_fasta)\\n ctg_fasta = os.path.abspath(args.ctg_fasta)\\n scf_fasta = os.path.abspath(args.scf_fasta)\\n ref_agp = os.path.abspath(args.ref_agp)\\n scf_agp = os.path.abspath(args.scf_agp)\\n\\n # call evaluation code.\\n A, B, C, D, ppv, mcc, gap_dev, runtime, ref_N50, ctg_N50, scf_N50, tp_N50 = simulation_evaluation(ref_fasta, ctg_fasta, scf_fasta, ref_agp, scf_agp)\\n\\n # format and return.\\n txt = list()\\n txt.append('%d %d %d %d' % (A, B, C, D))\\n txt.append('%.2f %.2f' % (ppv, mcc))\\n txt.append('%.2f %.2f' % (gap_dev, runtime))\\n txt.append('%d %d %d %d' % (ref_N50, ctg_N50, scf_N50, tp_N50))\\n print ' '.join(txt)\\n\\ndef real_eval(args):\\n \\\"\\\"\\\"evaluates scaffold using alignme\\\"\\\"\\\"\\n\\n # simplify data.\\n ref_fasta = os.path.abspath(args.ref_fasta)\\n ctg_fasta = os.path.abspath(args.ctg_fasta)\\n scf_fasta = os.path.abspath(args.scf_fasta)\\n #ref_agp = os.path.abspath(args.ref_agp)\\n #scf_agp = os.path.abspath(args.scf_agp)\\n\\n # call quast\\n res = quast_evaluation(ref_fasta, ctg_fasta, scf_fasta, args.wd, args.threads)\\n\\n\\n # quast specific.\\n try: N50 = int(float(res[1,np.where(res[0,:] == \\\"N50\\\")[0][0]]))\\n except: N50 = 0\\n try: NG50 = int(float(res[1,np.where(res[0,:] == \\\"NG50\\\")[0][0]]))\\n except: NG50 = 0\\n try: GFRAC = float(res[1,np.where(res[0,:] == \\\"Genome fraction (%)\\\")[0][0]])\\n except: GFRAC = 0.0\\n try: NA50 = int(float(res[1,np.where(res[0,:] == \\\"NA50\\\")[0][0]]))\\n except: NA50 = 0\\n try: NGA50 = int(float(res[1,np.where(res[0,:] == \\\"NGA50\\\")[0][0]]))\\n except: NGA50 = 0\\n\\n # format and return.\\n txt = list()\\n txt.append(\\\"%d %d %.2f %d %d\\\" % (N50, NG50, GFRAC, NA50, NGA50))\\n\\n print ' '.join(txt)\\n\\n### script ###\\n\\nif __name__ == '__main__':\\n\\n # mode parser.\\n main_p = argparse.ArgumentParser()\\n subp = main_p.add_subparsers(help='sub-command help')\\n\\n ### data preparation ###\\n # import reference into working directory.\\n subp_p = subp.add_parser('align', help='aligns reads against contigs.')\\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\\n subp_p.add_argument('-p', dest='num_cpu', type=int, required=True, help='number of threads for bowtie2')\\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\\n subp_p.add_argument('-q1', dest='read1_fastq', required=True, help='read first file')\\n subp_p.add_argument('-q2', dest='read2_fastq', required=True, help='read second file')\\n subp_p.add_argument('-s', dest='size_file', required=True, help='size file')\\n subp_p.add_argument('-k', dest='key_size', type=int, required=True, help='size of PE key at end of each read')\\n subp_p.set_defaults(func=align)\\n\\n subp_p = subp.add_parser('pair', help='pairs 2 SAM files')\\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\\n subp_p.add_argument('-s1', dest='tmp1_sam', required=True, help='read first file')\\n subp_p.add_argument('-s2', dest='tmp2_sam', required=True, help='read second file')\\n subp_p.add_argument('-k', dest='key_size', type=int, required=True, help='size of PE key at end of each read')\\n subp_p.set_defaults(func=pair)\\n\\n # combines two seperate alignments.\\n subp_p = subp.add_parser('meta_combine', help='combines two seperate alignments. Used for meta scaffold testing.')\\n subp_p.add_argument('-w', dest='base_dir', required=True, help='working directory')\\n subp_p.add_argument('-w1', dest='work1_dir', required=True, help='working directory')\\n subp_p.add_argument('-w2', dest='work2_dir', required=True, help='working directory')\\n subp_p.add_argument('-s', dest='subsample', type=float, required=False, help='subsample first directory')\\n subp_p.set_defaults(func=meta_combine)\\n\\n # prepare the reference for scaffolding.\\n subp_p = subp.add_parser('prep', help='runs pre-processing stage.')\\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\\n subp_p.add_argument('-w', dest='base_dir', required=True, help='scaffolding directory')\\n subp_p.add_argument('-a', dest='align_dir', required=True, help='alignment directory')\\n subp_p.add_argument('-i', dest='ins_size', type=int, required=True, help='insert size')\\n subp_p.add_argument('-s', dest='std_dev', type=int, required=True, help='std_devition')\\n subp_p.add_argument('-b', dest='bundle_size', type=int, required=True, help='bundle size')\\n me_g = subp_p.add_mutually_exclusive_group(required=True)\\n me_g.add_argument('-ff', dest='pair_mode', action='store_const', const=0, help='SOLiD style -> ->')\\n me_g.add_argument('-fr', dest='pair_mode', action='store_const', const=1, help='innie style -> <-')\\n me_g.add_argument('-rf', dest='pair_mode', action='store_const', const=2, help='outtie style <- ->')\\n me_g = subp_p.add_mutually_exclusive_group(required=True)\\n me_g.add_argument('-silp', dest='meth_mode', action='store_const', const=0, help='SILP')\\n me_g.add_argument('-opera', dest='meth_mode', action='store_const', const=1, help='OPERA')\\n me_g.add_argument('-mip', dest='meth_mode', action='store_const', const=2, help='MIP')\\n subp_p.set_defaults(func=prepare)\\n\\n # run the scaffolding.\\n subp_p = subp.add_parser('run', help='runs the actual scaffolding')\\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\\n subp_p.add_argument('-w', dest='base_dir', required=True, help='scaffolding directory')\\n subp_p.add_argument('-a', dest='align_dir', required=True, help='alignment directory')\\n subp_p.add_argument('-i', dest='ins_size', type=int, required=True, help='insert size')\\n subp_p.add_argument('-s', dest='std_dev', type=int, required=True, help='std_devition')\\n subp_p.add_argument('-b', dest='bundle_size', type=int, required=True, help='bundle size')\\n me_g = subp_p.add_mutually_exclusive_group(required=True)\\n me_g.add_argument('-ff', dest='pair_mode', action='store_const', const=0, help='SOLiD style -> ->')\\n me_g.add_argument('-fr', dest='pair_mode', action='store_const', const=1, help='innie style -> <-')\\n me_g.add_argument('-rf', dest='pair_mode', action='store_const', const=2, help='outtie style <- ->')\\n me_g = subp_p.add_mutually_exclusive_group(required=True)\\n me_g.add_argument('-silp', dest='meth_mode', action='store_const', const=0, help='SILP')\\n me_g.add_argument('-opera', dest='meth_mode', action='store_const', const=1, help='OPERA')\\n me_g.add_argument('-mip', dest='meth_mode', action='store_const', const=2, help='MIP')\\n # SILP2 arguments.\\n subp_p.add_argument('-z', dest='weight_mode', type=int, default=0, help='SILP2: weight mode')\\n subp_p.set_defaults(func=run)\\n\\n # evaluate the scaffolding.\\n subp_p = subp.add_parser('sim_eval', help='evaluates scaffolding if there is a true AGP')\\n subp_p.add_argument('-r', dest='ref_fasta', required=True, help='reference fasta')\\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\\n subp_p.add_argument('-s', dest='scf_fasta', required=True, help='scaffold fasta')\\n subp_p.add_argument('-a', dest='ref_agp', required=True, help='reference agp')\\n subp_p.add_argument('-y', dest='scf_agp', required=True, help='predicted agp')\\n subp_p.set_defaults(func=sim_eval)\\n\\n # evaluate the scaffolding.\\n subp_p = subp.add_parser('real_eval', help='alignment based scaffold evaluation.')\\n subp_p.add_argument('-r', dest='ref_fasta', required=True, help='reference fasta')\\n subp_p.add_argument('-c', dest='ctg_fasta', required=True, help='contig fasta')\\n subp_p.add_argument('-s', dest='scf_fasta', required=True, help='scaffold fasta')\\n subp_p.add_argument('-y', dest='scf_agp', required=True, help='predicted agp')\\n subp_p.add_argument('-wd', dest='wd', required=True, help='alignment working directory')\\n subp_p.add_argument('-p', dest='threads', type=int, required=True, help='number of threads to align')\\n subp_p.set_defaults(func=real_eval)\\n\\n args = main_p.parse_args()\\n args.func(args)\\n\"\n },\n {\n \"alpha_fraction\": 0.492044597864151,\n \"alphanum_fraction\": 0.5010282397270203,\n \"avg_line_length\": 28.996753692626953,\n \"blob_id\": \"4b73b226cb70b797a4d76f19ced2424522dc0848\",\n \"content_id\": \"7c8f300d3e7e1ca4a613c8ea4663795fedce5b01\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 9239,\n \"license_type\": \"permissive\",\n \"max_line_length\": 143,\n \"num_lines\": 308,\n \"path\": \"/utils/run.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"'''\\ndrivers to prepare the data for scaffolding\\n'''\\nimport subprocess\\nimport os\\nimport time\\nimport numpy as np\\n\\nfrom utils.misc import *\\n\\n## private functions ##\\n\\n## public functions ##\\ndef run_silp(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\\"\\\"\\\" SILP scaffolder \\\"\\\"\\\"\\n\\n # create command base.\\n cmd_base = ['python', '/home/jrl03001/code/SILP2/silp.py']\\n\\n # scaffolding/\\n job = list()\\n job.append('#!/bin/bash')\\n job.append('# scaffolding')\\n job.append('# start time')\\n job.append('start=$(date +%s)')\\n job.append('%s orient -w %s -z %s ' % (' '.join(cmd_base), work_dir, args.weight_mode))\\n job.append('%s order -w %s ' % (' '.join(cmd_base), work_dir))\\n job.append('%s gap -w %s ' % (' '.join(cmd_base), work_dir))\\n job.append('%s write -w %s -a %s' % (' '.join(cmd_base), work_dir, ctg_agp))\\n job.append('%s fasta -w %s -a %s -c %s -f %s' % (' '.join(cmd_base), work_dir, ctg_agp, ctg_fasta, scf_fasta))\\n job.append('# stop time')\\n job.append('stop=$(date +%s)')\\n job.append('echo RUNTIME: $(expr $stop - $start) >> %s' % ctg_agp)\\n job.append('')\\n runit(job, run_sh)\\n\\n\\ndef run_opera(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\\"\\\"\\\" OPERA scaffolder \\\"\\\"\\\"\\n\\n # opera specific directories.\\n input_dir = '%s/input' % work_dir\\n results_dir = '%s/results' % work_dir\\n script_dir = '%s/script' % work_dir\\n output_dir = '%s/output' % work_dir\\n log_dir = '%s/log' % work_dir\\n for x in [input_dir, results_dir, script_dir, output_dir, log_dir]:\\n create_dir(x)\\n\\n # opera sepecific files.\\n edge_file = '%s/opera_raw.txt' % input_dir\\n config_file = '%s/opera.cfg' % input_dir\\n script_file = '%s/opera.sh' % input_dir\\n tout_file = '%s/scaffolds.scaf' % results_dir\\n tscf_file = '%s/scaffoldSeq.fasta' % results_dir\\n log_file = '%s/opera.log' % log_dir\\n\\n # write execution script.\\n job = list()\\n job.append('#!/bin/bash')\\n job.append('# scaffolding')\\n job.append('# start time')\\n job.append('start=$(date +%s)')\\n job.append('# run the job')\\n job.append('/opt/opera/bin/opera %s &> %s' % (config_file, log_file))\\n job.append('# stop time')\\n job.append('stop=$(date +%s)')\\n job.append('echo RUNTIME: $(expr $stop - $start) >> %s' % ctg_agp)\\n job.append('')\\n runit(job, run_sh)\\n\\n # load results.\\n fin = open(tout_file, \\\"rb\\\")\\n lines = fin.readlines()\\n fin.close()\\n\\n # load the runtime string.\\n with open(ctg_agp, 'rb') as fin:\\n time_info = fin.readline().strip()\\n\\n # create an AGP.\\n fout = open(ctg_agp, \\\"wb\\\")\\n for lidx in range(len(lines)):\\n\\n # setup line.\\n line = lines[lidx]\\n\\n # check header.\\n if line[0] == \\\">\\\":\\n header = line.strip().replace(\\\">\\\",\\\"\\\").split()[0]\\n #header = line.strip().replace(\\\">\\\",\\\"\\\")\\n part = 1\\n scaf_start = 1\\n scaf_stop = 0\\n continue\\n\\n # tokenize.\\n tmp = line.strip().split()\\n\\n # get ctgid.\\n ctgid = tmp[0]\\n\\n if tmp[1] == \\\"BE\\\":\\n orien = \\\"+\\\"\\n else:\\n orien = \\\"-\\\"\\n\\n ctglen = int(tmp[2])\\n gaplen = int(tmp[3])\\n\\n # make indexs.\\n scaf_stop = scaf_start + ctglen\\n\\n # write out AGP.\\n fout.write(\\\"%s\\\\t%i\\\\t%i\\\\t%i\\\\t%s\\\\t%s\\\\t%i\\\\t%i\\\\t%s\\\\n\\\" % \\\\\\n (header, scaf_start, scaf_stop, part, \\\"W\\\", ctgid, 1, ctglen, orien))\\n #print \\\"write\\\"\\n # increment pointers.\\n scaf_start = scaf_stop + 1\\n part += 1\\n\\n # add gap if size is not 0\\n if gaplen != 0:\\n\\n # make indexs.\\n scaf_stop = scaf_start + gaplen\\n\\n # add gap.\\n fout.write(\\\"%s\\\\t%i\\\\t%i\\\\t%i\\\\t%s\\\\t%i\\\\t%s\\\\t%s\\\\n\\\" % \\\\\\n (header, scaf_start, scaf_stop, part, \\\"N\\\", gaplen, \\\"fragment\\\", \\\"no\\\"))\\n #print \\\"write\\\"\\n # increment pointers.\\n scaf_start = scaf_stop + 1\\n part += 1\\n\\n # otherwise.\\n else:\\n # check if we can peak.\\n if lidx+1 >= len(lines):\\n continue\\n\\n\\n # check if new scaffold.\\n if lines[lidx+1][0] != \\\">\\\":\\n # make fake gap.\\n scaf_stop = scaf_start + 10\\n\\n # add gap.\\n fout.write(\\\"%s\\\\t%i\\\\t%i\\\\t%i\\\\t%s\\\\t%i\\\\t%s\\\\t%s\\\\n\\\" % \\\\\\n (header, scaf_start, scaf_stop, part, \\\"N\\\", gaplen, \\\"fragment\\\", \\\"no\\\"))\\n #print \\\"write\\\"\\n # increment pointers.\\n scaf_start = scaf_stop + 1\\n part += 1\\n continue\\n\\n # write the timer.\\n fout.write(time_info + '\\\\n')\\n\\n # close AGP file.\\n fout.close()\\n\\n # move the output files to standard locations.\\n subprocess.call(['cp', tscf_file, scf_fasta])\\n\\n\\ndef run_mip(work_dir, ant_dir, run_sh, ctg_fasta, scf_fasta, ctg_agp, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\n # simplify files.\\n ant_dir = '/dev/null'\\n\\n contig_file = ctg_fasta\\n test1 = read1_sam\\n test2 = read2_sam\\n \\n # mip specific files.\\n SAM_1_MOD = \\\"%s/sam_1.sam\\\" % work_dir\\n SAM_2_MOD = \\\"%s/sam_2.sam\\\" % work_dir\\n MERGED_FILE = \\\"%s/merged\\\" % work_dir\\n MERGED1_FILE = \\\"%s/merged.sorted1\\\" % work_dir\\n MERGED2_FILE = \\\"%s/merged.sorted2\\\" % work_dir\\n FILTERED_FILE = \\\"%s/filtered.txt\\\" % work_dir\\n COV_FILE = \\\"%s/coverage.txt\\\" % work_dir\\n PARAM_FILE = \\\"%s/parameters.txt\\\" % work_dir\\n MIP_FILE = \\\"%s/scaffolds2.txt\\\" % work_dir\\n OUT_FILE = \\\"%s/scaffolds.fasta\\\" % work_dir\\n\\n \\n # execute mip.\\n tstart = time.time()\\n cmd = list()\\n cmd.append(\\\"/opt/mip/scripts/mip-scaffolder.pl\\\")\\n cmd.append(PARAM_FILE)\\n cmd.append(contig_file)\\n cmd.append(COV_FILE)\\n cmd.append(work_dir)\\n \\n with open(run_sh, \\\"wb\\\") as fout:\\n fout.write('#!/bin/bash\\\\n')\\n fout.write(' '.join(cmd) + '\\\\n')\\n \\n subprocess.call([\\\"chmod\\\", \\\"u+x\\\", run_sh])\\n if subprocess.call([run_sh], cwd=work_dir) != 0:\\n logging.warning(\\\"couldn't run mip\\\")\\n sys.exit(1)\\n tstop = time.time()\\n \\n # compute time.\\n trun = tstop - tstart\\n \\n # load MIP results into dictionary.\\n fin = open(MIP_FILE, \\\"rb\\\")\\n lines = fin.readlines()\\n fin.close()\\n mip = {}\\n for line in lines:\\n \\n # tokenize.\\n tmp = line.split()\\n \\n # set current scaffold.\\n if tmp[0].count(\\\"scaffold\\\") > 0:\\n # set current.\\n curs = tmp[0]\\n \\n # set default.\\n mip[curs] = []\\n continue\\n \\n # append.\\n mip[curs].append(tmp)\\n \\n # count the number of rows for agp file.\\n size = 0\\n for scafid in mip:\\n size += len(mip[scafid]) + len(mip[scafid]) - 1\\n\\n # allocate the array.\\n agps = np.zeros(size, dtype=agp_dt)\\n\\n # begin copying data.\\n idx = 0\\n for scafid in mip:\\n scaf_start = 1\\n scaf_idx = 1\\n for i in range(len(mip[scafid])):\\n \\n # tokenize.\\n entry = mip[scafid][i]\\n ctg_name = entry[1]\\n if entry[2] == \\\"F\\\":\\n orien = 0\\n else:\\n orien = 1\\n start = int(entry[3])\\n stop = int(entry[4])\\n \\n # add to agp.\\n agps[idx]['scaf_name'] = scafid\\n agps[idx]['scaf_start'] = scaf_start\\n agps[idx]['scaf_stop'] = scaf_start + abs(stop - start)\\n agps[idx]['scaf_idx'] = scaf_idx\\n agps[idx]['comp_type'] = \\\"W\\\"\\n agps[idx]['comp_name'] = ctg_name\\n agps[idx]['comp_start'] = 1\\n agps[idx]['comp_stop'] = abs(stop - start)\\n agps[idx]['comp_orien'] = orien\\n agps[idx]['comp_linkage'] = 0\\n\\n # move up counts.\\n scaf_start = agps[idx]['scaf_stop'] + 1\\n scaf_idx += 1\\n idx += 1\\n \\n # do gap.\\n if entry[1] != mip[scafid][-1][1]:\\n \\n # add gap.\\n agps[idx]['scaf_name'] = scafid\\n agps[idx]['scaf_start'] = scaf_start\\n agps[idx]['scaf_stop'] = int(mip[scafid][i+1][3]) - 1\\n agps[idx]['scaf_idx'] = scaf_idx\\n agps[idx]['comp_type'] = \\\"N\\\"\\n agps[idx]['comp_name'] = \\\"fragment\\\"\\n agps[idx]['comp_start'] = 1\\n agps[idx]['comp_stop'] = abs(agps[idx]['scaf_stop'] - agps[idx]['scaf_start'])\\n agps[idx]['comp_orien'] = 0\\n agps[idx]['comp_linkage'] = 0 \\n \\n # move up counts.\\n scaf_start = int(mip[scafid][i+1][3])\\n scaf_idx += 1\\n idx += 1\\n\\n # copy results.\\n subprocess.call(['cp', OUT_FILE, scf_fasta])\\n\\n # save the agp.\\n save_agps(ctg_agp, agps)\\n\\n # add time.\\n with open(ctg_agp, 'rb') as fin:\\n lines = fin.read()\\n lines += 'RUNTIME: %.2f' % trun\\n with open(ctg_agp, 'wb') as fout:\\n fout.write(lines)\\n \\n # move the results.\\n\"\n },\n {\n \"alpha_fraction\": 0.5634479522705078,\n \"alphanum_fraction\": 0.5879085659980774,\n \"avg_line_length\": 28.347963333129883,\n \"blob_id\": \"23fb19e71a1584efb496e8b0dceba6961f3c1cfb\",\n \"content_id\": \"825f69eff1e75df7cb3760926609f855d9f39086\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 9362,\n \"license_type\": \"permissive\",\n \"max_line_length\": 167,\n \"num_lines\": 319,\n \"path\": \"/utils/prep.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"'''\\ndrivers to prepare the data for scaffolding\\n'''\\nimport sys\\nimport logging\\nimport string\\nimport subprocess\\nimport os\\n\\nfrom utils.misc import *\\n\\n## private functions ##\\n\\n## public functions ##\\ndef prep_silp(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\\"\\\"\\\" SILP scaffolder \\\"\\\"\\\"\\n\\n # create command base.\\n cmd_base = ['python', '/home/jrl03001/code/SILP2/silp.py']\\n\\n # preprocess.\\n job = list()\\n job.append('#!/bin/bash')\\n job.append('# preprocess')\\n job.append('%s nodes -w %s -c %s' % (' '.join(cmd_base), work_dir, ctg_fasta))\\n job.append('%s edges -w %s -i %i -s %i -%s -s1 %s -s2 %s' %\\n (' '.join(cmd_base), work_dir, ins_size, std_dev, pair_mode, read1_sam, read2_sam))\\n job.append('%s bundles -w %s -b %i -p 90 -bup 1 -r %s -i %i -s %i' % (' '.join(cmd_base), work_dir, bundle_size, ant_dir, ins_size, std_dev))\\n job.append('%s decompose -w %s -m 2500' % (' '.join(cmd_base), work_dir))\\n job.append('')\\n runit(job, prep_sh)\\n\\ndef prep_opera(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\\"\\\"\\\" opera scaffolder \\\"\\\"\\\"\\n\\n # opera specific directories.\\n input_dir = '%s/input' % work_dir\\n results_dir = '%s/results' % work_dir\\n script_dir = '%s/script' % work_dir\\n output_dir = '%s/output' % work_dir\\n log_dir = '%s/log' % work_dir\\n for x in [input_dir, results_dir, script_dir, output_dir, log_dir]:\\n create_dir(x)\\n\\n # opera sepecific files.\\n edge_file = '%s/opera_raw.txt' % input_dir\\n config_file = '%s/opera.cfg' % input_dir\\n script_file = '%s/opera.sh' % input_dir\\n tout_file = '%s/scaffolds.scaf' % results_dir\\n log_file = '%s/opera.log' % log_dir\\n\\n # open pair of sam files.\\n fin1 = open(read1_sam, \\\"rb\\\")\\n fin2 = open(read2_sam, \\\"rb\\\")\\n fout = open(edge_file, 'wb')\\n\\n # create the edge file from paired sam.\\n idx = 1\\n for line1 in fin1:\\n line2 = fin2.readline()\\n\\n # skip headers.\\n if line1[0] == \\\"@\\\" or line2[0] == \\\"@\\\":\\n continue\\n\\n # tokenize.\\n tokens1 = line1.strip().split(\\\"\\\\t\\\")\\n tokens2 = line2.strip().split(\\\"\\\\t\\\")\\n\\n # get data.\\n rname1 = tokens1[2]\\n rname2 = tokens2[2]\\n\\n qname1 = tokens1[0]\\n qname2 = tokens2[0]\\n\\n pos1 = int(tokens1[3])\\n pos2 = int(tokens2[3])\\n\\n szseq1 = len(tokens1[9])\\n szseq2 = len(tokens2[9])\\n\\n seq1 = tokens1[9]\\n seq2 = tokens2[9]\\n\\n # prepare orientation.\\n if tokens1[1] == \\\"0\\\":\\n orien1 = \\\"+\\\"\\n else:\\n orien1 = \\\"-\\\"\\n if tokens2[1] == \\\"0\\\":\\n orien2 = \\\"+\\\"\\n else:\\n orien2 = \\\"-\\\"\\n\\n # save names.\\n nm1 = \\\"%i.1\\\" % idx\\n nm2 = \\\"%i.2\\\" % idx\\n idx += 1\\n\\n # create txt.\\n line1 = \\\"%s\\\\t%s\\\\t%s\\\\t%i\\\\t%s\\\\t%s\\\\t%s\\\\n\\\" % (nm1, orien1, rname1, pos1, tokens1[9], tokens1[10], \\\"0\\\")\\n line2 = \\\"%s\\\\t%s\\\\t%s\\\\t%i\\\\t%s\\\\t%s\\\\t%s\\\\n\\\" % (nm2, orien2, rname2, pos2, tokens2[9], tokens2[10], \\\"0\\\")\\n\\n # write to file.\\n fout.write(line1)\\n fout.write(line2)\\n\\n # close up shop.\\n fin1.close()\\n fin2.close()\\n fout.close()\\n\\n # prepare config script\\n txt = \\\"\\\"\\\"#\\n# Essential Parameters\\n#\\n\\n# Please always supply absolute path of each file,\\n# Because relative path may not work all the time.\\n\\n# Output folder for final results\\noutput_folder=${opera_results_dir}\\n\\n# Contig file\\ncontig_file=${opera_node_file}\\n\\n#----------------------------------------------------------------------------------------------\\n# Advanced Parameters\\n\\n#\\n# Scaffolding related parameters\\n#\\n\\n# Scaffold name in result file\\nscaffold_name=scaffold\\n\\n# PET cluster threshold (default=5) (Opera will discard all clusters\\n\\n# Should Opera abort when running time for specific subgraph is longer\\n# than 30 minutes (true or false, default=true)\\nabort=false\\n\\n#----------------------------------------------------------------------------------------------\\n#\\n# Contig file related parameters\\n#\\n\\n# Format of contig file (fasta or statistic, default=fasta)\\nfile_format=fasta\\n\\n# Program name generating contig file (velvet or soap, default=velvet)\\nfile_type=velvet\\n\\n# Should the repeat contigs be filtered (yes or no, default=true)\\nfilter_repeat=yes\\n\\n# Repeat threshold (default=1.5): If the coverage of a contig is higher than\\n# (repeat threshold * average coverage), then it is considered as repeat\\nrepeat_threshold=1.5\\n\\n# Contig size threshold (default=500): Opera will not use the contigs whose length\\n# is shorter than this value\\ncontig_size_threshold=10\\n\\n#----------------------------------------------------------------------------------------------\\n#\\n# Library parameters.\\n#\\n\\n[LIB]\\ncalculate_ori=no\\nread_ori=in\\nmap_type=bowtie\\ncalculate_lib=no\\nlib_mean=${lib_mean}\\nlib_std=${lib_std}\\ncluster_threshold=${pet_size}\\nmap_file=${opera_edge_file}\\n\\\"\\\"\\\"\\n txt = string.Template(txt)\\n txt = txt.substitute(opera_results_dir=results_dir, opera_node_file=ctg_fasta, opera_edge_file=edge_file, pet_size=bundle_size, lib_mean=ins_size, lib_std=std_dev)\\n\\n # write to file.\\n fout = open(config_file, \\\"wb\\\")\\n fout.write(txt)\\n fout.close()\\n\\n\\ndef prep_mip(work_dir, ant_dir, prep_sh, ctg_fasta, read1_sam, read2_sam, ins_size, std_dev, bundle_size, pair_mode, args):\\n \\\"\\\"\\\" mip scaffolder \\\"\\\"\\\"\\n\\n # simplify files.\\n ant_dir = '/dev/null'\\n pre_sh = prep_sh\\n\\n contig_file = ctg_fasta\\n test1 = read1_sam\\n test2 = read2_sam\\n \\n # sanity.\\n if os.path.isfile(test1) == False or os.path.isfile(test2) == False:\\n logging.error(\\\"missing file:\\\")\\n logging.error(test1)\\n logging.error(test2)\\n \\n # mip specific files.\\n SAM_1_MOD = \\\"%s/sam_1.sam\\\" % work_dir\\n SAM_2_MOD = \\\"%s/sam_2.sam\\\" % work_dir\\n MERGED_FILE = \\\"%s/merged\\\" % work_dir\\n MERGED1_FILE = \\\"%s/merged.sorted1\\\" % work_dir\\n MERGED2_FILE = \\\"%s/merged.sorted2\\\" % work_dir\\n FILTERED_FILE = \\\"%s/filtered.txt\\\" % work_dir\\n COV_FILE = \\\"%s/coverage.txt\\\" % work_dir\\n PARAM_FILE = \\\"%s/parameters.txt\\\" % work_dir\\n MIP_FILE = \\\"%s/scaffolds2.txt\\\" % work_dir\\n\\n # modify SAM file to be happy with MIP.\\n fin1 = open(test1, \\\"rb\\\")\\n fin2 = open(test2, \\\"rb\\\")\\n fout1 = open(SAM_1_MOD, \\\"wb\\\")\\n fout2 = open(SAM_2_MOD, \\\"wb\\\")\\n for line1 in fin1:\\n line2 = fin2.readline()\\n \\n # tokenize.\\n tokens1 = line1.strip().split(\\\"\\\\t\\\")\\n tokens2 = line2.strip().split(\\\"\\\\t\\\")\\n \\n # change naming convention.\\n tokens1[0] = tokens1[0].replace(\\\"/1\\\",\\\"_R3\\\")\\n tokens2[0] = tokens2[0].replace(\\\"/2\\\",\\\"_F3\\\")\\n \\n # modify orientation.\\n if pair_mode == 'rf':\\n if tokens1[1] == \\\"0\\\":\\n tokens1[1] = \\\"16\\\"\\n else:\\n tokens1[1] = \\\"0\\\"\\n else:\\n print pair_mode\\n logging.error('un-written')\\n sys.exit(1)\\n \\n \\n # write it back out.\\n fout1.write('\\\\t'.join(tokens1) + '\\\\n')\\n fout2.write('\\\\t'.join(tokens2) + '\\\\n')\\n\\n fin1.close() \\n fin2.close() \\n fout1.close() \\n fout2.close() \\n\\n PROG_1 = \\\"/opt/mip/scripts/merge.sh\\\"\\n PROG_2 = \\\"/opt/mip/scripts/filter-mappings.sh\\\"\\n PROG_3 = \\\"/home/jrl03001/code/ScafValidate/mip/contig_coverage.py\\\"\\n #'''\\n # merge data.\\n with open(pre_sh, 'wb') as fout:\\n \\n # prepare.\\n fout.write('#!/bin/bash\\\\n')\\n cmd = [PROG_1, SAM_2_MOD, SAM_1_MOD, MERGED_FILE]\\n fout.write(' '.join(cmd) + '\\\\n')\\n cmd = [PROG_2, MERGED1_FILE, MERGED2_FILE, FILTERED_FILE]\\n fout.write(' '.join(cmd) + '\\\\n')\\n cmd = [\\\"python\\\", PROG_3, contig_file, COV_FILE, SAM_1_MOD, SAM_2_MOD]\\n fout.write(' '.join(cmd) + '\\\\n')\\n \\n # run it.\\n subprocess.call([\\\"chmod\\\", \\\"u+x\\\", pre_sh])\\n if subprocess.call([pre_sh], cwd=work_dir) != 0:\\n logging.error(\\\"couldn't prepare MIP\\\")\\n sys.exit(1)\\n\\n #'''\\n # write the config.\\n txt = '''# Upper bound for genome length (required)\\ngenome_length=5000000000\\n\\n#parameter specifications for the first stage\\n[STAGE]\\n# Maximum biconnected component size. (optional)\\n#maximum_biconnected_component=50\\n# Maximum allowed degree in scaffolding graph. (optional)\\nmaximum_degree=50\\n# Maximum coverage for nonrepetitive contig. (optional)\\n#maximum_coverage=100\\n# The maximum overlap between contigs that is allowed without checking for\\n# sequence similarity. By default this is set based on the variablility in\\n# insert size lengths of each library. (optional)\\n#maximum_overlap=100\\n# The minimum support for an edge. (optional)\\nminimum_support=%i\\n# Should edges with negative estimated distance be checked for sequence\\n# similarity or removed automatically? (optional)\\ncheck_negative_edges=1\\n\\n# library specification for the first stage\\n[LIBRARY]\\n# File in SAM format containing mappings for the mate pair reads\\n# to the contigs\\nmappings=%s\\n# Orientation of the mate pairs (in current version must be SOLID)\\norientation=SOLID\\n# Insert length\\ninsert_length=%i\\n# Minimum insert length\\nmin_insert_length=%i\\n# Maximum insert length\\nmax_insert_length=%i\\n''' % (bundle_size, FILTERED_FILE, ins_size, (ins_size - (3*std_dev)), (ins_size + (3*std_dev)))\\n\\n \\n # write to file.\\n fout = open(PARAM_FILE, \\\"wb\\\")\\n fout.write(txt)\\n fout.close()\\n\"\n },\n {\n \"alpha_fraction\": 0.7733333110809326,\n \"alphanum_fraction\": 0.7787878513336182,\n \"avg_line_length\": 48.93939208984375,\n \"blob_id\": \"e3a5c0f43aac28f5cb51851c0920604634639204\",\n \"content_id\": \"14d1bf9b18bb635859d30bb1b62a69d27e2d9e97\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Markdown\",\n \"length_bytes\": 1650,\n \"license_type\": \"permissive\",\n \"max_line_length\": 233,\n \"num_lines\": 33,\n \"path\": \"/README.md\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"scafathon\\n=========\\n\\n**Genome scaffolding comparison framework**\\n\\n\\n## Overview\\nScafathon is just a collection of scripts used to evaluate three genome scaffolding tools; SILP2, OPERA and MIP. It should be easy to extend this framework to add more tools. It relies on Quast for alignment based accuracy assesment.\\n\\n***Warning: This code is only intended for use by professionals. Modification of the source code is required to set proper paths to external executables. Furthermore adding additional scaffolding tools requires manual coding.***\\n\\n## Usage\\nThe tool is divided up into several sub-programs which need to be run in-order. Use the \\\"-h\\\" argument after each of the following sub-commands for a description of their usage.\\n```python\\npython silp.py [sub-command] -h\\n```\\n1. *align:* aligns the paired reads (required bowtie2) installed\\n2. *pair:* pairs two existing SAM files\\n3. *meta_combine:* combines two pairs of SAM files at different percentages [metagenomic simulations]\\n4. *prep:* prepares selected scaffold algorithm by running all preprocessing code\\n5. *run:* runs scaffolding tool\\n6. *sim_eval:* evaluates scaffold if there exists a reference AGP with locations of each contig\\n7. *real_eval:* uses alignment based accuracy metrics\\n\\n## Installation\\nThis is primarily a python program, it relies on several python packages:\\n* numpy\\n* networkx\\n\\nAlso several seperate packages are required. These include nucmer, quast and [parabio](https://github.com/jim-bo/parabio).\\n\\n## Disclaimer\\nThis is a research tool written in a research enviroment. No support is offered and bugs may be present. Only one library size is support at this time. \\n\\n\"\n },\n {\n \"alpha_fraction\": 0.4289953410625458,\n \"alphanum_fraction\": 0.4340822398662567,\n \"avg_line_length\": 25.505617141723633,\n \"blob_id\": \"b981c7a67de36752d838201660e7edad35900281\",\n \"content_id\": \"fd5e0fa3b08a8602cfa93f7b9fc56904188bc8a3\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 2359,\n \"license_type\": \"permissive\",\n \"max_line_length\": 67,\n \"num_lines\": 89,\n \"path\": \"/utils/misc.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import subprocess\\nimport os\\nimport numpy as np\\n\\nagp_dt = np.dtype([\\\\\\n ('scaf_name', 'S255'),\\\\\\n ('scaf_start', np.long),\\\\\\n ('scaf_stop', np.long),\\\\\\n ('scaf_idx', np.long),\\\\\\n ('comp_type', 'S50'),\\\\\\n ('comp_name', 'S255'),\\\\\\n ('comp_start', np.long),\\\\\\n ('comp_stop', np.long),\\\\\\n ('comp_orien', np.long),\\\\\\n ('comp_linkage', np.long),\\\\\\n])\\n\\n\\ndef runit(job, path):\\n \\\"\\\"\\\" runs the job \\\"\\\"\\\"\\n with open(path, 'wb') as fout:\\n fout.write('\\\\n'.join(job))\\n subprocess.call(['chmod', 'a+x', path])\\n subprocess.call(['bash', path])\\n\\ndef create_dir(dir_path):\\n ''' creates directory if necessary'''\\n if os.path.isdir(dir_path) == False:\\n if subprocess.call([\\\"mkdir\\\", dir_path]) != 0:\\n logging.error(\\\"couldn't make dir\\\")\\n sys.exit(1)\\n\\n\\n\\ndef save_agps(agp_file, agp):\\n ''' saves agp to disk.'''\\n\\n # write to file.\\n fout = open(agp_file, \\\"w\\\")\\n\\n # write each entry.\\n z = len(agp_dt.names)\\n for i in range(agp.size):\\n\\n # sanity skip.\\n if agp[i]['scaf_name'] == \\\"\\\":\\n continue\\n\\n # format result.\\n tmp = agp[i]\\n if tmp['comp_type'] == \\\"W\\\":\\n # get orientation.\\n if tmp[\\\"comp_orien\\\"] == 0:\\n o = \\\"+\\\"\\n else:\\n o = \\\"-\\\"\\n\\n # write contig.\\n txt = str(tmp['scaf_name']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_start']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_stop']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_idx']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_type']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_name']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_start']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_stop']) + \\\"\\\\t\\\"\\n txt += o + \\\"\\\\n\\\"\\n\\n else:\\n # get linkage.\\n if tmp['comp_linkage'] == 0:\\n o = \\\"no\\\"\\n else:\\n o = \\\"yes\\\"\\n\\n # write gap.\\n txt = str(tmp['scaf_name']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_start']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_stop']) + \\\"\\\\t\\\"\\n txt += str(tmp['scaf_idx']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_type']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_stop'] - tmp['comp_start']) + \\\"\\\\t\\\"\\n txt += str(tmp['comp_name']) + \\\"\\\\t\\\"\\n txt += o + \\\"\\\\n\\\"\\n\\n fout.write(txt)\\n\\n # close file.\\n fout.close()\\n\"\n },\n {\n \"alpha_fraction\": 0.5159717202186584,\n \"alphanum_fraction\": 0.5442575216293335,\n \"avg_line_length\": 23.1235294342041,\n \"blob_id\": \"b480607bf84c02ee5083aaa1ddb0970b00cae73c\",\n \"content_id\": \"d0f3285b47682ee4eb2c1e9f9ed79e596c539994\",\n \"detected_licenses\": [\n \"MIT\"\n ],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 8202,\n \"license_type\": \"permissive\",\n \"max_line_length\": 105,\n \"num_lines\": 340,\n \"path\": \"/utils/align.py\",\n \"repo_name\": \"jim-bo/scafathon\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"'''\\nalignment utility functions\\n'''\\nimport os\\nimport sys\\nimport subprocess\\nimport logging\\nimport mmap\\nfrom operator import itemgetter\\nimport numpy as np\\n\\n## public functions ##\\ndef create_idx(asm_fasta, index_file):\\n \\\"\\\"\\\" make bowtie2 index\\n Parameters:\\n -----------\\n asm_fasta : str\\n index_file : str\\n \\\"\\\"\\\"\\n\\n # run the command.\\n subprocess.call(['bowtie2-build', '-f', asm_fasta, index_file])\\n\\ndef create_aln(size_file, index_file, fastq_file, sam_file, ant_dir, num_cpu):\\n \\\"\\\"\\\" make bowtie2 alignment and\\n pull out multimappers/\\n Parameters:\\n -----------\\n index_file : str\\n fastq_file : str\\n \\\"\\\"\\\"\\n\\n # create sizes.\\n sizes = dict()\\n with open(size_file, \\\"rb\\\") as fin:\\n lines = fin.readlines()\\n for line in lines:\\n sz, name = line.strip().split()\\n sz = int(sz)\\n sizes[name] = sz\\n\\n # create the annotation arrays.\\n annotes = dict()\\n for ref in sizes:\\n annotes[ref] = np.zeros(sizes[ref], dtype=np.int)\\n\\n # create alignment command.\\n cmd = ['bowtie2','--reorder', '-k', '10', '-q','-p',str(num_cpu), '-x', index_file, '-U', fastq_file]\\n\\n # call the command and pipe output.\\n output = subprocess.Popen(cmd, stdout=subprocess.PIPE)\\n\\n # open single-sam file.\\n sam_out = open(sam_file, \\\"wb\\\")\\n\\n # loop over each alignment.\\n for status, line in _extract_sam(output):\\n\\n # dump good ones.\\n if status == True:\\n sam_out.write(line)\\n continue\\n\\n # record location of baduns.\\n tokens = line.strip().split()\\n start = int(tokens[3])\\n stop = start + len(tokens[9])\\n rname = tokens[2]\\n\\n # annotate that.\\n annotes[rname][start:stop] += 1\\n\\n # close output.\\n sam_out.close()\\n\\n # serialize multimap.\\n for ref in annotes:\\n\\n # create name.\\n fname = '%s/%s.npy' % (ant_dir, ref)\\n\\n # look for existing.\\n if os.path.isfile(fname):\\n tmp = np.load(fname)\\n annotes[ref] = annotes[ref] + tmp\\n\\n # serialize it.\\n np.save(fname, annotes[ref])\\n\\ndef pair_sam(sam_in_1, sam_in_2, sam_out_1, sam_out_2, key_size):\\n \\\"\\\"\\\" pairs SAM files \\\"\\\"\\\"\\n\\n # memory map the SAM files1.\\n fin1 = open(sam_in_1, \\\"r+\\\")\\n fin2 = open(sam_in_2, \\\"r+\\\")\\n\\n map1 = mmap.mmap(fin1.fileno(), 0, access=mmap.ACCESS_COPY)\\n map2 = mmap.mmap(fin2.fileno(), 0, access=mmap.ACCESS_COPY)\\n\\n # create lists from data.\\n hitlist1 = list()\\n hitlist2 = list()\\n for p1, p2 in _sam_gen(map1, map2, key_size):\\n hitlist1.append(p1)\\n hitlist2.append(p2)\\n\\n # seek files bake to begining.\\n map1.seek(0)\\n map2.seek(0)\\n\\n # sort lists by name, reverse so we can pop from end.\\n hitlist1.sort(key=itemgetter(1), reverse=True)\\n hitlist2.sort(key=itemgetter(1), reverse=True)\\n\\n # open output files.\\n fout1 = open(sam_out_1, \\\"wb\\\")\\n fout2 = open(sam_out_2, \\\"wb\\\")\\n\\n # generator of pairs.\\n for p1, p2 in _pair_gen(hitlist1, hitlist2):\\n\\n # load sam info from map.\\n map1.seek(p1[0])\\n map2.seek(p2[0])\\n\\n # write out info.\\n fout1.write(map1.readline())\\n fout2.write(map2.readline())\\n\\n # close output files.\\n fout1.close()\\n fout2.close()\\n\\n # close memmory mapped files.\\n map1.close()\\n map2.close()\\n\\n fin1.close()\\n fin2.close()\\n\\n\\ndef pair_sam2(sam_in_1, sam_in_2, sam_out_1, sam_out_2, key_size):\\n \\\"\\\"\\\" pairs SAM files \\\"\\\"\\\"\\n\\n # memory map the first SAM file.\\n logging.info(\\\"opening memory map files\\\")\\n\\n # build name arrays.\\n logging.info(\\\"extracting name array 1\\\")\\n id1 = _extract_names(sam_in_1, key_size)\\n logging.info(\\\"extracting name array 2\\\")\\n id2 = _extract_names(sam_in_2, key_size)\\n\\n # sort the names and copy.\\n logging.info(\\\"sorting name array 1\\\")\\n srt1 = np.sort(id1[:]['name'])\\n logging.info(\\\"sorting name array 2\\\")\\n srt2 = np.sort(id2[:]['name'])\\n\\n # compute unique in each pair.\\n logging.info(\\\"unique 1\\\")\\n uq1 = _numpy_unique(srt1)\\n logging.info(\\\"unique 2\\\")\\n uq2 = _numpy_unique(srt2)\\n\\n # compute the intersection of unique.\\n logging.info(\\\"intersection\\\")\\n valid_list = np.intersect1d(uq1, uq2, assume_unique=True)\\n\\n # sanity check.\\n assert len(valid_list) != 0, 'cant have no valid stuff'\\n\\n # create a set.\\n logging.info(\\\"set\\\")\\n valid = set(list(valid_list))\\n\\n # write the entries.\\n logging.info(\\\"writing\\\")\\n _write_valid(sam_in_1, id1, valid, sam_out_1)\\n _write_valid(sam_in_2, id2, valid, sam_out_2)\\n logging.info(\\\"done\\\")\\n\\n\\n## internal functions ##\\n\\ndef _write_valid(sam_in_1, id1, valid, sam_out_1):\\n \\\"\\\"\\\" writes entries from valid set\\\"\\\"\\\"\\n\\n # open output.\\n fout1 = open(sam_out_1, \\\"wb\\\")\\n fin1 = open(sam_in_1, \\\"rb\\\")\\n\\n # generator of pairs.\\n idx = 0\\n for line in fin1:\\n\\n # operate.\\n if id1[idx]['name'] in valid:\\n fout1.write(line)\\n\\n # udpate\\n idx += 1\\n\\n # close em.\\n fout1.close()\\n fin1.close()\\n\\ndef _numpy_unique(srt1):\\n \\\"\\\"\\\" return unique subset\\\"\\\"\\\"\\n\\n # create mask.\\n good = np.zeros(srt1.shape[0], dtype=np.bool)\\n good[:] = False\\n\\n # iterate over non-boundry cases.\\n for i in range(1, srt1.shape[0]-1):\\n\\n # must not match its neighbors.\\n if srt1[i-1] != srt1[i] and srt1[i+1] != srt1[i]:\\n good[i] = True\\n\\n # check the first one.\\n if srt1[0] != srt1[1]:\\n good[0] = True\\n\\n # check the last one.\\n if srt1[-1] != srt1[-2]:\\n good[-1] = True\\n\\n # return the subset slice.\\n return srt1[good]\\n\\n\\ndef _extract_names(file_name, key_size):\\n \\\"\\\"\\\" builds numpy array of name hits\\\"\\\"\\\"\\n\\n # count lines.\\n with open(file_name, \\\"rb\\\") as fin:\\n line_cnt1 = 0\\n for line in fin:\\n line_cnt1 += 1\\n\\n # allocate array.\\n id1 = np.zeros(line_cnt1, dtype=np.dtype([('name','S25'),('row',np.int)]))\\n\\n # copy data into array.\\n with open(file_name, \\\"rb\\\") as fin:\\n\\n idx = 0\\n for line1 in fin:\\n # operate.\\n if key_size == 0:\\n id1[idx]['name'] = line1.split(\\\"\\\\t\\\")[0]\\n else:\\n id1[idx]['name'] = line1.split(\\\"\\\\t\\\")[0][0:-key_size]\\n id1[idx]['row'] = idx\\n\\n # reset.\\n idx += 1\\n\\n # return the array.\\n return id1\\n\\ndef _extract_sam(output):\\n ''' extracts output form SAM'''\\n\\n # extract unique to file, save multimap annotations.\\n for line in iter(output.stdout.readline,''):\\n\\n # skip header.\\n if line[0] == '@': continue\\n\\n # split.\\n tokens = line.strip().split()\\n\\n # check for no align.\\n if tokens[2] == '*':\\n continue\\n\\n # check for MAPQ > 2:\\n if int(tokens[4]) < 2:\\n yield False, line\\n else:\\n # its good, yield it.\\n yield True, line\\n\\n\\ndef _sam_gen(map1, map2, key_size):\\n '''yields the SAM name and the line index'''\\n\\n # loop till end of file.\\n line1 = map1.readline()\\n line2 = map2.readline()\\n pos1 = 0\\n pos2 = 0\\n while line1 != '' and line2 != '':\\n\\n # process it.\\n tok1 = line1.strip().split()\\n tok2 = line2.strip().split()\\n\\n # remove to key.\\n if key_size != 0:\\n key1 = tok1[0][0:-key_size]\\n key2 = tok2[0][0:-key_size]\\n else:\\n key1 = tok1[0]\\n key2 = tok2[0]\\n\\n # yield the name and line number.\\n yield (pos1, key1), (pos2, key2)\\n\\n # update info.\\n pos1 += len(line1)\\n pos2 += len(line2)\\n line1 = map1.readline()\\n line2 = map2.readline()\\n\\ndef _pair_gen(hitlist1, hitlist2):\\n ''' does an in-order walk to find pairs '''\\n\\n # loop till each list is empty.\\n while len(hitlist1) > 0 and len(hitlist2) > 0:\\n\\n # peek for a match.\\n if hitlist1[-1][1] == hitlist2[-1][1]:\\n\\n # yield it.\\n yield hitlist1[-1], hitlist2[-1]\\n\\n # change left.\\n hitlist1.pop()\\n\\n else:\\n\\n # pop smaller.\\n if hitlist1[-1][1] < hitlist2[-1][1]:\\n hitlist1.pop()\\n else:\\n hitlist2.pop()\\n\"\n }\n]"},"num_files":{"kind":"number","value":7,"string":"7"}}},{"rowIdx":2978314,"cells":{"repo_name":{"kind":"string","value":"BlackCyn/IshmuratovDaniilVTIP2"},"repo_url":{"kind":"string","value":"https://github.com/BlackCyn/IshmuratovDaniilVTIP2"},"snapshot_id":{"kind":"string","value":"f7d237be831eb04edbd2aff9b4768d42de7f2cbb"},"revision_id":{"kind":"string","value":"e7cc19f8ad1290ce18e1eab959f8bc96ec794c5a"},"directory_id":{"kind":"string","value":"fb27a87d3666efc19b484a9b300f6df8b2c96527"},"branch_name":{"kind":"string","value":"refs/heads/main"},"visit_date":{"kind":"timestamp","value":"2023-01-10T09:59:35.243515","string":"2023-01-10T09:59:35.243515"},"revision_date":{"kind":"timestamp","value":"2020-11-15T05:48:46","string":"2020-11-15T05:48:46"},"committer_date":{"kind":"timestamp","value":"2020-11-15T05:48:46","string":"2020-11-15T05:48:46"},"github_id":{"kind":"number","value":312966508,"string":"312,966,508"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.5271122455596924,"alphanum_fraction":0.5526931881904602,"avg_line_length":23.463302612304688,"blob_id":"ec18c590bd8cdc02b3766648520b18353a848259","content_id":"8f11df4364c75d0d8c0d3fa6d59ac03cacb53b95","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":6570,"license_type":"no_license","max_line_length":100,"num_lines":218,"path":"/ВТИП2.py","repo_name":"BlackCyn/IshmuratovDaniilVTIP2","src_encoding":"UTF-8","text":"#Сортировка выборкой\r\ndef selection(numbers): \r\n # i = количеству отсортированных значений\r\n for i in range(len(numbers)):\r\n # Исходно считаем наименьшим первый элемент\r\n lowest = i\r\n # Этот цикл перебирает несортированные элементы\r\n for j in range(i + 1, len(numbers)):\r\n if numbers[j] < numbers[lowest]:\r\n lowest = j\r\n # меняем самый маленький элемент в списке на самый первый\r\n numbers[i], numbers[lowest] = numbers[lowest], numbers[i]\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\nselection(numb) \r\nprint(\"Массив, отсортированный выборкой\", numb)\r\n\r\n\r\n\r\n#Пузырьковая сортировка\r\ndef bubble(numbers): \r\n # Присваиваем переменной switch, чтобы цикл запустился хотя бы один раз\r\n switch = True\r\n while switch:\r\n switch = False\r\n for i in range(len(numbers) - 1):\r\n if numbers[i] > numbers[i + 1]:\r\n # Меняем элементы \r\n numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]\r\n # Устанавливаем switch в True для следующей итерации\r\n switch = True\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\nbubble(numb) \r\nprint(\"Массив, отсортированный методом пузырька\", numb)\r\n\r\n\r\n\r\n#Сортировка вставками\r\ndef insertion(numbers): \r\n for i in range(1, len(numbers)):\r\n item_to_insert = numbers[i]\r\n # Ссылку на индекс предыдущего элемента сохраняем\r\n j = i - 1\r\n # Элементы отсортированного сегмента перемещаем вперёд, если они больше элемента для вставки\r\n while j >= 0 and numbers[j] > item_to_insert:\r\n numbers[j + 1] = numbers[j]\r\n j -= 1\r\n # Вставляем элемент\r\n numbers[j + 1] = item_to_insert\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\ninsertion(numb) \r\nprint(\"Массив, отсортированный методом вставки\", numb)\r\n\r\n\r\n\r\n#Пирамидальная сортировка\r\ndef heapify(numbers, size, index): \r\n # Индекс наибольшего элемента считаем корневым индексом\r\n largest = index\r\n left = (2 * index) + 1\r\n right = (2 * index) + 2\r\n\r\n if left < size and numbers[left] > numbers[largest]:\r\n largest = left\r\n\r\n if right < size and numbers[right] > numbers[largest]:\r\n largest = right\r\n\r\n if largest != index:\r\n numbers[index], numbers[largest] = numbers[largest], numbers[index]\r\n heapify(numbers, size, largest)\r\n\r\ndef heap_sort(nums): \r\n n = len(nums)\r\n\r\n # Создаём Max Heap из списка\r\n for i in range(n, -1, -1):\r\n heapify(nums, n, i)\r\n\r\n # Перемещаем корень Max Heap в конец списка\r\n for i in range(n - 1, 0, -1):\r\n nums[i], nums[0] = nums[0], nums[i]\r\n heapify(nums, i, 0)\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\nheap_sort(numb) \r\nprint(\"Массива отсортированный пирамидальным методов\", numb)\r\n\r\n\r\n\r\n#Быстрая сортировка\r\ndef split(numbers, low, high): \r\n # Cредний элемент выбираем в качестве опорного\r\n\r\n pivot = numbers[(low + high) // 2]\r\n i = low - 1\r\n j = high + 1\r\n while True:\r\n i += 1\r\n while numbers[i] < pivot:\r\n i += 1\r\n\r\n j -= 1\r\n while numbers[j] > pivot:\r\n j -= 1\r\n\r\n if i >= j:\r\n return j\r\n\r\n # Если левый от опорного элемента больше чем правый, меняем их местаими\r\n numbers[i], numbers[j] = numbers[j], numbers[i]\r\n\r\ndef quick1(numbers): \r\n def quick2(items, low, high):\r\n if low < high:\r\n index = split(items, low, high)\r\n quick2(items, low, index)\r\n quick2(items, index + 1, high)\r\n\r\n quick2(numbers, 0, len(numbers) - 1)\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\nquick1(numb) \r\nprint(\"Массив, отсортированный методом быстрой сортировки\", numb) \r\n\r\n\r\n\r\n#Сортировка методом слияния\r\ndef merge(left, right): \r\n sorted = []\r\n left_index = right_index = 0\r\n\r\n left_length, right_length = len(left), len(right)\r\n\r\n for _ in range(left_length + right_length):\r\n if left_index < left_length and right_index < right_length:\r\n # Сравниваем первые элементы в начале каждого списка\r\n\r\n if left[left_index] <= right[right_index]:\r\n sorted.append(left[left_index])\r\n left_index += 1\r\n else:\r\n sorted.append(right[right_index])\r\n right_index += 1\r\n\r\n elif left_index == left_length:\r\n sorted.append(right[right_index])\r\n right_index += 1\r\n\r\n elif right_index == right_length:\r\n sorted.append(left[left_index])\r\n left_index += 1\r\n\r\n return sorted\r\n\r\ndef merge_sort(numbers): \r\n\r\n if len(numbers) <= 1:\r\n return numbers\r\n \r\n mid = len(numbers) // 2\r\n\r\n left = merge_sort(numbers[:mid])\r\n right = merge_sort(numbers[mid:])\r\n\r\n return merge(left, right)\r\n\r\n# Проверка\r\nnumb = [4, 2, 55, 123, 22] \r\nnumb = merge_sort(numb) \r\nprint(\"Массив, отсортированный методом слияния\", numb)\r\n\r\n\r\n\r\n\r\nimport math \r\ndef my_sin (x,n): \r\n x = x/180*math.pi \r\n q = x\r\n s = 0 \r\n for i in range(1, n+1):\r\n s = s+ q\r\n q = q* (-1) * (x*x) / ((2*i+1) * (2*i)) \r\n return s \r\n\r\n\r\n\r\n\r\n\r\ndef f(x):\r\n return 2.718281828459045**(1+x)\r\ndef tailor(x, eps):\r\n x = 1+x\r\n sum = 1+x\r\n term = x;\r\n n = 2;\r\n while term*term > eps*eps:\r\n term *= x/n\r\n n += 1\r\n sum += term\r\n return sum\r\n\r\na=3.0\r\nb=4.0\r\nkrok=(b-a)/10\r\n\r\nwhile a<=b: \r\n print(round(a,2), end=' ')\r\n print(round(f(a),5),end=' ')\r\n print(round(tailor(a,1e-6),5))\r\n a+=krok\r\n"}],"string":"[\n {\n \"alpha_fraction\": 0.5271122455596924,\n \"alphanum_fraction\": 0.5526931881904602,\n \"avg_line_length\": 23.463302612304688,\n \"blob_id\": \"ec18c590bd8cdc02b3766648520b18353a848259\",\n \"content_id\": \"8f11df4364c75d0d8c0d3fa6d59ac03cacb53b95\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 6570,\n \"license_type\": \"no_license\",\n \"max_line_length\": 100,\n \"num_lines\": 218,\n \"path\": \"/ВТИП2.py\",\n \"repo_name\": \"BlackCyn/IshmuratovDaniilVTIP2\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#Сортировка выборкой\\r\\ndef selection(numbers): \\r\\n # i = количеству отсортированных значений\\r\\n for i in range(len(numbers)):\\r\\n # Исходно считаем наименьшим первый элемент\\r\\n lowest = i\\r\\n # Этот цикл перебирает несортированные элементы\\r\\n for j in range(i + 1, len(numbers)):\\r\\n if numbers[j] < numbers[lowest]:\\r\\n lowest = j\\r\\n # меняем самый маленький элемент в списке на самый первый\\r\\n numbers[i], numbers[lowest] = numbers[lowest], numbers[i]\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\nselection(numb) \\r\\nprint(\\\"Массив, отсортированный выборкой\\\", numb)\\r\\n\\r\\n\\r\\n\\r\\n#Пузырьковая сортировка\\r\\ndef bubble(numbers): \\r\\n # Присваиваем переменной switch, чтобы цикл запустился хотя бы один раз\\r\\n switch = True\\r\\n while switch:\\r\\n switch = False\\r\\n for i in range(len(numbers) - 1):\\r\\n if numbers[i] > numbers[i + 1]:\\r\\n # Меняем элементы \\r\\n numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]\\r\\n # Устанавливаем switch в True для следующей итерации\\r\\n switch = True\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\nbubble(numb) \\r\\nprint(\\\"Массив, отсортированный методом пузырька\\\", numb)\\r\\n\\r\\n\\r\\n\\r\\n#Сортировка вставками\\r\\ndef insertion(numbers): \\r\\n for i in range(1, len(numbers)):\\r\\n item_to_insert = numbers[i]\\r\\n # Ссылку на индекс предыдущего элемента сохраняем\\r\\n j = i - 1\\r\\n # Элементы отсортированного сегмента перемещаем вперёд, если они больше элемента для вставки\\r\\n while j >= 0 and numbers[j] > item_to_insert:\\r\\n numbers[j + 1] = numbers[j]\\r\\n j -= 1\\r\\n # Вставляем элемент\\r\\n numbers[j + 1] = item_to_insert\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\ninsertion(numb) \\r\\nprint(\\\"Массив, отсортированный методом вставки\\\", numb)\\r\\n\\r\\n\\r\\n\\r\\n#Пирамидальная сортировка\\r\\ndef heapify(numbers, size, index): \\r\\n # Индекс наибольшего элемента считаем корневым индексом\\r\\n largest = index\\r\\n left = (2 * index) + 1\\r\\n right = (2 * index) + 2\\r\\n\\r\\n if left < size and numbers[left] > numbers[largest]:\\r\\n largest = left\\r\\n\\r\\n if right < size and numbers[right] > numbers[largest]:\\r\\n largest = right\\r\\n\\r\\n if largest != index:\\r\\n numbers[index], numbers[largest] = numbers[largest], numbers[index]\\r\\n heapify(numbers, size, largest)\\r\\n\\r\\ndef heap_sort(nums): \\r\\n n = len(nums)\\r\\n\\r\\n # Создаём Max Heap из списка\\r\\n for i in range(n, -1, -1):\\r\\n heapify(nums, n, i)\\r\\n\\r\\n # Перемещаем корень Max Heap в конец списка\\r\\n for i in range(n - 1, 0, -1):\\r\\n nums[i], nums[0] = nums[0], nums[i]\\r\\n heapify(nums, i, 0)\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\nheap_sort(numb) \\r\\nprint(\\\"Массива отсортированный пирамидальным методов\\\", numb)\\r\\n\\r\\n\\r\\n\\r\\n#Быстрая сортировка\\r\\ndef split(numbers, low, high): \\r\\n # Cредний элемент выбираем в качестве опорного\\r\\n\\r\\n pivot = numbers[(low + high) // 2]\\r\\n i = low - 1\\r\\n j = high + 1\\r\\n while True:\\r\\n i += 1\\r\\n while numbers[i] < pivot:\\r\\n i += 1\\r\\n\\r\\n j -= 1\\r\\n while numbers[j] > pivot:\\r\\n j -= 1\\r\\n\\r\\n if i >= j:\\r\\n return j\\r\\n\\r\\n # Если левый от опорного элемента больше чем правый, меняем их местаими\\r\\n numbers[i], numbers[j] = numbers[j], numbers[i]\\r\\n\\r\\ndef quick1(numbers): \\r\\n def quick2(items, low, high):\\r\\n if low < high:\\r\\n index = split(items, low, high)\\r\\n quick2(items, low, index)\\r\\n quick2(items, index + 1, high)\\r\\n\\r\\n quick2(numbers, 0, len(numbers) - 1)\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\nquick1(numb) \\r\\nprint(\\\"Массив, отсортированный методом быстрой сортировки\\\", numb) \\r\\n\\r\\n\\r\\n\\r\\n#Сортировка методом слияния\\r\\ndef merge(left, right): \\r\\n sorted = []\\r\\n left_index = right_index = 0\\r\\n\\r\\n left_length, right_length = len(left), len(right)\\r\\n\\r\\n for _ in range(left_length + right_length):\\r\\n if left_index < left_length and right_index < right_length:\\r\\n # Сравниваем первые элементы в начале каждого списка\\r\\n\\r\\n if left[left_index] <= right[right_index]:\\r\\n sorted.append(left[left_index])\\r\\n left_index += 1\\r\\n else:\\r\\n sorted.append(right[right_index])\\r\\n right_index += 1\\r\\n\\r\\n elif left_index == left_length:\\r\\n sorted.append(right[right_index])\\r\\n right_index += 1\\r\\n\\r\\n elif right_index == right_length:\\r\\n sorted.append(left[left_index])\\r\\n left_index += 1\\r\\n\\r\\n return sorted\\r\\n\\r\\ndef merge_sort(numbers): \\r\\n\\r\\n if len(numbers) <= 1:\\r\\n return numbers\\r\\n \\r\\n mid = len(numbers) // 2\\r\\n\\r\\n left = merge_sort(numbers[:mid])\\r\\n right = merge_sort(numbers[mid:])\\r\\n\\r\\n return merge(left, right)\\r\\n\\r\\n# Проверка\\r\\nnumb = [4, 2, 55, 123, 22] \\r\\nnumb = merge_sort(numb) \\r\\nprint(\\\"Массив, отсортированный методом слияния\\\", numb)\\r\\n\\r\\n\\r\\n\\r\\n\\r\\nimport math \\r\\ndef my_sin (x,n): \\r\\n x = x/180*math.pi \\r\\n q = x\\r\\n s = 0 \\r\\n for i in range(1, n+1):\\r\\n s = s+ q\\r\\n q = q* (-1) * (x*x) / ((2*i+1) * (2*i)) \\r\\n return s \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\ndef f(x):\\r\\n return 2.718281828459045**(1+x)\\r\\ndef tailor(x, eps):\\r\\n x = 1+x\\r\\n sum = 1+x\\r\\n term = x;\\r\\n n = 2;\\r\\n while term*term > eps*eps:\\r\\n term *= x/n\\r\\n n += 1\\r\\n sum += term\\r\\n return sum\\r\\n\\r\\na=3.0\\r\\nb=4.0\\r\\nkrok=(b-a)/10\\r\\n\\r\\nwhile a<=b: \\r\\n print(round(a,2), end=' ')\\r\\n print(round(f(a),5),end=' ')\\r\\n print(round(tailor(a,1e-6),5))\\r\\n a+=krok\\r\\n\"\n }\n]"},"num_files":{"kind":"number","value":1,"string":"1"}}},{"rowIdx":2978315,"cells":{"repo_name":{"kind":"string","value":"smitthakkar96/Punchit.io_website_master"},"repo_url":{"kind":"string","value":"https://github.com/smitthakkar96/Punchit.io_website_master"},"snapshot_id":{"kind":"string","value":"94f38b11e93739fc48c9f511fd128530af1f6eba"},"revision_id":{"kind":"string","value":"008dae83b389b5a09b30f882df9ef52d4017be16"},"directory_id":{"kind":"string","value":"d4a619b5f11fcfd48d0e73dfc4556476f8c6ba09"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2023-01-05T16:48:02.772822","string":"2023-01-05T16:48:02.772822"},"revision_date":{"kind":"timestamp","value":"2016-03-05T05:08:49","string":"2016-03-05T05:08:49"},"committer_date":{"kind":"timestamp","value":"2016-03-05T05:08:49","string":"2016-03-05T05:08:49"},"github_id":{"kind":"number","value":50392439,"string":"50,392,439"},"star_events_count":{"kind":"number","value":1,"string":"1"},"fork_events_count":{"kind":"number","value":1,"string":"1"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"timestamp","value":"2016-01-26T00:58:00","string":"2016-01-26T00:58:00"},"gha_updated_at":{"kind":"timestamp","value":"2016-01-30T03:26:11","string":"2016-01-30T03:26:11"},"gha_pushed_at":{"kind":"timestamp","value":"2022-12-26T20:00:23","string":"2022-12-26T20:00:23"},"gha_language":{"kind":"string","value":"JavaScript"},"files":{"kind":"list like","value":[{"alpha_fraction":0.642259418964386,"alphanum_fraction":0.6861924529075623,"avg_line_length":94.80000305175781,"blob_id":"459f25a606d0475450b932ac225ab8020b90df56","content_id":"e061ccb507e037405840d580e127ab29a9c6d9ac","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"JavaScript","length_bytes":478,"license_type":"no_license","max_line_length":380,"num_lines":5,"path":"/images/logos/punchit.io_files/DdQOHnWx7V2.js","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"/*!CK:97048086!*//*1441684666,*/\n\nif (self.CavalryLogger) { CavalryLogger.start_js([\"TVKMf\"]); }\n\n__d('PaymentTokenProxyUtils',['URI'],function a(b,c,d,e,f,g,h){if(c.__markCompiled)c.__markCompiled();var i={getURI:function(j){var k=new h('/ajax/payment/token_proxy.php').setDomain(window.location.hostname).setProtocol('https').addQueryData(j),l=k.getDomain().split('.');if(l.indexOf('secure')<0){l.splice(1,0,'secure');k.setDomain(l.join('.'));}return k;}};f.exports=i;},null);"},{"alpha_fraction":0.5920848250389099,"alphanum_fraction":0.6048547625541687,"avg_line_length":26.922222137451172,"blob_id":"7b89cc119595c869b8d3d935d866cf4801dae8b8","content_id":"3a10b86cb962cf4308c5a09caef0200b16692f38","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"JavaScript","length_bytes":27643,"license_type":"no_license","max_line_length":168,"num_lines":990,"path":"/js/controllers.js","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"var app = angular.module('app.controllers',[]);\n\napp.filter('unique', function() {\n return function(collection, keyname) {\n var output = [],\n keys = [];\n\n angular.forEach(collection, function(item) {\n var key = item[keyname];\n if(keys.indexOf(key) === -1) {\n keys.push(key);\n output.push(item);\n }\n });\n\n return output;\n };\n});\n\napp.controller('myCtrl',['$scope','$http','Model',function($scope,$http,Model) {\n\t$scope.text = \"ddd\";\n\t// $scope.Data = Data\n\tParse.initialize(\"Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4\", \"fR1P17QhE9b7PKOa1wXozi0yo8IAlYLSIzqYh4EU\");\n\t$http.get('/GetSessionToken')\n\t.then(function(response) {\n\t\t// console.log(response.data);\n\tParse.User.become(response.data)\n\t})\n\tvar current_user = Parse.User.current()\n\t$scope.Name = current_user.get(\"Ninja_name\")\n\t$scope.ProfilePicture_url = current_user.get(\"ProfilePicture\").url();\n\t\t$scope.logout = function() {\n\t\t\t// console.log(\"clicked\")\n\t\t\t\t$http({\n\t\t\t\t\tmethod: 'GET',\n\t\t\t\t\t\turl: '/logout'\n\t\t\t\t\t\t}).then(function successCallback(response) {\n\t\t\t\t\t\t}, function errorCallback(response) {\n\t\t\t\t\t\t// called asynchronously if an error occurs\n\t\t\t\t\t\t// or server returns response with an error status.\n\t\t\t\t\t});\n\t};\n\t$scope.$watch('Value',function(){\n\t\t\tModel.Value = $scope.Value\n\t},true)\n\t}])\n\napp.controller('bodyCtrl',function($scope,$http,PostService,Model,Search) {\n\tPusher.log = function(message) {\n\t\tif (window.console && window.console.log) {\n\t\t\twindow.console.log(message);\n\t\t}\n\t};\n try{\n\t var newPunches = document.getElementById('newPunches')\n\tnewPunches.style.display = 'none'\n}\ncatch(e)\n{\n\n}\n\tvar pusher = new Pusher('2f8f1cab459e648a27fd', {\n\t\tencrypted: true\n\t});\n\tvar channel = pusher.subscribe('PostChannel');\n\tchannel.bind('NewUpdate', function(data) {\n\tvar prom = PostService.GetSinglePost(data.message)\n\tprom.then(function(newPost){\n\t\t// console.log(JSON.stringify(newPost));\n\t\tArray.prototype.insert = function (index, item) {\n\t\t this.splice(index, 0, item);\n\t\t};\n\t\tvar newPunches = document.getElementById('newPunches')\n\t\tnewPunches.style.display = 'block'\n // unshift(Data[0])\n // ($scope.$$phase || $scope.$root.$$phase) ? unshift() : $scope.$apply(unshift);\n $scope.posts.unshift(newPost)\n //console.log($scope.posts);\n })\n\t})\n if(location.href.split('/').indexOf(\"share\") != -1)\n {\n var objectId = location.href.split('/')[location.href.split('/').indexOf(\"share\") + 1]\n //console.log(objectId);\n var myprom = PostService.GetSinglePost(objectId)\n myprom.then(function(Data){\n // console.log(JSON.stringify(Data));\n // unshift(Data[0])\n $scope.SinglePost = Data[0]\n //console.log($scope.posts);\n })\n }\n\n\tfunction detectmob() {\n\t if( navigator.userAgent.match(/Android/i)\n\t || navigator.userAgent.match(/webOS/i)\n\t || navigator.userAgent.match(/iPhone/i)\n\t || navigator.userAgent.match(/iPad/i)\n\t || navigator.userAgent.match(/iPod/i)\n\t || navigator.userAgent.match(/BlackBerry/i)\n\t || navigator.userAgent.match(/Windows Phone/i)\n\t ){\n\t return true;\n\t }\n\t else {\n\t return false;\n\t }\n\t}\n\tvar url = document.URL\n\tif(url.indexOf(\"Posts\")!=-1)\n\t{\n\t\tvar objectId = url.split('/')[2];\n\t\tvar SinglePostPromise = PostService.GetSinglePost(\"8pzy70zCXr\")\n\t\tSinglePostPromise.then(function(Data){\n\t\t\t$scope.SinglePost = Data[0]\n\t\t})\n\t}\n\t$scope.Enter = function(isChecked){\n\t\tif(isChecked)\n\t\t{\n\t\t\t$scope.PostComment();\n\t\t}\n\t}\n\tif(detectmob())\n\t{\n\t\t$scope.width = \"100%\";\n\t}\n\telse {\n\t\t$scope.width=\"70%\"\n\t}\n\n\t$scope.posts = new Array()\n\t$scope.PostsVisibility = true\n\t$scope.$watch(function(){return Model.Value},function(){\n\t\tif(Model.Value != null && Model.Value!='undefined'){\n\t\tvar SearchPromise = Search.SearchAccordingToKeyWord(Model.Value)\n\t\tSearchPromise.then(function(SearchResults){\n\t\t\t$scope.posts = SearchResults\n\t\t})\n\t}\n\telse {\n\t\t$scope.Posts = $scope.backup\n\t}\n\t},true)\n\ttry {\n\t\tvar spinner = document.getElementById('spinner')\n\t\tspinner.style.display = 'block'\n\t\tvar LoadMore = document.getElementById('LoadMore')\n\t\tLoadMore.style.display = 'none'\n\n\t} catch (e) {\n\n\t} finally {\n\n\t}\nvar promise = PostService.GetPosts([])\npromise.then(\nfunction(Data){\n\t$scope.posts = Data\n\t$scope.backup = $scope.posts\n\t$scope.PostsVisibility = false;\n\t\t\ttry {\n\t\t\t\tvar spinner = document.getElementById('spinner')\n\t\t\t\tspinner.style.display = 'none'\n\t\t\t\t\t\t\t\t\t // LoadMore\n\t\t\t\tvar LoadMore = document.getElementById('LoadMore')\n\t\t\t\tLoadMore.style.display = 'block'\n\t\t\t} catch (e) {\n\t\t\t\t// console.log(e);\n\t\t\t} finally {\n\n\t\t\t}\t\t\t //spinner\n},function(reason){\n //console.log(reason);\n},function (update) {\n //console.log(\"Update\");\n $scope.posts = update\n});\n\n\t$scope.openComment = function(index) {\n\t\t// console.log(\"df\");\n\t\t$('#modal1').openModal();\n\t\tGetComments($scope.posts[index].id)\n\n\t}\n\t$scope.LoadMore = function () {\n\t\t// console.log(\"clicked\");\n\t\t//spinner\n\t\tvar spinner = document.getElementById('spinner')\n\t\tspinner.style.display = 'block'\n\t\t// LoadMore\n\t\tvar LoadMore = document.getElementById('LoadMore')\n\t\tLoadMore.style.display = 'none'\n\t\tvar promise = PostService.GetPosts($scope.posts)\n\t\tpromise.then(function(Data){\n\t\t\t// console.log(Data)\n\t\t LoadMore = document.getElementById('LoadMore')\n\t\t\tLoadMore.style.display = 'block'\n\t\t\tspinner.style.display = \"none\"\n\t\t})\n\t}\n\t$scope.Punch = function(index,which){\n\t\t\tvar current_user = Parse.User.current()\n\t\t\tvar objectId = $scope.posts[index].id;\n\n\t\t\t\t\tParse.Cloud.run(\"TapTap\", {which:which,userObjID:current_user.id,objectId:objectId},{\n\t\t\t\t\t\tsuccess:function(response) {\n\t\t\t\t\t\t\t// console.log(JSON.stringify(response));\n if(which==1)\n {\n response.set('isVoted1',\"block\")\n response.set(\"isVoted2\",\"none\")\n }else {\n response.set('isVoted2',\"block\")\n response.set(\"isVoted1\",\"none\")\n }\n\n\t\t\t\t\t\t\t$scope.posts[index] = response\n\t\t\t\t\t\t\t$scope.$apply()\n\t\t\t\t\t\t},\n\t\t\t\t\t\terror : function(error) {\n\t\t\t\t\t\t\t// console.log(error);\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t}\n\n$scope.PostComment=function(){\n\tvar objectId = $scope.objectId\n\tvar CommentObj = Parse.Object.extend(\"Comment\")\n\tvar Comment = new CommentObj();\n\tvar Post = {\n\t__type: 'Pointer',\n\tclassName: 'Posts',\n\tobjectId: objectId\n\t}\n\tComment.set(\"User\",Parse.User.current())\n\tComment.set(\"Post\",Post)\n\tComment.set(\"comment\",$scope.cc)\n\tif($scope.cc != null && $scope.cc !=\"undefined\")\n\t{\n\tComment.save()\n\t$scope.comments.push(Comment)\n\t$scope.cc = null\n\t// $scope.$apply();\n\tMaterialize.toast('Comment Added successfully', 4000)\n\t}\n\telse {\n\t\tMaterialize.toast('Comment cannot be null', 4000)\n\t}\n}\n\nfunction GetComments(objectId)\n{\n\t\t\t$scope.objectId = objectId\n\t\t\tvar Comment = Parse.Object.extend(\"Comment\")\n\t\t\tvar CommentQuery = new Parse.Query(Comment);\n\t\t\tvar Post = {\n\t\t\t__type: 'Pointer',\n\t\t\tclassName: 'Posts',\n\t\t\tobjectId: objectId\n\t\t\t}\n\t\t\tCommentQuery.equalTo(\"Post\",Post)\n\t\t\tCommentQuery.find({\n\t\t\t\tsuccess : function (Comments) {\n\t\t\t\t\t\tfor(var i=0;i 5 || Image2.files[0] / 1000000 > 5)\n {\n var $toastContent = $('File size cannot be larger than 3 mbs ');\n\t\t\t\t\tMaterialize.toast($toastContent, 5000);\n }\n else if(Image1.files.length > 0 && Image2.files.length > 0 && Image1Title != null && Image2Title != null && InterestsArray.length > 0 && Title != null)\n\t\t\t\t{\n wait.style.display = \"block\"\n\t Image1File = new Parse.File(\"Image1.png\",Image1.files[0])\n\t Image2File = new Parse.File(\"Image2.png\",Image2.files[0])\n var quality = 20\n // output file format (jpg || png)\n output_format = 'jpg'\n //This function returns an Image Object\n //console.log(Image1.files[0]);\n // console.log($('#Preview1').attr('src'));\n var image = new Image();\n image.src = $('#Preview1').attr('src');\n\n var image1 = new Image();\n image1.src = $('#Preview2').attr('src');\n\n var target_img = jic.compress(image,quality,output_format).src;\n var target_img1 = jic.compress(image1,quality,output_format).src;\n console.log(target_img1);\n Image1File = new Parse.File(\"Image1\",{base64:target_img})\n Image2File = new Parse.File(\"Image2\",{base64:target_img1})\n // console.log({base64:target_img});\n\t\t\t\t\t\tPost.set(\"Title\",Title);\n\t\t\t\t\t\tPost.set(\"Image1\",Image1File);\n\t\t\t\t\t\tPost.set(\"Image2\",Image2File);\n\t\t\t\t\t\tPost.set(\"By\",current_user);\n\t\t\t\t\t\tPost.set(\"Image1Title\",Image1Title);\n\t\t\t\t\t\tPost.set(\"Image2Title\",Image2Title);\n\t\t\t\t\t\tPost.set(\"Punchers1\",new Array())\n\t\t\t\t\t\tPost.set(\"Punchers2\",new Array())\n\t\t\t\t\t\t// var InterestsArray = Communites.split(\",\");\n\t\t\t\t\t\tPost.set(\"TargetIntrests\",InterestsArray);\n\t\t\t\t\t\tPost.save(null,{\n\t\t\t\t\t\t\tsuccess : function (Post) {\n\t\t\t\t\t\t\t\t\t\t$('#PunchModel').closeModal();\n\t\t\t\t\t\t\t\t\t\tvar $toastContent = $(' Posted successfully ');\n\t\t\t\t\t\t\t\t\t\tMaterialize.toast($toastContent, 5000);\n $('#CreatePunch').load(document.URL + ' #CreatePunch');\n location.reload();\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\terror: function (error) {\n\t\t\t\t\t\t\t\tvar $toastContent = $(''+String(error)+' ');\n\t\t\t\t\t\t\t\tMaterialize.toast($toastContent, 5000);\n wait.style.display = \"none\"\n location.reload();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n }\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tvar $toastContent = $('Please check and fill all the fields ');\n\t\t\t\t\tMaterialize.toast($toastContent, 5000);\n\t\t\t\t}\n }\n\t\t\t// }\n});\n\nfunction uniq(a) {\n return a.sort().filter(function(item, pos, ary) {\n return !pos || item != ary[pos - 1];\n })\n}\n\n\napp.controller('DetailsController',function($scope,$http,Data) {\n\n\n\nfunction detectmob() {\n\t if( navigator.userAgent.match(/Android/i)\n\t || navigator.userAgent.match(/webOS/i)\n\t || navigator.userAgent.match(/iPhone/i)\n\t || navigator.userAgent.match(/iPad/i)\n\t || navigator.userAgent.match(/iPod/i)\n\t || navigator.userAgent.match(/BlackBerry/i)\n\t || navigator.userAgent.match(/Windows Phone/i)\n ){\n\t\t\treturn true;\n\t\t}\n\t else {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tif(!detectmob())\n\t{\n\t\t$scope.width = \"100%\";\n\t\t$scope.blur_img = \"width:90%;margin-left:6%;margin-top:-10px; height:480px\";\n\t\t$scope.dp = \"width:15%\";\n\t\t$scope.follow_div = \"right:170px;height:30px; width:100px;margin-top:-110px;float:right\";\n\t\t$scope.color = \"red\"\n\t\t$scope.ffp_full = \"width:90%;margin-left:6%;margin-top:2%;\";\n\t\t$scope.follower = \"width:50px; height:10px; padding-top:2px\";\n\t\t$scope.divider1 = \"width:2px;margin-top:10px; height:70px\";\n\t\t$scope.following = \"null\";\n\t\t$scope.divider2 = \"width:2px;margin-top:10px; height:70px\";\n\t}\n\telse {\n\t\t$scope.width=\"70%\"\n\t\t$scope.blur_img = \"width:100%;margin-left:6%;margin-top:-10px; height:480px\";\n\t\t$scope.dp = \"width:20%\";\n\t\t$scope.follow_div = \"margin-left:35%;height:30px;float:left;\";\n\t\t$scope.color = \"red\"\n\t\t$scope.ffp_full = \"width:100%;margin-left:5%;\";\n\t\t$scope.follower = \"\";\n\t\t$scope.divider1 = \"width:2px;margin-top:10px; height:70px;\";\n\t\t$scope.following = \"\";\n\t\t$scope.divider2 = \"width:2px;margin-top:10px; height:70px;\";\n\t}\n\n\n\tvar params = {};\n\tvar User = null;\n\tif (location.search) {\n\t\t\tvar parts = location.search.substring(1).split('&');\n\n\t\t\tfor (var i = 0; i < parts.length; i++) {\n\t\t\t\t\tvar nv = parts[i].split('=');\n\t\t\t\t\tif (!nv[0]) continue;\n\t\t\t\t\tparams[nv[0]] = nv[1] || true;\n\t\t\t}\n\t}\n\tvar objectId = params.id\n\tif(objectId == Parse.User.current().id || objectId == null)\n\t{\n\tUser = Parse.User.current()\n\t$scope.Name = Parse.User.current().get(\"Name\")\n\t$scope.Ninja_name = Parse.User.current().get(\"Ninja_name\")\n\t$scope.ProfilePicture = Parse.User.current().get(\"ProfilePicture\").url()\n\tvar Follow = document.getElementById('Follow')\n\t$scope.display = 'none'\n\t}\n\telse {\n\t\tUser = new Parse.User();\n\t\tUser.id = objectId\n\t\tUser.fetch({\n\t\t\tsuccess : function (usr) {\n\t\t\t\t// console.log(\"----Name ==\" + usr.get(\"Name\"))\n\t\t\t\t$scope.Name = User.get(\"Name\")\n\t\t\t\t$scope.Ninja_name = User.get(\"Ninja_name\")\n\t\t\t\t$scope.ProfilePicture = User.get(\"ProfilePicture\").url()\n\t\t\t}\n\t\t})\n\t\tCheckIfIamFollowing()\n\t\t$scope.display = 'block'\n\t}\n\n\t// $(\"#ProfilePicture\").load(function() {\n\t// \tvar img = document.getElementById('ProfilePicture')\n\t// \txi=new XMLHttpRequest();\n\t// \txi.open(\"GET\",img.src,true);\n\t// \txi.send();\n\t//\n\t// xi.onreadystatechange=function() {\n\t// if(xi.readyState==4 && xi.status==200) {\n\t// img=new Image;\n\t// img.onload=function(){\n\t//\n\t// }\n\t// img.src=xi.responseText;\n\t// }\n\t// }\n\t// })\n\n\n\t$scope.isFollowing = \"Please wait ..\"\n\tGetFollowers()\n\tGetFollowing()\n\t$scope.Data = Data\n\tfunction GetFollowers()\n\t{\n\t$scope.Posts = Data.Value\n\tvar FollowObject = Parse.Object.extend(\"FollowList\")\n\tvar GetFollowersQuery = new Parse.Query(FollowObject)\n\tGetFollowersQuery.equalTo(\"Following\",User)\n\tGetFollowersQuery.find({\n\t\tsuccess : function (Followers) {\n\t\t\t// console.log(Followers.length);\n\t\t\t$scope.Followers = Followers.length\n\t\t\t$scope.$apply()\n\t\t}\n\t})\n\t}\n\tfunction GetFollowing()\n\t{\n\tvar FollowObject = Parse.Object.extend(\"FollowList\")\n\tvar GetFollowingQuery = new Parse.Query(FollowObject)\n\tGetFollowingQuery.equalTo(\"Follower\",User)\n\tGetFollowingQuery.find({\n\t\tsuccess : function (Following) {\n\t\t\tconsole.log(Following.length);\n\t\t\t$scope.Following = Following.length\n\t\t\t$scope.$apply()\n\t\t}\n\t})\n\t}\n\n\t$scope.FollowUnfollowAction = function()\n\t{\n\t\tvar FollowType = Parse.Object.extend(\"FollowList\")\n\t\tvar FollowObject = new FollowType();\n\t\tFollowObject.set(\"Follower\",Parse.User.current())\n\t\tFollowObject.set(\"Following\",User)\n\t\tFollowObject.set(\"FollowingName\",User.get(\"Name\"))\n\t\tif($scope.isFollowing == \"Follow\")\n\t\t{\n\t\t\tFollowObject.save({success : function(Object) {\n\t\t\t\t$scope.objectIdOfFollowObject = Object.id\n\t\t\t}})\n\t\t\t$scope.isFollowing = \"Unfollow\"\n\t\t\t$scope.icon = \"Follwing\"\n\t\t\t$scope.Followers += 1\n\t\t}\n\t\telse {\n\t\t\tFollowObject = new FollowType();\n\t\t\tvar Query = new Parse.Query(FollowType);\n\t\t\tQuery.equalTo(\"objectId\",$scope.objectIdOfFollowObject)\n\t\t\tQuery.find({\n\t\t\t\tsuccess:function(Objects) {\n\t\t\t\t\tObjects[0].destroy()\n\t\t\t\t}\n\t\t\t})\n\n\t\t\t$scope.isFollowing = \"Follow\"\n\t\t\t$scope.icon = \"+Follow\"\n\t\t\t$scope.Followers -= 1\n\t\t}\n\t}\n\nfunction CheckIfIamFollowing()\n{\n\tvar FollowObject = Parse.Object.extend(\"FollowList\")\n\tvar GetFollowingQuery = new Parse.Query(FollowObject)\n\tGetFollowingQuery.equalTo(\"Follower\",Parse.User.current())\n\tGetFollowingQuery.find({\n\t\tsuccess : function (Following) {\n\t\t\tif(Following.length == 0)\n\t\t\t{\n\t\t\t\t$scope.isFollowing = \"Follow\"\n\t\t\t\t$scope.icon = \"+Follow\"\n\t\t\t}\n\t\t\tfor(var i=0;i 0){\n\t\t\t// console.log(\"load more\");\n\t\t\tvar ExistingObjectIds=new Array();\n\t\t\tfor(var i=0;i<$scope.posts.length;i++)\n\t\t\t{\n\t\t\t\t// console.log($scope.posts[i].id);\n\t\t\t\tExistingObjectIds[i] = $scope.posts[i].id;\n\t\t\t}\n\t\t\t// console.log(ExistingObjectIds);\n\t\t\tQuery.notContainedIn(\"objectId\",ExistingObjectIds)\n\t\t}\n\t\tQuery.descending(\"createdAt\")\n\t\tQuery.find({\n\t\t\tsuccess : function (data) {\n\t\t\t\t\tData.Value = data.length\n\t\t\t\t\tif(data !=null && data != 'undefined'){\n\t\t\t\t\t\t// $scope.posts=data\n\t\t\t\t\t\t// console.log(typeof($scope.post));\n\t\t\t\t\t\tfor(var i=0;i 0 || SinglePost.get('Votes2') > 0)\n {\n if(SinglePost.get('Punchers1').indexOf(Parse.User.current().id) > -1)\n {\n SinglePost.set('isVoted1',\"block\")\n SinglePost.set('isVoted2',\"none\")\n // alert(SinglePost.Image1Title + SinglePost.Image2Title + \" = isVoted1 = \" + SinglePost.get('isVoted1') + \" isVoted2 = \" + SinglePost.get('isVoted2'));\n }\n\n else if(SinglePost.get('Punchers2').indexOf(Parse.User.current().id) > -1)\n {\n SinglePost.set('isVoted1',\"none\")\n SinglePost.set('isVoted2',\"block\")\n // alert(SinglePost.Image1Title + SinglePost.Image2Title + \" = isVoted1 = \" + SinglePost.get('isVoted1') + \" isVoted2 = \" + SinglePost.get('isVoted2'));\n }\n else {\n SinglePost.set('isVoted1',\"none\")\n SinglePost.set('isVoted2',\"none\")\n }\n }\n else {\n SinglePost.set('isVoted1',\"none\")\n SinglePost.set('isVoted2',\"none\")\n }\n\t\t\t\t\t\t\t$scope.posts.push(SinglePost)\n\t\t\t\t\t\t}\n\t\t\t\t\t\t$scope.PostsVisibility = false;\n\t\t\t\t\t\t//spinner\n\t\t\t\t\t\tvar spinner = document.getElementById('spinner')\n\t\t\t\t\t\tspinner.style.display = 'none'\n\t\t\t\t\t\t$scope.$apply()\n\t\t\t\t\t\t// console.log($scope.posts.length);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\t// console.log(\"null\");\n\t\t\t\t\t}\n\t\t\t},\n\t\t\terror : function (error) {\n\t\t\t\t// console.log(error);\n\t\t\t}\n\t\t})\n}\n\nfunction GetTimeStamp(createdAt)\n{\n\tvar currentDate = new Date()\n\tvar Time;\n\tif(Math.abs(currentDate.getMonth() - createdAt.getMonth()) == 0)\n\t{\n\t\tif(Math.abs(currentDate.getDay() - createdAt.getDay()) > 7)\n\t\t{\n\t\t\tTime = String(parseInt(Math.abs(currentDate.getDay() - createdAt.getDay())) / 7 ) + \"W\"\n\t\t}\n\t\telse if (Math.abs(currentDate.getDay() - createdAt.getDay()) > 0)\n\t\t{\n\t\t\tTime = String(Math.abs(currentDate.getDay() - createdAt.getDay())) + \"d\"\n\t\t}\n\t\telse if (Math.abs(currentDate.getHours() - createdAt.getHours()) > 0){\n\t\t\tTime = String(Math.abs(currentDate.getHours() - createdAt.getHours())) + \"h\"\n\t\t}\n\t\telse {\n\t\t{\n\t\t\t\t\tTime = String(Math.abs(currentDate.getMinutes() - createdAt.getMinutes())) + 'm'\n\t\t}\n\t\t}\n\t}\n\telse {\n\t\tTime = String(Math.abs(currentDate.getMonth() - createdAt.getMonth())) + 'M'\n\t}\n\treturn Time;\n}\n\n$scope.PostComment=function(){\n\tvar objectId = $scope.objectId\n\tvar CommentObj = Parse.Object.extend(\"Comment\")\n\tvar Comment = new CommentObj();\n\tvar Post = {\n\t__type: 'Pointer',\n\tclassName: 'Posts',\n\tobjectId: objectId\n\t}\n\tComment.set(\"User\",Parse.User.current())\n\tComment.set(\"Post\",Post)\n\tComment.set(\"comment\",$scope.cc)\n\tif($scope.cc != null && $scope.cc !=\"undefined\")\n\t{\n\tComment.save()\n\t$scope.comments.push(Comment)\n\t$scope.cc = null\n\t$scope.$apply();\n\tMaterialize.toast('Comment Added successfully', 4000)\n\t}\n\telse {\n\t\tMaterialize.toast('Comment cannot be null', 4000)\n\t}\n}\n\nfunction GetComments(objectId)\n{\n\t\t\t$scope.objectId = objectId\n\t\t\tvar Comment = Parse.Object.extend(\"Comment\")\n\t\t\tvar CommentQuery = new Parse.Query(Comment);\n\t\t\tvar Post = {\n\t\t\t__type: 'Pointer',\n\t\t\tclassName: 'Posts',\n\t\t\tobjectId: objectId\n\t\t\t}\n\t\t\tCommentQuery.equalTo(\"Post\",Post)\n\t\t\tCommentQuery.find({\n\t\t\t\tsuccess : function (Comments) {\n\t\t\t\t\t\tfor(var i=0;i scope.wmBlockLength){\n e.preventDefault();\n return false;\n }\n });\n }\n }\n});\n\napp.config(['$interpolateProvider', function($interpolateProvider) {\n $interpolateProvider.startSymbol('{a');\n $interpolateProvider.endSymbol('a}');\n}])\n"},{"alpha_fraction":0.682009756565094,"alphanum_fraction":0.6914516687393188,"avg_line_length":27.37799072265625,"blob_id":"bbd5774b2cea381c06eb92f5e673f2ee4c8b5592","content_id":"d94be2f9bf013010d76b485f73f5c444ddaa1458","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":5931,"license_type":"no_license","max_line_length":108,"num_lines":209,"path":"/hello.py","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"from parse_rest.user import User\nimport settings_local\nfrom flask import Flask,request,redirect, url_for ,render_template,send_from_directory,session,make_response\nfrom parse_rest.connection import SessionToken, register\nfrom parse_rest.datatypes import Function\nimport json,httplib\nimport os\nfrom flask.ext.triangle import Form,Triangle\nfrom flask.ext.triangle.widgets.standard import TextInput\nfrom datetime import timedelta\nfrom flask import session, app\nimport os\nimport pusher\nimport getPost\nfrom flask import Blueprint\n\nsettings_local.initParse()\napp = Flask(__name__)\nTriangle(app)\napp.config['UPLOAD_FOLDER'] = 'uploads/'\n\nHackathon = Blueprint('Hackathon', __name__,\n template_folder='templates',subdomain=\"hack404\")\napp.register_blueprint(Hackathon)\n\n\n@app.before_request\ndef make_session_permanent():\n session.permanent = True\n app.permanent_session_lifetime = timedelta(minutes=46440)\n\n@app.route('/',methods=['GET', 'POST'])\ndef index():\n #\tsettings_local.initParse()\n\t# if request.method == 'POST' and request.form[\"what\"]== 'Login':\n\t# \ttry:\n\t# \t\tprint request.form[\"password\"]\n\t# \t\tu = User.login(request.form[\"username\"],request.form[\"password\"])\n\t# \t\tsession['session_token'] = u.sessionToken\n\t# \t\tresp = make_response(render_template(\"index.html\"))\n\t# \t\treturn resp\n\t# \texcept:\n\t# \t\treturn render_template('login.html',error=\"Invalid username or password\")\n\t# elif request.method == 'POST' and request.form[\"what\"]=='SignUp':\n\t# \temail = request.form[\"email\"]\n\t# \tpassword = request.form[\"password\"]\n\t# \tninja = request.form[\"ninja\"]\n\t# \tbirthdate = request.form[\"birthdate\"]\n\t# \tu = User.signup(email,password)\n\t# \tu.email=email\n\t# \tu.save()\n\t# \t# proPic.save(os.path.join(app.config['UPLOAD_FOLDER']),\"userdp.png\")\n\t\t# connection = httplib.HTTPSConnection('api.parse.com', 443)\n\t\t# connection.connect()\n\t\t# connection.request('POST', '/1/files/profilePic.png', open('userdp.png', 'rb').read(), {\n\t\t# \"X-Parse-Application-Id\": \"${Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4}\",\n\t\t# \"X-Parse-REST-API-Key\": \"${nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO}\",\n\t\t# \"Content-Type\": \"image/png\"\n\t\t# })\n\t\t# result = json.loads(connection.getresponse().read())\n\t\t# print result\n\t\t# connection.request('POST', '/1/classes/_User', json.dumps({\n\t\t# \"username\": email,\n\t\t# \"picture\": {\n\t\t# \"name\": \"profilePic.png\",\n\t\t# \"__type\": \"File\"\n\t\t# }\n\t\t# }), {\n\t\t# \"X-Parse-Application-Id\": \"${Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4}\",\n\t\t# \"X-Parse-REST-API-Key\": \"${nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO}\",\n\t\t# \"Content-Type\": \"application/json\"\n\t\t# })\n\t\t# result = json.loads(connection.getresponse().read())\n\t\t# print result\n\t# \tsession['session_token'] = u.sessionToken\n\t# \tresp = make_response(render_template(\"index.html\"))\n\t# \treturn u.sessionToken\n\t# else:\n\t# \tif session.get('session_token') is None:\n\t# \t\tprint \"nohhh\"\n\t# \t\treturn render_template('login.html')\n\t# \telse:\n\t# \t\tprint \"yes\"\n\t# \t\treturn render_template('index.html')\n # print \"hack\"\n\treturn render_template('Error.html')\n\n@app.route('/hack404')\ndef hackathon():\n return render_template('hackathon.html')\n\n@app.route('/js/')\ndef send_js(path):\n\tprint path\n\treturn send_from_directory('js', path)\n\n@app.route('/assets/images/')\ndef send_from_assets_images(path):\n print path\n return send_from_directory('assets/images', path)\n\n@app.route('/assets/javascripts/')\ndef send_from_assets_js(path):\n print path\n return send_from_directory('assets/javascripts', path)\n\n@app.route('/assets/stylesheets/')\ndef send_from_assets_css(path):\n print path\n return send_from_directory('assets/stylesheets', path)\n\n@app.route('/mobileLogin')\ndef mobileLogin():\n if session.get('session_token') is None:\n return render_template('mlogin.html')\n\n@app.route('/css/')\ndef send_css(path):\n\tprint path\n\treturn send_from_directory('css', path)\n\n@app.route('/font/')\ndef send_font(path):\n\tprint path\n\treturn send_from_directory('font', path)\n\n@app.route('/NewUpdate/')\ndef NewUpdate(objectId):\n p = pusher.Pusher(app_id='173885',key='2f8f1cab459e648a27fd',secret='80905f147470664954bd',ssl=True,port=443)\n p.trigger('PostChannel', 'NewUpdate', {'message': objectId})\n return \"success\"\n\n\n@app.route('/images/')\ndef send_images(path):\n\tprint path\n\treturn send_from_directory('images', path)\n\n@app.route('/Icons/')\ndef Icons(path):\n\tprint path\n\treturn send_from_directory('Icons', path)\n\n@app.route('/logout')\ndef logout():\n\t# session.Abandon()\n\tsession.clear()\n\treturn redirect(url_for('index'))\n\ndef GetCurrentUser():\n\ttoken = session.get('session_token')\n\tsettings_local.initParse(token)\n\tme = User.current_user()\n\treturn me\n\n@app.route('/setSession/')\ndef setSession(path):\n\tsession['session_token'] = path\n\treturn render_template('index.html')\n\n@app.route('/GetSessionToken')\ndef GetSessionToken():\n\ttoken = session.get('session_token')\n\treturn str(token)\n\n@app.route('/GetUserInterests')\ndef GetUserInterests():\n\td = []\n\tGetCurrentUser()\n\tuser_interest_function = Function(\"GetUserIntrest\")\n\td = user_interest_function()\n\treturn json.dumps(d)\n\n@app.route('/Profile')\ndef Profile():\n if session.get('session_token') != None:\n return render_template('profile.html')\n else:\n return render_template('login.html')\n\n@app.route('/Select_Interests')\ndef Select_Interests():\n if session.get('session_token') != None:\n return render_template('Settings.html')\n else:\n return render_template('login.html')\n\n@app.route('/share/')\ndef share(path):\n SinglePost = getPost.getSinglePost(path)\n return render_template('Posts.html',SinglePost=SinglePost)\n\n@app.route('/Settings')\ndef Settings():\n\treturn render_template('Settings.html')\n\n@app.route('/download')\ndef download():\n\treturn render_template('Error.html')\n\nport = int(os.environ.get('PORT', 5000))\napp.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'\napp.run(host=\"0.0.0.0\",debug=True,port=port)\n\n\n# font images)\n\n\n#font images\n"},{"alpha_fraction":0.7622377872467041,"alphanum_fraction":0.7657342553138733,"avg_line_length":27.5,"blob_id":"62f78f3fa14a99765ef773d21b5fbdf3b23dc9b4","content_id":"546131a2fa95f80bae1149dc9cd49eafa8c4203f","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":286,"license_type":"no_license","max_line_length":49,"num_lines":10,"path":"/getPost.py","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"from parse_rest.datatypes import Object\nimport settings_local\n\ndef getSinglePost(objectId):\n settings_local.initParse()\n className=\"Posts\"\n Posts=Object.factory(className)\n SinglePost=Posts.Query.get(objectId=objectId)\n print SinglePost.Image1.url\n return SinglePost\n\n"},{"alpha_fraction":0.47630923986434937,"alphanum_fraction":0.7057356834411621,"avg_line_length":15.708333015441895,"blob_id":"2e3852d89487488dc8db3caa49287e45f55e1925","content_id":"b47167c63d19da04c180e6b1b4680ddad4b8905c","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Text","length_bytes":401,"license_type":"no_license","max_line_length":24,"num_lines":24,"path":"/requirements.txt","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"cffi==1.5.0\ncryptography==1.2.1\nenum34==1.1.2\nFlask==0.10.1\nFlask-Triangle==0.5.4\nfunctools32==3.2.3.post2\ngunicorn==19.4.5\nidna==2.0\nipaddress==1.0.16\nitsdangerous==0.24\nJinja2==2.8\njsonschema==2.5.1\nMarkupSafe==0.23\nndg-httpsclient==0.4.0\nparse-rest==0.2.20141004\npusher==1.2.3\npyasn1==0.1.9\npycparser==2.14\npyOpenSSL==0.15.1\nrequests==2.9.1\nsix==1.10.0\nurllib3==1.14\nWerkzeug==0.11.3\nwheel==0.24.0\n"},{"alpha_fraction":0.7755101919174194,"alphanum_fraction":0.7755101919174194,"avg_line_length":23.5,"blob_id":"cc96392561bb672e9eebef2d75d924dc4df1f923","content_id":"83970e5afba48b22e8f45a5fa414cbdd35ac4a33","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Markdown","length_bytes":49,"license_type":"no_license","max_line_length":27,"num_lines":2,"path":"/README.md","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"#Punchit.io website \n# Punchit.io_website_master\n"},{"alpha_fraction":0.5850793123245239,"alphanum_fraction":0.58977872133255,"avg_line_length":27.691011428833008,"blob_id":"c892e846422dea2a83ba45eb8fd14fa45a0f100e","content_id":"9577360b647e37ea5805d8e7997d66db62a8d56a","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"JavaScript","length_bytes":5107,"license_type":"no_license","max_line_length":152,"num_lines":178,"path":"/js/SettingsController.js","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"var app = angular.module('app',['app.controllers','app.factory'])\n\napp.controller(\"MainController\",function($scope){\n\n});\n\napp.controller(\"FriendsController\",['$scope','GetFacebookFriends','GetFriendsFromInterests',function($scope,GetFacebookFriends,GetFriendsFromInterests){\n var promise = GetFacebookFriends.GetFriends()\n promise.then(function(Data){\n for(var i=0;i 0) {\n var file = fileUploadControl.files[0];\n // alert(JSON.stringify(file))\n var name = \"profilePic.png\";\n var parseFile = new Parse.File(name, file);\n parseFile.save().then(function(){\n user.set(\"ProfilePicture\",parseFile);\n user.set(\"email\",$scope.Email)\n user.set(\"Ninja_name\",$scope.Ninja_name)\n user.set(\"Name\",$scope.Name)\n user.save({\n success: function(user){\n Materialize.toast('Your Profile was successfully updated', 3000);\n location.reload()\n },\n error : function(error){\n Materialize.toast(error, 2000);\n }\n });\n\n },function(){})\n }\n else {\n Materialize.toast('Please choose your Profile Picture', 2000);\n }\n }\n})\n\napp.controller(\"ChangePassword\",function($scope){\n $scope.update = function(){\n var user = Parse.User.current()\n if($scope.Pass_con == $scope.Pass_main)\n {\n user.set(\"password\",$scope.Pass_main)\n user.save({\n success : function(user){\n Materialize.toast('Password updated', 3000);\n }\n })\n }\n }\n})\n"},{"alpha_fraction":0.641121506690979,"alphanum_fraction":0.7028037309646606,"avg_line_length":88.33333587646484,"blob_id":"527b8428136f46856665a47213c052405f2929da","content_id":"0381f979a1c73785cf3b33e2956268ad33979af4","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"JavaScript","length_bytes":535,"license_type":"no_license","max_line_length":278,"num_lines":6,"path":"/images/logos/punchit.io_files/FkQNViGi-sj.js","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"/*!CK:2686195818!*//*1441808114,*/\n\nif (self.CavalryLogger) { CavalryLogger.start_js([\"tLt9Y\"]); }\n\n__d('IntlLithuanianNumberType',['IntlVariations'],function a(b,c,d,e,f,g,h){if(c.__markCompiled)c.__markCompiled();var i={getNumberVariationType:function(j){var k=j%100,l=k%10;return l===0||k>10&&k<20?h.NUMBER_DUAL:l===1?h.NUMBER_SINGULAR:h.NUMBER_PLURAL;}};f.exports=i;},null);\n__d('legacy:pages-suggest-ui-nullable',['NullableInput'],function a(b,c,d,e){if(c.__markCompiled)c.__markCompiled();b.NullableInput=c('NullableInput');},3);"},{"alpha_fraction":0.618453860282898,"alphanum_fraction":0.7605984807014465,"avg_line_length":33.869564056396484,"blob_id":"375952e502352a00b3701552bf058a0dda0bac31","content_id":"b192365761eb3c0ac972cbb4bd4b2c288cb39484","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":802,"license_type":"no_license","max_line_length":121,"num_lines":23,"path":"/Process.py","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"import requests\nimport sys\nfrom PIL import Image\n\nf = open('Image1.jpg', 'wb')\nurl1 = \"http://files.parsetfss.com/b7dd35dc-b01c-4492-b846-ef2a47bafc6b/tfss-0b3759e3-2265-430a-b033-f8f4421cdaab-Image1\"\nf.write(requests.get(url1).content)\nf.close()\nf1 = open('Image2.jpg', 'wb')\nurl2 = \"http://files.parsetfss.com/b7dd35dc-b01c-4492-b846-ef2a47bafc6b/tfss-0b3759e3-2265-430a-b033-f8f4421cdaab-Image1\"\nf1.write(requests.get(url2).content)\nf1.close()\nbackground = Image.open('images/Share_Pattern.jpg')\nbackground.thumbnail((300,300),Image.ANTIALIAS)\n# background.show()\nimage1 = Image.open('Image1.jpg')\nimage1.thumbnail((75,100),Image.ANTIALIAS)\n# image1.show()\nimage2 = Image.open('Image2.jpg')\nimage2.thumbnail((75,100),Image.ANTIALIAS)\nimage2.show()\nbackground.paste(image1,(40,10))\nbackground.show()\n"},{"alpha_fraction":0.7219731211662292,"alphanum_fraction":0.7219731211662292,"avg_line_length":30.85714340209961,"blob_id":"9b1e6d55b7141d3e9fff3c2996bb72b5734e33b6","content_id":"0447e1b307e96b56b82935f03d688a58f1ffc6c1","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":223,"license_type":"no_license","max_line_length":54,"num_lines":7,"path":"/settings_local.py","repo_name":"smitthakkar96/Punchit.io_website_master","src_encoding":"UTF-8","text":"from parse_rest.connection import register\ndef initParse(sessionToken=None):\n\tprint \"init\"\n\tif sessionToken == None:\n\t\tregister('Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4','nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO',master_key=None)\n\telse:\n\t\tregister('Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4','nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO',session_token=sessionToken)\n"}],"string":"[\n {\n \"alpha_fraction\": 0.642259418964386,\n \"alphanum_fraction\": 0.6861924529075623,\n \"avg_line_length\": 94.80000305175781,\n \"blob_id\": \"459f25a606d0475450b932ac225ab8020b90df56\",\n \"content_id\": \"e061ccb507e037405840d580e127ab29a9c6d9ac\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"JavaScript\",\n \"length_bytes\": 478,\n \"license_type\": \"no_license\",\n \"max_line_length\": 380,\n \"num_lines\": 5,\n \"path\": \"/images/logos/punchit.io_files/DdQOHnWx7V2.js\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*!CK:97048086!*//*1441684666,*/\\n\\nif (self.CavalryLogger) { CavalryLogger.start_js([\\\"TVKMf\\\"]); }\\n\\n__d('PaymentTokenProxyUtils',['URI'],function a(b,c,d,e,f,g,h){if(c.__markCompiled)c.__markCompiled();var i={getURI:function(j){var k=new h('/ajax/payment/token_proxy.php').setDomain(window.location.hostname).setProtocol('https').addQueryData(j),l=k.getDomain().split('.');if(l.indexOf('secure')<0){l.splice(1,0,'secure');k.setDomain(l.join('.'));}return k;}};f.exports=i;},null);\"\n },\n {\n \"alpha_fraction\": 0.5920848250389099,\n \"alphanum_fraction\": 0.6048547625541687,\n \"avg_line_length\": 26.922222137451172,\n \"blob_id\": \"7b89cc119595c869b8d3d935d866cf4801dae8b8\",\n \"content_id\": \"3a10b86cb962cf4308c5a09caef0200b16692f38\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"JavaScript\",\n \"length_bytes\": 27643,\n \"license_type\": \"no_license\",\n \"max_line_length\": 168,\n \"num_lines\": 990,\n \"path\": \"/js/controllers.js\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"var app = angular.module('app.controllers',[]);\\n\\napp.filter('unique', function() {\\n return function(collection, keyname) {\\n var output = [],\\n keys = [];\\n\\n angular.forEach(collection, function(item) {\\n var key = item[keyname];\\n if(keys.indexOf(key) === -1) {\\n keys.push(key);\\n output.push(item);\\n }\\n });\\n\\n return output;\\n };\\n});\\n\\napp.controller('myCtrl',['$scope','$http','Model',function($scope,$http,Model) {\\n\\t$scope.text = \\\"ddd\\\";\\n\\t// $scope.Data = Data\\n\\tParse.initialize(\\\"Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4\\\", \\\"fR1P17QhE9b7PKOa1wXozi0yo8IAlYLSIzqYh4EU\\\");\\n\\t$http.get('/GetSessionToken')\\n\\t.then(function(response) {\\n\\t\\t// console.log(response.data);\\n\\tParse.User.become(response.data)\\n\\t})\\n\\tvar current_user = Parse.User.current()\\n\\t$scope.Name = current_user.get(\\\"Ninja_name\\\")\\n\\t$scope.ProfilePicture_url = current_user.get(\\\"ProfilePicture\\\").url();\\n\\t\\t$scope.logout = function() {\\n\\t\\t\\t// console.log(\\\"clicked\\\")\\n\\t\\t\\t\\t$http({\\n\\t\\t\\t\\t\\tmethod: 'GET',\\n\\t\\t\\t\\t\\t\\turl: '/logout'\\n\\t\\t\\t\\t\\t\\t}).then(function successCallback(response) {\\n\\t\\t\\t\\t\\t\\t}, function errorCallback(response) {\\n\\t\\t\\t\\t\\t\\t// called asynchronously if an error occurs\\n\\t\\t\\t\\t\\t\\t// or server returns response with an error status.\\n\\t\\t\\t\\t\\t});\\n\\t};\\n\\t$scope.$watch('Value',function(){\\n\\t\\t\\tModel.Value = $scope.Value\\n\\t},true)\\n\\t}])\\n\\napp.controller('bodyCtrl',function($scope,$http,PostService,Model,Search) {\\n\\tPusher.log = function(message) {\\n\\t\\tif (window.console && window.console.log) {\\n\\t\\t\\twindow.console.log(message);\\n\\t\\t}\\n\\t};\\n try{\\n\\t var newPunches = document.getElementById('newPunches')\\n\\tnewPunches.style.display = 'none'\\n}\\ncatch(e)\\n{\\n\\n}\\n\\tvar pusher = new Pusher('2f8f1cab459e648a27fd', {\\n\\t\\tencrypted: true\\n\\t});\\n\\tvar channel = pusher.subscribe('PostChannel');\\n\\tchannel.bind('NewUpdate', function(data) {\\n\\tvar prom = PostService.GetSinglePost(data.message)\\n\\tprom.then(function(newPost){\\n\\t\\t// console.log(JSON.stringify(newPost));\\n\\t\\tArray.prototype.insert = function (index, item) {\\n\\t\\t this.splice(index, 0, item);\\n\\t\\t};\\n\\t\\tvar newPunches = document.getElementById('newPunches')\\n\\t\\tnewPunches.style.display = 'block'\\n // unshift(Data[0])\\n // ($scope.$$phase || $scope.$root.$$phase) ? unshift() : $scope.$apply(unshift);\\n $scope.posts.unshift(newPost)\\n //console.log($scope.posts);\\n })\\n\\t})\\n if(location.href.split('/').indexOf(\\\"share\\\") != -1)\\n {\\n var objectId = location.href.split('/')[location.href.split('/').indexOf(\\\"share\\\") + 1]\\n //console.log(objectId);\\n var myprom = PostService.GetSinglePost(objectId)\\n myprom.then(function(Data){\\n // console.log(JSON.stringify(Data));\\n // unshift(Data[0])\\n $scope.SinglePost = Data[0]\\n //console.log($scope.posts);\\n })\\n }\\n\\n\\tfunction detectmob() {\\n\\t if( navigator.userAgent.match(/Android/i)\\n\\t || navigator.userAgent.match(/webOS/i)\\n\\t || navigator.userAgent.match(/iPhone/i)\\n\\t || navigator.userAgent.match(/iPad/i)\\n\\t || navigator.userAgent.match(/iPod/i)\\n\\t || navigator.userAgent.match(/BlackBerry/i)\\n\\t || navigator.userAgent.match(/Windows Phone/i)\\n\\t ){\\n\\t return true;\\n\\t }\\n\\t else {\\n\\t return false;\\n\\t }\\n\\t}\\n\\tvar url = document.URL\\n\\tif(url.indexOf(\\\"Posts\\\")!=-1)\\n\\t{\\n\\t\\tvar objectId = url.split('/')[2];\\n\\t\\tvar SinglePostPromise = PostService.GetSinglePost(\\\"8pzy70zCXr\\\")\\n\\t\\tSinglePostPromise.then(function(Data){\\n\\t\\t\\t$scope.SinglePost = Data[0]\\n\\t\\t})\\n\\t}\\n\\t$scope.Enter = function(isChecked){\\n\\t\\tif(isChecked)\\n\\t\\t{\\n\\t\\t\\t$scope.PostComment();\\n\\t\\t}\\n\\t}\\n\\tif(detectmob())\\n\\t{\\n\\t\\t$scope.width = \\\"100%\\\";\\n\\t}\\n\\telse {\\n\\t\\t$scope.width=\\\"70%\\\"\\n\\t}\\n\\n\\t$scope.posts = new Array()\\n\\t$scope.PostsVisibility = true\\n\\t$scope.$watch(function(){return Model.Value},function(){\\n\\t\\tif(Model.Value != null && Model.Value!='undefined'){\\n\\t\\tvar SearchPromise = Search.SearchAccordingToKeyWord(Model.Value)\\n\\t\\tSearchPromise.then(function(SearchResults){\\n\\t\\t\\t$scope.posts = SearchResults\\n\\t\\t})\\n\\t}\\n\\telse {\\n\\t\\t$scope.Posts = $scope.backup\\n\\t}\\n\\t},true)\\n\\ttry {\\n\\t\\tvar spinner = document.getElementById('spinner')\\n\\t\\tspinner.style.display = 'block'\\n\\t\\tvar LoadMore = document.getElementById('LoadMore')\\n\\t\\tLoadMore.style.display = 'none'\\n\\n\\t} catch (e) {\\n\\n\\t} finally {\\n\\n\\t}\\nvar promise = PostService.GetPosts([])\\npromise.then(\\nfunction(Data){\\n\\t$scope.posts = Data\\n\\t$scope.backup = $scope.posts\\n\\t$scope.PostsVisibility = false;\\n\\t\\t\\ttry {\\n\\t\\t\\t\\tvar spinner = document.getElementById('spinner')\\n\\t\\t\\t\\tspinner.style.display = 'none'\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t // LoadMore\\n\\t\\t\\t\\tvar LoadMore = document.getElementById('LoadMore')\\n\\t\\t\\t\\tLoadMore.style.display = 'block'\\n\\t\\t\\t} catch (e) {\\n\\t\\t\\t\\t// console.log(e);\\n\\t\\t\\t} finally {\\n\\n\\t\\t\\t}\\t\\t\\t //spinner\\n},function(reason){\\n //console.log(reason);\\n},function (update) {\\n //console.log(\\\"Update\\\");\\n $scope.posts = update\\n});\\n\\n\\t$scope.openComment = function(index) {\\n\\t\\t// console.log(\\\"df\\\");\\n\\t\\t$('#modal1').openModal();\\n\\t\\tGetComments($scope.posts[index].id)\\n\\n\\t}\\n\\t$scope.LoadMore = function () {\\n\\t\\t// console.log(\\\"clicked\\\");\\n\\t\\t//spinner\\n\\t\\tvar spinner = document.getElementById('spinner')\\n\\t\\tspinner.style.display = 'block'\\n\\t\\t// LoadMore\\n\\t\\tvar LoadMore = document.getElementById('LoadMore')\\n\\t\\tLoadMore.style.display = 'none'\\n\\t\\tvar promise = PostService.GetPosts($scope.posts)\\n\\t\\tpromise.then(function(Data){\\n\\t\\t\\t// console.log(Data)\\n\\t\\t LoadMore = document.getElementById('LoadMore')\\n\\t\\t\\tLoadMore.style.display = 'block'\\n\\t\\t\\tspinner.style.display = \\\"none\\\"\\n\\t\\t})\\n\\t}\\n\\t$scope.Punch = function(index,which){\\n\\t\\t\\tvar current_user = Parse.User.current()\\n\\t\\t\\tvar objectId = $scope.posts[index].id;\\n\\n\\t\\t\\t\\t\\tParse.Cloud.run(\\\"TapTap\\\", {which:which,userObjID:current_user.id,objectId:objectId},{\\n\\t\\t\\t\\t\\t\\tsuccess:function(response) {\\n\\t\\t\\t\\t\\t\\t\\t// console.log(JSON.stringify(response));\\n if(which==1)\\n {\\n response.set('isVoted1',\\\"block\\\")\\n response.set(\\\"isVoted2\\\",\\\"none\\\")\\n }else {\\n response.set('isVoted2',\\\"block\\\")\\n response.set(\\\"isVoted1\\\",\\\"none\\\")\\n }\\n\\n\\t\\t\\t\\t\\t\\t\\t$scope.posts[index] = response\\n\\t\\t\\t\\t\\t\\t\\t$scope.$apply()\\n\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\terror : function(error) {\\n\\t\\t\\t\\t\\t\\t\\t// console.log(error);\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t})\\n\\t\\t}\\n\\n$scope.PostComment=function(){\\n\\tvar objectId = $scope.objectId\\n\\tvar CommentObj = Parse.Object.extend(\\\"Comment\\\")\\n\\tvar Comment = new CommentObj();\\n\\tvar Post = {\\n\\t__type: 'Pointer',\\n\\tclassName: 'Posts',\\n\\tobjectId: objectId\\n\\t}\\n\\tComment.set(\\\"User\\\",Parse.User.current())\\n\\tComment.set(\\\"Post\\\",Post)\\n\\tComment.set(\\\"comment\\\",$scope.cc)\\n\\tif($scope.cc != null && $scope.cc !=\\\"undefined\\\")\\n\\t{\\n\\tComment.save()\\n\\t$scope.comments.push(Comment)\\n\\t$scope.cc = null\\n\\t// $scope.$apply();\\n\\tMaterialize.toast('Comment Added successfully', 4000)\\n\\t}\\n\\telse {\\n\\t\\tMaterialize.toast('Comment cannot be null', 4000)\\n\\t}\\n}\\n\\nfunction GetComments(objectId)\\n{\\n\\t\\t\\t$scope.objectId = objectId\\n\\t\\t\\tvar Comment = Parse.Object.extend(\\\"Comment\\\")\\n\\t\\t\\tvar CommentQuery = new Parse.Query(Comment);\\n\\t\\t\\tvar Post = {\\n\\t\\t\\t__type: 'Pointer',\\n\\t\\t\\tclassName: 'Posts',\\n\\t\\t\\tobjectId: objectId\\n\\t\\t\\t}\\n\\t\\t\\tCommentQuery.equalTo(\\\"Post\\\",Post)\\n\\t\\t\\tCommentQuery.find({\\n\\t\\t\\t\\tsuccess : function (Comments) {\\n\\t\\t\\t\\t\\t\\tfor(var i=0;i 5 || Image2.files[0] / 1000000 > 5)\\n {\\n var $toastContent = $('File size cannot be larger than 3 mbs ');\\n\\t\\t\\t\\t\\tMaterialize.toast($toastContent, 5000);\\n }\\n else if(Image1.files.length > 0 && Image2.files.length > 0 && Image1Title != null && Image2Title != null && InterestsArray.length > 0 && Title != null)\\n\\t\\t\\t\\t{\\n wait.style.display = \\\"block\\\"\\n\\t Image1File = new Parse.File(\\\"Image1.png\\\",Image1.files[0])\\n\\t Image2File = new Parse.File(\\\"Image2.png\\\",Image2.files[0])\\n var quality = 20\\n // output file format (jpg || png)\\n output_format = 'jpg'\\n //This function returns an Image Object\\n //console.log(Image1.files[0]);\\n // console.log($('#Preview1').attr('src'));\\n var image = new Image();\\n image.src = $('#Preview1').attr('src');\\n\\n var image1 = new Image();\\n image1.src = $('#Preview2').attr('src');\\n\\n var target_img = jic.compress(image,quality,output_format).src;\\n var target_img1 = jic.compress(image1,quality,output_format).src;\\n console.log(target_img1);\\n Image1File = new Parse.File(\\\"Image1\\\",{base64:target_img})\\n Image2File = new Parse.File(\\\"Image2\\\",{base64:target_img1})\\n // console.log({base64:target_img});\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Title\\\",Title);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Image1\\\",Image1File);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Image2\\\",Image2File);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"By\\\",current_user);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Image1Title\\\",Image1Title);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Image2Title\\\",Image2Title);\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Punchers1\\\",new Array())\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"Punchers2\\\",new Array())\\n\\t\\t\\t\\t\\t\\t// var InterestsArray = Communites.split(\\\",\\\");\\n\\t\\t\\t\\t\\t\\tPost.set(\\\"TargetIntrests\\\",InterestsArray);\\n\\t\\t\\t\\t\\t\\tPost.save(null,{\\n\\t\\t\\t\\t\\t\\t\\tsuccess : function (Post) {\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t$('#PunchModel').closeModal();\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tvar $toastContent = $(' Posted successfully ');\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tMaterialize.toast($toastContent, 5000);\\n $('#CreatePunch').load(document.URL + ' #CreatePunch');\\n location.reload();\\n\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\terror: function (error) {\\n\\t\\t\\t\\t\\t\\t\\t\\tvar $toastContent = $(''+String(error)+' ');\\n\\t\\t\\t\\t\\t\\t\\t\\tMaterialize.toast($toastContent, 5000);\\n wait.style.display = \\\"none\\\"\\n location.reload();\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t});\\n }\\n\\t\\t\\t\\telse\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tvar $toastContent = $('Please check and fill all the fields ');\\n\\t\\t\\t\\t\\tMaterialize.toast($toastContent, 5000);\\n\\t\\t\\t\\t}\\n }\\n\\t\\t\\t// }\\n});\\n\\nfunction uniq(a) {\\n return a.sort().filter(function(item, pos, ary) {\\n return !pos || item != ary[pos - 1];\\n })\\n}\\n\\n\\napp.controller('DetailsController',function($scope,$http,Data) {\\n\\n\\n\\nfunction detectmob() {\\n\\t if( navigator.userAgent.match(/Android/i)\\n\\t || navigator.userAgent.match(/webOS/i)\\n\\t || navigator.userAgent.match(/iPhone/i)\\n\\t || navigator.userAgent.match(/iPad/i)\\n\\t || navigator.userAgent.match(/iPod/i)\\n\\t || navigator.userAgent.match(/BlackBerry/i)\\n\\t || navigator.userAgent.match(/Windows Phone/i)\\n ){\\n\\t\\t\\treturn true;\\n\\t\\t}\\n\\t else {\\n\\t\\t\\treturn false;\\n\\t\\t}\\n\\t}\\n\\n\\tif(!detectmob())\\n\\t{\\n\\t\\t$scope.width = \\\"100%\\\";\\n\\t\\t$scope.blur_img = \\\"width:90%;margin-left:6%;margin-top:-10px; height:480px\\\";\\n\\t\\t$scope.dp = \\\"width:15%\\\";\\n\\t\\t$scope.follow_div = \\\"right:170px;height:30px; width:100px;margin-top:-110px;float:right\\\";\\n\\t\\t$scope.color = \\\"red\\\"\\n\\t\\t$scope.ffp_full = \\\"width:90%;margin-left:6%;margin-top:2%;\\\";\\n\\t\\t$scope.follower = \\\"width:50px; height:10px; padding-top:2px\\\";\\n\\t\\t$scope.divider1 = \\\"width:2px;margin-top:10px; height:70px\\\";\\n\\t\\t$scope.following = \\\"null\\\";\\n\\t\\t$scope.divider2 = \\\"width:2px;margin-top:10px; height:70px\\\";\\n\\t}\\n\\telse {\\n\\t\\t$scope.width=\\\"70%\\\"\\n\\t\\t$scope.blur_img = \\\"width:100%;margin-left:6%;margin-top:-10px; height:480px\\\";\\n\\t\\t$scope.dp = \\\"width:20%\\\";\\n\\t\\t$scope.follow_div = \\\"margin-left:35%;height:30px;float:left;\\\";\\n\\t\\t$scope.color = \\\"red\\\"\\n\\t\\t$scope.ffp_full = \\\"width:100%;margin-left:5%;\\\";\\n\\t\\t$scope.follower = \\\"\\\";\\n\\t\\t$scope.divider1 = \\\"width:2px;margin-top:10px; height:70px;\\\";\\n\\t\\t$scope.following = \\\"\\\";\\n\\t\\t$scope.divider2 = \\\"width:2px;margin-top:10px; height:70px;\\\";\\n\\t}\\n\\n\\n\\tvar params = {};\\n\\tvar User = null;\\n\\tif (location.search) {\\n\\t\\t\\tvar parts = location.search.substring(1).split('&');\\n\\n\\t\\t\\tfor (var i = 0; i < parts.length; i++) {\\n\\t\\t\\t\\t\\tvar nv = parts[i].split('=');\\n\\t\\t\\t\\t\\tif (!nv[0]) continue;\\n\\t\\t\\t\\t\\tparams[nv[0]] = nv[1] || true;\\n\\t\\t\\t}\\n\\t}\\n\\tvar objectId = params.id\\n\\tif(objectId == Parse.User.current().id || objectId == null)\\n\\t{\\n\\tUser = Parse.User.current()\\n\\t$scope.Name = Parse.User.current().get(\\\"Name\\\")\\n\\t$scope.Ninja_name = Parse.User.current().get(\\\"Ninja_name\\\")\\n\\t$scope.ProfilePicture = Parse.User.current().get(\\\"ProfilePicture\\\").url()\\n\\tvar Follow = document.getElementById('Follow')\\n\\t$scope.display = 'none'\\n\\t}\\n\\telse {\\n\\t\\tUser = new Parse.User();\\n\\t\\tUser.id = objectId\\n\\t\\tUser.fetch({\\n\\t\\t\\tsuccess : function (usr) {\\n\\t\\t\\t\\t// console.log(\\\"----Name ==\\\" + usr.get(\\\"Name\\\"))\\n\\t\\t\\t\\t$scope.Name = User.get(\\\"Name\\\")\\n\\t\\t\\t\\t$scope.Ninja_name = User.get(\\\"Ninja_name\\\")\\n\\t\\t\\t\\t$scope.ProfilePicture = User.get(\\\"ProfilePicture\\\").url()\\n\\t\\t\\t}\\n\\t\\t})\\n\\t\\tCheckIfIamFollowing()\\n\\t\\t$scope.display = 'block'\\n\\t}\\n\\n\\t// $(\\\"#ProfilePicture\\\").load(function() {\\n\\t// \\tvar img = document.getElementById('ProfilePicture')\\n\\t// \\txi=new XMLHttpRequest();\\n\\t// \\txi.open(\\\"GET\\\",img.src,true);\\n\\t// \\txi.send();\\n\\t//\\n\\t// xi.onreadystatechange=function() {\\n\\t// if(xi.readyState==4 && xi.status==200) {\\n\\t// img=new Image;\\n\\t// img.onload=function(){\\n\\t//\\n\\t// }\\n\\t// img.src=xi.responseText;\\n\\t// }\\n\\t// }\\n\\t// })\\n\\n\\n\\t$scope.isFollowing = \\\"Please wait ..\\\"\\n\\tGetFollowers()\\n\\tGetFollowing()\\n\\t$scope.Data = Data\\n\\tfunction GetFollowers()\\n\\t{\\n\\t$scope.Posts = Data.Value\\n\\tvar FollowObject = Parse.Object.extend(\\\"FollowList\\\")\\n\\tvar GetFollowersQuery = new Parse.Query(FollowObject)\\n\\tGetFollowersQuery.equalTo(\\\"Following\\\",User)\\n\\tGetFollowersQuery.find({\\n\\t\\tsuccess : function (Followers) {\\n\\t\\t\\t// console.log(Followers.length);\\n\\t\\t\\t$scope.Followers = Followers.length\\n\\t\\t\\t$scope.$apply()\\n\\t\\t}\\n\\t})\\n\\t}\\n\\tfunction GetFollowing()\\n\\t{\\n\\tvar FollowObject = Parse.Object.extend(\\\"FollowList\\\")\\n\\tvar GetFollowingQuery = new Parse.Query(FollowObject)\\n\\tGetFollowingQuery.equalTo(\\\"Follower\\\",User)\\n\\tGetFollowingQuery.find({\\n\\t\\tsuccess : function (Following) {\\n\\t\\t\\tconsole.log(Following.length);\\n\\t\\t\\t$scope.Following = Following.length\\n\\t\\t\\t$scope.$apply()\\n\\t\\t}\\n\\t})\\n\\t}\\n\\n\\t$scope.FollowUnfollowAction = function()\\n\\t{\\n\\t\\tvar FollowType = Parse.Object.extend(\\\"FollowList\\\")\\n\\t\\tvar FollowObject = new FollowType();\\n\\t\\tFollowObject.set(\\\"Follower\\\",Parse.User.current())\\n\\t\\tFollowObject.set(\\\"Following\\\",User)\\n\\t\\tFollowObject.set(\\\"FollowingName\\\",User.get(\\\"Name\\\"))\\n\\t\\tif($scope.isFollowing == \\\"Follow\\\")\\n\\t\\t{\\n\\t\\t\\tFollowObject.save({success : function(Object) {\\n\\t\\t\\t\\t$scope.objectIdOfFollowObject = Object.id\\n\\t\\t\\t}})\\n\\t\\t\\t$scope.isFollowing = \\\"Unfollow\\\"\\n\\t\\t\\t$scope.icon = \\\"Follwing\\\"\\n\\t\\t\\t$scope.Followers += 1\\n\\t\\t}\\n\\t\\telse {\\n\\t\\t\\tFollowObject = new FollowType();\\n\\t\\t\\tvar Query = new Parse.Query(FollowType);\\n\\t\\t\\tQuery.equalTo(\\\"objectId\\\",$scope.objectIdOfFollowObject)\\n\\t\\t\\tQuery.find({\\n\\t\\t\\t\\tsuccess:function(Objects) {\\n\\t\\t\\t\\t\\tObjects[0].destroy()\\n\\t\\t\\t\\t}\\n\\t\\t\\t})\\n\\n\\t\\t\\t$scope.isFollowing = \\\"Follow\\\"\\n\\t\\t\\t$scope.icon = \\\"+Follow\\\"\\n\\t\\t\\t$scope.Followers -= 1\\n\\t\\t}\\n\\t}\\n\\nfunction CheckIfIamFollowing()\\n{\\n\\tvar FollowObject = Parse.Object.extend(\\\"FollowList\\\")\\n\\tvar GetFollowingQuery = new Parse.Query(FollowObject)\\n\\tGetFollowingQuery.equalTo(\\\"Follower\\\",Parse.User.current())\\n\\tGetFollowingQuery.find({\\n\\t\\tsuccess : function (Following) {\\n\\t\\t\\tif(Following.length == 0)\\n\\t\\t\\t{\\n\\t\\t\\t\\t$scope.isFollowing = \\\"Follow\\\"\\n\\t\\t\\t\\t$scope.icon = \\\"+Follow\\\"\\n\\t\\t\\t}\\n\\t\\t\\tfor(var i=0;i 0){\\n\\t\\t\\t// console.log(\\\"load more\\\");\\n\\t\\t\\tvar ExistingObjectIds=new Array();\\n\\t\\t\\tfor(var i=0;i<$scope.posts.length;i++)\\n\\t\\t\\t{\\n\\t\\t\\t\\t// console.log($scope.posts[i].id);\\n\\t\\t\\t\\tExistingObjectIds[i] = $scope.posts[i].id;\\n\\t\\t\\t}\\n\\t\\t\\t// console.log(ExistingObjectIds);\\n\\t\\t\\tQuery.notContainedIn(\\\"objectId\\\",ExistingObjectIds)\\n\\t\\t}\\n\\t\\tQuery.descending(\\\"createdAt\\\")\\n\\t\\tQuery.find({\\n\\t\\t\\tsuccess : function (data) {\\n\\t\\t\\t\\t\\tData.Value = data.length\\n\\t\\t\\t\\t\\tif(data !=null && data != 'undefined'){\\n\\t\\t\\t\\t\\t\\t// $scope.posts=data\\n\\t\\t\\t\\t\\t\\t// console.log(typeof($scope.post));\\n\\t\\t\\t\\t\\t\\tfor(var i=0;i 0 || SinglePost.get('Votes2') > 0)\\n {\\n if(SinglePost.get('Punchers1').indexOf(Parse.User.current().id) > -1)\\n {\\n SinglePost.set('isVoted1',\\\"block\\\")\\n SinglePost.set('isVoted2',\\\"none\\\")\\n // alert(SinglePost.Image1Title + SinglePost.Image2Title + \\\" = isVoted1 = \\\" + SinglePost.get('isVoted1') + \\\" isVoted2 = \\\" + SinglePost.get('isVoted2'));\\n }\\n\\n else if(SinglePost.get('Punchers2').indexOf(Parse.User.current().id) > -1)\\n {\\n SinglePost.set('isVoted1',\\\"none\\\")\\n SinglePost.set('isVoted2',\\\"block\\\")\\n // alert(SinglePost.Image1Title + SinglePost.Image2Title + \\\" = isVoted1 = \\\" + SinglePost.get('isVoted1') + \\\" isVoted2 = \\\" + SinglePost.get('isVoted2'));\\n }\\n else {\\n SinglePost.set('isVoted1',\\\"none\\\")\\n SinglePost.set('isVoted2',\\\"none\\\")\\n }\\n }\\n else {\\n SinglePost.set('isVoted1',\\\"none\\\")\\n SinglePost.set('isVoted2',\\\"none\\\")\\n }\\n\\t\\t\\t\\t\\t\\t\\t$scope.posts.push(SinglePost)\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t$scope.PostsVisibility = false;\\n\\t\\t\\t\\t\\t\\t//spinner\\n\\t\\t\\t\\t\\t\\tvar spinner = document.getElementById('spinner')\\n\\t\\t\\t\\t\\t\\tspinner.style.display = 'none'\\n\\t\\t\\t\\t\\t\\t$scope.$apply()\\n\\t\\t\\t\\t\\t\\t// console.log($scope.posts.length);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\t\\t// console.log(\\\"null\\\");\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t},\\n\\t\\t\\terror : function (error) {\\n\\t\\t\\t\\t// console.log(error);\\n\\t\\t\\t}\\n\\t\\t})\\n}\\n\\nfunction GetTimeStamp(createdAt)\\n{\\n\\tvar currentDate = new Date()\\n\\tvar Time;\\n\\tif(Math.abs(currentDate.getMonth() - createdAt.getMonth()) == 0)\\n\\t{\\n\\t\\tif(Math.abs(currentDate.getDay() - createdAt.getDay()) > 7)\\n\\t\\t{\\n\\t\\t\\tTime = String(parseInt(Math.abs(currentDate.getDay() - createdAt.getDay())) / 7 ) + \\\"W\\\"\\n\\t\\t}\\n\\t\\telse if (Math.abs(currentDate.getDay() - createdAt.getDay()) > 0)\\n\\t\\t{\\n\\t\\t\\tTime = String(Math.abs(currentDate.getDay() - createdAt.getDay())) + \\\"d\\\"\\n\\t\\t}\\n\\t\\telse if (Math.abs(currentDate.getHours() - createdAt.getHours()) > 0){\\n\\t\\t\\tTime = String(Math.abs(currentDate.getHours() - createdAt.getHours())) + \\\"h\\\"\\n\\t\\t}\\n\\t\\telse {\\n\\t\\t{\\n\\t\\t\\t\\t\\tTime = String(Math.abs(currentDate.getMinutes() - createdAt.getMinutes())) + 'm'\\n\\t\\t}\\n\\t\\t}\\n\\t}\\n\\telse {\\n\\t\\tTime = String(Math.abs(currentDate.getMonth() - createdAt.getMonth())) + 'M'\\n\\t}\\n\\treturn Time;\\n}\\n\\n$scope.PostComment=function(){\\n\\tvar objectId = $scope.objectId\\n\\tvar CommentObj = Parse.Object.extend(\\\"Comment\\\")\\n\\tvar Comment = new CommentObj();\\n\\tvar Post = {\\n\\t__type: 'Pointer',\\n\\tclassName: 'Posts',\\n\\tobjectId: objectId\\n\\t}\\n\\tComment.set(\\\"User\\\",Parse.User.current())\\n\\tComment.set(\\\"Post\\\",Post)\\n\\tComment.set(\\\"comment\\\",$scope.cc)\\n\\tif($scope.cc != null && $scope.cc !=\\\"undefined\\\")\\n\\t{\\n\\tComment.save()\\n\\t$scope.comments.push(Comment)\\n\\t$scope.cc = null\\n\\t$scope.$apply();\\n\\tMaterialize.toast('Comment Added successfully', 4000)\\n\\t}\\n\\telse {\\n\\t\\tMaterialize.toast('Comment cannot be null', 4000)\\n\\t}\\n}\\n\\nfunction GetComments(objectId)\\n{\\n\\t\\t\\t$scope.objectId = objectId\\n\\t\\t\\tvar Comment = Parse.Object.extend(\\\"Comment\\\")\\n\\t\\t\\tvar CommentQuery = new Parse.Query(Comment);\\n\\t\\t\\tvar Post = {\\n\\t\\t\\t__type: 'Pointer',\\n\\t\\t\\tclassName: 'Posts',\\n\\t\\t\\tobjectId: objectId\\n\\t\\t\\t}\\n\\t\\t\\tCommentQuery.equalTo(\\\"Post\\\",Post)\\n\\t\\t\\tCommentQuery.find({\\n\\t\\t\\t\\tsuccess : function (Comments) {\\n\\t\\t\\t\\t\\t\\tfor(var i=0;i scope.wmBlockLength){\\n e.preventDefault();\\n return false;\\n }\\n });\\n }\\n }\\n});\\n\\napp.config(['$interpolateProvider', function($interpolateProvider) {\\n $interpolateProvider.startSymbol('{a');\\n $interpolateProvider.endSymbol('a}');\\n}])\\n\"\n },\n {\n \"alpha_fraction\": 0.682009756565094,\n \"alphanum_fraction\": 0.6914516687393188,\n \"avg_line_length\": 27.37799072265625,\n \"blob_id\": \"bbd5774b2cea381c06eb92f5e673f2ee4c8b5592\",\n \"content_id\": \"d94be2f9bf013010d76b485f73f5c444ddaa1458\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 5931,\n \"license_type\": \"no_license\",\n \"max_line_length\": 108,\n \"num_lines\": 209,\n \"path\": \"/hello.py\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from parse_rest.user import User\\nimport settings_local\\nfrom flask import Flask,request,redirect, url_for ,render_template,send_from_directory,session,make_response\\nfrom parse_rest.connection import SessionToken, register\\nfrom parse_rest.datatypes import Function\\nimport json,httplib\\nimport os\\nfrom flask.ext.triangle import Form,Triangle\\nfrom flask.ext.triangle.widgets.standard import TextInput\\nfrom datetime import timedelta\\nfrom flask import session, app\\nimport os\\nimport pusher\\nimport getPost\\nfrom flask import Blueprint\\n\\nsettings_local.initParse()\\napp = Flask(__name__)\\nTriangle(app)\\napp.config['UPLOAD_FOLDER'] = 'uploads/'\\n\\nHackathon = Blueprint('Hackathon', __name__,\\n template_folder='templates',subdomain=\\\"hack404\\\")\\napp.register_blueprint(Hackathon)\\n\\n\\n@app.before_request\\ndef make_session_permanent():\\n session.permanent = True\\n app.permanent_session_lifetime = timedelta(minutes=46440)\\n\\n@app.route('/',methods=['GET', 'POST'])\\ndef index():\\n #\\tsettings_local.initParse()\\n\\t# if request.method == 'POST' and request.form[\\\"what\\\"]== 'Login':\\n\\t# \\ttry:\\n\\t# \\t\\tprint request.form[\\\"password\\\"]\\n\\t# \\t\\tu = User.login(request.form[\\\"username\\\"],request.form[\\\"password\\\"])\\n\\t# \\t\\tsession['session_token'] = u.sessionToken\\n\\t# \\t\\tresp = make_response(render_template(\\\"index.html\\\"))\\n\\t# \\t\\treturn resp\\n\\t# \\texcept:\\n\\t# \\t\\treturn render_template('login.html',error=\\\"Invalid username or password\\\")\\n\\t# elif request.method == 'POST' and request.form[\\\"what\\\"]=='SignUp':\\n\\t# \\temail = request.form[\\\"email\\\"]\\n\\t# \\tpassword = request.form[\\\"password\\\"]\\n\\t# \\tninja = request.form[\\\"ninja\\\"]\\n\\t# \\tbirthdate = request.form[\\\"birthdate\\\"]\\n\\t# \\tu = User.signup(email,password)\\n\\t# \\tu.email=email\\n\\t# \\tu.save()\\n\\t# \\t# proPic.save(os.path.join(app.config['UPLOAD_FOLDER']),\\\"userdp.png\\\")\\n\\t\\t# connection = httplib.HTTPSConnection('api.parse.com', 443)\\n\\t\\t# connection.connect()\\n\\t\\t# connection.request('POST', '/1/files/profilePic.png', open('userdp.png', 'rb').read(), {\\n\\t\\t# \\\"X-Parse-Application-Id\\\": \\\"${Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4}\\\",\\n\\t\\t# \\\"X-Parse-REST-API-Key\\\": \\\"${nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO}\\\",\\n\\t\\t# \\\"Content-Type\\\": \\\"image/png\\\"\\n\\t\\t# })\\n\\t\\t# result = json.loads(connection.getresponse().read())\\n\\t\\t# print result\\n\\t\\t# connection.request('POST', '/1/classes/_User', json.dumps({\\n\\t\\t# \\\"username\\\": email,\\n\\t\\t# \\\"picture\\\": {\\n\\t\\t# \\\"name\\\": \\\"profilePic.png\\\",\\n\\t\\t# \\\"__type\\\": \\\"File\\\"\\n\\t\\t# }\\n\\t\\t# }), {\\n\\t\\t# \\\"X-Parse-Application-Id\\\": \\\"${Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4}\\\",\\n\\t\\t# \\\"X-Parse-REST-API-Key\\\": \\\"${nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO}\\\",\\n\\t\\t# \\\"Content-Type\\\": \\\"application/json\\\"\\n\\t\\t# })\\n\\t\\t# result = json.loads(connection.getresponse().read())\\n\\t\\t# print result\\n\\t# \\tsession['session_token'] = u.sessionToken\\n\\t# \\tresp = make_response(render_template(\\\"index.html\\\"))\\n\\t# \\treturn u.sessionToken\\n\\t# else:\\n\\t# \\tif session.get('session_token') is None:\\n\\t# \\t\\tprint \\\"nohhh\\\"\\n\\t# \\t\\treturn render_template('login.html')\\n\\t# \\telse:\\n\\t# \\t\\tprint \\\"yes\\\"\\n\\t# \\t\\treturn render_template('index.html')\\n # print \\\"hack\\\"\\n\\treturn render_template('Error.html')\\n\\n@app.route('/hack404')\\ndef hackathon():\\n return render_template('hackathon.html')\\n\\n@app.route('/js/')\\ndef send_js(path):\\n\\tprint path\\n\\treturn send_from_directory('js', path)\\n\\n@app.route('/assets/images/')\\ndef send_from_assets_images(path):\\n print path\\n return send_from_directory('assets/images', path)\\n\\n@app.route('/assets/javascripts/')\\ndef send_from_assets_js(path):\\n print path\\n return send_from_directory('assets/javascripts', path)\\n\\n@app.route('/assets/stylesheets/')\\ndef send_from_assets_css(path):\\n print path\\n return send_from_directory('assets/stylesheets', path)\\n\\n@app.route('/mobileLogin')\\ndef mobileLogin():\\n if session.get('session_token') is None:\\n return render_template('mlogin.html')\\n\\n@app.route('/css/')\\ndef send_css(path):\\n\\tprint path\\n\\treturn send_from_directory('css', path)\\n\\n@app.route('/font/')\\ndef send_font(path):\\n\\tprint path\\n\\treturn send_from_directory('font', path)\\n\\n@app.route('/NewUpdate/')\\ndef NewUpdate(objectId):\\n p = pusher.Pusher(app_id='173885',key='2f8f1cab459e648a27fd',secret='80905f147470664954bd',ssl=True,port=443)\\n p.trigger('PostChannel', 'NewUpdate', {'message': objectId})\\n return \\\"success\\\"\\n\\n\\n@app.route('/images/')\\ndef send_images(path):\\n\\tprint path\\n\\treturn send_from_directory('images', path)\\n\\n@app.route('/Icons/')\\ndef Icons(path):\\n\\tprint path\\n\\treturn send_from_directory('Icons', path)\\n\\n@app.route('/logout')\\ndef logout():\\n\\t# session.Abandon()\\n\\tsession.clear()\\n\\treturn redirect(url_for('index'))\\n\\ndef GetCurrentUser():\\n\\ttoken = session.get('session_token')\\n\\tsettings_local.initParse(token)\\n\\tme = User.current_user()\\n\\treturn me\\n\\n@app.route('/setSession/')\\ndef setSession(path):\\n\\tsession['session_token'] = path\\n\\treturn render_template('index.html')\\n\\n@app.route('/GetSessionToken')\\ndef GetSessionToken():\\n\\ttoken = session.get('session_token')\\n\\treturn str(token)\\n\\n@app.route('/GetUserInterests')\\ndef GetUserInterests():\\n\\td = []\\n\\tGetCurrentUser()\\n\\tuser_interest_function = Function(\\\"GetUserIntrest\\\")\\n\\td = user_interest_function()\\n\\treturn json.dumps(d)\\n\\n@app.route('/Profile')\\ndef Profile():\\n if session.get('session_token') != None:\\n return render_template('profile.html')\\n else:\\n return render_template('login.html')\\n\\n@app.route('/Select_Interests')\\ndef Select_Interests():\\n if session.get('session_token') != None:\\n return render_template('Settings.html')\\n else:\\n return render_template('login.html')\\n\\n@app.route('/share/')\\ndef share(path):\\n SinglePost = getPost.getSinglePost(path)\\n return render_template('Posts.html',SinglePost=SinglePost)\\n\\n@app.route('/Settings')\\ndef Settings():\\n\\treturn render_template('Settings.html')\\n\\n@app.route('/download')\\ndef download():\\n\\treturn render_template('Error.html')\\n\\nport = int(os.environ.get('PORT', 5000))\\napp.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'\\napp.run(host=\\\"0.0.0.0\\\",debug=True,port=port)\\n\\n\\n# font images)\\n\\n\\n#font images\\n\"\n },\n {\n \"alpha_fraction\": 0.7622377872467041,\n \"alphanum_fraction\": 0.7657342553138733,\n \"avg_line_length\": 27.5,\n \"blob_id\": \"62f78f3fa14a99765ef773d21b5fbdf3b23dc9b4\",\n \"content_id\": \"546131a2fa95f80bae1149dc9cd49eafa8c4203f\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 286,\n \"license_type\": \"no_license\",\n \"max_line_length\": 49,\n \"num_lines\": 10,\n \"path\": \"/getPost.py\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from parse_rest.datatypes import Object\\nimport settings_local\\n\\ndef getSinglePost(objectId):\\n settings_local.initParse()\\n className=\\\"Posts\\\"\\n Posts=Object.factory(className)\\n SinglePost=Posts.Query.get(objectId=objectId)\\n print SinglePost.Image1.url\\n return SinglePost\\n\\n\"\n },\n {\n \"alpha_fraction\": 0.47630923986434937,\n \"alphanum_fraction\": 0.7057356834411621,\n \"avg_line_length\": 15.708333015441895,\n \"blob_id\": \"2e3852d89487488dc8db3caa49287e45f55e1925\",\n \"content_id\": \"b47167c63d19da04c180e6b1b4680ddad4b8905c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Text\",\n \"length_bytes\": 401,\n \"license_type\": \"no_license\",\n \"max_line_length\": 24,\n \"num_lines\": 24,\n \"path\": \"/requirements.txt\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"cffi==1.5.0\\ncryptography==1.2.1\\nenum34==1.1.2\\nFlask==0.10.1\\nFlask-Triangle==0.5.4\\nfunctools32==3.2.3.post2\\ngunicorn==19.4.5\\nidna==2.0\\nipaddress==1.0.16\\nitsdangerous==0.24\\nJinja2==2.8\\njsonschema==2.5.1\\nMarkupSafe==0.23\\nndg-httpsclient==0.4.0\\nparse-rest==0.2.20141004\\npusher==1.2.3\\npyasn1==0.1.9\\npycparser==2.14\\npyOpenSSL==0.15.1\\nrequests==2.9.1\\nsix==1.10.0\\nurllib3==1.14\\nWerkzeug==0.11.3\\nwheel==0.24.0\\n\"\n },\n {\n \"alpha_fraction\": 0.7755101919174194,\n \"alphanum_fraction\": 0.7755101919174194,\n \"avg_line_length\": 23.5,\n \"blob_id\": \"cc96392561bb672e9eebef2d75d924dc4df1f923\",\n \"content_id\": \"83970e5afba48b22e8f45a5fa414cbdd35ac4a33\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Markdown\",\n \"length_bytes\": 49,\n \"license_type\": \"no_license\",\n \"max_line_length\": 27,\n \"num_lines\": 2,\n \"path\": \"/README.md\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#Punchit.io website \\n# Punchit.io_website_master\\n\"\n },\n {\n \"alpha_fraction\": 0.5850793123245239,\n \"alphanum_fraction\": 0.58977872133255,\n \"avg_line_length\": 27.691011428833008,\n \"blob_id\": \"c892e846422dea2a83ba45eb8fd14fa45a0f100e\",\n \"content_id\": \"9577360b647e37ea5805d8e7997d66db62a8d56a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"JavaScript\",\n \"length_bytes\": 5107,\n \"license_type\": \"no_license\",\n \"max_line_length\": 152,\n \"num_lines\": 178,\n \"path\": \"/js/SettingsController.js\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"var app = angular.module('app',['app.controllers','app.factory'])\\n\\napp.controller(\\\"MainController\\\",function($scope){\\n\\n});\\n\\napp.controller(\\\"FriendsController\\\",['$scope','GetFacebookFriends','GetFriendsFromInterests',function($scope,GetFacebookFriends,GetFriendsFromInterests){\\n var promise = GetFacebookFriends.GetFriends()\\n promise.then(function(Data){\\n for(var i=0;i 0) {\\n var file = fileUploadControl.files[0];\\n // alert(JSON.stringify(file))\\n var name = \\\"profilePic.png\\\";\\n var parseFile = new Parse.File(name, file);\\n parseFile.save().then(function(){\\n user.set(\\\"ProfilePicture\\\",parseFile);\\n user.set(\\\"email\\\",$scope.Email)\\n user.set(\\\"Ninja_name\\\",$scope.Ninja_name)\\n user.set(\\\"Name\\\",$scope.Name)\\n user.save({\\n success: function(user){\\n Materialize.toast('Your Profile was successfully updated', 3000);\\n location.reload()\\n },\\n error : function(error){\\n Materialize.toast(error, 2000);\\n }\\n });\\n\\n },function(){})\\n }\\n else {\\n Materialize.toast('Please choose your Profile Picture', 2000);\\n }\\n }\\n})\\n\\napp.controller(\\\"ChangePassword\\\",function($scope){\\n $scope.update = function(){\\n var user = Parse.User.current()\\n if($scope.Pass_con == $scope.Pass_main)\\n {\\n user.set(\\\"password\\\",$scope.Pass_main)\\n user.save({\\n success : function(user){\\n Materialize.toast('Password updated', 3000);\\n }\\n })\\n }\\n }\\n})\\n\"\n },\n {\n \"alpha_fraction\": 0.641121506690979,\n \"alphanum_fraction\": 0.7028037309646606,\n \"avg_line_length\": 88.33333587646484,\n \"blob_id\": \"527b8428136f46856665a47213c052405f2929da\",\n \"content_id\": \"0381f979a1c73785cf3b33e2956268ad33979af4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"JavaScript\",\n \"length_bytes\": 535,\n \"license_type\": \"no_license\",\n \"max_line_length\": 278,\n \"num_lines\": 6,\n \"path\": \"/images/logos/punchit.io_files/FkQNViGi-sj.js\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"/*!CK:2686195818!*//*1441808114,*/\\n\\nif (self.CavalryLogger) { CavalryLogger.start_js([\\\"tLt9Y\\\"]); }\\n\\n__d('IntlLithuanianNumberType',['IntlVariations'],function a(b,c,d,e,f,g,h){if(c.__markCompiled)c.__markCompiled();var i={getNumberVariationType:function(j){var k=j%100,l=k%10;return l===0||k>10&&k<20?h.NUMBER_DUAL:l===1?h.NUMBER_SINGULAR:h.NUMBER_PLURAL;}};f.exports=i;},null);\\n__d('legacy:pages-suggest-ui-nullable',['NullableInput'],function a(b,c,d,e){if(c.__markCompiled)c.__markCompiled();b.NullableInput=c('NullableInput');},3);\"\n },\n {\n \"alpha_fraction\": 0.618453860282898,\n \"alphanum_fraction\": 0.7605984807014465,\n \"avg_line_length\": 33.869564056396484,\n \"blob_id\": \"375952e502352a00b3701552bf058a0dda0bac31\",\n \"content_id\": \"b192365761eb3c0ac972cbb4bd4b2c288cb39484\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 802,\n \"license_type\": \"no_license\",\n \"max_line_length\": 121,\n \"num_lines\": 23,\n \"path\": \"/Process.py\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import requests\\nimport sys\\nfrom PIL import Image\\n\\nf = open('Image1.jpg', 'wb')\\nurl1 = \\\"http://files.parsetfss.com/b7dd35dc-b01c-4492-b846-ef2a47bafc6b/tfss-0b3759e3-2265-430a-b033-f8f4421cdaab-Image1\\\"\\nf.write(requests.get(url1).content)\\nf.close()\\nf1 = open('Image2.jpg', 'wb')\\nurl2 = \\\"http://files.parsetfss.com/b7dd35dc-b01c-4492-b846-ef2a47bafc6b/tfss-0b3759e3-2265-430a-b033-f8f4421cdaab-Image1\\\"\\nf1.write(requests.get(url2).content)\\nf1.close()\\nbackground = Image.open('images/Share_Pattern.jpg')\\nbackground.thumbnail((300,300),Image.ANTIALIAS)\\n# background.show()\\nimage1 = Image.open('Image1.jpg')\\nimage1.thumbnail((75,100),Image.ANTIALIAS)\\n# image1.show()\\nimage2 = Image.open('Image2.jpg')\\nimage2.thumbnail((75,100),Image.ANTIALIAS)\\nimage2.show()\\nbackground.paste(image1,(40,10))\\nbackground.show()\\n\"\n },\n {\n \"alpha_fraction\": 0.7219731211662292,\n \"alphanum_fraction\": 0.7219731211662292,\n \"avg_line_length\": 30.85714340209961,\n \"blob_id\": \"9b1e6d55b7141d3e9fff3c2996bb72b5734e33b6\",\n \"content_id\": \"0447e1b307e96b56b82935f03d688a58f1ffc6c1\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 223,\n \"license_type\": \"no_license\",\n \"max_line_length\": 54,\n \"num_lines\": 7,\n \"path\": \"/settings_local.py\",\n \"repo_name\": \"smitthakkar96/Punchit.io_website_master\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"from parse_rest.connection import register\\ndef initParse(sessionToken=None):\\n\\tprint \\\"init\\\"\\n\\tif sessionToken == None:\\n\\t\\tregister('Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4','nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO',master_key=None)\\n\\telse:\\n\\t\\tregister('Y4Txek5e5lKnGzkArbcNMVKqMHyaTk3XR6COOpg4','nJOJNtVr1EvNiyjo6F6M8zfiUdzv8lPx31FBHiwO',session_token=sessionToken)\\n\"\n }\n]"},"num_files":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":2978316,"cells":{"repo_name":{"kind":"string","value":"clearskky/Scopus_Scrape"},"repo_url":{"kind":"string","value":"https://github.com/clearskky/Scopus_Scrape"},"snapshot_id":{"kind":"string","value":"2fdf0b8e8e650b749c05ef45ff6aa4a16014e6be"},"revision_id":{"kind":"string","value":"f0af9110c6b18a665de6f3a961d36a2d9973e10c"},"directory_id":{"kind":"string","value":"8914855d0900f44001c6115410a12d464e6e77a4"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2021-01-26T14:33:56.923301","string":"2021-01-26T14:33:56.923301"},"revision_date":{"kind":"timestamp","value":"2020-02-27T06:41:00","string":"2020-02-27T06:41:00"},"committer_date":{"kind":"timestamp","value":"2020-02-27T06:41:00","string":"2020-02-27T06:41:00"},"github_id":{"kind":"number","value":243449516,"string":"243,449,516"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.5965327024459839,"alphanum_fraction":0.6356711387634277,"avg_line_length":49.445945739746094,"blob_id":"f1a75eb0a093308c617ec5cbbeb66dce43175435","content_id":"7e9ff297a8056ec8f69ff0131b843b92f9c0f068","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":3852,"license_type":"no_license","max_line_length":269,"num_lines":74,"path":"/ScopusScrape.py","repo_name":"clearskky/Scopus_Scrape","src_encoding":"UTF-8","text":"import requests\r\nimport json\r\nfrom bs4 import BeautifulSoup #HTML sayfasını parse etmek için gereken kütüphane\r\nfrom time import sleep \r\n\r\noffset = 1 # URL'de offset parametresi sayfanın başında hangi makalenin yer alacağını belirler. Örneğin offset 41 olduğu zaman sayfada 41-60 arası makaleler listelenir.\r\npubyear = 2019\r\nscopus_1 = \"https://www.scopus.com/results/results.uri?sort=cp-f&src=s&st1=%22human-computer+interaction%22&nlo=&nlr=&nls=&sid=f65b0436cf4718bd9b60238fd65a4454&sot=b&sdt=b&sl=78&s=TITLE-ABS-KEY%28%22human-computer+interaction%22%29+AND+DOCTYPE%28ar%29+AND+PUBYEAR+%3d+\"\r\nscopus_2 = \"&cl=t&offset=\"\r\nscopus_3 = \"&origin=resultslist&ss=cp-f&ws=r-f&ps=r-f&cs=r-f&cc=10&txGid=7575ff4e603f1469d35288c9add1ab14\"\r\narticles = {}\r\n#totalArticleCount = 100\r\n\r\n\r\nhdr = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',\r\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\r\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\r\n 'Accept-Encoding': 'none',\r\n 'Accept-Language': 'en-US,en;q=0.8',\r\n 'Connection': 'keep-alive'}\r\n\r\nfor k in range(25): #Range * 20 = Elde edilecek makale sayısı. Her sayfada 20 makale yer almakta\r\n myURL = scopus_1 + str(pubyear) + scopus_2 + str(offset) + scopus_3\r\n r = requests.post(url=myURL, headers=hdr)\r\n parsedPage = BeautifulSoup(r.text, \"lxml\")\r\n searchAreas = parsedPage.find_all(\"tr\", attrs={\"class\":\"searchArea\"})\r\n print(len(searchAreas))\r\n for i in range(len(searchAreas)):\r\n #Her makalenin belirli bazı verileri elde edilir\r\n searchArea = searchAreas[i].find(\"a\", attrs={\"class\":\"ddmDocTitle\"})\r\n docTitle = searchArea.get_text()\r\n docLink = searchArea.attrs[\"href\"]\r\n citations = searchAreas[i].find_all(\"td\", attrs={\"class\":\"textRight\"})[1].get_text()\r\n keywords = []\r\n\r\n \r\n print(str(offset+i) + \".ci makalenin sayfasından etiketler çekiliyor\")\r\n\r\n #Makalenin anahtar kelimelerini elde etmek için makalenin sayfasına gidilir\r\n try:\r\n r2 = requests.post(url=docLink, headers=hdr)\r\n parsedArticle = BeautifulSoup(r2.text, \"lxml\")\r\n #print(\"parsedArticle BeautifulSoup nesnesi oluşturuldu\")\r\n authorKeywords = parsedArticle.find(\"section\", attrs={\"id\":\"authorKeywords\"})\r\n #print(\"Keyword'lerin yer aldığı section elde edildi\")\r\n badges = authorKeywords.find_all(\"span\", attrs={\"class\":\"badges\"})\r\n #print(\"Bütün badge'ler bulundu\")\r\n keywords = []\r\n for j in range(len(badges)):\r\n keywords.append(badges[j].get_text())\r\n print(str(offset+i) +\".ci makalenin bütün anahtarlar kelimeleri elde edildi\")\r\n print(\"------------------------------------\")\r\n except:\r\n print(str(offset+i) +\".ci makalenin yazar tarafından verilen etiketleri yok ---------!!!\")\r\n print(\"------------------------------------\")\r\n \r\n \r\n #Bulgular dictionary'nin uygun alanlarına yerleştirilir\r\n \r\n articles[\"article\" + str(offset+i)] = {}\r\n articles[\"article\" + str(offset+i)][\"docTitle\"] = docTitle\r\n articles[\"article\" + str(offset+i)][\"docLink\"] = docLink\r\n articles[\"article\" + str(offset+i)][\"citations\"] = citations.strip(\"\\n\")\r\n articles[\"article\" + str(offset+i)][\"keywords\"] = keywords\r\n offset+= 20\r\nprint(\"Bütün bulgular dictionary'e yerleştirildi\")\r\n\r\n\r\n \r\nprint(\"JSON Yazım işlemleri başlıyor\")\r\nwith open(\"scopus500articles2019.json\", \"w\", encoding=\"utf-8\") as jsonFile:\r\n #json.dump(complaints, jsonFile, ensure_ascii=False).encode(\"utf8\")\r\n json.dump(articles, jsonFile)\r\n print(\"Dosya yazım işlemi başarıyla tamamlandı\")\r\n"},{"alpha_fraction":0.5679903626441956,"alphanum_fraction":0.5848375558853149,"avg_line_length":35.772727966308594,"blob_id":"a7185cc51872b96ff3258c2dfaeebed432fbbaf4","content_id":"c5fa6a51e1f340a80667b8449be00010007bf756","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":836,"license_type":"no_license","max_line_length":100,"num_lines":22,"path":"/ScopusCitationsCounter.py","repo_name":"clearskky/Scopus_Scrape","src_encoding":"UTF-8","text":"import json\r\n\r\nfile = \"scopus500articles201\"\r\nfileNumber = 5\r\n\r\ncitations = {}\r\nfor i in range(5,10):\r\n targetFile = file + str(i) + \".json\"\r\n with open(targetFile, \"r\") as articles:\r\n articleData = json.load(articles)\r\n for article, data in articleData.items():\r\n year = \"201\" + str(i)\r\n if year not in citations.keys():\r\n citations[year] = int(data[\"citations\"].strip(\"\\n\").strip(\"\\t\"))\r\n else:\r\n citations[year] += int(data[\"citations\"].strip(\"\\n\").strip(\"\\t\"))\r\n \r\n\r\nwith open(\"ArticleCitationCountByYear.json\", \"w\") as destination:\r\n citations = {k: v for k, v in sorted(citations.items(), key=lambda item: item[1], reverse=True)}\r\n json.dump(citations, destination)\r\n print(\"Dosya yazım işlemi başarıyla tamamlandı\")\r\n"},{"alpha_fraction":0.5452696084976196,"alphanum_fraction":0.5666327476501465,"avg_line_length":35.57692337036133,"blob_id":"7678fcf76a084fa829b7d8beb39deaf3ef841672","content_id":"5c75f464e486b21ae490f1c60dadfc80137015a4","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":995,"license_type":"no_license","max_line_length":102,"num_lines":26,"path":"/ScopusKeywordCounter.py","repo_name":"clearskky/Scopus_Scrape","src_encoding":"UTF-8","text":"import json\r\n\r\nfile = \"scopus500articles201\"\r\nfileNumber = 5\r\n\r\nkeywords = {}\r\nfor i in range(5,10):\r\n targetFile = file + str(i) + \".json\"\r\n with open(targetFile, \"r\") as articles:\r\n articleData = json.load(articles)\r\n for article, data in articleData.items():\r\n for keyword in data[\"keywords\"]:\r\n if len(data[\"keywords\"]) < 1:\r\n keywords[\"noKeywords\"] += 1\r\n if keyword not in keywords:\r\n keywords[keyword] = 1\r\n else:\r\n keywords[keyword] += 1\r\n\r\n destinationFile = \"500ArticleKeywords201\" + str(i) + \".json\"\r\n with open(destinationFile, \"w\") as destination:\r\n keywords = {k: v for k, v in sorted(keywords.items(), key=lambda item: item[1], reverse=True)}\r\n json.dump(keywords, destination)\r\n print(\"Dosya yazım işlemi başarıyla tamamlandı\")\r\n \r\nprint(\"Bütün dosya yazım işlemleri başarıyla tamamlandı\")\r\n \r\n"}],"string":"[\n {\n \"alpha_fraction\": 0.5965327024459839,\n \"alphanum_fraction\": 0.6356711387634277,\n \"avg_line_length\": 49.445945739746094,\n \"blob_id\": \"f1a75eb0a093308c617ec5cbbeb66dce43175435\",\n \"content_id\": \"7e9ff297a8056ec8f69ff0131b843b92f9c0f068\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3852,\n \"license_type\": \"no_license\",\n \"max_line_length\": 269,\n \"num_lines\": 74,\n \"path\": \"/ScopusScrape.py\",\n \"repo_name\": \"clearskky/Scopus_Scrape\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import requests\\r\\nimport json\\r\\nfrom bs4 import BeautifulSoup #HTML sayfasını parse etmek için gereken kütüphane\\r\\nfrom time import sleep \\r\\n\\r\\noffset = 1 # URL'de offset parametresi sayfanın başında hangi makalenin yer alacağını belirler. Örneğin offset 41 olduğu zaman sayfada 41-60 arası makaleler listelenir.\\r\\npubyear = 2019\\r\\nscopus_1 = \\\"https://www.scopus.com/results/results.uri?sort=cp-f&src=s&st1=%22human-computer+interaction%22&nlo=&nlr=&nls=&sid=f65b0436cf4718bd9b60238fd65a4454&sot=b&sdt=b&sl=78&s=TITLE-ABS-KEY%28%22human-computer+interaction%22%29+AND+DOCTYPE%28ar%29+AND+PUBYEAR+%3d+\\\"\\r\\nscopus_2 = \\\"&cl=t&offset=\\\"\\r\\nscopus_3 = \\\"&origin=resultslist&ss=cp-f&ws=r-f&ps=r-f&cs=r-f&cc=10&txGid=7575ff4e603f1469d35288c9add1ab14\\\"\\r\\narticles = {}\\r\\n#totalArticleCount = 100\\r\\n\\r\\n\\r\\nhdr = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',\\r\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',\\r\\n 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',\\r\\n 'Accept-Encoding': 'none',\\r\\n 'Accept-Language': 'en-US,en;q=0.8',\\r\\n 'Connection': 'keep-alive'}\\r\\n\\r\\nfor k in range(25): #Range * 20 = Elde edilecek makale sayısı. Her sayfada 20 makale yer almakta\\r\\n myURL = scopus_1 + str(pubyear) + scopus_2 + str(offset) + scopus_3\\r\\n r = requests.post(url=myURL, headers=hdr)\\r\\n parsedPage = BeautifulSoup(r.text, \\\"lxml\\\")\\r\\n searchAreas = parsedPage.find_all(\\\"tr\\\", attrs={\\\"class\\\":\\\"searchArea\\\"})\\r\\n print(len(searchAreas))\\r\\n for i in range(len(searchAreas)):\\r\\n #Her makalenin belirli bazı verileri elde edilir\\r\\n searchArea = searchAreas[i].find(\\\"a\\\", attrs={\\\"class\\\":\\\"ddmDocTitle\\\"})\\r\\n docTitle = searchArea.get_text()\\r\\n docLink = searchArea.attrs[\\\"href\\\"]\\r\\n citations = searchAreas[i].find_all(\\\"td\\\", attrs={\\\"class\\\":\\\"textRight\\\"})[1].get_text()\\r\\n keywords = []\\r\\n\\r\\n \\r\\n print(str(offset+i) + \\\".ci makalenin sayfasından etiketler çekiliyor\\\")\\r\\n\\r\\n #Makalenin anahtar kelimelerini elde etmek için makalenin sayfasına gidilir\\r\\n try:\\r\\n r2 = requests.post(url=docLink, headers=hdr)\\r\\n parsedArticle = BeautifulSoup(r2.text, \\\"lxml\\\")\\r\\n #print(\\\"parsedArticle BeautifulSoup nesnesi oluşturuldu\\\")\\r\\n authorKeywords = parsedArticle.find(\\\"section\\\", attrs={\\\"id\\\":\\\"authorKeywords\\\"})\\r\\n #print(\\\"Keyword'lerin yer aldığı section elde edildi\\\")\\r\\n badges = authorKeywords.find_all(\\\"span\\\", attrs={\\\"class\\\":\\\"badges\\\"})\\r\\n #print(\\\"Bütün badge'ler bulundu\\\")\\r\\n keywords = []\\r\\n for j in range(len(badges)):\\r\\n keywords.append(badges[j].get_text())\\r\\n print(str(offset+i) +\\\".ci makalenin bütün anahtarlar kelimeleri elde edildi\\\")\\r\\n print(\\\"------------------------------------\\\")\\r\\n except:\\r\\n print(str(offset+i) +\\\".ci makalenin yazar tarafından verilen etiketleri yok ---------!!!\\\")\\r\\n print(\\\"------------------------------------\\\")\\r\\n \\r\\n \\r\\n #Bulgular dictionary'nin uygun alanlarına yerleştirilir\\r\\n \\r\\n articles[\\\"article\\\" + str(offset+i)] = {}\\r\\n articles[\\\"article\\\" + str(offset+i)][\\\"docTitle\\\"] = docTitle\\r\\n articles[\\\"article\\\" + str(offset+i)][\\\"docLink\\\"] = docLink\\r\\n articles[\\\"article\\\" + str(offset+i)][\\\"citations\\\"] = citations.strip(\\\"\\\\n\\\")\\r\\n articles[\\\"article\\\" + str(offset+i)][\\\"keywords\\\"] = keywords\\r\\n offset+= 20\\r\\nprint(\\\"Bütün bulgular dictionary'e yerleştirildi\\\")\\r\\n\\r\\n\\r\\n \\r\\nprint(\\\"JSON Yazım işlemleri başlıyor\\\")\\r\\nwith open(\\\"scopus500articles2019.json\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as jsonFile:\\r\\n #json.dump(complaints, jsonFile, ensure_ascii=False).encode(\\\"utf8\\\")\\r\\n json.dump(articles, jsonFile)\\r\\n print(\\\"Dosya yazım işlemi başarıyla tamamlandı\\\")\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5679903626441956,\n \"alphanum_fraction\": 0.5848375558853149,\n \"avg_line_length\": 35.772727966308594,\n \"blob_id\": \"a7185cc51872b96ff3258c2dfaeebed432fbbaf4\",\n \"content_id\": \"c5fa6a51e1f340a80667b8449be00010007bf756\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 836,\n \"license_type\": \"no_license\",\n \"max_line_length\": 100,\n \"num_lines\": 22,\n \"path\": \"/ScopusCitationsCounter.py\",\n \"repo_name\": \"clearskky/Scopus_Scrape\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import json\\r\\n\\r\\nfile = \\\"scopus500articles201\\\"\\r\\nfileNumber = 5\\r\\n\\r\\ncitations = {}\\r\\nfor i in range(5,10):\\r\\n targetFile = file + str(i) + \\\".json\\\"\\r\\n with open(targetFile, \\\"r\\\") as articles:\\r\\n articleData = json.load(articles)\\r\\n for article, data in articleData.items():\\r\\n year = \\\"201\\\" + str(i)\\r\\n if year not in citations.keys():\\r\\n citations[year] = int(data[\\\"citations\\\"].strip(\\\"\\\\n\\\").strip(\\\"\\\\t\\\"))\\r\\n else:\\r\\n citations[year] += int(data[\\\"citations\\\"].strip(\\\"\\\\n\\\").strip(\\\"\\\\t\\\"))\\r\\n \\r\\n\\r\\nwith open(\\\"ArticleCitationCountByYear.json\\\", \\\"w\\\") as destination:\\r\\n citations = {k: v for k, v in sorted(citations.items(), key=lambda item: item[1], reverse=True)}\\r\\n json.dump(citations, destination)\\r\\n print(\\\"Dosya yazım işlemi başarıyla tamamlandı\\\")\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.5452696084976196,\n \"alphanum_fraction\": 0.5666327476501465,\n \"avg_line_length\": 35.57692337036133,\n \"blob_id\": \"7678fcf76a084fa829b7d8beb39deaf3ef841672\",\n \"content_id\": \"5c75f464e486b21ae490f1c60dadfc80137015a4\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 995,\n \"license_type\": \"no_license\",\n \"max_line_length\": 102,\n \"num_lines\": 26,\n \"path\": \"/ScopusKeywordCounter.py\",\n \"repo_name\": \"clearskky/Scopus_Scrape\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import json\\r\\n\\r\\nfile = \\\"scopus500articles201\\\"\\r\\nfileNumber = 5\\r\\n\\r\\nkeywords = {}\\r\\nfor i in range(5,10):\\r\\n targetFile = file + str(i) + \\\".json\\\"\\r\\n with open(targetFile, \\\"r\\\") as articles:\\r\\n articleData = json.load(articles)\\r\\n for article, data in articleData.items():\\r\\n for keyword in data[\\\"keywords\\\"]:\\r\\n if len(data[\\\"keywords\\\"]) < 1:\\r\\n keywords[\\\"noKeywords\\\"] += 1\\r\\n if keyword not in keywords:\\r\\n keywords[keyword] = 1\\r\\n else:\\r\\n keywords[keyword] += 1\\r\\n\\r\\n destinationFile = \\\"500ArticleKeywords201\\\" + str(i) + \\\".json\\\"\\r\\n with open(destinationFile, \\\"w\\\") as destination:\\r\\n keywords = {k: v for k, v in sorted(keywords.items(), key=lambda item: item[1], reverse=True)}\\r\\n json.dump(keywords, destination)\\r\\n print(\\\"Dosya yazım işlemi başarıyla tamamlandı\\\")\\r\\n \\r\\nprint(\\\"Bütün dosya yazım işlemleri başarıyla tamamlandı\\\")\\r\\n \\r\\n\"\n }\n]"},"num_files":{"kind":"number","value":3,"string":"3"}}},{"rowIdx":2978317,"cells":{"repo_name":{"kind":"string","value":"tkys/fasttext_text_classifier"},"repo_url":{"kind":"string","value":"https://github.com/tkys/fasttext_text_classifier"},"snapshot_id":{"kind":"string","value":"38bcb9775f548cb634c5e26d0010bb3b737139fa"},"revision_id":{"kind":"string","value":"face711911dc0528c1d2959c3339847ea3dcba9e"},"directory_id":{"kind":"string","value":"50a11bdb92a2f74bf8ac69bfb01d6149275a8748"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2020-08-08T12:20:18.556333","string":"2020-08-08T12:20:18.556333"},"revision_date":{"kind":"timestamp","value":"2019-10-09T11:25:04","string":"2019-10-09T11:25:04"},"committer_date":{"kind":"timestamp","value":"2019-10-09T11:25:04","string":"2019-10-09T11:25:04"},"github_id":{"kind":"number","value":213830846,"string":"213,830,846"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.4791809022426605,"alphanum_fraction":0.4955631494522095,"avg_line_length":20.865671157836914,"blob_id":"40ac1ce88cfe4c3a50be4e4e90a0e21f3a474317","content_id":"8927bda9a4d0f046da97b545cca16c2c73ac0456","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":1601,"license_type":"no_license","max_line_length":88,"num_lines":67,"path":"/train_data_fasttext.py","repo_name":"tkys/fasttext_text_classifier","src_encoding":"UTF-8","text":"import csv\nimport re\nimport sys\nimport MeCab\n\n# いらない品詞（stop word）があるならばコメントアウト \nhinshi_list = [\n \"名詞\",\n \"動詞\",\n \"形容詞\",\n \"形容動詞\",\n \"記号\",\n \"助詞\",\n \"助動詞\",\n \"副詞\"\n ]\n\n\ndef convert2fasttext(bunrui):\n \"\"\" fastText用のラベルに変換 \"\"\"\n labels = {\n \"1\": \"__label__1\",\n \"2\": \"__label__2\",\n \"3\": \"__label__3\"\n #\"4\": \"__label__4\",\n #\"5\": \"__label__5\"\n }\n return labels[bunrui]\n\ndef convert2wakati(text, tagger):\n\n r=[]\n mojiretu=' '\n \"\"\" わかち書きに変換 \"\"\"\n node = tagger.parseToNode(text)\n\n while node:\n # 単語を取得\n if node.feature.split(\",\")[6] == '*':\n word = node.surface\n else:\n word = node.feature.split(\",\")[6]\n #word = node.surface\n\n # 品詞を取得\n hinshi = node.feature.split(\",\")[0]\n\n if hinshi in hinshi_list:\n r.append(word)\n node = node.next\n\n mojiretu = (' '.join(r)).strip()\n\n return mojiretu\n\ndef main():\n tagger = MeCab.Tagger('-d /usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd')\n with open(sys.argv[1]) as file:\n reader = csv.reader(file)\n for row in reader:\n label = convert2fasttext(row[0])\n comment = convert2wakati(\"\".join(row[1:]), tagger)\n # comment = stopword(comment)\n print(\"{label}, {comment}\\n\".format(label=label, comment=comment), end=\"\")\n\nif __name__ == \"__main__\":\n main()\n"},{"alpha_fraction":0.6632140874862671,"alphanum_fraction":0.6782799959182739,"avg_line_length":21.10416603088379,"blob_id":"0d0441f5dea3b2ab8ec398794a49054b4d5ca91c","content_id":"ae553fa9424e07cacf126ddca55cce0c44686ad0","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Markdown","length_bytes":5190,"license_type":"no_license","max_line_length":165,"num_lines":144,"path":"/README.md","repo_name":"tkys/fasttext_text_classifier","src_encoding":"UTF-8","text":"# fasttext_text_classifier\n\n Ubuntu 18.04 LTS\n* Python 3\n* MeCab\n* mecab-python3\n* mecab-ipadic-NEologd (MeCabの新語辞書)\n* fasttext\n\n\n\n### MeCab関連の環境構築\n\nmecabインストール、neologd辞書の用意、ipadicとか\n\n```\n$ sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file\n\n$ pip3 install mecab-python3\n```\n\n\n## mecab-ipadic-NEologd：MeCabの新語辞書 mecab-ipadic-NEologdのインストール/更新方法\n\n辞書のシードデータは、GitHubリポジトリを介して配布されます。\n\n「git clone」し複製されたリポジトリのディレクトリに移動、\n次のコマンドで、最近のmecab-ipadic-NEologdをインストールまたは更新（上書き）できます。\n\n```\n$ git clone --depth 1 https://github.com/neologd/mecab-ipadic-neologd.git\n$ cd mecab-ipadic-neologd\n$ ./bin/install-mecab-ipadic-neologd -n\n```\n途中のメッセージからmecab-configをインストールした場合は、使用するmecab-configのパスを設定する必要があります。\n\n\n次のヘルプコマンドにてコマンドラインオプションを確認できます。\n\n```\n$ ./bin/install-mecab-ipadic-neologd -h\n```\n\n### neologd辞書の場所を確認\n```\n$ echo `mecab-config --dicdir`\"/mecab-ipadic-neologd\"\n\n/usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd\n```\n\n--------\n### fasttextの環境構築\n\nfastTextのインストールは通常`pip install fasttext `。すごく楽。\nただし今回はオートチューニングを使いたいので、最新リポジトリからもってきてインストール。\n\n```\nautotune is a new feature that is not included in the last release (0.9.1). You should install the \"dev\" version, that is, clone the repo\n\n$ git clone https://github.com/facebookresearch/fastText.git\n$ cd fastText\n$ pip install .\n\n```\n\n\n\n--------\n## fasttext用の学習用データの作成\n\n### インプットデータ用意\n\n1行に `{label},{text} `の形式で用意します\n\n* input.txt\n```\n1,変換時に、Stop Wordの処理をしたりしますが、まずはStop Word無しで学習させてみます。\n3,fastTextでクラス分けをする際の教師データは、下記のようなフォーマットなのでcsvから変換します。\n2,教師データとしてはあまり宜しくない感じはしますが、とりあえずfastTextに入力してみます。\n1,精度は、fastTextによって予測されたラベルの中の正しいラベルの数です。リコールは、すべての実際のラベルのうち、正常に予測されたラベルの数です。これをより明確にする例を見てみましょう。\n3,モデルによって予測されるラベルはですfood-safety。これは関係ありません。どういうわけか、モデルは単純な例では失敗するようです。\n```\n\n### fasttext形式ラベルと分かち書き\n以下コマンドにて、 `__label__N,(分かち書き済みテキスト)` の形式で log.txtに出力します。\n```\n$python3 train_data_fasttext.py input.csv > log.txt\n```\n\n\n### log.txt の確認\n\n```\n$cat log.txt\n__label__1, 変換 時 に 、 Stop Word の 処理 を する たり する ます が 、 Stop Word 無し で 学習 する せる て みる ます 。\n__label__3, fastText で クラス 分け を する 際 の 教師 データ は 、 下記 の よう だ フォーマット だ ので CSV から 変換 する ます 。\n__label__2, 教師 データ として は あまり 宜しい ない 感じ は する ます が 、 とりあえず fastText に 入力 する て みる ます 。\n__label__1, 精度 は 、 fastText によって 予測 する れる た ラベル の 中 の 正しい ラベル の 数 です 。 リコール は 、 すべて の 実際 の ラベル の うち 、 正常 に 予測 する れる た ラベル の 数 です 。 これ を より 明確 に する 例 を 見る て みる ます う 。\n__label__3, モデル によって 予測 する れる ラベル は です Food - safety 。 これ は 関係 ある ます ん 。 わけ か 、 モデル は 単純 だ 例 で は 失敗 する よう です 。\n\n```\n\n### train_data_fasttext.py でのMeCabの分かち書き挙動とfasttext形式ラベル付けの対応\n\n* 抽出する品詞の指定\n```\n# いらない品詞があるならばコメントアウト\nhinshi_list = [\n \"名詞\",\n \"動詞\",\n \"形容詞\",\n \"形容動詞\",\n \"記号\",\n \"助詞\",\n \"助動詞\",\n \"副詞\"\n ]\n```\n\n* MeCabの辞書（mecab-ipadic-neologd）のpath指定\n```\n tagger = MeCab.Tagger('-d /usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd')\n```\n\n\n\n* fasttext形式でのラベル付け対応\n\n```\ndef convert2fasttext(bunrui):\n \"\"\" fastText用のラベルに変換 \"\"\"\n labels = {\n \"1\": \"__label__1\",\n \"2\": \"__label__2\",\n \"3\": \"__label__3\"\n #\"4\": \"__label__4\",\n #\"5\": \"__label__5\"\n }\n return labels[bunrui]\n```\nここではinput.csvの要素1列目の{label}が 1,2,3 でラベルしてあるケースとしています\n\n\n--------\n\n\n\n"}],"string":"[\n {\n \"alpha_fraction\": 0.4791809022426605,\n \"alphanum_fraction\": 0.4955631494522095,\n \"avg_line_length\": 20.865671157836914,\n \"blob_id\": \"40ac1ce88cfe4c3a50be4e4e90a0e21f3a474317\",\n \"content_id\": \"8927bda9a4d0f046da97b545cca16c2c73ac0456\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1601,\n \"license_type\": \"no_license\",\n \"max_line_length\": 88,\n \"num_lines\": 67,\n \"path\": \"/train_data_fasttext.py\",\n \"repo_name\": \"tkys/fasttext_text_classifier\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import csv\\nimport re\\nimport sys\\nimport MeCab\\n\\n# いらない品詞（stop word）があるならばコメントアウト \\nhinshi_list = [\\n \\\"名詞\\\",\\n \\\"動詞\\\",\\n \\\"形容詞\\\",\\n \\\"形容動詞\\\",\\n \\\"記号\\\",\\n \\\"助詞\\\",\\n \\\"助動詞\\\",\\n \\\"副詞\\\"\\n ]\\n\\n\\ndef convert2fasttext(bunrui):\\n \\\"\\\"\\\" fastText用のラベルに変換 \\\"\\\"\\\"\\n labels = {\\n \\\"1\\\": \\\"__label__1\\\",\\n \\\"2\\\": \\\"__label__2\\\",\\n \\\"3\\\": \\\"__label__3\\\"\\n #\\\"4\\\": \\\"__label__4\\\",\\n #\\\"5\\\": \\\"__label__5\\\"\\n }\\n return labels[bunrui]\\n\\ndef convert2wakati(text, tagger):\\n\\n r=[]\\n mojiretu=' '\\n \\\"\\\"\\\" わかち書きに変換 \\\"\\\"\\\"\\n node = tagger.parseToNode(text)\\n\\n while node:\\n # 単語を取得\\n if node.feature.split(\\\",\\\")[6] == '*':\\n word = node.surface\\n else:\\n word = node.feature.split(\\\",\\\")[6]\\n #word = node.surface\\n\\n # 品詞を取得\\n hinshi = node.feature.split(\\\",\\\")[0]\\n\\n if hinshi in hinshi_list:\\n r.append(word)\\n node = node.next\\n\\n mojiretu = (' '.join(r)).strip()\\n\\n return mojiretu\\n\\ndef main():\\n tagger = MeCab.Tagger('-d /usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd')\\n with open(sys.argv[1]) as file:\\n reader = csv.reader(file)\\n for row in reader:\\n label = convert2fasttext(row[0])\\n comment = convert2wakati(\\\"\\\".join(row[1:]), tagger)\\n # comment = stopword(comment)\\n print(\\\"{label}, {comment}\\\\n\\\".format(label=label, comment=comment), end=\\\"\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\"\n },\n {\n \"alpha_fraction\": 0.6632140874862671,\n \"alphanum_fraction\": 0.6782799959182739,\n \"avg_line_length\": 21.10416603088379,\n \"blob_id\": \"0d0441f5dea3b2ab8ec398794a49054b4d5ca91c\",\n \"content_id\": \"ae553fa9424e07cacf126ddca55cce0c44686ad0\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Markdown\",\n \"length_bytes\": 5190,\n \"license_type\": \"no_license\",\n \"max_line_length\": 165,\n \"num_lines\": 144,\n \"path\": \"/README.md\",\n \"repo_name\": \"tkys/fasttext_text_classifier\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# fasttext_text_classifier\\n\\n Ubuntu 18.04 LTS\\n* Python 3\\n* MeCab\\n* mecab-python3\\n* mecab-ipadic-NEologd (MeCabの新語辞書)\\n* fasttext\\n\\n\\n\\n### MeCab関連の環境構築\\n\\nmecabインストール、neologd辞書の用意、ipadicとか\\n\\n```\\n$ sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file\\n\\n$ pip3 install mecab-python3\\n```\\n\\n\\n## mecab-ipadic-NEologd：MeCabの新語辞書 mecab-ipadic-NEologdのインストール/更新方法\\n\\n辞書のシードデータは、GitHubリポジトリを介して配布されます。\\n\\n「git clone」し複製されたリポジトリのディレクトリに移動、\\n次のコマンドで、最近のmecab-ipadic-NEologdをインストールまたは更新（上書き）できます。\\n\\n```\\n$ git clone --depth 1 https://github.com/neologd/mecab-ipadic-neologd.git\\n$ cd mecab-ipadic-neologd\\n$ ./bin/install-mecab-ipadic-neologd -n\\n```\\n途中のメッセージからmecab-configをインストールした場合は、使用するmecab-configのパスを設定する必要があります。\\n\\n\\n次のヘルプコマンドにてコマンドラインオプションを確認できます。\\n\\n```\\n$ ./bin/install-mecab-ipadic-neologd -h\\n```\\n\\n### neologd辞書の場所を確認\\n```\\n$ echo `mecab-config --dicdir`\\\"/mecab-ipadic-neologd\\\"\\n\\n/usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd\\n```\\n\\n--------\\n### fasttextの環境構築\\n\\nfastTextのインストールは通常`pip install fasttext `。すごく楽。\\nただし今回はオートチューニングを使いたいので、最新リポジトリからもってきてインストール。\\n\\n```\\nautotune is a new feature that is not included in the last release (0.9.1). You should install the \\\"dev\\\" version, that is, clone the repo\\n\\n$ git clone https://github.com/facebookresearch/fastText.git\\n$ cd fastText\\n$ pip install .\\n\\n```\\n\\n\\n\\n--------\\n## fasttext用の学習用データの作成\\n\\n### インプットデータ用意\\n\\n1行に `{label},{text} `の形式で用意します\\n\\n* input.txt\\n```\\n1,変換時に、Stop Wordの処理をしたりしますが、まずはStop Word無しで学習させてみます。\\n3,fastTextでクラス分けをする際の教師データは、下記のようなフォーマットなのでcsvから変換します。\\n2,教師データとしてはあまり宜しくない感じはしますが、とりあえずfastTextに入力してみます。\\n1,精度は、fastTextによって予測されたラベルの中の正しいラベルの数です。リコールは、すべての実際のラベルのうち、正常に予測されたラベルの数です。これをより明確にする例を見てみましょう。\\n3,モデルによって予測されるラベルはですfood-safety。これは関係ありません。どういうわけか、モデルは単純な例では失敗するようです。\\n```\\n\\n### fasttext形式ラベルと分かち書き\\n以下コマンドにて、 `__label__N,(分かち書き済みテキスト)` の形式で log.txtに出力します。\\n```\\n$python3 train_data_fasttext.py input.csv > log.txt\\n```\\n\\n\\n### log.txt の確認\\n\\n```\\n$cat log.txt\\n__label__1, 変換 時 に 、 Stop Word の 処理 を する たり する ます が 、 Stop Word 無し で 学習 する せる て みる ます 。\\n__label__3, fastText で クラス 分け を する 際 の 教師 データ は 、 下記 の よう だ フォーマット だ ので CSV から 変換 する ます 。\\n__label__2, 教師 データ として は あまり 宜しい ない 感じ は する ます が 、 とりあえず fastText に 入力 する て みる ます 。\\n__label__1, 精度 は 、 fastText によって 予測 する れる た ラベル の 中 の 正しい ラベル の 数 です 。 リコール は 、 すべて の 実際 の ラベル の うち 、 正常 に 予測 する れる た ラベル の 数 です 。 これ を より 明確 に する 例 を 見る て みる ます う 。\\n__label__3, モデル によって 予測 する れる ラベル は です Food - safety 。 これ は 関係 ある ます ん 。 わけ か 、 モデル は 単純 だ 例 で は 失敗 する よう です 。\\n\\n```\\n\\n### train_data_fasttext.py でのMeCabの分かち書き挙動とfasttext形式ラベル付けの対応\\n\\n* 抽出する品詞の指定\\n```\\n# いらない品詞があるならばコメントアウト\\nhinshi_list = [\\n \\\"名詞\\\",\\n \\\"動詞\\\",\\n \\\"形容詞\\\",\\n \\\"形容動詞\\\",\\n \\\"記号\\\",\\n \\\"助詞\\\",\\n \\\"助動詞\\\",\\n \\\"副詞\\\"\\n ]\\n```\\n\\n* MeCabの辞書（mecab-ipadic-neologd）のpath指定\\n```\\n tagger = MeCab.Tagger('-d /usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd')\\n```\\n\\n\\n\\n* fasttext形式でのラベル付け対応\\n\\n```\\ndef convert2fasttext(bunrui):\\n \\\"\\\"\\\" fastText用のラベルに変換 \\\"\\\"\\\"\\n labels = {\\n \\\"1\\\": \\\"__label__1\\\",\\n \\\"2\\\": \\\"__label__2\\\",\\n \\\"3\\\": \\\"__label__3\\\"\\n #\\\"4\\\": \\\"__label__4\\\",\\n #\\\"5\\\": \\\"__label__5\\\"\\n }\\n return labels[bunrui]\\n```\\nここではinput.csvの要素1列目の{label}が 1,2,3 でラベルしてあるケースとしています\\n\\n\\n--------\\n\\n\\n\\n\"\n }\n]"},"num_files":{"kind":"number","value":2,"string":"2"}}},{"rowIdx":2978318,"cells":{"repo_name":{"kind":"string","value":"Terairk/WEconnect"},"repo_url":{"kind":"string","value":"https://github.com/Terairk/WEconnect"},"snapshot_id":{"kind":"string","value":"175f5fca3073b31d0011edf77bd46ef41b12f393"},"revision_id":{"kind":"string","value":"4bbadc6cdbd9b2b477ecb742c98bf98abefcd0c5"},"directory_id":{"kind":"string","value":"56ff0a3909ed366afd4891d59fa23b432858118d"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2022-12-12T23:50:29.333522","string":"2022-12-12T23:50:29.333522"},"revision_date":{"kind":"timestamp","value":"2020-09-19T00:32:48","string":"2020-09-19T00:32:48"},"committer_date":{"kind":"timestamp","value":"2020-09-19T00:32:48","string":"2020-09-19T00:32:48"},"github_id":{"kind":"number","value":296277259,"string":"296,277,259"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":1,"string":"1"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.7682926654815674,"alphanum_fraction":0.7879924774169922,"avg_line_length":70.06666564941406,"blob_id":"0e69934fe756ac489b7f952b8e820674f2df2f5c","content_id":"8d370c385a69d31edc6ced24d410a53ca1383ebf","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Markdown","length_bytes":1066,"license_type":"no_license","max_line_length":256,"num_lines":15,"path":"/README.md","repo_name":"Terairk/WEconnect","src_encoding":"UTF-8","text":"# WEconnect\nThis is a project for the Brunei AI for Good Hackathon\n\nThe main code is in app.py\nFor those who are wondering, main.py and generatevalues.py are places where i tested the code separetly from the flask project then later added them into the flask thing. The client_secret.json file contains info to access the google spreadsheets via code.\n\nThe actual website link to the project being deployed onto a server is http://43.245.220.12:5000/\nThat's where you can test the website for yourself and see what it does.\n\nThe UI is a bit bad but I think you'll get the main point. The final part is where it ranks the companies from best to worst (fake companies mind you)\n\nHere's the link to the figma (the frontend mock up that looks much better than this)\nhttps://www.figma.com/proto/5MqnNJjrJ7MtPUCK0xZglq/Team-6-Prototype---Students?node-id=15%3A2&scaling=min-zoom\n\nAlso if you want to run this code for yourselves, you need to import nltk and do nltk.download() in your python installation. And of course download all the files in the requirements.txt file.\n"},{"alpha_fraction":0.6445690989494324,"alphanum_fraction":0.6727434992790222,"avg_line_length":36.53110122680664,"blob_id":"2ba13de95b928a637b77ca88cab2a75e5f8fb9e3","content_id":"b5240ef37d784682acb00e7e4f0f7a62f4d2dcbf","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":7844,"license_type":"no_license","max_line_length":225,"num_lines":209,"path":"/app.py","repo_name":"Terairk/WEconnect","src_encoding":"UTF-8","text":"# copied from main.py which was used for testing\n\nimport gspread\nfrom oauth2client.service_account import ServiceAccountCredentials\nfrom nltk.corpus import wordnet as wn\nfrom PyDictionary import PyDictionary\n\ndictionary = PyDictionary()\n\n# Setting up the api's and their links\n# This project uses the google sheet api (which is connected to the google forms)\n# An adjective extractor library to extract adjectives from the extended response\n# This is done by nltk\n# Then we have the synonyms library to get synonyms for each adjective\n\n# Adjectives & Synonyms will be a multidimensional array, each sublist is each person's adjectives in their response\nadjectives = []\nsynonyms = []\n\n# Google sheets api set up\nscope = ['https://spreadsheets.google.com/feeds', \"https://www.googleapis.com/auth/drive\"]\ncreds = ServiceAccountCredentials.from_json_keyfile_name(\"client_secret.json\", scope)\nclient = gspread.authorize(creds)\nsheet = client.open(\"Students (Responses)\").sheet1\n\nperson = sheet.row_values(sheet.row_count)\n# for every response to the survey\nwords = person[11].split(\" \")\n\n# Whole thing checks if any words are adjectives and gets their synonyms\nfor w in words:\n if wn.synsets(w):\n\n tmp = wn.synsets(w)[0].pos()\n if tmp == \"a\":\n print(w, \":\", tmp)\n wSynonym = dictionary.synonym(w)\n synonyms += wSynonym\n\nprint(synonyms)\n\n# Start of employers lists\n# These are fake companies (some are based on real companies), you can tell from the names\n# Some of the subjects for some of the employers aren't super realistic, but others are\n# I just put in what came to mind for variety, Also locations are also fictional\n# A proper version would have actual employers with actual locations and what not\n# The values in the list are based on the spreadsheet questions\n# Values are randomised externally (not in the website for consistency) using random.org, so they're not real values\n\nemployer1 = [2020, \"computerland\", \"Belait\", True, [\"English\", \"History\", \"Business\", \"Computer Science\"], 1, 5, 6, 4, 6, True, ['honest', 'confident', 'adventurous', 'productive', 'original', 'courteous']]\nemployer2 = [2020, \"novideo\", \"Belait\", False, [\"Maths\", \"Computer Science\", \"Business\", \"Economics\", \"Physics\"], 2, 5, 10, 8, 10, False, ['positive', 'creative thinking', 'reliable', 'confident', 'agreeable', 'considerate']]\nemployer3 = [2020, \"ayyyymd\", \"Brunei-Muara\", False, [\"Maths\", \"Computer Science\", \"Business\", \"Economics\", \"Physics\"], 4, 10, 3, 3, 10, True, ['positive', 'honest', 'reliable', 'confident', 'agreeable', 'adventurous']]\nemployer4 = [2020, \"shintel\", \"Temburong\", False, [\"Maths\", \"Computer Science\", \"Business\", \"Economics\", \"Physics\"], 7, 4, 9, 10, 10, False, ['positive', 'reliable', 'confident', 'considerate', 'adventurous', 'original']]\nemployer5 = [2020, \"Bdope\", \"Tutong\", True, [\"Art\", \"Psychology\", \"Business\", \"Economics\"], 2, 8, 4, 4, 5, True, ['positive', 'honest', 'creative thinking', 'reliable', 'confident', 'agreeable']]\nemployer6 = [2020, \"Lavinci\", \"Brunei-Muara\", True, [\"Art\", \"English\", \"Psychology\", \"Economics\"], 7, 2, 2, 10, 10, True, ['positive', 'creative thinking', 'reliable', 'confident', 'agreeable', 'considerate']]\nemployer7 = [2020, \"yCircle\", \"Belait\", False, [\"Maths\", \"Physics\", \"Computer Science\"], 3, 7, 6, 2, 9, False, ['loyal', 'reliable', 'agreeable', 'considerate', 'enthusiastic', 'courteous']]\nemployer8 = [2020, \"Shell\", \"Brunei-Muara\", False, [\"Economics\", \"Business\", \"Geography\"], 6, 2, 1, 9, 10, True, ['positive', 'confident', 'agreeable', 'productive', 'fluent', 'sincere']]\nemployer9 = [2020, \"Pear\", \"Tutong\", True, [\"Computer Science\", \"Physics\", \"Business\"], 9, 3, 5, 2, 10, True, ['honest', 'confident', 'considerate', 'adventurous', 'productive', 'enthusiastic']]\nemployer10 = [2020, \"Wacdonalds\", \"Belait\", False, [\"Psychology\", \"English\", \"Geography\", \"Economics\", \"Drama\"], 10, 10, 1, 5, 10, True, ['honest', 'creative thinking', 'reliable', 'considerate', 'original', 'trustworthy']]\nemployer11 = [2020, \"WagyuQueen\", \"Belait\", False, [\"Psychology\", \"English\", \"Geography\", \"Economics\"], 1, 4, 8, 10, 3, False, ['positive', 'honest', 'confident', 'adventurous', 'considerate', 'productive']]\n\nemployers = []\nemployers.append(employer1)\nemployers.append(employer2)\nemployers.append(employer3)\nemployers.append(employer4)\nemployers.append(employer5)\nemployers.append(employer6)\nemployers.append(employer7)\nemployers.append(employer8)\nemployers.append(employer9)\nemployers.append(employer10)\nemployers.append(employer11)\n\n\nemployersWeightingScores = {}\nfor i in range(11):\n employersWeightingScores[i] = 0.1\n\n# Weighting Algorithm Part\n# There are some arbitary values that I've decided to use for the weight\n# like how location is worth 5 and virtual work is worth 2.\n# Also the higher the weight for the employers, the better\n# It's like the employers score\n\ni = 0\nfor employer in employers:\n weight = float(0)\n #Location\n userLocation = person[2]\n if userLocation == employer[2]:\n weight += 5\n\n #VirtualWork\n\n if person[3] == employer[3]:\n weight += 2\n\n #Subjects\n\n usersubjects = person[4].split(', ')\n for user_subject in usersubjects:\n for employer_subject in employer[4]:\n if user_subject == employer_subject:\n weight += 1.5\n\n #Teamwork skills\n\n # If an employer has a 2 for importance on teamwork, then it'll have a weight of 0.4 per point that the user has.\n # If an employer has a 9 for importance on teamwork, then it'll have a weight of 1.8 per point that the user has.\n # Ie it dictates how important the employer values teamwork and future skills\n weight += float(person[5]) * (float(employer[5]) * 0.1)\n\n #Creativity\n\n weight += float(person[6]) * (float(employer[6]) * 0.1)\n\n #Organization skills\n\n weight += float(person[7]) * (float(employer[7]) * 0.1)\n\n #Problem Solving Skills\n\n weight += float(person[8]) * (float(employer[8]) * 0.1)\n\n #General Computer Skills\n\n weight += float(person[9]) * (float(employer[9]) * 0.1)\n\n #Willingness to learn\n\n if person[10] == False and employer[10] == True:\n weight -= 3\n elif person[10] == True and employer[10] == True:\n weight += 3\n\n #Qualities\n for employerquality in employer[11]:\n for userquality in synonyms:\n if userquality == employerquality:\n weight += 0.5\n\n employersWeightingScores[i] = weight\n i += 1\n\nfinalList = []\n# sort employers weighting score\nsortedRankings = sorted(employersWeightingScores, key=employersWeightingScores.get)\nsortedRankings.reverse()\nfor i in range(11):\n employerName = employers[sortedRankings[i]][1]\n s = str(i+1) + \": \" + employerName\n print(s)\n finalList.append(s)\n\nfrom flask import Flask, render_template, url_for\napp = Flask(__name__)\n\nposts = [\n {\n \"author\": \"Ahmad Jamsari\",\n \"title\": \"Blog Post 1\",\n \"content\": \"First content\",\n \"date_posted\": \"April 20, 2018\"\n },\n {\n \"author\": \"Jane Doe\",\n \"title\": \"Blog Post 2\",\n \"content\": \"Second post content\",\n \"date_posted\": \"April 21, 2018\"\n }\n]\n\n@app.route('/')\n@app.route(\"/home\")\ndef home():\n return render_template(\"home.html\", posts=posts)\n\n\n@app.route('/about')\ndef about():\n return render_template(\"about.html\", title=\"About\")\n\n\n@app.route('/login')\ndef login():\n return render_template(\"login.html\")\n\n\n@app.route('/register')\ndef register():\n return render_template(\"register.html\")\n\n\n@app.route('/employers')\ndef employer():\n return render_template(\"employer.html\")\n\n\n@app.route('/students')\ndef student():\n return render_template(\"students.html\")\n\n@app.route('/final')\ndef final():\n return render_template(\"final.html\", companies = finalList)\n\nif __name__ == '__main__':\n app.run()\n"},{"alpha_fraction":0.5,"alphanum_fraction":0.692307710647583,"avg_line_length":12.166666984558105,"blob_id":"059a8c35b50ba0941f8cde1eaec7acddb025b914","content_id":"3ef17d42369bc1d914dd553cea5e6a88d0ab2b51","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Text","length_bytes":78,"license_type":"no_license","max_line_length":19,"num_lines":6,"path":"/requirements.txt","repo_name":"Terairk/WEconnect","src_encoding":"UTF-8","text":"Flask==1.1.2\n\ngspread~=3.6.0\noauth2client~=4.1.3\nnltk~=3.5\nPyDictionary~=2.0.1"},{"alpha_fraction":0.5957327485084534,"alphanum_fraction":0.605277955532074,"avg_line_length":31.290908813476562,"blob_id":"cee088ae713138195bc087b66f9f582ad4256569","content_id":"4de0e0659fa30e7277f202f3017167d31a8c3413","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":1781,"license_type":"no_license","max_line_length":109,"num_lines":55,"path":"/generate_values.py","repo_name":"Terairk/WEconnect","src_encoding":"UTF-8","text":"# This is a python file to generate the values for various employers\n# Manually inputting values from random.org is kinda a pain\n# Also manually inputting lots of qualities is also a pain\n# I had to manually input subjects and it was kind of a pain\n# So to save me from this pain, I'll create a whole new program\n# This might save me time, it might not, this file generates the values after the subjects for employer lists\n# Edit: It saved me time\n# Noticed that code isn't perfect as it could generate multiple of the same quality but that's fine\n\nfrom random import randint\n\n# Qualities that Employers want\nqualities = [\"friendly\", \"positive\", \"fluent\", \"confident\", \"honest\", \"humble\", \"courteous\", \"trustworthy\",\n \"honorable\", \"creative thinking\", \"original\", \"inventive\", \"productive\", \"adventurous\",\n \"agreeable\", \"ambitious\", \"bright\", \"considerate\", \"enthusiastic\", \"helpful\",\n \"loyal\", \"reliable\", \"sensible\", \"sincere\"]\n\n\n# Loop for each employer\nfor i in range(11):\n\n # Get the 5 values after the subjects\n for i in range(5):\n value = randint(1,10)\n print(value, end=\", \")\n\n # True or False\n willingnessToLearn = randint(0,1)\n toLearn = False\n if willingnessToLearn == 0:\n print(\"False\", end=\", \")\n else:\n print(\"True\", end=\", \")\n\n temp = []\n\n # Employer qualities\n print(\"[\", end=\"\")\n for i in range(20):\n value = randint(0, len(qualities) - 1)\n # fixes duplicates\n temp.append(qualities[value])\n temp = list(set(temp))\n s = \"'\" + temp[-1] + \"'\"\n\n\n for i in range(6):\n s = \"'\" + temp[i] + \"'\"\n if i == 5:\n print(s, end=\"\")\n else:\n print(s, end=\", \")\n\n print(\"]\", end=\"\")\n print()\n\n\n\n\n\n"}],"string":"[\n {\n \"alpha_fraction\": 0.7682926654815674,\n \"alphanum_fraction\": 0.7879924774169922,\n \"avg_line_length\": 70.06666564941406,\n \"blob_id\": \"0e69934fe756ac489b7f952b8e820674f2df2f5c\",\n \"content_id\": \"8d370c385a69d31edc6ced24d410a53ca1383ebf\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Markdown\",\n \"length_bytes\": 1066,\n \"license_type\": \"no_license\",\n \"max_line_length\": 256,\n \"num_lines\": 15,\n \"path\": \"/README.md\",\n \"repo_name\": \"Terairk/WEconnect\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# WEconnect\\nThis is a project for the Brunei AI for Good Hackathon\\n\\nThe main code is in app.py\\nFor those who are wondering, main.py and generatevalues.py are places where i tested the code separetly from the flask project then later added them into the flask thing. The client_secret.json file contains info to access the google spreadsheets via code.\\n\\nThe actual website link to the project being deployed onto a server is http://43.245.220.12:5000/\\nThat's where you can test the website for yourself and see what it does.\\n\\nThe UI is a bit bad but I think you'll get the main point. The final part is where it ranks the companies from best to worst (fake companies mind you)\\n\\nHere's the link to the figma (the frontend mock up that looks much better than this)\\nhttps://www.figma.com/proto/5MqnNJjrJ7MtPUCK0xZglq/Team-6-Prototype---Students?node-id=15%3A2&scaling=min-zoom\\n\\nAlso if you want to run this code for yourselves, you need to import nltk and do nltk.download() in your python installation. And of course download all the files in the requirements.txt file.\\n\"\n },\n {\n \"alpha_fraction\": 0.6445690989494324,\n \"alphanum_fraction\": 0.6727434992790222,\n \"avg_line_length\": 36.53110122680664,\n \"blob_id\": \"2ba13de95b928a637b77ca88cab2a75e5f8fb9e3\",\n \"content_id\": \"b5240ef37d784682acb00e7e4f0f7a62f4d2dcbf\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 7844,\n \"license_type\": \"no_license\",\n \"max_line_length\": 225,\n \"num_lines\": 209,\n \"path\": \"/app.py\",\n \"repo_name\": \"Terairk/WEconnect\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# copied from main.py which was used for testing\\n\\nimport gspread\\nfrom oauth2client.service_account import ServiceAccountCredentials\\nfrom nltk.corpus import wordnet as wn\\nfrom PyDictionary import PyDictionary\\n\\ndictionary = PyDictionary()\\n\\n# Setting up the api's and their links\\n# This project uses the google sheet api (which is connected to the google forms)\\n# An adjective extractor library to extract adjectives from the extended response\\n# This is done by nltk\\n# Then we have the synonyms library to get synonyms for each adjective\\n\\n# Adjectives & Synonyms will be a multidimensional array, each sublist is each person's adjectives in their response\\nadjectives = []\\nsynonyms = []\\n\\n# Google sheets api set up\\nscope = ['https://spreadsheets.google.com/feeds', \\\"https://www.googleapis.com/auth/drive\\\"]\\ncreds = ServiceAccountCredentials.from_json_keyfile_name(\\\"client_secret.json\\\", scope)\\nclient = gspread.authorize(creds)\\nsheet = client.open(\\\"Students (Responses)\\\").sheet1\\n\\nperson = sheet.row_values(sheet.row_count)\\n# for every response to the survey\\nwords = person[11].split(\\\" \\\")\\n\\n# Whole thing checks if any words are adjectives and gets their synonyms\\nfor w in words:\\n if wn.synsets(w):\\n\\n tmp = wn.synsets(w)[0].pos()\\n if tmp == \\\"a\\\":\\n print(w, \\\":\\\", tmp)\\n wSynonym = dictionary.synonym(w)\\n synonyms += wSynonym\\n\\nprint(synonyms)\\n\\n# Start of employers lists\\n# These are fake companies (some are based on real companies), you can tell from the names\\n# Some of the subjects for some of the employers aren't super realistic, but others are\\n# I just put in what came to mind for variety, Also locations are also fictional\\n# A proper version would have actual employers with actual locations and what not\\n# The values in the list are based on the spreadsheet questions\\n# Values are randomised externally (not in the website for consistency) using random.org, so they're not real values\\n\\nemployer1 = [2020, \\\"computerland\\\", \\\"Belait\\\", True, [\\\"English\\\", \\\"History\\\", \\\"Business\\\", \\\"Computer Science\\\"], 1, 5, 6, 4, 6, True, ['honest', 'confident', 'adventurous', 'productive', 'original', 'courteous']]\\nemployer2 = [2020, \\\"novideo\\\", \\\"Belait\\\", False, [\\\"Maths\\\", \\\"Computer Science\\\", \\\"Business\\\", \\\"Economics\\\", \\\"Physics\\\"], 2, 5, 10, 8, 10, False, ['positive', 'creative thinking', 'reliable', 'confident', 'agreeable', 'considerate']]\\nemployer3 = [2020, \\\"ayyyymd\\\", \\\"Brunei-Muara\\\", False, [\\\"Maths\\\", \\\"Computer Science\\\", \\\"Business\\\", \\\"Economics\\\", \\\"Physics\\\"], 4, 10, 3, 3, 10, True, ['positive', 'honest', 'reliable', 'confident', 'agreeable', 'adventurous']]\\nemployer4 = [2020, \\\"shintel\\\", \\\"Temburong\\\", False, [\\\"Maths\\\", \\\"Computer Science\\\", \\\"Business\\\", \\\"Economics\\\", \\\"Physics\\\"], 7, 4, 9, 10, 10, False, ['positive', 'reliable', 'confident', 'considerate', 'adventurous', 'original']]\\nemployer5 = [2020, \\\"Bdope\\\", \\\"Tutong\\\", True, [\\\"Art\\\", \\\"Psychology\\\", \\\"Business\\\", \\\"Economics\\\"], 2, 8, 4, 4, 5, True, ['positive', 'honest', 'creative thinking', 'reliable', 'confident', 'agreeable']]\\nemployer6 = [2020, \\\"Lavinci\\\", \\\"Brunei-Muara\\\", True, [\\\"Art\\\", \\\"English\\\", \\\"Psychology\\\", \\\"Economics\\\"], 7, 2, 2, 10, 10, True, ['positive', 'creative thinking', 'reliable', 'confident', 'agreeable', 'considerate']]\\nemployer7 = [2020, \\\"yCircle\\\", \\\"Belait\\\", False, [\\\"Maths\\\", \\\"Physics\\\", \\\"Computer Science\\\"], 3, 7, 6, 2, 9, False, ['loyal', 'reliable', 'agreeable', 'considerate', 'enthusiastic', 'courteous']]\\nemployer8 = [2020, \\\"Shell\\\", \\\"Brunei-Muara\\\", False, [\\\"Economics\\\", \\\"Business\\\", \\\"Geography\\\"], 6, 2, 1, 9, 10, True, ['positive', 'confident', 'agreeable', 'productive', 'fluent', 'sincere']]\\nemployer9 = [2020, \\\"Pear\\\", \\\"Tutong\\\", True, [\\\"Computer Science\\\", \\\"Physics\\\", \\\"Business\\\"], 9, 3, 5, 2, 10, True, ['honest', 'confident', 'considerate', 'adventurous', 'productive', 'enthusiastic']]\\nemployer10 = [2020, \\\"Wacdonalds\\\", \\\"Belait\\\", False, [\\\"Psychology\\\", \\\"English\\\", \\\"Geography\\\", \\\"Economics\\\", \\\"Drama\\\"], 10, 10, 1, 5, 10, True, ['honest', 'creative thinking', 'reliable', 'considerate', 'original', 'trustworthy']]\\nemployer11 = [2020, \\\"WagyuQueen\\\", \\\"Belait\\\", False, [\\\"Psychology\\\", \\\"English\\\", \\\"Geography\\\", \\\"Economics\\\"], 1, 4, 8, 10, 3, False, ['positive', 'honest', 'confident', 'adventurous', 'considerate', 'productive']]\\n\\nemployers = []\\nemployers.append(employer1)\\nemployers.append(employer2)\\nemployers.append(employer3)\\nemployers.append(employer4)\\nemployers.append(employer5)\\nemployers.append(employer6)\\nemployers.append(employer7)\\nemployers.append(employer8)\\nemployers.append(employer9)\\nemployers.append(employer10)\\nemployers.append(employer11)\\n\\n\\nemployersWeightingScores = {}\\nfor i in range(11):\\n employersWeightingScores[i] = 0.1\\n\\n# Weighting Algorithm Part\\n# There are some arbitary values that I've decided to use for the weight\\n# like how location is worth 5 and virtual work is worth 2.\\n# Also the higher the weight for the employers, the better\\n# It's like the employers score\\n\\ni = 0\\nfor employer in employers:\\n weight = float(0)\\n #Location\\n userLocation = person[2]\\n if userLocation == employer[2]:\\n weight += 5\\n\\n #VirtualWork\\n\\n if person[3] == employer[3]:\\n weight += 2\\n\\n #Subjects\\n\\n usersubjects = person[4].split(', ')\\n for user_subject in usersubjects:\\n for employer_subject in employer[4]:\\n if user_subject == employer_subject:\\n weight += 1.5\\n\\n #Teamwork skills\\n\\n # If an employer has a 2 for importance on teamwork, then it'll have a weight of 0.4 per point that the user has.\\n # If an employer has a 9 for importance on teamwork, then it'll have a weight of 1.8 per point that the user has.\\n # Ie it dictates how important the employer values teamwork and future skills\\n weight += float(person[5]) * (float(employer[5]) * 0.1)\\n\\n #Creativity\\n\\n weight += float(person[6]) * (float(employer[6]) * 0.1)\\n\\n #Organization skills\\n\\n weight += float(person[7]) * (float(employer[7]) * 0.1)\\n\\n #Problem Solving Skills\\n\\n weight += float(person[8]) * (float(employer[8]) * 0.1)\\n\\n #General Computer Skills\\n\\n weight += float(person[9]) * (float(employer[9]) * 0.1)\\n\\n #Willingness to learn\\n\\n if person[10] == False and employer[10] == True:\\n weight -= 3\\n elif person[10] == True and employer[10] == True:\\n weight += 3\\n\\n #Qualities\\n for employerquality in employer[11]:\\n for userquality in synonyms:\\n if userquality == employerquality:\\n weight += 0.5\\n\\n employersWeightingScores[i] = weight\\n i += 1\\n\\nfinalList = []\\n# sort employers weighting score\\nsortedRankings = sorted(employersWeightingScores, key=employersWeightingScores.get)\\nsortedRankings.reverse()\\nfor i in range(11):\\n employerName = employers[sortedRankings[i]][1]\\n s = str(i+1) + \\\": \\\" + employerName\\n print(s)\\n finalList.append(s)\\n\\nfrom flask import Flask, render_template, url_for\\napp = Flask(__name__)\\n\\nposts = [\\n {\\n \\\"author\\\": \\\"Ahmad Jamsari\\\",\\n \\\"title\\\": \\\"Blog Post 1\\\",\\n \\\"content\\\": \\\"First content\\\",\\n \\\"date_posted\\\": \\\"April 20, 2018\\\"\\n },\\n {\\n \\\"author\\\": \\\"Jane Doe\\\",\\n \\\"title\\\": \\\"Blog Post 2\\\",\\n \\\"content\\\": \\\"Second post content\\\",\\n \\\"date_posted\\\": \\\"April 21, 2018\\\"\\n }\\n]\\n\\n@app.route('/')\\n@app.route(\\\"/home\\\")\\ndef home():\\n return render_template(\\\"home.html\\\", posts=posts)\\n\\n\\n@app.route('/about')\\ndef about():\\n return render_template(\\\"about.html\\\", title=\\\"About\\\")\\n\\n\\n@app.route('/login')\\ndef login():\\n return render_template(\\\"login.html\\\")\\n\\n\\n@app.route('/register')\\ndef register():\\n return render_template(\\\"register.html\\\")\\n\\n\\n@app.route('/employers')\\ndef employer():\\n return render_template(\\\"employer.html\\\")\\n\\n\\n@app.route('/students')\\ndef student():\\n return render_template(\\\"students.html\\\")\\n\\n@app.route('/final')\\ndef final():\\n return render_template(\\\"final.html\\\", companies = finalList)\\n\\nif __name__ == '__main__':\\n app.run()\\n\"\n },\n {\n \"alpha_fraction\": 0.5,\n \"alphanum_fraction\": 0.692307710647583,\n \"avg_line_length\": 12.166666984558105,\n \"blob_id\": \"059a8c35b50ba0941f8cde1eaec7acddb025b914\",\n \"content_id\": \"3ef17d42369bc1d914dd553cea5e6a88d0ab2b51\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Text\",\n \"length_bytes\": 78,\n \"license_type\": \"no_license\",\n \"max_line_length\": 19,\n \"num_lines\": 6,\n \"path\": \"/requirements.txt\",\n \"repo_name\": \"Terairk/WEconnect\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"Flask==1.1.2\\n\\ngspread~=3.6.0\\noauth2client~=4.1.3\\nnltk~=3.5\\nPyDictionary~=2.0.1\"\n },\n {\n \"alpha_fraction\": 0.5957327485084534,\n \"alphanum_fraction\": 0.605277955532074,\n \"avg_line_length\": 31.290908813476562,\n \"blob_id\": \"cee088ae713138195bc087b66f9f582ad4256569\",\n \"content_id\": \"4de0e0659fa30e7277f202f3017167d31a8c3413\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 1781,\n \"license_type\": \"no_license\",\n \"max_line_length\": 109,\n \"num_lines\": 55,\n \"path\": \"/generate_values.py\",\n \"repo_name\": \"Terairk/WEconnect\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"# This is a python file to generate the values for various employers\\n# Manually inputting values from random.org is kinda a pain\\n# Also manually inputting lots of qualities is also a pain\\n# I had to manually input subjects and it was kind of a pain\\n# So to save me from this pain, I'll create a whole new program\\n# This might save me time, it might not, this file generates the values after the subjects for employer lists\\n# Edit: It saved me time\\n# Noticed that code isn't perfect as it could generate multiple of the same quality but that's fine\\n\\nfrom random import randint\\n\\n# Qualities that Employers want\\nqualities = [\\\"friendly\\\", \\\"positive\\\", \\\"fluent\\\", \\\"confident\\\", \\\"honest\\\", \\\"humble\\\", \\\"courteous\\\", \\\"trustworthy\\\",\\n \\\"honorable\\\", \\\"creative thinking\\\", \\\"original\\\", \\\"inventive\\\", \\\"productive\\\", \\\"adventurous\\\",\\n \\\"agreeable\\\", \\\"ambitious\\\", \\\"bright\\\", \\\"considerate\\\", \\\"enthusiastic\\\", \\\"helpful\\\",\\n \\\"loyal\\\", \\\"reliable\\\", \\\"sensible\\\", \\\"sincere\\\"]\\n\\n\\n# Loop for each employer\\nfor i in range(11):\\n\\n # Get the 5 values after the subjects\\n for i in range(5):\\n value = randint(1,10)\\n print(value, end=\\\", \\\")\\n\\n # True or False\\n willingnessToLearn = randint(0,1)\\n toLearn = False\\n if willingnessToLearn == 0:\\n print(\\\"False\\\", end=\\\", \\\")\\n else:\\n print(\\\"True\\\", end=\\\", \\\")\\n\\n temp = []\\n\\n # Employer qualities\\n print(\\\"[\\\", end=\\\"\\\")\\n for i in range(20):\\n value = randint(0, len(qualities) - 1)\\n # fixes duplicates\\n temp.append(qualities[value])\\n temp = list(set(temp))\\n s = \\\"'\\\" + temp[-1] + \\\"'\\\"\\n\\n\\n for i in range(6):\\n s = \\\"'\\\" + temp[i] + \\\"'\\\"\\n if i == 5:\\n print(s, end=\\\"\\\")\\n else:\\n print(s, end=\\\", \\\")\\n\\n print(\\\"]\\\", end=\\\"\\\")\\n print()\\n\\n\\n\\n\\n\\n\"\n }\n]"},"num_files":{"kind":"number","value":4,"string":"4"}}},{"rowIdx":2978319,"cells":{"repo_name":{"kind":"string","value":"MoMiJ1/Fungus"},"repo_url":{"kind":"string","value":"https://github.com/MoMiJ1/Fungus"},"snapshot_id":{"kind":"string","value":"34a1bfd7038da87a722bc155f7453656e1fc3168"},"revision_id":{"kind":"string","value":"e280984f84557c7ac48dd1bbcd848f08bb6d50f3"},"directory_id":{"kind":"string","value":"6966c91325bfdccbe3626368e53eea2e4e4edc63"},"branch_name":{"kind":"string","value":"refs/heads/master"},"visit_date":{"kind":"timestamp","value":"2021-07-02T15:11:51.131692","string":"2021-07-02T15:11:51.131692"},"revision_date":{"kind":"timestamp","value":"2021-06-22T11:43:14","string":"2021-06-22T11:43:14"},"committer_date":{"kind":"timestamp","value":"2021-06-22T11:43:14","string":"2021-06-22T11:43:14"},"github_id":{"kind":"number","value":237172413,"string":"237,172,413"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_pushed_at":{"kind":"null"},"gha_language":{"kind":"null"},"files":{"kind":"list like","value":[{"alpha_fraction":0.3710247278213501,"alphanum_fraction":0.3922261595726013,"avg_line_length":18.285715103149414,"blob_id":"2186f1ff72ce5687b0765c71d891e6f0ae087af8","content_id":"dc777ff39f21a6dca77b181805fa8f9d3ff8b206","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":572,"license_type":"no_license","max_line_length":46,"num_lines":28,"path":"/leetcode/leetcode9.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 9. 回文数\r\n\r\nclass Solution {\r\npublic:\r\n bool isPalindrome(int x) {\r\n queue que;\r\n int count=0;\r\n long a=0;\r\n long b = x;\r\n if (x<0){\r\n return false;\r\n }\r\n while (x!=0){\r\n que.push(x%10);\r\n x = x/10;\r\n count++;\r\n }\r\n while (!que.empty()){\r\n a = a+que.front()*pow(10,--count);\r\n que.pop();\r\n }\r\n if (a-b == 0){ return true;}\r\n return false;\r\n }\r\n};"},{"alpha_fraction":0.4955357015132904,"alphanum_fraction":0.5106026530265808,"avg_line_length":36.12765884399414,"blob_id":"734ae03af3791214ec2d4cbe8a4d20f66bd569c1","content_id":"e475f293153eda5c122349f803a4a047fad2c275","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":3782,"license_type":"no_license","max_line_length":107,"num_lines":94,"path":"/python/PSO.py","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"import numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\n# 计算函数 f(x,y) = 5cos(xy) + xy + y^3 的最小值\r\n# x ∈ [ -5, 5 ] y ∈ [-5，5 ]\r\n\r\n\r\nclass PSO:\r\n def __init__(self, iterTimes, groupSize, varNums, bound):\r\n '''\r\n :param iterTimes: 迭代次数\r\n :param groupSize: 解集大小\r\n :param varNums: 变量数量\r\n :param bound: 变量约束 [[x_min, y_min, z_min...] [x_max, y_max, z_max]]\r\n '''\r\n self.iterTimes = iterTimes\r\n self.groupSize = groupSize\r\n self.varNums = varNums\r\n self.bound = bound\r\n\r\n self.p_sites = np.zeros((self.groupSize, self.varNums))\r\n self.p_v = np.zeros((self.groupSize, self.varNums))\r\n self.p_optimal = np.zeros((self.groupSize, self.varNums))\r\n self.Optimal = np.zeros((1, self.varNums))\r\n self.alpha1, self.alpha2 = 1, 1\r\n self.weight = 0.5\r\n\r\n self.initialize()\r\n\r\n def initialize(self):\r\n temp_score = -1\r\n for i in range(self.groupSize):\r\n for j in range(self.varNums):\r\n # 1. 随机初始化粒子位置与速度\r\n self.p_sites[i][j] = np.random.uniform(self.bound[0][j], self.bound[1][j])\r\n self.p_v[i][j] = np.random.uniform(0, 1)\r\n # 2. 初始化粒子最好位置\r\n self.p_optimal[i] = self.p_sites[i]\r\n # 3. 评价当前粒子最好位置\r\n score = self.fitness(self.p_optimal[i])\r\n # 4. 更新全局最好位置\r\n if score > temp_score:\r\n self.Optimal = self.p_optimal[i]\r\n temp_score = score\r\n\r\n # 自定义函数\r\n def fitness(self, values):\r\n return (5 * np.cos(values[0] * values[1]) + values[0] * values[1] + pow(values[1], 3))\r\n\r\n # 更新位置与速度\r\n def update_params(self, group_size):\r\n for i in range(group_size):\r\n # 1. 更新速度\r\n self.p_v[i] = self.weight * self.p_v[i] + \\\r\n self.alpha1 * np.random.uniform(0, 1) * (self.p_optimal[i] - self.p_sites[i]) + \\\r\n self.alpha2 * np.random.uniform(0, 1) * (self.Optimal - self.p_sites[i])\r\n # 2. 更新位置\r\n self.p_sites[i] = self.p_sites[i] + self.p_v[i]\r\n # 3. 防止变量越界\r\n for j in range(self.varNums):\r\n if self.p_sites[i][j] < self.bound[0][j]:\r\n self.p_sites[i][j] = self.bound[0][j]\r\n if self.p_sites[i][j] > self.bound[1][j]:\r\n self.p_sites[i][j] = self.bound[1][j]\r\n # 4. 更新最优位置\r\n if self.fitness(self.p_sites[i]) > self.fitness(self.p_optimal[i]):\r\n self.p_optimal[i] = self.p_sites[i]\r\n if self.fitness(self.p_sites[i]) > self.fitness(self.Optimal):\r\n self.Optimal = self.p_sites[i]\r\n\r\n def run(self):\r\n scores = []\r\n self.tempOptimal = np.zeros((1, self.varNums))[0]\r\n for i in range(self.iterTimes):\r\n self.update_params(self.groupSize)\r\n scores.append(-self.fitness(self.Optimal))\r\n if self.fitness(self.Optimal) > self.fitness(self.tempOptimal):\r\n self.tempOptimal = self.Optimal.copy()\r\n print(f\"{i}代 : {-self.fitness(self.tempOptimal)} : {self.tempOptimal}\")\r\n self.display(scores)\r\n\r\n def display(self, data):\r\n plt.plot(range(self.iterTimes), data, color='lightcoral')\r\n plt.title(\"iteration - score\", color='r')\r\n plt.xlabel(\"iteration\")\r\n plt.ylabel(\"score\")\r\n plt.show()\r\n\r\n\r\nif __name__ == \"__main__\":\r\n bound = [[-5, -5], [5, 5]]\r\n pso = PSO(iterTimes=50, groupSize=20, varNums=2, bound=bound)\r\n pso.run()\r\n"},{"alpha_fraction":0.41992881894111633,"alphanum_fraction":0.43505337834358215,"avg_line_length":20.078432083129883,"blob_id":"76e9803f12d0ccc83b06112a315247da113a2d49","content_id":"20907660afc4e8e9a8ad1077af2a112044c992af","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1156,"license_type":"no_license","max_line_length":55,"num_lines":51,"path":"/leetcode/leetcode26_27_28.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 26.删除有序数组的重复项\r\n\r\nclass Solution {\r\npublic:\r\n int removeDuplicates(vector& nums) {\r\n int i = 0;\r\n for (int j = 1; j < nums.size(); j++) {\r\n if (nums[j] == nums[j-1]){\r\n j--;\r\n nums.erase(nums.begin()+j);\r\n }\r\n }\r\n int k = nums.size();\r\n return k;\r\n }\r\n};\r\n\r\n// LeetCode 27.移除元素\r\n\r\nclass Solution {\r\npublic:\r\n int removeElement(vector& nums, int val) {\r\n int k = 0;\r\n for(int i = 0;i haystack.size()){return -1;}\r\n for (int i = 0; i < haystack.size()-l+1; i++) {\r\n if (haystack.compare(i,l,needle)==0) {\r\n return i;\r\n }\r\n }\r\n return -1;\r\n }\r\n};"},{"alpha_fraction":0.4502212405204773,"alphanum_fraction":0.49668142199516296,"avg_line_length":32.846153259277344,"blob_id":"28f99fe7a74016f29c0e93d4ef24528287f799ec","content_id":"8eb6626bf652fbce216bb0b7a5c750f0e5bf0b7c","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":914,"license_type":"no_license","max_line_length":65,"num_lines":26,"path":"/leetcode/leetcode539.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n# define DAY 1440\r\n\r\n// LeetCode 539.最小时间差\r\n\r\nclass Solution {\r\npublic:\r\n int findMinDifference(vector& timePoints) {\r\n sort(timePoints.begin(),timePoints.end());\r\n int res = 1440;\r\n for(int i = 0; i < timePoints.size()-1; i++){\r\n int h1 = atoi(timePoints[i].substr(0,2).c_str());\r\n int m1 = atoi(timePoints[i].substr(3,2).c_str());\r\n for(int j = i + 1; j < timePoints.size(); j++){\r\n if(timePoints[i] == timePoints[j]) return 0;\r\n int h2 = atoi(timePoints[j].substr(0,2).c_str());\r\n int m2 = atoi(timePoints[j].substr(3,2).c_str());\r\n int tmp1 = abs(h2*60+m2-h1*60-m1);\r\n int tmp2 = DAY - tmp1;\r\n if(min(tmp1,tmp2) < res) res = min(tmp1,tmp2);\r\n }\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.5071805119514465,"alphanum_fraction":0.5268133282661438,"avg_line_length":29.4228572845459,"blob_id":"64c82c35ccba02240b1b234bc00b13f70667f829","content_id":"fa69bc1e5fc7ede17d5819e61ddeb4e151823e1a","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":6269,"license_type":"no_license","max_line_length":107,"num_lines":175,"path":"/python/gui.py","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"import sys\r\nif sys.version_info.major < 3:\r\n import Tkinter\r\nelse:\r\n import tkinter as Tkinter\r\n\r\n\r\n'''\r\n 【基本控件】\r\n 1. Radiobutton(root, text, variable, value)\r\n :param root: Tk\r\n :param text: 选项的文本\r\n :param variable: 绑定选择的变量\r\n :param value: 该选项对应的值\r\n\r\n 2. Button(root, text, command)\r\n :param root: Tk\r\n :param text: 选项的文本\r\n :param command: 点击时调用的函数\r\n\r\n 3. Checkbutton(root, text, variable)\r\n :param root: Tk\r\n :param text: 选项的文本\r\n :param variable: 绑定选择变量\r\n\r\n 4. Scale(root, label, length, from_, to, resolution, variable, orient)\r\n :param root: Tk\r\n :param label: 显示的名称\r\n :param length: 滑块长度\r\n :param from_: 左边界\r\n :param to: 右边界\r\n :param resolution: 步长\r\n :param variable: 绑定选择变量\r\n :param orient: 滑动方向\r\n \r\n 5. Label(root, text, textvariable, font, justify, foreground, underline, anchor, width, height, bg)\r\n :param text: 静态文本\r\n :param textvariable: 动态文本\r\n :param font: 字体，格式为一个tuple (font_name, font_size)\r\n :param justify: 对齐方式，有:['center','left','right']\r\n :param foreground: 文本颜色\r\n :param underline: 单个字符添加下划线，传入值为目标字符串的索引\r\n :param anchor: 位置，可选(n,s,w,e,ne,nw,sw,se,center)，eswn对应东南西北\r\n \r\n 6. grid(row, column)\r\n :param row: 控件所在的行位置\r\n :param column:控件所在的列位置 \r\n'''\r\ndef basic_widget(method=\"pack\"):\r\n def initUI(name='gui', size='900x600'):\r\n root = Tkinter.Tk()\r\n root.title(name)\r\n root.geometry(size)\r\n return root\r\n\r\n def click(i):\r\n if i == 1:\r\n print('选择：', choose_list[choose.get()])\r\n elif i == 2:\r\n selects = []\r\n for k, v in abcd.items():\r\n if v.get(): selects.append(k)\r\n print(\"选择：\", selects)\r\n elif i == 3:\r\n print(factor.get())\r\n\r\n\r\n if __name__ == \"__main__\":\r\n root = initUI()\r\n\r\n # 单选\r\n choose_list = ['A', 'B', 'C', 'D']\r\n choose = Tkinter.IntVar()\r\n choose.set(0)\r\n for i, val in enumerate(choose_list):\r\n Tkinter.Radiobutton(root, text=val, variable=choose, value=i).pack()\r\n Tkinter.Button(root, text=\"单选\", command=click(1)).pack()\r\n\r\n # 复选\r\n a, b, c, d = Tkinter.BooleanVar(), Tkinter.BooleanVar(), Tkinter.BooleanVar(), Tkinter.BooleanVar()\r\n abcd = {'A': a, 'B': b, 'C': c, 'D': d}\r\n for k, v in abcd.items():\r\n v.set(0)\r\n Tkinter.Checkbutton(root, text=k, variable=v).pack()\r\n Tkinter.Button(root, text=\"复选\", command=click(2)).pack()\r\n\r\n # 滑块\r\n factor = Tkinter.DoubleVar()\r\n factor.set(0.800)\r\n Tkinter.Scale(root, label='滑块', length=200, from_=0., to=1.0, resolution=0.001,\r\n variable=factor, orient=Tkinter.HORIZONTAL).pack()\r\n Tkinter.Button(root, text='输出', command=click(3)).pack()\r\n\r\n # 文本显示\r\n text = Tkinter.StringVar()\r\n text.set(\"This is a text;这是个文本。\")\r\n label = Tkinter.Label(root,textvariable=text,font=('宋体',15),foreground='black',\r\n underline=3,anchor='nw',width=30,height=2,bg='white')\r\n\r\n # 文本输入\r\n e = Tkinter.Entry(root)\r\n e.pack()\r\n Tkinter.Button(root, text=\"修改\").pack()\r\n\r\n root.mainloop()\r\n\r\n\r\n\r\n'''\r\n 【画布】\r\n 1. Canvas(root, bg, width, height)\r\n :param root: Tk\r\n :param bg: 画布背景颜色\r\n :param width: 画布宽\r\n :param heigth: 画布高\r\n \r\n 2. create_line(point, arrow, arrowshape, dash, width)\r\n :param point: 要连线的点的坐标\r\n :param arrow: 箭头，first--箭头在起始点，last--箭头在目标点，both--双箭头\r\n :param arrowshape: 箭头大小，传入一个tuple，如--(3,4,5)\r\n :param dash: 是否绘制虚线，默认False\r\n :param width: 线的宽度\r\n :param tags: 标签\r\n \r\n 3. create_oval(point, fill, outline, width)\r\n :param point: 椭圆的外接矩形的左上角和右下角坐标\r\n :param fill: 内部填充颜色\r\n :param outline: 边颜色\r\n :param width: 边宽\r\n :param tags: 标签\r\n \r\n 4. create_text(point, text, font)\r\n :param point: 文字所在点\r\n :param text: 文本内容\r\n :param font: 使用字体，传入tuple，如：(\"宋体\",12)\r\n \r\n 5. bind(event, handler)\r\n :param event: \r\n 常用的:\r\n (1) 26个字母，如: 'n','s'等，直接按键盘对应的键就可\r\n (2) :鼠标左键点击, : 右键点击\r\n : 向上滚轮, : 向下滚轮\r\n : 左键双击，右键同理\r\n (3) :回车；:删除；:esc\r\n ,,,: 方向键\r\n :param handler: event发生后的操作，可以是一个函数\r\n'''\r\n# 画布\r\ndef tk_canvas():\r\n def initUI(name='windows', size='900x600', width=900, height=500, bg='white'):\r\n root = Tkinter.Tk()\r\n root.geometry(size)\r\n root.title(name)\r\n cv = Tkinter.Canvas(root, bg=bg, width=width, height=height)\r\n return root,cv\r\n\r\n\r\n if __name__ == \"__main__\":\r\n root,cv = initUI()\r\n p1 = [[100,100],[300,200]]\r\n\r\n cv.create_line(p1,arrow=\"first\",arrowshape=(7,7,7),dash=True,width=5,tags=\"line\")\r\n cv.create_oval(p1,outline='blue',fill=\"pink\",width=10,tags=\"oval\")\r\n cv.create_text((400,300),text=\"hello\",font=(\"source code pro\",12))\r\n cv.grid(row=0)\r\n\r\n Tkinter.Button(root,text=\"btn1\").grid(row=1,column=0)\r\n Tkinter.Button(root,text=\"btn2\").grid(row=2)\r\n\r\n root.mainloop()\r\n\r\n\r\nif __name__ == \"__main__\":\r\n basic_widget()\r\n tk_canvas()\r\n\r\n"},{"alpha_fraction":0.44222721457481384,"alphanum_fraction":0.4641132950782776,"avg_line_length":30.705263137817383,"blob_id":"a7923267a9f81a50749fd9b4cc97f50ffef35e3b","content_id":"102b08a78297878655185913bdac578b8503dd51","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":3261,"license_type":"no_license","max_line_length":119,"num_lines":95,"path":"/python/GA_simple.py","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"import numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport random\r\n\r\n\r\nclass GA_extremum:\r\n\r\n # 求解 x*sin(2x)*e^(-0.5x) 在 0<=x<=1 时的最大值\r\n # 使用浮点数编码\r\n\r\n def __init__(self, M_Size, T, Pc, Pm, bound_min, bound_max):\r\n '''\r\n :param M_Size: 种群数量\r\n :param T: 遗传代数\r\n :param Pc: 交叉概率\r\n :param Pm: 变异概率\r\n :param bound_min: 搜素上届\r\n :param bound_max: 搜索下界\r\n '''\r\n self.M_Size = M_Size\r\n self.T = T\r\n self.Pc = Pc\r\n self.Pm = Pm\r\n self.bound_min = bound_min\r\n self.bound_max = bound_max\r\n\r\n self.Optimal = [0, 0]\r\n\r\n # 随机生成初始解\r\n def initM(self):\r\n return [np.random.uniform(self.bound_min, self.bound_max) for i in range(self.M_Size)]\r\n\r\n # 目标函数\r\n def myfunc(self, x):\r\n return x * np.sin(2 * x) * np.exp(-0.5 * x)\r\n\r\n # 适应度函数\r\n def fitness(self, M):\r\n return [self.myfunc(M[i]) for i in range(self.M_Size)]\r\n\r\n # 选择: 最优保存选择\r\n def select(self, fitness, M):\r\n if np.max(fitness) > self.Optimal[1]:\r\n self.Optimal = [M[np.argmax(fitness)], np.max(fitness)]\r\n fitness[np.argmin(fitness)] = self.Optimal[1]\r\n M[np.argmin(fitness)] = M[np.argmax(fitness)]\r\n return fitness, M\r\n\r\n # 算术交叉\r\n def cross(self, M):\r\n s = []\r\n for i in range(self.M_Size // 2):\r\n if np.random.random() < self.Pc:\r\n x1 = np.random.randint(0, self.M_Size)\r\n while x1 in s:\r\n x1 = np.random.randint(0, self.M_Size)\r\n x2 = np.random.randint(0, self.M_Size)\r\n while x2 in s:\r\n x2 = np.random.randint(0, self.M_Size)\r\n s.append(x2)\r\n a, b = M[x1], M[x2]\r\n alpha = np.random.uniform(0, 0.05)\r\n M[x1] = sorted([np.random.choice([-1, 1]) * alpha * b + (1 - alpha) * a, 0, 1])[1]\r\n M[x2] = sorted([np.random.choice([-1, 1]) * alpha * a + (1 - alpha) * b, 0, 1])[1]\r\n return M\r\n\r\n # 变异\r\n def mutation(self, M, t):\r\n if t < 0.8 * self.T:\r\n for i in range(self.M_Size):\r\n if np.random.random() < self.Pm:\r\n M[i] = np.random.uniform(self.bound_min, self.bound_max)\r\n else:\r\n for i in range(self.M_Size):\r\n if np.random.random() < self.Pm:\r\n M[i] = sorted([M[i] + np.random.choice([-1, 1]) * random.gauss(\r\n (self.bound_min + self.bound_max) / 2, 2 * (self.bound_max - self.bound_min) / self.M_Size), 0,\r\n 1])[1]\r\n return M\r\n\r\n def run(self):\r\n M = self.initM()\r\n t = 1\r\n while t <= self.T:\r\n fitness = self.fitness(M)\r\n fitness, M = self.select(fitness, M)\r\n M = self.cross(M)\r\n M = self.mutation(M, t)\r\n t += 1\r\n\r\n\r\nif __name__ == \"__main__\":\r\n ga = GA_extremum(M_Size=40, T=50, Pm=0.05, Pc=0.5, bound_min=0, bound_max=1)\r\n res = ga.run()\r\n print(\"最优解为：x={}\\n极值：{}\".format(res[0], res[1]))\r\n"},{"alpha_fraction":0.45602163672447205,"alphanum_fraction":0.4736129939556122,"avg_line_length":23.55172348022461,"blob_id":"54f041c7f468f99414aaa5a1c4fe8295535618db","content_id":"671e15e246ba1ae3d09a47195927c62682ac94b3","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":755,"license_type":"no_license","max_line_length":70,"num_lines":29,"path":"/leetcode/leetcode973.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 973.最接近原点的K个点\r\n\r\nclass Solution {\r\npublic:\r\n struct elem\r\n {\r\n vector point;\r\n int dist;\r\n friend bool operator < (elem e1, elem e2) {\r\n return e1.dist >= e2.dist;\r\n }\r\n };\r\n vector> kClosest(vector>& points, int k) {\r\n priority_queue pq;\r\n vector>res;\r\n for(int i = 0; i < points.size(); i++){\r\n int temp = pow(points[i][0],2) + pow(points[i][1],2);\r\n pq.push({points[i],temp});\r\n }\r\n for(int i = 0; i < k; i++){\r\n res.push_back(pq.top().point);\r\n pq.pop();\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.363778293132782,"alphanum_fraction":0.37548789381980896,"avg_line_length":28.452381134033203,"blob_id":"318718580cc626ff3539f25e1a7d982ba73c8482","content_id":"07b19fcff3d54c10266b2f10f10b88707d59d2ff","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1345,"license_type":"no_license","max_line_length":72,"num_lines":42,"path":"/leetcode/leetcode15.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 15.三数之和\r\n\r\nclass Solution {\r\npublic:\r\n vector> threeSum(vector& nums) {\r\n vector> res;\r\n // 特判\r\n if(nums.size()<3) return res;\r\n sort(nums.begin(), nums.end());\r\n int i = 0;\r\n // 只要搜索到数组的倒数第三个就可以了，之后凑不齐3个数了\r\n while (i < nums.size()-2)\r\n {\r\n if(nums[i] > 0) return res;\r\n int left = i+1, right = nums.size()-1;\r\n while (left < right)\r\n {\r\n if(nums[i]+nums[left]+nums[right] == 0){\r\n res.push_back({nums[i],nums[left],nums[right]});\r\n while(left < right && nums[left] == nums[left+1]){\r\n left++;\r\n }\r\n while(left < right && nums[right] == nums[right-1]){\r\n right--;\r\n }\r\n left++;\r\n right--;\r\n } else if(nums[i]+nums[left]+nums[right] < 0){\r\n left++;\r\n } else right--;\r\n }\r\n while(i < nums.size()-2 && nums[i] == nums[i+1]){\r\n i++;\r\n }\r\n i++;\r\n }\r\n return res;\r\n }\r\n};\r\n\r\n"},{"alpha_fraction":0.38492199778556824,"alphanum_fraction":0.3903883397579193,"avg_line_length":26.3258056640625,"blob_id":"d6816a28c1b9602b686b1998e2aa0754c85615d8","content_id":"9274e8eebd9d10310b5a166179777ebf12ed5d96","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":10223,"license_type":"no_license","max_line_length":101,"num_lines":310,"path":"/C/sorted.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\n#include\r\n#include\r\n#include\r\n#include\r\nusing namespace std;\r\n\r\n\r\nstruct LinkNode\r\n {\r\n int key;\r\n LinkNode *next;\r\n LinkNode(int x) : key(x), next(NULL) {}\r\n }; \r\n\r\n\r\nclass sort_Insert //直接插入排序\r\n{ \r\npublic:\r\n\r\n /* 一、数组排序 */\r\n // 基本思想：从有序界开始与当前数字进行比较，如果比当前数字大，有序界数字向后移动\r\n void sort_InsertArray(int array[],int n) { \r\n int i , p;\r\n for (p = 1; p < n; p++) //排序界从1开始\r\n {\r\n int temp = array[p];\r\n for (i = p-1; i>0 && array[i]>temp ; i--)\r\n {\r\n array[i] = array[i-1]; //将比待排序数字大的数字都向后移一位\r\n }\r\n array[i] = temp;\r\n }\r\n }\r\n\r\n /*二、链表排序*/\r\n LinkNode* sort_InsertLink(LinkNode* head){\r\n if(head==NULL || head->next==NULL) return head;\r\n\r\n //定义伪头结点Tower\r\n LinkNode* Tower = new LinkNode(INT_MIN);\r\n Tower->next = head;\r\n\r\n //pre指向上一次移动的结点、end指向有序边界结点、now指向正在排序的结点\r\n LinkNode *pre=Tower, *end=Tower, *now=head;\r\n while (now)\r\n {\r\n if (now->key > end->key) //这种情况不变化\r\n {\r\n end = end->next;\r\n now = now->next;\r\n }\r\n else\r\n {\r\n if (now->key < pre->key) //正在排序的数比上次排序的数小，说明要进行移动，将pre置于头结点\r\n {\r\n pre = Tower;\r\n }\r\n while (pre->next && pre->next->key < now->key) //找到要操作的结点\r\n {\r\n pre = pre->next;\r\n }\r\n LinkNode* temp = now->next; //先保留下一个要操作的结点位置\r\n now->next = pre->next; //将正在排序的数与其后面的结点相连\r\n pre->next = now; //pre为上次移动的结点，因此置于正在操作的结点处\r\n end->next = temp; //有序界向后移动\r\n now = end->next; //更新正在操作的结点\r\n } \r\n }\r\n LinkNode* res = Tower->next;\r\n delete Tower;\r\n return res;\r\n }\r\n\r\n LinkNode* sort_InsertComplex(LinkNode* head){\r\n if (head==NULL || head->next==NULL) return head;\r\n LinkNode *Tower = new LinkNode(INT_MIN); // Tower是伪头结点，指向头结点\r\n Tower->next = head;\r\n LinkNode *p = Tower, *end = Tower, *cur = head; // p用于从头搜索数值，end用于确定已有序的区间，cur为正在排序的结点\r\n while (cur)\r\n {\r\n if (cur->key > end->key) // 这种情况顺序是合理的\r\n {\r\n end = end->next;\r\n cur = cur->next;\r\n }\r\n else \r\n {\r\n p = Tower; // 先将用于搜索的指针置于伪头\r\n while (p->next && p->next->key < cur->key)\r\n {\r\n p = p->next; // 找到要移动的结点\r\n } \r\n LinkNode *temp = cur->next; //正在排序部分的局部顺序应该是 head-->...->cur->p->...->end->temp->...\r\n cur->next = p->next; \r\n p->next = cur;\r\n end->next = temp;\r\n cur = end->next; \r\n } \r\n }\r\n return Tower->next; // 返回头结点\r\n }\r\n\r\n LinkNode* creatLink(){\r\n LinkNode *head = new LinkNode(INT_MIN);\r\n LinkNode *pre = new LinkNode(INT_MIN);\r\n pre = head;\r\n for (int i = 8; i >= 0; i--)\r\n {\r\n LinkNode *p = new LinkNode(0);\r\n p->key = i;\r\n pre->next = p;\r\n pre = p;\r\n }\r\n return head;\r\n }\r\n \r\n void print(LinkNode *head){\r\n while (head->next)\r\n {\r\n printf(\"%d \",head->next->key);\r\n head = head->next;\r\n }\r\n }\r\n};\r\n\r\nclass sort_Bubble //冒泡排序\r\n{\r\npublic:\r\n /*一、数组排序*/\r\n void sort_BubbleArray(int array[],int n){\r\n bool flag; // 指示是否发生元素移动，如果没发生，说明已经有序，终止排序\r\n for (int i = n-1; i >= 0; i--) //由于每轮排序将最大的数排至末尾，因此要指定末尾的位置\r\n {\r\n flag = false;\r\n for (int j = 0; j < i; j++)\r\n {\r\n if (array[j]>array[j+1])\r\n {\r\n int temp = array[j];\r\n array[j] = array[j+1];\r\n array[j+1] = temp;\r\n flag = true;\r\n } \r\n }\r\n if(!flag) break; \r\n } \r\n }\r\n\r\n /*二、链表排序*/\r\n LinkNode* sort_BubbleLink(LinkNode* head){\r\n LinkNode *pre, *cur, *tail;\r\n tail = NULL;\r\n while (head->next != tail) // 根据冒泡排序的特性，每次会将最大数排至最后，因此设置尾指针区分排序区\r\n {\r\n pre = head;\r\n cur = head->next; // cur表示正在排序的位置\r\n while (cur->next != tail) // 在有序区之前\r\n {\r\n if (cur->key > cur->next->key)\r\n {\r\n pre->next = cur->next;\r\n cur->next = pre->next->next;\r\n pre->next->next = cur;\r\n }\r\n else cur = cur->next;\r\n pre = pre->next; \r\n }\r\n tail = cur; // 每轮排序结束后更新界指针\r\n }\r\n return head; \r\n }\r\n};\r\n\r\nclass sort_Heap{ //堆排序\r\npublic:\r\n // 将以root为根的子树调整为大根堆\r\n void heap_Adjust(int array[],int root,int n){ \r\n int parent, child;\r\n int temp;\r\n temp = array[root]; // 每次比较是用传入的root节点的值与各个孩子节点进行比较\r\n for (parent = root; parent*2+1 < n; parent=child)\r\n {\r\n child = parent * 2 + 1;\r\n if (child!=n-1 && array[child]= array[child]) break; //判断孩子值是否大于根值\r\n else\r\n {\r\n array[parent] = array[child];\r\n } \r\n }\r\n array[parent] = temp; // 最后剩下的空位就是parent的值应在的位置 \r\n }\r\n\r\n // 根据堆进行排序\r\n void sort_heap(int array[], int n){\r\n int i;\r\n for (i = n/2-1; i >= 0; i--) // 无序数组建堆\r\n {\r\n heap_Adjust(array,i,n);\r\n }\r\n for (i = n-1; i > 0; i--) // 弹出顶元素（排序过程）\r\n {\r\n int temp = array[0]; // 每次将待排序列最大值移至尾部，再重建堆，直到堆清空\r\n array[0] = array[i];\r\n array[i] = temp; \r\n heap_Adjust(array,0,i);\r\n } \r\n }\r\n};\r\n\r\nclass sort_Shell // 希尔排序\r\n{\r\npublic:\r\n void sort_shellArray(int array[],int n){\r\n int gap = n;\r\n int i, j, temp;\r\n for (gap>>=2; gap>0; gap>>=2){\r\n for (i = gap; i < n; i++)\r\n {\r\n j = 0;\r\n temp = array[i];\r\n for (j = i-gap; j>=0 && temp vec[n];\r\n for (int i = 0; i < n; i++){\r\n int bi = array[i];\r\n vec[bi].push_back(array[i]);\r\n }\r\n for (int i = 0; i < n; i++)\r\n sort(vec[i].begin(),vec[i].end());\r\n \r\n int index = 0;\r\n for (int i = 0; i < n; i++)\r\n for (int j = 0;j < vec[i].size(); j++)\r\n array[index++] = vec[i][j];\r\n }\r\n};\r\n"},{"alpha_fraction":0.3597733676433563,"alphanum_fraction":0.39376771450042725,"avg_line_length":17.61111068725586,"blob_id":"1ee0dd284729a04b4ad926c8fec98aca6f34b856","content_id":"e351c8975ae54edc97d1f75831cd4a11d577b67e","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":357,"license_type":"no_license","max_line_length":36,"num_lines":18,"path":"/leetcode/leetcode263.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 263.丑数\r\n\r\nclass Solution {\r\npublic:\r\n bool isUgly(int n) {\r\n if(n <= 0) return false;\r\n int arr[3] = {2,3,5};\r\n for(int i = 0;i < 3;i++){\r\n while(n % arr[i] == 0) {\r\n n /= arr[i];\r\n }\r\n }\r\n return n == 1;\r\n }\r\n};\r\n"},{"alpha_fraction":0.3565604090690613,"alphanum_fraction":0.36767977476119995,"avg_line_length":21.59649085998535,"blob_id":"e252216e46a6114ad286216bf57ee3bf37bb6fda","content_id":"06c4d4436e57aae375667a866ce2a8e6c3a6770d","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1517,"license_type":"no_license","max_line_length":102,"num_lines":57,"path":"/C/Floyd.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\n#include\r\nusing namespace std;\r\n\r\n/*\r\n原理：\r\n 如果有一个点 K ，使得 i-->K-->j 的距离小于 i-->j 的距离\r\n 则：用点 K作为点(i,j)的中介点\r\n\r\n伪代码：\r\n void Floyd() {\r\n 枚举顶点 K：\r\n 以 K作为中介点，枚举顶点 i，j：\r\n if (dist[i][k] + dist[k][j] < dist[i][j])\r\n {\r\n dist[i][j] = dist[i][k] + dist[k][j]\r\n }\r\n }\r\n*/\r\n\r\nconst int MAX = 200;\r\nint n, m;\r\nint dist[MAX][MAX]; // 默认为 INT_MAX\r\n\r\n// 算法\r\nvoid Floyd() {\r\n for (int k = 0; k < n; k++)\r\n for (int i = 0; i < n; i++)\r\n for (int j = 0; j < n; j++)\r\n if(dist[i][k] != INT_MAX && dist[k][j] != INT_MAX && dist[i][k]+dist[k][j]\r\nusing namespace std;\r\n\r\n// LeetCode 23.合并k个升序链表\r\n\r\nstruct ListNode {\r\n int val;\r\n ListNode *next;\r\n ListNode() : val(0), next(nullptr) {}\r\n ListNode(int x) : val(x), next(nullptr) {}\r\n ListNode(int x, ListNode *next) : val(x), next(next) {}\r\n};\r\n\r\nclass Solution {\r\npublic:\r\n ListNode* mergeKLists(vector& lists) {\r\n ListNode *tower = nullptr;\r\n for(int i = 0; i < lists.size(); i++){\r\n tower = mergeTwoLists(tower,lists[i]);\r\n }\r\n return tower;\r\n }\r\n\r\n ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {\r\n if(l1 == nullptr && l2 != nullptr) return l2;\r\n else if(l1 != nullptr && l2 == nullptr) return l1;\r\n else if(l1 == nullptr && l2 == nullptr) return nullptr;\r\n ListNode *head = new ListNode(1);\r\n ListNode *ret = head;\r\n while (l1 != NULL && l2 != NULL){\r\n if (l1->val <= l2->val){\r\n ret->next = l1;\r\n l1 = l1->next;\r\n } else{\r\n ret->next = l2;\r\n l2 = l2->next;\r\n }\r\n ret = ret->next;\r\n }\r\n ret->next = l1 == NULL ? l2 : l1;\r\n return head->next;\r\n }\r\n};\r\n"},{"alpha_fraction":0.5370370149612427,"alphanum_fraction":0.5555555820465088,"avg_line_length":17.81818199157715,"blob_id":"ae7353ca375c558d969154c2ba545c98a7f8cb8a","content_id":"b37c54e78ff24b82b35aff1c9a03990cce201e95","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":238,"license_type":"no_license","max_line_length":63,"num_lines":11,"path":"/leetcode/leetcode_sword65.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 剑指offer-65. 不用加减乘除做加法\r\n\r\nclass Solution {\r\npublic:\r\n int add(int a, int b) {\r\n return b == 0 ? a : add(a^b, (unsigned int)(a&b) << 1);\r\n }\r\n};"},{"alpha_fraction":0.3787755072116852,"alphanum_fraction":0.38938775658607483,"avg_line_length":23.040817260742188,"blob_id":"7e830d55345b4839e0a83c7f6f0081f5dfe5a359","content_id":"190352669cbd1c165fecd0540815af5bf418bbe8","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1579,"license_type":"no_license","max_line_length":70,"num_lines":49,"path":"/leetcode/leetcode880.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 880. 索引处的解码字符串\r\n\r\n/*\r\n思路：\r\n1.首先遍历整个字符串，记录最终字符串的长度：\r\n 若当前解析出的字符串长度 < K,继续解析；\r\n 若 > K,停止解析\r\n2. 当前字符串长度为 sum>K\r\n 从停止解析前最后遍历的字符 S[i] 开始回退：\r\n 若该字符c为数字，则 sum/c（因为说明总长度遇到这个数字后重复了c遍）\r\n 若 sum/c < K，说明第 K位在 sum/c ~ sum这段区间内，且结果字符存在于 sum/c这段字符串内；\r\n 则 K %= (sum/c) ，如果 K=0，则退出搜索，结果为 S[i]\r\n 若该字符c为字母，则 sum--\r\n i--\r\n 当前字符串长度 sum == K，退出搜索，结果为 S[i]\r\n3. \r\n\r\n*/\r\n\r\nclass Solution {\r\npublic:\r\n string decodeAtIndex(string S, int K) {\r\n string ans;\r\n int n = S.length();\r\n long sum = 0, i = 0; \r\n for (; i < n; i++) { \r\n if (isalpha(S[i])) sum++;\r\n else { sum *= (S[i] - '0'); }\r\n if (sum >= K) break;\r\n }\r\n for (; i >= 0; i--) {\r\n if (sum > K){\r\n if (isdigit(S[i])) {\r\n sum /= (S[i] - '0');\r\n if (K > sum){\r\n K %= sum;\r\n if (K == 0) break;\r\n }\r\n } else sum--;\r\n } else if (sum == K) break;\r\n }\r\n while (isdigit(S[i])) i--;\r\n ans += S[i];\r\n return ans;\r\n }\r\n};"},{"alpha_fraction":0.3832857012748718,"alphanum_fraction":0.39500001072883606,"avg_line_length":21.72881317138672,"blob_id":"cce2ef1bacd7d81b3ed5ddbc881795aa599591d1","content_id":"9ba38ea2d309717fc3742a9b98dfb3d1d29299c4","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":8664,"license_type":"no_license","max_line_length":108,"num_lines":295,"path":"/C/dijkstra.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n#define MAX 500\r\n\r\n/* dijkstra 计算最短距离的伪代码\r\n\r\n#define MAX 500\r\nint Graph[MAX][MAX];\r\nint dist[MAX]; \r\nbool visit[MAX];\r\n\r\nvoid dijkstra(int start)\r\n{\r\n 初始化dist (1) \r\n for(循环n次) \r\n {\r\n u = dist[MAX]中最小且没被访问过的顶点 (2)\r\n visit[u] = true\r\n for(从u出发能到达的所有顶点k) (3)\r\n {\r\n if(k没被访问过 && 以u为中转点的start-->k的距离比dist[k]小) (4)\r\n {\r\n 更新dist[k] (5)\r\n }\r\n }\r\n }\r\n}\r\n*/\r\n\r\nint Graph[MAX][MAX];\r\nint dist[MAX];\r\nbool visit[MAX];\r\n\r\nvoid dijkstra_1(int start){ // dijkstra计算最短距离\r\n\r\n // （1）. 初始化dist\r\n fill(dist,dist+MAX,INT_MAX); \r\n dist[start] = 0;\r\n\r\n // （2）.找到dist[]中最小且没被访问过的点\r\n\r\n for(int i = 0; i < MAX;i++)\r\n {\r\n int u = -1, minDist = INT_MIN;\r\n for(int j = 0;j < MAX;j++)\r\n {\r\n if(!visit[j] && dist[j]u-->k”的距离比现有的“起点-->k”更短\r\n if(!visit[k] && Graph[u][k]!=INT_MAX && dist[u] + Graph[u][k] < dist[k])\r\n {\r\n dist[k] = dist[u] + Graph[u][k];\r\n }\r\n }\r\n }\r\n}\r\n\r\n\r\n/* 修改： dijkstra 解最短路径\r\n\r\n需要增添一个 preNode[MAX],记录点k的前驱\r\n代码上只需要在第一部分伪代码的序号（5）后面增加一条：\r\n\r\n \"令k的前驱为u\" (6)\r\n\r\nvoid dijkstra(int start)\r\n{\r\n 初始化dist (1) \r\n for(循环n次) \r\n {\r\n u = dist[MAX]中最小且没被访问过的顶点 (2)\r\n visit[u] = true\r\n for(从u出发能到达的所有顶点k) (3)\r\n {\r\n if(k没被访问过 && 以u为中转点的start-->k的距离比dist[k]小) (4)\r\n {\r\n 更新dist[k] (5)\r\n 令k的前驱为u (6)\r\n }\r\n }\r\n }\r\n}\r\n\r\n但是preNode中得到的是每个顶点的直接前驱，想要得到完整的最短路径，需要用 DFS不断递归寻找前驱，直到到达 start\r\n\r\n*/\r\n\r\nint preNode[MAX];\r\n\r\nvoid dijkstra_2(int start)\r\n{\r\n // （1）初始化 dist[] 和 preNode[]\r\n fill(dist,dist+MAX,INT_MAX);\r\n dist[start] = 0;\r\n for(int i = 0;i < MAX;i++) preNode[i] = i;\r\n\r\n // （2）.找到dist[]中最小且没被访问过的点\r\n for(int i = 0; i < MAX;i++)\r\n {\r\n int u = -1, minDist = INT_MIN;\r\n for(int j = 0;j < MAX;j++)\r\n {\r\n if(!visit[j] && dist[j]u-->k”的距离比现有的“起点-->k”更短\r\n if(!visit[k] && Graph[u][k]!=INT_MAX && dist[u] + Graph[u][k] < dist[k])\r\n {\r\n dist[k] = dist[u] + Graph[u][k];\r\n preNode[k] = u; // 更新前驱\r\n }\r\n } \r\n } \r\n}\r\n\r\n\r\n/* 附加条件：如果对每条边增加一个边权(额外开销)，求在最短路径有多少条时要求路径上的花费之和最大/小\r\n\r\n新增一个开销矩阵 Cost[MAX][MAX]\r\n并对第一段伪代码的序号 （3）修改\r\n*/\r\n\r\nint C[MAX][MAX];\r\nint cost[MAX];\r\n\r\nvoid dijkstra_3(int start)\r\n{\r\n // （1）初始化 dist[] \r\n fill(dist,dist+MAX,INT_MAX);\r\n dist[start] = 0;\r\n\r\n // （2）.找到dist[]中最小且没被访问过的点\r\n for(int i = 0; i < MAX;i++)\r\n {\r\n int u = -1, minDist = INT_MIN;\r\n for(int j = 0;j < MAX;j++)\r\n {\r\n if(!visit[j] && dist[j]u 的最短路径条数的数组 roadNum[MAX]\r\n初始条件下，roadNum[start]=1,其它为0；\r\n每次更新最短距离时，令 roadNum[k]继承 roadNum[u]；\r\n当最短距离相同，将 roadNum[u] 加到 roadNum[k]上\r\n\r\n修改的位置依旧是 （3）\r\n\r\n*/\r\n\r\nint roadNum[MAX];\r\n\r\nvoid dijkstra_5(int start)\r\n{\r\n // （1）初始化 dist[] ，roadNum[]\r\n fill(dist,dist+MAX,INT_MAX);\r\n fill(roadNum,roadNum+MAX,0);\r\n dist[start] = 0;\r\n roadNum[start] = 1;\r\n\r\n\r\n // （2）.找到dist[]中最小且没被访问过的点\r\n for(int i = 0; i < MAX;i++)\r\n {\r\n int u = -1, minDist = INT_MIN;\r\n for(int j = 0;j < MAX;j++)\r\n {\r\n if(!visit[j] && dist[j]\r\nusing namespace std;\r\n\r\n// LeetCode 14.最长公共子串\r\n\r\nclass Solution {\r\npublic:\r\n string longestCommonPrefix(vector& strs) {\r\n if(strs.size() == 0) return \"\";\r\n string res = \"\", first = strs[0];\r\n char c;\r\n for(int i = 0;i < first.length();i++){\r\n c = first[i];\r\n for(int j = 1;j < strs.size();j++){\r\n if(i == strs[j].length() || strs[j][i] != c){\r\n return res;\r\n }\r\n }\r\n res += c;\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.4541501998901367,"alphanum_fraction":0.47648221254348755,"avg_line_length":25.351350784301758,"blob_id":"51a4edb2743f0c0e6d6d619781fe659ef3d3e9a1","content_id":"cf0bfe46eab98ae23ba35954b7132d4f31fd562f","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":5463,"license_type":"no_license","max_line_length":116,"num_lines":185,"path":"/python/TSP_GA.py","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"import numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\n# 个体类\r\nclass Indv:\r\n # 传入个体的基因\r\n def __init__(self, gene):\r\n self.gene = gene\r\n self.score = -1\r\n\r\n\r\nclass GA:\r\n def __init__(self, Pc, Pm, indvNums, scoreFunc, geneLength):\r\n '''\r\n :param Pc: 交叉概率\r\n :param Pm: 变异概率\r\n :param indvNums: 个体数量\r\n :param scoreFunc: 适应度函数\r\n :param geneLength: 基因长度\r\n '''\r\n self.Pc = Pc\r\n self.Pm = Pm\r\n self.indvNums = indvNums\r\n self.scoreFunc = scoreFunc\r\n self.geneLength = geneLength\r\n\r\n self.Groups = []\r\n self.t = 0\r\n self.Optimal = None\r\n self.crossNums = 0\r\n self.mutationNums = 0\r\n self.scoreSum = 0.0\r\n\r\n self.initialize()\r\n\r\n def initialize(self):\r\n self.Groups = []\r\n for i in range(self.indvNums):\r\n # 1. gene = [0,1,2...genelength]\r\n gene = [i for i in range(self.geneLength)]\r\n # 2. 打乱 gene\r\n np.random.shuffle(gene)\r\n # 3. 新个体\r\n indv = Indv(gene)\r\n self.Groups.append(indv)\r\n\r\n # 计算适应度\r\n def fitness(self):\r\n # 1. 初始化\r\n self.scoreSum = 0.0\r\n self.Optimal = self.Groups[0]\r\n for indv in self.Groups:\r\n # 2. 计算个体适应度\r\n indv.score = self.scoreFunc(indv)\r\n self.scoreSum += indv.score\r\n # 3. 更新最优个体\r\n if self.Optimal.score > indv.score:\r\n self.Optimal = indv\r\n\r\n # 交叉\r\n def cross(self, dad, mom):\r\n son, position = [], 0\r\n # 1. 确定交叉片段位置\r\n index1 = np.random.randint(0, self.geneLength - 1)\r\n index2 = np.random.randint(0, self.geneLength - 1)\r\n segment = mom.gene[index1: index2]\r\n for x in dad.gene:\r\n # 2. 到达交叉起点\r\n if position == index1:\r\n son.extend(segment)\r\n position += 1\r\n # 3. 其它情况，直接将基因插入子代 gene\r\n if x not in son:\r\n son.append(x)\r\n position += 1\r\n self.crossNums += 1\r\n return son\r\n\r\n # 变异\r\n def mutation(self, gene):\r\n son = gene[:]\r\n # 1. 确定变异点\r\n index1 = np.random.randint(0, self.geneLength - 1)\r\n index2 = np.random.randint(0, self.geneLength - 1)\r\n # 2. 交换两点基因\r\n son[index1], son[index2] = son[index2], son[index1]\r\n self.mutationNums += 1\r\n return son\r\n\r\n # 选择\r\n def select(self):\r\n # 1. 利用总适应度选择\r\n s = np.random.uniform(0, self.scoreSum)\r\n for indv in self.Groups:\r\n s -= indv.score\r\n if s <= 0:\r\n return indv\r\n raise Exception(\"Error\", self.scoreSum)\r\n\r\n # 产生新子代\r\n def generate(self):\r\n dad = self.select()\r\n # 1. 交叉\r\n P = np.random.random()\r\n if P < self.Pc:\r\n mom = self.select()\r\n gene = self.cross(dad, mom)\r\n else:\r\n gene = dad.gene\r\n # 2. 变异\r\n P = np.random.random()\r\n if P < self.Pm:\r\n gene = self.mutation(gene)\r\n return Indv(gene)\r\n\r\n # 产生新种群\r\n def evolve(self):\r\n # 1. 计算适应度\r\n self.fitness()\r\n # 2. 新一代\r\n groups = [self.Optimal]\r\n # 3. 产生新子代\r\n while len(groups) < self.indvNums:\r\n groups.append(self.generate())\r\n # 4. 更新种群\r\n self.Groups = groups\r\n self.t += 1\r\n\r\n\r\nclass TSP:\r\n def __init__(self, indvNums):\r\n self.indvNums = indvNums\r\n self.initialize()\r\n self.ga = GA(Pc=0.7, Pm=0.1, indvNums=self.indvNums, geneLength=len(self.sites), scoreFunc=self.scoreFunc())\r\n\r\n # 初始化\r\n def initialize(self):\r\n self.sites = []\r\n # 随机生成点\r\n for i in range(100):\r\n x = np.random.randint(0, 200)\r\n y = np.random.randint(0, 200)\r\n self.sites.append((x, y))\r\n\r\n # 计算某基因（路径）的总距离\r\n # 适应度函数\r\n def distance(self, gene):\r\n dist = 0.0\r\n for i in range(-1, len(self.sites) - 1):\r\n index1, index2 = gene[i], gene[i + 1]\r\n site1, site2 = self.sites[index1], self.sites[index2]\r\n # 欧式距离\r\n dist += np.sqrt(pow(site1[0] - site2[0], 2) + pow(site1[1] - site2[1], 2))\r\n return dist / 1000\r\n\r\n def scoreFunc(self):\r\n return lambda indv: self.distance(indv.gene)\r\n\r\n # 运行函数\r\n def run(self, T=0):\r\n res, n = [], 0\r\n # 1. 判断终止条件\r\n while n < T:\r\n # 2. 生成新种群\r\n self.ga.evolve()\r\n # 3. 计算当前迭代最优结果\r\n dist = self.distance(self.ga.Optimal.gene)\r\n print(f'{self.ga.t} : {round(dist, 5)}')\r\n res.append(dist)\r\n n += 1\r\n self.display(res, T)\r\n\r\n # 结果可视化\r\n def display(self, res, T):\r\n plt.plot(range(T), res, color='lightcoral')\r\n plt.title(\"iteration - score\", color='r')\r\n plt.xlabel(\"iteration\")\r\n plt.ylabel(\"score ×10^3\")\r\n plt.show()\r\n\r\n\r\nif __name__ == \"__main__\":\r\n tsp = TSP(100)\r\n tsp.run(500)\r\n"},{"alpha_fraction":0.3672390878200531,"alphanum_fraction":0.4095112383365631,"avg_line_length":26.11111068725586,"blob_id":"525150fd7544595c014023d1e274e9a323da41af","content_id":"7888d61cbd8e4e16be7498bcecbfde41a97fea02","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":771,"license_type":"no_license","max_line_length":68,"num_lines":27,"path":"/leetcode/leetcode16_10.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 面试题 16.10. 生存人数\r\n\r\nclass Solution {\r\npublic:\r\n int maxAliveYear(vector& birth, vector& death) {\r\n int live[101] = {0};\r\n int MAX_year = 0, MAX_nums = 0;\r\n\r\n for (int i = 0; i < birth.size(); i++)\r\n {\r\n int start = birth[i], end = death[i];\r\n for(int j = start-1900;j <= end-1900;j++){\r\n live[j] += 1;\r\n if(live[j] > MAX_nums){\r\n MAX_year = j + 1900;\r\n MAX_nums = live[j];\r\n } else if(live[j] == MAX_nums && j+1900 < MAX_year){\r\n MAX_year = j + 1900;\r\n }\r\n }\r\n }\r\n return MAX_year;\r\n }\r\n};"},{"alpha_fraction":0.44312795996665955,"alphanum_fraction":0.4620853066444397,"avg_line_length":21.55555534362793,"blob_id":"4b925bb4eba036cfe42971b537d3457ab6f1947e","content_id":"57854e7f66640a28f0d73457bdae14f22cc96966","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":436,"license_type":"no_license","max_line_length":79,"num_lines":18,"path":"/leetcode/leetcode1800.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 1800. 最大升序子数组\r\n\r\nclass Solution {\r\npublic:\r\n int maxAscendingSum(vector& nums) {\r\n int p = 0, res = 0;\r\n while (p < nums.size()){\r\n int temp = nums[p];\r\n while (p < nums.size()-1 && nums[p+1] > nums[p]) temp += nums[++p];\r\n res = max(res, temp);\r\n p++;\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.2758132815361023,"alphanum_fraction":0.2927864193916321,"avg_line_length":24.259260177612305,"blob_id":"2226d821d5317ffacd92a73d1335c34f560e98ed","content_id":"045570a219a5c583dff8f2d7b9b35678212e2077","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":719,"license_type":"no_license","max_line_length":62,"num_lines":27,"path":"/leetcode/leetcode1576.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 1576.替换所有问号\r\n\r\nclass Solution {\r\npublic:\r\n string modifyString(string s) {\r\n char a = 'a';\r\n for(int i = 0; i < s.length(); i++){\r\n if(s[i] == '?'){\r\n int k = 0;\r\n if(i == 0){\r\n while (a+k == s[i+1]) k++;\r\n s[i] = a + k;\r\n } else if(i == s.length()-1){\r\n while (a+k == s[i-1]) k++;\r\n s[i] = a + k;\r\n } else {\r\n while(a+k == s[i-1] || a+k == s[i+1]) k++;\r\n s[i] = a + k;\r\n }\r\n }\r\n }\r\n return s;\r\n }\r\n};"},{"alpha_fraction":0.4261796176433563,"alphanum_fraction":0.4292237460613251,"avg_line_length":23.269229888916016,"blob_id":"ba9aecbb6ffb7de84f78578ddc7ef41acb316ce7","content_id":"40b9b516856045a5ee266e88f2c5a794941ef49b","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":677,"license_type":"no_license","max_line_length":57,"num_lines":26,"path":"/leetcode/leetcode1.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 1.两数之和\r\n\r\nclass Solution {\r\npublic:\r\n vector twoSum(vector& nums, int target) {\r\n map mp; // first是值，second是索引\r\n vector res;\r\n int pair;\r\n for (int i = 0; i < nums.size(); i++)\r\n {\r\n pair = target - nums[i];\r\n map::iterator iter = mp.find(pair);\r\n if(iter != mp.end()){\r\n res.push_back(iter->second);\r\n res.push_back(i);\r\n break;\r\n } else {\r\n mp[nums[i]] = i;\r\n }\r\n }\r\n return res;\r\n }\r\n};\r\n"},{"alpha_fraction":0.38494935631752014,"alphanum_fraction":0.40086829662323,"avg_line_length":22.75,"blob_id":"e74cdd13d96c1e7e23cd27d6bb32f873bd5a6431","content_id":"2510fa7ba3bf0cc386baf27be7eeeab50a995462","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":699,"license_type":"no_license","max_line_length":57,"num_lines":28,"path":"/leetcode/leetcode1447.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 1447.最简分数\r\n\r\nclass Solution {\r\npublic:\r\n vector simplifiedFractions(int n) {\r\n vector vec;\r\n if(n == 1) return vec;\r\n string temp;\r\n for(int i = 2;i <= n;i++){\r\n for(int j = 1;j < i;j++){\r\n if(j == 1 || check(j, i)){\r\n temp = to_string(j)+'/'+to_string(i);\r\n vec.push_back(temp);\r\n }\r\n }\r\n }\r\n return vec;\r\n }\r\n bool check(int a, int b){\r\n for(int i = 2;i <= a;i++){\r\n if(a % i == 0 && b % i == 0) return false;\r\n }\r\n return true;\r\n }\r\n};"},{"alpha_fraction":0.3242603540420532,"alphanum_fraction":0.35384616255760193,"avg_line_length":19.174999237060547,"blob_id":"f6600897445003d5af3cc8a217a28f4c836e4a0d","content_id":"5890affa91840d03705feaf94d231d806aba1d04","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":859,"license_type":"no_license","max_line_length":56,"num_lines":40,"path":"/leetcode/leetcode13.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 13.罗马数字转整数\r\n\r\nclass Solution {\r\npublic:\r\n int romanToInt(string s) {\r\n int res = 0;\r\n for(int i = s.size()-1; i >= 0; i--){\r\n if(i != 0 && values(s[i]) > values(s[i-1])){\r\n res += (values(s[i]) - values(s[i-1]));\r\n i--;\r\n } else {\r\n res += values(s[i]);\r\n }\r\n }\r\n return res;\r\n }\r\n\r\n int values(char c) {\r\n switch (c){\r\n case 'I':\r\n return 1;\r\n case 'V':\r\n return 5;\r\n case 'X':\r\n return 10;\r\n case 'L':\r\n return 50;\r\n case 'C':\r\n return 100;\r\n case 'D':\r\n return 500;\r\n case 'M':\r\n return 1000;\r\n }\r\n return 0;\r\n }\r\n};"},{"alpha_fraction":0.4258679747581482,"alphanum_fraction":0.46061599254608154,"avg_line_length":19.92751693725586,"blob_id":"3a05376e14e3dd81ec5d177a11cf7c64172d4fbc","content_id":"a5ce1f5e263e22532a2c38c7f1dbce2a442c4e7b","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":39281,"license_type":"no_license","max_line_length":161,"num_lines":1559,"path":"/C/双学位C语言/Cpp1.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\n#include\r\n#include\r\n#include\r\n#include\r\n#include \r\n#define MAX 1000\r\n//**************************************** paramster\r\nstruct USER // 定义用户结构体\r\n{\r\n\tchar id[7]; // 用户编号\r\n\tchar card[5]; // 卡类型\r\n\tlong valid; //有效期/次数\r\n\tchar carid1[7]; //车牌号1\r\n\tchar carid2[7]; //车牌号2\r\n\tchar car1in[13]; //车1入场时间\r\n\tchar car2in[13]; //车2入场时间\r\n}user[MAX];\r\n\r\n//定义月份数组，用于计算天数\r\nint month[13][2]={{0,0},{31,31},{28,29},{31,31},{30,30},{31,31},{30,30},{31,31},{31,31},{30,30},{31,31},{30,30},{31,31}};\r\n//**************************************** function\r\nvoid showmenu();\r\nvoid save(int);\r\nvoid creat();\r\nvoid display();\r\nvoid add();\r\nvoid modify();\r\nvoid carin();\r\nvoid carout();\r\nvoid sort();\r\n//**************************************** main function\r\nint main()\r\n{\r\n\tint select,flag,e;\r\n\tshowmenu();\r\n\tprintf(\"请输入您要进行的操作：\");\r\n\tscanf(\"%d\",&select);\r\n\tprintf(\"\\n\"); \r\n\tdo\t\t\t\t\t\t\t\t\t\t//指令选择\r\n\t{\r\n\t\tif(select>=1&&select<=8)\r\n\t\t{\r\n\t\t\tflag=1;\r\n\t\t\tbreak;\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tflag=0;\r\n\t\t\tprintf(\"input error.choose again.\\n\");\r\n\t\t}\r\n\t}while(!flag);\r\n\twhile(flag) //指令执行\r\n\t{ \r\n\t\tswitch(select)\r\n\t\t{\r\n\t\tcase 1:\r\n\t\t\tprintf(\"创建记录会导致原有记录全部清空，确定继续操作吗(1/0)？\");\r\n\t\t\tscanf(\"%d\",&e);\r\n\t\t\tif(e==1){\r\n\t\t\t\tcreat();\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t\telse\r\n\t\t\t\tbreak;\r\n\t\tcase 2:\r\n\t\t\tadd();\r\n\t\t\tbreak;\r\n\t\t\tcase 3:\r\n\t\t\tdisplay();\r\n\t\t\tbreak;\r\n\t\tcase 4:\r\n\t\t\tcarin();\r\n\t\t\tbreak;\r\n\t\tcase 5:\r\n\t\t\tcarout();\r\n\t\t\tbreak;\r\n\t\tcase 6:\r\n\t\t\tmodify();\r\n\t\t\tbreak;\r\n\t\tcase 7:\r\n\t\t\tsort();\r\n\t\t\tbreak;\r\n\t\tcase 8:\r\n\t\t\texit(0); //exit(0):程序正常运行并退出 \r\n\t\t\tbreak;\r\n\t\tdefault:break;\r\n\t\t};\r\n\t\tprintf(\"\\n\");\r\n\t\tprintf(\"是否继续操作?(1/0):\");\r\n\t\tscanf(\"%d\",&e);\r\n\t\tif(e==1)\r\n\t\t{\r\n\t\t\tflag=1;\r\n\t\t\tsystem(\"cls\");\r\n\t\t\tshowmenu();\r\n\t\t\tprintf(\"请输入您要进行的操作： \");\r\n\t\t\tscanf(\"%d\",&select);\r\n\t\t\tprintf(\"\\n\");\r\n\t\t}\r\n\t\telse\r\n\t\t\tflag=0;\r\n\t};\r\n\tprintf(\"*****感谢您的使用。*****\\n\");\r\n\tprintf(\"\\n\");\r\n\treturn 0;\r\n};\r\n//**************************************** functions \r\n\r\nvoid showmenu() //指令菜单\r\n{\r\n\tprintf( \"====== 校园车辆管理系统 ======\\n\" );\r\n\tprintf(\"======\\t1、创建记录\\t======\\n\");\r\n\tprintf(\"======\\t2、添加记录\\t======\\n\");\r\n\tprintf(\"======\\t3、浏览记录\\t======\\n\");\r\n\tprintf (\"======\\t4、车辆进入\\t======\\n\");\r\n\tprintf (\"======\\t5、车辆离开\\t======\\n\");\r\n\tprintf(\"======\\t6、修改记录\\t======\\n\");\r\n\tprintf (\"======\\t7、排序显示\\t======\\n\");\r\n\tprintf (\"======\\t8、离开系统\\t======\\n\");\r\n\tprintf (\"==============================\\n\") ;\r\n\tprintf(\"如要退出系统，请保存信息！\\n\");\r\n};\r\n\r\nvoid save(int m){ //保存信息\r\n\tint i;\r\n\tFILE* fp;\r\n\tif((fp=fopen(\"car.txt\",\"wb\"))==NULL)\r\n\t{\r\n\t\tprintf(\"cannot open file\\n\");\r\n\t\texit(0);\r\n\t}\r\n\tfor(i=0;i1000);\r\n\r\n\tfor(i=0;i30 || v<=0)\r\n\t\t\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\t}while(!flag);\r\n\t\t\t\t\tuser[i].valid=v;\r\n\t\t\t\t\tstrcpy(user[i].card,\"time\");\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}while(flag);\r\n\r\n\t\t\tstrcpy(user[i].car1in,\"车辆未进入\");\r\n\t\t\tstrcpy(user[i].car2in,\"车辆未进入\");\r\n\t\t\tif((strcmp(user[i].carid2,\"0\"))==0)\r\n\t\t\t\tstrcpy(user[i].car2in,\"无车辆\");\r\n\t\t\tprintf(\"\\n\");\r\n\t\t};\r\n\t};\r\n\tprintf(\"OK!\");\r\n\tsave(m);\r\n};\r\n\r\nvoid add() //添加信息\r\n{ //add函数的所有添加，验证，容错功能都与creat相同\r\n\tFILE* fp;\r\n\tint n,i,j,flag,k,count=0;\r\n\tint m=load();\r\n\tchar uid[7],ucid1[7],ucid2[7],t[7],va[7],tcard[5];\r\n\tlong time,v;\r\n\r\n\tif (isFull()){printf(\"用户已满，不能添加！\");return;} // 判断是否达到容量上限\r\n\r\n\tdo //日期输入\r\n\t{\r\n\t\tflag=1;\r\n\t\tprintf(\"请输入今日日期(例190212): \");\r\n\t\tscanf(\"%s\",&t);\r\n\t\tif(strlen(t)!=6)\r\n\t\t\tflag=0;\r\n\t\tfor(k=0;t[k]!='\\0' && flag;k++)\r\n\t\t\tif(isdigit(t[k])==0)\r\n\t\t\t\tflag=0;\r\n\t}while(!flag);\r\n\ttime=atol(t);\r\n\r\n\tfp=fopen(\"car.txt\",\"a\");\r\n\tdo{\r\n\t\tprintf(\"现在已有%d个用户，最多还可添加%d个用户，要添加几个？\",m,1000-m);\r\n\t\tscanf(\"%d\",&n);\r\n\t}while(n+m>1000);\r\n\tfor(i=m;i<(m+n);i++)\r\n\t{\r\n\t\tdo\t\t\t\t\t\t\t\t\t\t\t//录入用户id并检查是否合理\r\n\t\t{\r\n\t\t\tdo\r\n\t\t\t{\r\n\t\t\t\tflag=1;\r\n\t\t\t\tprintf(\"请输入由字母与数字组成的用户ID：\");\r\n\t\t\t\tscanf(\"%s\",&uid);\r\n\t\t\t\tif(strlen(uid)!=6)\r\n\t\t\t\t\tflag=0;\r\n\t\t\t\tfor(k=0;uid[k]!='\\0' && flag;k++)\r\n\t\t\t\t\tif(isalnum(uid[k])==0)\r\n\t\t\t\t\t\tflag=0;\r\n\t\t\t}while(!flag);\r\n\t\t for(j=0;j30 || v<=0)\r\n\t\t\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\t}while(!flag);\r\n\t\t\t\t\tuser[i].valid=v;\r\n\t\t\t\t\tstrcpy(user[i].card,\"time\");\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}while(flag);\r\n\r\n\t\t\tstrcpy(user[i].car1in,\"车辆未进入\");\r\n\t\t\tstrcpy(user[i].car2in,\"车辆未进入\");\r\n\t\t\tif((strcmp(user[i].carid2,\"0\"))==0)\r\n\t\t\t\tstrcpy(user[i].car2in,\"无车辆\");\r\n\t\t\tprintf(\"\\n\");\r\n\t\t};\r\n\t\tcount+=1;\r\n\t};\r\n\tprintf(\"OK!\\n\");\r\n\tm=m+count;\r\n\tsave(m); //保存\r\n\tfclose(fp);\r\n};\r\n\r\nvoid modify() //修改信息函数\r\n{ \r\n\tint q,f,loc=-1,i,k,j,ss,x; //loc代表用户序号\r\n\tint m=load();\r\n\tchar id[6],cid[6];\r\n\tdo\r\n\t{\r\n\t\tf=1;\r\n\t\tprintf(\"按用户id修改请选择1，按车牌修改请选择2,放弃修改选择3：\");\r\n\t\tscanf(\"%d\",&q);\r\n\t\tif(q>=1&&q<=3)\r\n\t\t{\r\n\t\t\tf=1;\r\n\t\t\tbreak;\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tf=0;\r\n\t\t\tprintf(\"无效的选择!\\n\");\r\n\t\t}\r\n\t}while(!f); \r\n\r\n\tswitch(q)\r\n\t{\r\n\tcase 1:\r\n\t\tprintf(\"请输入要修改的用户id:\");\r\n\t\tscanf(\"%s\",id);\r\n\t\tfor(i=0;i4 || c<1)\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=0;\r\n\t\t\t\t\tprintf(\"无效的选择，请重新选择：\");\r\n\t\t\t\t}\r\n\t\t\t}while(!flag);\r\n\t\t}\r\n\t}\r\n\r\n\tif(!flag){return;}\r\n\r\n\tdo\r\n\t{\r\n\t\tswitch(c)\r\n\t\t{\r\n\t\tcase 1:\r\n\t\t\tdo\r\n\t\t\t{\r\n\t\t\t\tflag=1;\r\n\t\t\t\tdo\r\n\t\t\t\t{\r\n\t\t\t\t\tprintf(\"请输入由数字与字母组成的修改后的用户ID：\");\r\n\t\t\t\t\tscanf(\"%s\",&id);\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tif(strlen(id)!=6){flag=0;}\r\n\t\t\t\t\tfor(k=0;id[k]!='\\0' && flag;k++)\r\n\t\t\t\t\t\tif(isalnum(id[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\tfor(j=0;j30 || v<=0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\tuser[loc].valid=v;\r\n\t\t\t}\t\r\n\t\t\telse if((strcmp(card,\"year\"))==0)\r\n\t\t\t{\r\n\t\t\t\tstrcpy(user[loc].card,card);\r\n\t\t\t\tdo\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tprintf(\"请输入今日日期(例190212): \");\r\n\t\t\t\t\tscanf(\"%s\",&t);\r\n\t\t\t\t\tif(strlen(t)!=6) // 判断日期是否为6位，并且是数字\r\n\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tfor(k=0;t[k]!='\\0' && flag;k++)\r\n\t\t\t\t\t\tif(isdigit(t[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\ttd=atol(t);\t\r\n\t\t\t\tdo\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tprintf(\"请输入有效使用期:\");\r\n\t\t\t\t\tscanf(\"%s\",&va);\r\n\t\t\t\t\tif(strlen(va)!=6)\r\n\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tfor(k=0;va[k]!='\\0' && flag;k++) // 有效期必须大于今日日期\r\n\t\t\t\t\t\tif(isdigit(va[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tif(flag)\r\n\t\t\t\t\t\tv=atol(va);\r\n\t\t\t\t\t\tif(v<=td)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\tuser[loc].valid=v;\r\n\t\t\t};\r\n\t\t\tbreak;\r\n\r\n\t\tcase 3:\r\n\t\t\tif((strcmp(user[loc].card,\"time\"))==0)\r\n\t\t\t{\r\n\t\t\t\tdo //修改有效次数\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tprintf(\"请输入该卡有效次数：\");\r\n\t\t\t\t\tscanf(\"%s\",&va);\r\n\t\t\t\t\tfor(k=0;va[k]!='\\0' && flag;k++) \r\n\t\t\t\t\t\tif(isdigit(va[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tif(flag)\r\n\t\t\t\t\t\tv=atoi(va);\r\n\t\t\t\t\t\tif(v>30 || v<=0)\r\n\t\t\t\t\t\t\tflag=0;\t\t\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\tuser[loc].valid=v;\r\n\t\t\t}\r\n\t\t\telse if((strcmp(user[loc].card,\"year\"))==0)\r\n\t\t\t{\r\n\t\t\t\tdo //修改有效日期\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tprintf(\"请输入今日日期(例190212): \");\r\n\t\t\t\t\tscanf(\"%s\",&t);\r\n\t\t\t\t\tif(strlen(t)!=6)\r\n\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tfor(k=0;t[k]!='\\0' && flag;k++)\r\n\t\t\t\t\t\tif(isdigit(t[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\ttd=atol(t);\t\r\n\t\t\t\tdo\r\n\t\t\t\t{\r\n\t\t\t\t\tflag=1;\r\n\t\t\t\t\tprintf(\"请输入有效使用期:\");\r\n\t\t\t\t\tscanf(\"%s\",&va);\r\n\t\t\t\t\tif(strlen(va)!=6)\r\n\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tfor(k=0;va[k]!='\\0' && flag;k++)\r\n\t\t\t\t\t\tif(isdigit(va[k])==0)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\tif(flag)\r\n\t\t\t\t\t\tv=atol(va);\r\n\t\t\t\t\t\tif(v<=td)\r\n\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t}while(!flag);\r\n\t\t\t\tuser[loc].valid=v;\t\t\r\n\t\t\t};\r\n\t\t\tbreak;\r\n\r\n\t\tcase 4:\r\n\t\t\tif((strcmp(user[loc].carid1,\"0\")!=0) && (strcmp(user[loc].carid2 ,\"0\")!=0)) // 当用户有2辆车\r\n\t\t\t{\r\n\t\t\t\tprintf(\"该用户有2辆车，修改车辆1请按1，修改车辆2请按2，都要修改请按3，放弃修改请按4：\");\r\n\t\t\t\tscanf(\"%d\",&ss);\r\n\t\t\t\tif(ss==1) //修改车1\r\n\t\t\t\t{\r\n\t\t\t\t\tdo\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tdo\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tflag=1;\r\n\t\t\t\t\t\t\tprintf(\"输入由字母与数字组成的修改后的车牌号：\");\r\n\t\t\t\t\t\t\tscanf(\"%s\",&c1id);\t\r\n\t\t\t\t\t\t\tfor(k=0;c1id[k]!='\\0' && flag;k++) // 判断车牌号是否合理\r\n\t\t\t\t\t\t\t\tif(isalnum(c1id[k])==0)\r\n\t\t\t\t\t\t\t\t\tflag=0;\r\n\t\t\t\t\t\t}while(!flag);\r\n\t\t\t\t\t\tif(strcmp(c1id,\"0\")!=0) // 验证车牌号是否存在\r\n\t\t\t\t\t\t{\r\n\t\t\t\t\t\t\tfor(j=0;j0)\r\n hour++;\r\n\thour=hour+24*day;\r\n p=5+3*(hour-1); // 计算费用\r\n return p;\r\n};\r\n\r\nvoid carin(){\r\n\tFILE* fp;\r\n\tint m=load();\r\n\tint i,n,j,k=0,flag,tag,loc=-1,f; //tag代表车1还是车2\r\n\tbool ft=true;\r\n\tchar car[6],time[12],tim[6];\r\n\tchar sto[7];\r\n\tlong v;\r\n\tdo\r\n\t{\r\n\t\tflag=1;\r\n\t\tprintf(\"请输入车牌号：\"); // 确定车牌号\r\n\t\tscanf(\"%s\",car);\r\n\t\tfor(i=0;car[i]!='\\0' && flag;i++)\r\n\t\t{\r\n\t\t\tif(isalnum(car[i])==0)\r\n\t\t\t\tflag=0;\r\n\t\t}\r\n\t}while(!flag);\r\n\tstrcpy(sto,car);\r\n\r\n\tfor(i=0;i=user[loc].valid){ft=false;} \r\n\t\t};\r\n\r\n\t\tif(ft){ // ft是true代表会员没到期\r\n\t\t\tif(tag==1) //tag代表等待进入的是车主的几号车\r\n\t\t\t{\r\n\t\t\t\tif(strcmp(user[loc].car2in,\"vip\")==0)\r\n\t\t\t\t\tstrcpy(user[loc].car1in,time);\r\n\t\t\t\telse if(strcmp(user[loc].car2in,\"无车辆\")==0 || strcmp(user[loc].car2in,\"车辆未进入\")==0)\r\n\t\t\t\t\tstrcpy(user[loc].car1in,\"vip\");\r\n\t\t\t}\r\n\t\t\telse if(tag==2)\r\n\t\t\t{\r\n\t\t\t\tif(strcmp(user[loc].car1in,\"vip\")==0)\r\n\t\t\t\t\tstrcpy(user[loc].car2in,time);\r\n\t\t\t\telse if(strcmp(user[loc].car1in,\"无车辆\")==0 || strcmp(user[loc].car1in,\"车辆未进入\")==0)\r\n\t\t\t\t\tstrcpy(user[loc].car2in,\"vip\");\r\n\t\t\t};\r\n\t\t\tsave(m);\r\n\t\t\tprintf(\"请进入！\");\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tfor(j=loc;j6)\r\n\t\t{\r\n\t\t\tprintf(\"输入不合法，请重新输入：\");\r\n\t\t\tscanf(\"%d\",&s1);\r\n\t\t\tflag=0;\r\n\t\t\tbreak;\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tflag=1;\r\n\t\t\tbreak;\r\n\t\t}\r\n\t}while(!flag);\r\n\r\n\tswitch(s1)\r\n\t{\r\n\tcase 1: // 按id排序\r\n\t\tstd::sort(user,user+m,cmp_id);\r\n\t\tbreak;\r\n\tcase 2: //按卡类型排序\r\n\t\tstd::sort(user,user+m,cmp_card);\r\n\t\tbreak;\r\n\tcase 3: //按有效期排序\r\n\t\tstd::sort(user,user+m,cmp_v);\r\n\t\tbreak;\r\n\tcase 4: // 按车牌号排序\r\n\t\tstd::sort(user,user+m,cmp_car);\r\n\t\tbreak;\r\n\tcase 5: // 按入场时间排序\r\n\t\tstd::sort(user,user+m,cmp_in);\r\n\t\tbreak;\r\n\tdefault:return;\r\n\t}\r\n\tprintf(\"降序排列选择1，升序排列选择2：\");\r\n\tscanf(\"%d\",&s2);\r\n\tif(s2==1)\r\n\t{\r\n\t\tfor(i=m-1;i>=0;i--){\r\n\t\t\tprintf(\"\\t%s,\\t%s,\\t%d,\\t%s,\\t%s,\\t%s,\\t%s\\n\",user[i].id,user[i].card,user[i].valid,user[i].carid1,user[i].carid2,user[i].car1in,user[i].car2in);\r\n\t\t}\r\n\t}\r\n\telse if(s2==2)\r\n\t{\r\n\t\tfor(i=0;i\r\nusing namespace std;\r\n\r\n// LeetCode 938. 二叉搜索树的范围和\r\n\r\nstruct TreeNode {\r\n int val;\r\n TreeNode *left;\r\n TreeNode *right;\r\n TreeNode() : val(0), left(nullptr), right(nullptr) {}\r\n TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\r\n TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\r\n};\r\n\r\nclass Solution {\r\npublic:\r\n void midOrder(TreeNode *root,vector &res){\r\n if(!root) return;\r\n midOrder(root->left, res);\r\n res.push_back(root->val);\r\n midOrder(root->right, res);\r\n }\r\n int rangeSumBST(TreeNode* root, int low, int high) {\r\n int cnt = 0;\r\n vector vec;\r\n midOrder(root,vec);\r\n for(int i = 0; i < vec.size() && vec[i] <= high; i++){\r\n if(vec[i] >= low){\r\n cnt += vec[i];\r\n }\r\n }\r\n return cnt;\r\n }\r\n};\r\n\r\nclass Solution {\r\npublic:\r\n int cnt = 0, l, h;\r\n void midOrder(TreeNode *root){\r\n if(!root) return;\r\n midOrder(root->left);\r\n if(root->val >= l && root->val <= h){\r\n cnt += root->val;\r\n } else if(root->val > h) return;\r\n midOrder(root->right);\r\n }\r\n int rangeSumBST(TreeNode* root, int low, int high) {\r\n l = low, h = high;\r\n midOrder(root);\r\n return cnt;\r\n }\r\n};"},{"alpha_fraction":0.4268292784690857,"alphanum_fraction":0.4481707215309143,"avg_line_length":18.625,"blob_id":"04746ccc57a770036d9337946a961c2a595117b9","content_id":"344e53b55392be5e4ab1aa67bfb7ceefea54c8dc","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":338,"license_type":"no_license","max_line_length":41,"num_lines":16,"path":"/leetcode/leetcode344.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 344. 反转字符串\r\n\r\nclass Solution {\r\npublic:\r\n void reverseString(vector& s) {\r\n int size = s.size();\r\n for(int i = 0; i < size/2; i++){\r\n char c = s[i];\r\n s[i] = s[size-i-1];\r\n s[size-i-1] = c;\r\n }\r\n }\r\n};"},{"alpha_fraction":0.3904418349266052,"alphanum_fraction":0.4138863980770111,"avg_line_length":24.404762268066406,"blob_id":"4854f761625a9da358d54847eb0e18eca7d0e91f","content_id":"7c84e2a4cbc6872e5b4a2562be681f28c1591610","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1117,"license_type":"no_license","max_line_length":59,"num_lines":42,"path":"/leetcode/leetcode2.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 2.两数相加\r\n\r\nstruct ListNode {\r\n int val;\r\n ListNode *next;\r\n ListNode() : val(0), next(nullptr) {}\r\n ListNode(int x) : val(x), next(nullptr) {}\r\n ListNode(int x, ListNode *next) : val(x), next(next) {}\r\n};\r\n\r\nclass Solution {\r\npublic:\r\n ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {\r\n ListNode *head = nullptr, *temp = head;\r\n int carry = 0, sum = 0;\r\n while(l1 != nullptr || l2 != nullptr || carry == 1)\r\n {\r\n if(l1 != nullptr){\r\n sum += l1->val;\r\n l1 = l1->next;\r\n }\r\n if(l2 != nullptr){\r\n sum += l2->val;\r\n l2 = l2->next;\r\n }\r\n sum += carry;\r\n if(!head) {\r\n head = temp = new ListNode(sum%10);\r\n carry = sum/10;\r\n } else {\r\n temp->next = new ListNode(sum%10);\r\n carry = sum/10;\r\n temp = temp->next;\r\n }\r\n sum = 0;\r\n }\r\n return head;\r\n }\r\n};\r\n"},{"alpha_fraction":0.41961851716041565,"alphanum_fraction":0.4291553199291229,"avg_line_length":25.259260177612305,"blob_id":"4d50bacb15da514d08ed2bb375c2fd24a3c0ca80","content_id":"5549e2b4d8771803bc6752e059814bad39b9f973","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":746,"license_type":"no_license","max_line_length":72,"num_lines":27,"path":"/leetcode/leetcode819.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 819. 最常见的单词\r\n\r\nclass Solution {\r\npublic:\r\n string mostCommonWord(string paragraph, vector& banned) {\r\n unordered_mapmp,ban;\r\n string res, tmp;\r\n int cnt = 0;\r\n for(int i = 0; i < banned.size(); i++){\r\n ban[banned[i]]++;\r\n }\r\n for(int i = 0; i <= paragraph.size(); i++){\r\n while(isalpha(paragraph[i])) tmp += tolower(paragraph[i++]);\r\n if(ban[tmp] != 1 && tmp != \"\"){\r\n if(cnt < ++mp[tmp]){\r\n cnt = mp[tmp];\r\n res = tmp;\r\n }\r\n }\r\n tmp.clear();\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.3715847134590149,"alphanum_fraction":0.3846994638442993,"avg_line_length":25.787878036499023,"blob_id":"9ad0bfc88e48acd22bfa1b88a14593156b614b24","content_id":"319d2544e5a22b6f77703d17786e93256f35b940","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":931,"license_type":"no_license","max_line_length":66,"num_lines":33,"path":"/leetcode/leetcode16.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 16.最接近的三数之和\r\n\r\nclass Solution {\r\npublic:\r\n int threeSumClosest(vector& nums, int target) {\r\n int res = 20000;\r\n sort(nums.begin(), nums.end());\r\n int i = 0;\r\n while (i < nums.size())\r\n {\r\n int left = i+1, right = nums.size()-1;\r\n while(left < right)\r\n {\r\n int temp = nums[i] + nums[left] + nums[right];\r\n if(abs(temp-target) < abs(res-target)){\r\n res = temp;\r\n }\r\n if(temp == target){\r\n i = nums.size();\r\n break;\r\n } else if(temp > target){\r\n right--;\r\n } else left++;\r\n }\r\n while(i < nums.size()-2 && nums[i] == nums[i+1]){i++;}\r\n i++;\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.4316239356994629,"alphanum_fraction":0.44871795177459717,"avg_line_length":22.736841201782227,"blob_id":"684034e1811754607e34254aaf89f46f29183b6c","content_id":"0ce763531aba0f3686fe139e8e9b8d827be5609a","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":486,"license_type":"no_license","max_line_length":46,"num_lines":19,"path":"/leetcode/leetcode657.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 657. 机器人能否返回原点\r\n\r\nclass Solution {\r\npublic:\r\n bool judgeCircle(string moves) {\r\n int row = 0, col = 0;\r\n for(int i = 0; i < moves.size(); i++){\r\n if(moves[i] == 'R') row++;\r\n else if(moves[i] == 'L') row--;\r\n else if(moves[i] == 'U') col++;\r\n else col--;\r\n }\r\n if(row == 0 && col == 0) return true;\r\n return false;\r\n }\r\n};"},{"alpha_fraction":0.3288690447807312,"alphanum_fraction":0.3333333432674408,"avg_line_length":24.39215660095215,"blob_id":"d533ac1d644d8329ed3ac5e5a26b650146c86736","content_id":"ce0aea992e93d7cba1892090995bbff5ec7ad589","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":1354,"license_type":"no_license","max_line_length":65,"num_lines":51,"path":"/leetcode/leetcode20.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 20. 有效的括号\r\n\r\nclass Solution {\r\npublic:\r\n bool isValid(string s) {\r\n stack stk;\r\n stk.push(s[0]);\r\n for(int i = 1;i < s.length();i++){\r\n if(!stk.empty() && check(stk.top(), s[i])) stk.pop();\r\n else stk.push(s[i]);\r\n }\r\n if(!stk.empty()) return true;\r\n else return false;\r\n\r\n }\r\n bool check(char a, char b){\r\n if(a == '(' && b ==')') return true;\r\n else if(a == '[' && b == ']') return true;\r\n else if(a == '{' && b == '}') return true;\r\n else return false;\r\n }\r\n};\r\n\r\n// class Solution {\r\n// public:\r\n// bool isValid(string s) {\r\n// if(s.size()==0)return true;\r\n// stacks_;\r\n// int i=0;\r\n// while(s[i]){\r\n// if(!s_.empty()){\r\n// char a=s_.top();\r\n// if(s[i]==')'&&a=='(')\r\n// s_.pop();\r\n// else if(s[i]=='}'&&a=='{')\r\n// s_.pop();\r\n// else if(s[i]==']'&&a=='[')\r\n// s_.pop();\r\n// else\r\n// s_.push(s[i]);\r\n// }\r\n// else\r\n// s_.push(s[i]);\r\n// i++;\r\n// }\r\n// return s_.empty();\r\n// }\r\n// };"},{"alpha_fraction":0.46123260259628296,"alphanum_fraction":0.47514909505844116,"avg_line_length":22.047618865966797,"blob_id":"4041327d8f81301d6cc0491627a97cab5613b93d","content_id":"3efe70b6d34a0034870204ce0bb3efe0eee0a095","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":521,"license_type":"no_license","max_line_length":58,"num_lines":21,"path":"/leetcode/leetcode686.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 686. 重复叠加字符串匹配\r\n\r\nclass Solution {\r\npublic:\r\n int repeatedStringMatch(string a, string b) {\r\n if(a.empty() || b.empty()) return -1;\r\n int res = 1;\r\n string temp = a;\r\n int aSize = a.size(), bSize = b.size();\r\n while (temp.find(b) == string::npos)\r\n {\r\n if(temp.size() > aSize * 2 + bSize) return -1;\r\n temp += a;\r\n res++;\r\n }\r\n return res;\r\n }\r\n};"},{"alpha_fraction":0.4554242789745331,"alphanum_fraction":0.47878625988960266,"avg_line_length":27.72800064086914,"blob_id":"1e9b3c712a7432dd270e0a0940fafbda2ce8d903","content_id":"73b3b84d04c6276f45d01bbb506e6271a0b0aeb0","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"Python","length_bytes":4046,"license_type":"no_license","max_line_length":101,"num_lines":125,"path":"/python/SA.py","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"import numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\n# 计算函数 f(x,y) = 5cos(xy) + xy + y^3 的最小值\r\n# x ∈ [ -5, 5 ] y ∈ [-5，5 ]\r\nclass Particle:\r\n def __init__(self, res):\r\n self.res = res\r\n self.score = -1\r\n\r\n\r\nclass SA:\r\n def __init__(self, scoreFunc):\r\n # 评分函数\r\n self.scoreFunc = scoreFunc\r\n # 退火速率\r\n self.lamda = 0.9\r\n # 初始温度\r\n self.T = 1000\r\n # 终止条件\r\n self.Tmin = 1\r\n # 解集\r\n self.Solutions = []\r\n # 解数量\r\n self.solutionNums = 20\r\n # 最优解\r\n self.Optimal = None\r\n # 局部最优解\r\n self.localOptimal = None\r\n # 每个 T的迭代次数\r\n self.iterTimes = 100\r\n # 系数 K\r\n self.K = 1\r\n\r\n self.initialize()\r\n\r\n # 初始化\r\n def initialize(self):\r\n self.Solutions = []\r\n self.T = 1000\r\n # 根据变量范围生成初始解\r\n for i in range(self.solutionNums):\r\n res = [np.random.uniform(-5, 5), np.random.uniform(-5, 5)]\r\n particle = Particle(res)\r\n self.Solutions.append(particle)\r\n\r\n # 评价解集\r\n def score(self):\r\n self.localOptimal = self.Solutions[0]\r\n for particle in self.Solutions:\r\n # 1. 计算能量\r\n particle.score = self.scoreFunc(particle)\r\n # 2. 更新全局最优解\r\n if particle.score > self.Optimal.score:\r\n self.Optimal = particle\r\n # 3. 更新局部最优解\r\n if particle.score > self.localOptimal.score:\r\n self.localOptimal = particle\r\n\r\n # 交换概率\r\n def Probability(self, p_old, p_new):\r\n if p_new.score > p_old.score:\r\n return 1\r\n else:\r\n return np.exp((p_old.score - p_new.score) / (self.K * self.T))\r\n\r\n # 在当前解附近搜索新解\r\n def search(self, p):\r\n x = sorted([-5, 5, p.res[0] + np.random.uniform(-1, 1)])[1]\r\n y = sorted([-5, 5, p.res[1] + np.random.uniform(-1, 1)])[1]\r\n p_new = Particle([x, y])\r\n return p_new\r\n\r\n # 迭代过程\r\n def iteration(self):\r\n n = 0\r\n while n <= self.iterTimes:\r\n # 1. 计算解集评分\r\n self.score()\r\n # 2. 扰动解集\r\n for i in range(self.solutionNums):\r\n p = self.Solutions[i]\r\n p_new = self.search(p)\r\n # 3. 依概率更新解集\r\n if (np.random.random() < self.Probability(p, p_new)):\r\n self.Solutions[i] = p_new\r\n n += 1\r\n\r\n # 降温\r\n def cooling(self):\r\n # 初始化\r\n g_scores, l_scores = [], []\r\n self.Optimal = self.Solutions[0]\r\n # 1. 判断终止条件\r\n while self.T > self.Tmin:\r\n # 2. 该温度下迭代\r\n self.iteration()\r\n # 3. 记录当前温度下的局部最优解\r\n print(f'{round(self.T, 5)}:{-round(self.localOptimal.score, 5)}:{self.localOptimal.res}')\r\n g_scores.append(-round(self.Optimal.score, 4))\r\n l_scores.append(-round(self.localOptimal.score, 4))\r\n # 4. 降温\r\n self.T *= self.lamda\r\n print(f\"最优解：{self.Optimal.res}:{-round(self.Optimal.score, 4)}\")\r\n self.display(g_scores, l_scores)\r\n\r\n # 结果可视化\r\n def display(self, res1, res2):\r\n fig, ax = plt.subplots(1, 2, figsize=(10, 4))\r\n ax[0].plot(res1, color='lightcoral')\r\n ax[0].set_title(\"Global Optimal\", color='r')\r\n ax[0].set_xlabel(\"iteration\")\r\n ax[0].set_ylabel(\"score\")\r\n\r\n ax[1].plot(res2, color='#4b5cc4')\r\n ax[1].set_title(\"Local Optimal\", color='r')\r\n ax[1].set_xlabel(\"iteration\")\r\n ax[1].set_ylabel(\"score\")\r\n plt.show()\r\n\r\n\r\nif __name__ == \"__main__\":\r\n sa = SA(lambda p: -(5 * np.cos(p.res[0] * p.res[1]) + p.res[0] * p.res[1] + pow(p.res[1], 3)))\r\n sa.cooling()\r\n\r\n \r\n"},{"alpha_fraction":0.38923075795173645,"alphanum_fraction":0.41846153140068054,"avg_line_length":20.482759475708008,"blob_id":"f214009015b61657dbc92dd80552339b61455a40","content_id":"a4db3ca5978961b95defd92eb7192499804b4d4d","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":658,"license_type":"no_license","max_line_length":60,"num_lines":29,"path":"/leetcode/leetcode7.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 7.整数翻转\r\n\r\nclass Solution {\r\npublic:\r\n int reverse(int x){\r\n queue que;\r\n int temp,count=0;\r\n long long result=0;\r\n bool flag = false;\r\n if(x<0){flag = true;}\r\n while (x != 0){\r\n temp = x%10;\r\n que.push(temp);\r\n x = x/10;\r\n count++;\r\n }\r\n while (!que.empty()){\r\n result = result + que.front()*(pow(10,--count));\r\n que.pop();\r\n }\r\n if(result>=pow(2,31)-1 || result<=-pow(2,31)){\r\n return 0;\r\n }\r\n return result;\r\n }\r\n};"},{"alpha_fraction":0.4656991958618164,"alphanum_fraction":0.48218998312950134,"avg_line_length":24.172412872314453,"blob_id":"bd17e0fdab18c0ae792735721511dabfc06a524d","content_id":"db20962785e06daa1e4aae3de1032df30a05ef22","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":2118,"license_type":"no_license","max_line_length":61,"num_lines":58,"path":"/leetcode/leetcode3.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 3.无重复最长子串\r\n\r\n// Solution 1\r\n// 从第一位扫描，每次将未出现过的字符保存进 map\r\n// 当发现重复字符，更新最大长度，从该重复字符第一次出现的位置的下一位开始扫描\r\n// 这么写结果的 时间复杂度、空间复杂度都很高\r\nclass Solution {\r\npublic:\r\n int lengthOfLongestSubstring(string s) {\r\n if (s == \"\") return 0;\r\n map mp; // 字符、索引\r\n int res = 0, MAX_Length = 0, i = 0;\r\n int length = s.size();\r\n while (i < length) {\r\n map:: iterator iter = mp.find(s[i]);\r\n if (iter != mp.end()) { // 出现重复字符\r\n i = iter->second + 1;\r\n mp.clear();\r\n MAX_Length = max(res, MAX_Length);\r\n res = 0;\r\n } else {\r\n mp[s[i]] = i;\r\n res += 1;\r\n i++;\r\n }\r\n }\r\n return max(res, MAX_Length);\r\n }\r\n};\r\n\r\n// Solution 2\r\n// 采用滑动窗口\r\n/* \r\n s：输入的字符串\r\n i：最长子字符串的起点数组下标\r\n j：最长子字符串的终点数组下标\r\n ans：最长子字符串长度\r\n str[]：下标(序号)表示 \"字符\"，储存的值表示该字符位置+1\r\n*/\r\nint lengthOfLongestSubstring(string s) {\r\n vector str(128,0); // 初始将所有值都设为0\r\n int i = 0, ans = 0;\r\n for (int j = 0;j < s.size();j++) // 在整个字符串长度之内\r\n {\r\n /* \r\n 1.如果当前字符在之前没出现过，那么其值肯定是0，不会改变当前扫描起点\r\n 2.如果s[j]出现过，则其值一定大于0：如果起点i小于str[s[j]]，说明重复的字符在当前的子串内，\r\n 此时应该切换扫描起点至s[j]上一次出现位置的下一位(str[s[j]]储存的值)，重新扫描\r\n */\r\n i = max(i, str[s[j]]); \r\n str[s[j]] = j + 1; // 当前字符的坐标更新\r\n ans = max(ans, j-i+1); // 比较哪个距离更大\r\n }\r\n return ans;\r\n}"},{"alpha_fraction":0.43491125106811523,"alphanum_fraction":0.4467455744743347,"avg_line_length":18,"blob_id":"5ade1709c7ca452379d5087453161af8690399e2","content_id":"ae4da83242f6cae056c7528cc245c6522a9d012b","detected_licenses":[],"is_generated":false,"is_vendor":false,"language":"C++","length_bytes":346,"license_type":"no_license","max_line_length":51,"num_lines":17,"path":"/leetcode/leetcode27.cpp","repo_name":"MoMiJ1/Fungus","src_encoding":"UTF-8","text":"#include\r\nusing namespace std;\r\n\r\n// LeetCode 27.移出元素\r\n\r\nclass Solution {\r\npublic:\r\n int removeElement(vector& nums, int val) {\r\n int k = 0;\r\n for(int i = 0;i\\r\\nusing namespace std;\\r\\n\\r\\n// LeetCode 9. 回文数\\r\\n\\r\\nclass Solution {\\r\\npublic:\\r\\n bool isPalindrome(int x) {\\r\\n queue que;\\r\\n int count=0;\\r\\n long a=0;\\r\\n long b = x;\\r\\n if (x<0){\\r\\n return false;\\r\\n }\\r\\n while (x!=0){\\r\\n que.push(x%10);\\r\\n x = x/10;\\r\\n count++;\\r\\n }\\r\\n while (!que.empty()){\\r\\n a = a+que.front()*pow(10,--count);\\r\\n que.pop();\\r\\n }\\r\\n if (a-b == 0){ return true;}\\r\\n return false;\\r\\n }\\r\\n};\"\n },\n {\n \"alpha_fraction\": 0.4955357015132904,\n \"alphanum_fraction\": 0.5106026530265808,\n \"avg_line_length\": 36.12765884399414,\n \"blob_id\": \"734ae03af3791214ec2d4cbe8a4d20f66bd569c1\",\n \"content_id\": \"e475f293153eda5c122349f803a4a047fad2c275\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 3782,\n \"license_type\": \"no_license\",\n \"max_line_length\": 107,\n \"num_lines\": 94,\n \"path\": \"/python/PSO.py\",\n \"repo_name\": \"MoMiJ1/Fungus\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import numpy as np\\r\\nimport matplotlib.pyplot as plt\\r\\n\\r\\n\\r\\n# 计算函数 f(x,y) = 5cos(xy) + xy + y^3 的最小值\\r\\n# x ∈ [ -5, 5 ] y ∈ [-5，5 ]\\r\\n\\r\\n\\r\\nclass PSO:\\r\\n def __init__(self, iterTimes, groupSize, varNums, bound):\\r\\n '''\\r\\n :param iterTimes: 迭代次数\\r\\n :param groupSize: 解集大小\\r\\n :param varNums: 变量数量\\r\\n :param bound: 变量约束 [[x_min, y_min, z_min...] [x_max, y_max, z_max]]\\r\\n '''\\r\\n self.iterTimes = iterTimes\\r\\n self.groupSize = groupSize\\r\\n self.varNums = varNums\\r\\n self.bound = bound\\r\\n\\r\\n self.p_sites = np.zeros((self.groupSize, self.varNums))\\r\\n self.p_v = np.zeros((self.groupSize, self.varNums))\\r\\n self.p_optimal = np.zeros((self.groupSize, self.varNums))\\r\\n self.Optimal = np.zeros((1, self.varNums))\\r\\n self.alpha1, self.alpha2 = 1, 1\\r\\n self.weight = 0.5\\r\\n\\r\\n self.initialize()\\r\\n\\r\\n def initialize(self):\\r\\n temp_score = -1\\r\\n for i in range(self.groupSize):\\r\\n for j in range(self.varNums):\\r\\n # 1. 随机初始化粒子位置与速度\\r\\n self.p_sites[i][j] = np.random.uniform(self.bound[0][j], self.bound[1][j])\\r\\n self.p_v[i][j] = np.random.uniform(0, 1)\\r\\n # 2. 初始化粒子最好位置\\r\\n self.p_optimal[i] = self.p_sites[i]\\r\\n # 3. 评价当前粒子最好位置\\r\\n score = self.fitness(self.p_optimal[i])\\r\\n # 4. 更新全局最好位置\\r\\n if score > temp_score:\\r\\n self.Optimal = self.p_optimal[i]\\r\\n temp_score = score\\r\\n\\r\\n # 自定义函数\\r\\n def fitness(self, values):\\r\\n return (5 * np.cos(values[0] * values[1]) + values[0] * values[1] + pow(values[1], 3))\\r\\n\\r\\n # 更新位置与速度\\r\\n def update_params(self, group_size):\\r\\n for i in range(group_size):\\r\\n # 1. 更新速度\\r\\n self.p_v[i] = self.weight * self.p_v[i] + \\\\\\r\\n self.alpha1 * np.random.uniform(0, 1) * (self.p_optimal[i] - self.p_sites[i]) + \\\\\\r\\n self.alpha2 * np.random.uniform(0, 1) * (self.Optimal - self.p_sites[i])\\r\\n # 2. 更新位置\\r\\n self.p_sites[i] = self.p_sites[i] + self.p_v[i]\\r\\n # 3. 防止变量越界\\r\\n for j in range(self.varNums):\\r\\n if self.p_sites[i][j] < self.bound[0][j]:\\r\\n self.p_sites[i][j] = self.bound[0][j]\\r\\n if self.p_sites[i][j] > self.bound[1][j]:\\r\\n self.p_sites[i][j] = self.bound[1][j]\\r\\n # 4. 更新最优位置\\r\\n if self.fitness(self.p_sites[i]) > self.fitness(self.p_optimal[i]):\\r\\n self.p_optimal[i] = self.p_sites[i]\\r\\n if self.fitness(self.p_sites[i]) > self.fitness(self.Optimal):\\r\\n self.Optimal = self.p_sites[i]\\r\\n\\r\\n def run(self):\\r\\n scores = []\\r\\n self.tempOptimal = np.zeros((1, self.varNums))[0]\\r\\n for i in range(self.iterTimes):\\r\\n self.update_params(self.groupSize)\\r\\n scores.append(-self.fitness(self.Optimal))\\r\\n if self.fitness(self.Optimal) > self.fitness(self.tempOptimal):\\r\\n self.tempOptimal = self.Optimal.copy()\\r\\n print(f\\\"{i}代 : {-self.fitness(self.tempOptimal)} : {self.tempOptimal}\\\")\\r\\n self.display(scores)\\r\\n\\r\\n def display(self, data):\\r\\n plt.plot(range(self.iterTimes), data, color='lightcoral')\\r\\n plt.title(\\\"iteration - score\\\", color='r')\\r\\n plt.xlabel(\\\"iteration\\\")\\r\\n plt.ylabel(\\\"score\\\")\\r\\n plt.show()\\r\\n\\r\\n\\r\\nif __name__ == \\\"__main__\\\":\\r\\n bound = [[-5, -5], [5, 5]]\\r\\n pso = PSO(iterTimes=50, groupSize=20, varNums=2, bound=bound)\\r\\n pso.run()\\r\\n\"\n },\n {\n \"alpha_fraction\": 0.41992881894111633,\n \"alphanum_fraction\": 0.43505337834358215,\n \"avg_line_length\": 20.078432083129883,\n \"blob_id\": \"76e9803f12d0ccc83b06112a315247da113a2d49\",\n \"content_id\": \"20907660afc4e8e9a8ad1077af2a112044c992af\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C++\",\n \"length_bytes\": 1156,\n \"license_type\": \"no_license\",\n \"max_line_length\": 55,\n \"num_lines\": 51,\n \"path\": \"/leetcode/leetcode26_27_28.cpp\",\n \"repo_name\": \"MoMiJ1/Fungus\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#include\\r\\nusing namespace std;\\r\\n\\r\\n// LeetCode 26.删除有序数组的重复项\\r\\n\\r\\nclass Solution {\\r\\npublic:\\r\\n int removeDuplicates(vector& nums) {\\r\\n int i = 0;\\r\\n for (int j = 1; j < nums.size(); j++) {\\r\\n if (nums[j] == nums[j-1]){\\r\\n j--;\\r\\n nums.erase(nums.begin()+j);\\r\\n }\\r\\n }\\r\\n int k = nums.size();\\r\\n return k;\\r\\n }\\r\\n};\\r\\n\\r\\n// LeetCode 27.移除元素\\r\\n\\r\\nclass Solution {\\r\\npublic:\\r\\n int removeElement(vector& nums, int val) {\\r\\n int k = 0;\\r\\n for(int i = 0;i haystack.size()){return -1;}\\r\\n for (int i = 0; i < haystack.size()-l+1; i++) {\\r\\n if (haystack.compare(i,l,needle)==0) {\\r\\n return i;\\r\\n }\\r\\n }\\r\\n return -1;\\r\\n }\\r\\n};\"\n },\n {\n \"alpha_fraction\": 0.4502212405204773,\n \"alphanum_fraction\": 0.49668142199516296,\n \"avg_line_length\": 32.846153259277344,\n \"blob_id\": \"28f99fe7a74016f29c0e93d4ef24528287f799ec\",\n \"content_id\": \"8eb6626bf652fbce216bb0b7a5c750f0e5bf0b7c\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"C++\",\n \"length_bytes\": 914,\n \"license_type\": \"no_license\",\n \"max_line_length\": 65,\n \"num_lines\": 26,\n \"path\": \"/leetcode/leetcode539.cpp\",\n \"repo_name\": \"MoMiJ1/Fungus\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"#include\\r\\nusing namespace std;\\r\\n# define DAY 1440\\r\\n\\r\\n// LeetCode 539.最小时间差\\r\\n\\r\\nclass Solution {\\r\\npublic:\\r\\n int findMinDifference(vector& timePoints) {\\r\\n sort(timePoints.begin(),timePoints.end());\\r\\n int res = 1440;\\r\\n for(int i = 0; i < timePoints.size()-1; i++){\\r\\n int h1 = atoi(timePoints[i].substr(0,2).c_str());\\r\\n int m1 = atoi(timePoints[i].substr(3,2).c_str());\\r\\n for(int j = i + 1; j < timePoints.size(); j++){\\r\\n if(timePoints[i] == timePoints[j]) return 0;\\r\\n int h2 = atoi(timePoints[j].substr(0,2).c_str());\\r\\n int m2 = atoi(timePoints[j].substr(3,2).c_str());\\r\\n int tmp1 = abs(h2*60+m2-h1*60-m1);\\r\\n int tmp2 = DAY - tmp1;\\r\\n if(min(tmp1,tmp2) < res) res = min(tmp1,tmp2);\\r\\n }\\r\\n }\\r\\n return res;\\r\\n }\\r\\n};\"\n },\n {\n \"alpha_fraction\": 0.5071805119514465,\n \"alphanum_fraction\": 0.5268133282661438,\n \"avg_line_length\": 29.4228572845459,\n \"blob_id\": \"64c82c35ccba02240b1b234bc00b13f70667f829\",\n \"content_id\": \"fa69bc1e5fc7ede17d5819e61ddeb4e151823e1a\",\n \"detected_licenses\": [],\n \"is_generated\": false,\n \"is_vendor\": false,\n \"language\": \"Python\",\n \"length_bytes\": 6269,\n \"license_type\": \"no_license\",\n \"max_line_length\": 107,\n \"num_lines\": 175,\n \"path\": \"/python/gui.py\",\n \"repo_name\": \"MoMiJ1/Fungus\",\n \"src_encoding\": \"UTF-8\",\n \"text\": \"import sys\\r\\nif sys.version_info.major < 3:\\r\\n import Tkinter\\r\\nelse:\\r\\n import tkinter as Tkinter\\r\\n\\r\\n\\r\\n'''\\r\\n 【基本控件】\\r\\n 1. Radiobutton(root, text, variable, value)\\r\\n :param root: Tk\\r\\n :param text: 选项的文本\\r\\n :param variable: 绑定选择的变量\\r\\n :param value: 该选项对应的值\\r\\n\\r\\n 2. Button(root, text, command)\\r\\n :param root: Tk\\r\\n :param text: 选项的文本\\r\\n :param command: 点击时调用的函数\\r\\n\\r\\n 3. Checkbutton(root, text, variable)\\r\\n :param root: Tk\\r\\n :param text: 选项的文本\\r\\n :param variable: 绑定选择变量\\r\\n\\r\\n 4. Scale(root, label, length, from_, to, resolution, variable, orient)\\r\\n :param root: Tk\\r\\n :param label: 显示的名称\\r\\n :param length: 滑块长度\\r\\n :param from_: 左边界\\r\\n :param to: 右边界\\r\\n :param resolution: 步长\\r\\n :param variable: 绑定选择变量\\r\\n :param orient: 滑动方向\\r\\n \\r\\n 5. Label(root, text, textvariable, font, justify, foreground, underline, anchor, width, height, bg)\\r\\n :param text: 静态文本\\r\\n :param textvariable: 动态文本\\r\\n :param font: 字体，格式为一个tuple (font_name, font_size)\\r\\n :param justify: 对齐方式，有:['center','left','right']\\r\\n :param foreground: 文本颜色\\r\\n :param underline: 单个字符添加下划线，传入值为目标字符串的索引\\r\\n :param anchor: 位置，可选(n,s,w,e,ne,nw,sw,se,center)，eswn对应东南西北\\r\\n \\r\\n 6. grid(row, column)\\r\\n :param row: 控件所在的行位置\\r\\n :param column:控件所在的列位置 \\r\\n'''\\r\\ndef basic_widget(method=\\\"pack\\\"):\\r\\n def initUI(name='gui', size='900x600'):\\r\\n root = Tkinter.Tk()\\r\\n root.title(name)\\r\\n root.geometry(size)\\r\\n return root\\r\\n\\r\\n def click(i):\\r\\n if i == 1:\\r\\n print('选择：', choose_list[choose.get()])\\r\\n elif i == 2:\\r\\n selects = []\\r\\n for k, v in abcd.items():\\r\\n if v.get(): selects.append(k)\\r\\n print(\\\"选择：\\\", selects)\\r\\n elif i == 3:\\r\\n print(factor.get())\\r\\n\\r\\n\\r\\n if __name__ == \\\"__main__\\\":\\r\\n root = initUI()\\r\\n\\r\\n # 单选\\r\\n choose_list = ['A', 'B', 'C', 'D']\\r\\n choose = Tkinter.IntVar()\\r\\n choose.set(0)\\r\\n for i, val in enumerate(choose_list):\\r\\n Tkinter.Radiobutton(root, text=val, variable=choose, value=i).pack()\\r\\n Tkinter.Button(root, text=\\\"单选\\\", command=click(1)).pack()\\r\\n\\r\\n # 复选\\r\\n a, b, c, d = Tkinter.BooleanVar(), Tkinter.BooleanVar(), Tkinter.BooleanVar(), Tkinter.BooleanVar()\\r\\n abcd = {'A': a, 'B': b, 'C': c, 'D': d}\\r\\n for k, v in abcd.items():\\r\\n v.set(0)\\r\\n Tkinter.Checkbutton(root, text=k, variable=v).pack()\\r\\n Tkinter.Button(root, text=\\\"复选\\\", command=click(2)).pack()\\r\\n\\r\\n # 滑块\\r\\n factor = Tkinter.DoubleVar()\\r\\n factor.set(0.800)\\r\\n Tkinter.Scale(root, label='滑块', length=200, from_=0., to=1.0, resolution=0.001,\\r\\n variable=factor, orient=Tkinter.HORIZONTAL).pack()\\r\\n Tkinter.Button(root, text='输出', command=click(3)).pack()\\r\\n\\r\\n # 文本显示\\r\\n text = Tkinter.StringVar()\\r\\n text.set(\\\"This is a text;这是个文本。\\\")\\r\\n label = Tkinter.Label(root,textvariable=text,font=('宋体',15),foreground='black',\\r\\n underline=3,anchor='nw',width=30,height=2,bg='white')\\r\\n\\r\\n # 文本输入\\r\\n e = Tkinter.Entry(root)\\r\\n e.pack()\\r\\n Tkinter.Button(root, text=\\\"修改\\\").pack()\\r\\n\\r\\n root.mainloop()\\r\\n\\r\\n\\r\\n\\r\\n'''\\r\\n 【画布】\\r\\n 1. Canvas(root, bg, width, height)\\r\\n :param root: Tk\\r\\n :param bg: 画布背景颜色\\r\\n :param width: 画布宽\\r\\n :param heigth: 画布高\\r\\n \\r\\n 2. create_line(point, arrow, arrowshape, dash, width)\\r\\n :param point: 要连线的点的坐标\\r\\n :param arrow: 箭头，first--箭头在起始点，last--箭头在目标点，both--双箭头\\r\\n :param arrowshape: 箭头大小，传入一个tuple，如--(3,4,5)\\r\\n :param dash: 是否绘制虚线，默认False\\r\\n :param width: 线的宽度\\r\\n :param tags: 标签\\r\\n \\r\\n 3. create_oval(point, fill, outline, width)\\r\\n :param point: 椭圆的外接矩形的左上角和右下角坐标\\r\\n :param fill: 内部填充颜色\\r\\n :param outline: 边颜色\\r\\n :param width: 边宽\\r\\n :param tags: 标签\\r\\n \\r\\n 4. create_text(point, text, font)\\r\\n :param point: 文字所在点\\r\\n :param text: 文本内容\\r\\n :param font: 使用字体，传入tuple，如：(\\\"宋体\\\",12)\\r\\n \\r\\n 5. bind(event, handler)\\r\\n :param event: \\r\\n 常用的:\\r\\n (1) 26个字母，如: 'n','s'等，直接按键盘对应的键就可\\r\\n (2) :鼠标左键点击, ![\\\"glalteva\\\"/](\\\"https://avatars2.githubusercontent.com/u/14296143?v=4?s=100\\\")
![\\\"adswa\\\"/](\\\"https://avatars1.githubusercontent.com/u/29738718?v=4?s=100\\\")
![\\\"chrhaeusler\\\"/](\\\"https://avatars0.githubusercontent.com/u/8115807?v=4?s=100\\\")
![\\\"soichih\\\"/](\\\"https://avatars3.githubusercontent.com/u/923896?v=4?s=100\\\")
![\\\"mvdoc\\\"/](\\\"https://avatars1.githubusercontent.com/u/6150554?v=4?s=100\\\")
![\\\"mih\\\"/](\\\"https://avatars1.githubusercontent.com/u/136479?v=4?s=100\\\")
![\\\"yarikoptic\\\"/](\\\"https://avatars3.githubusercontent.com/u/39889?v=4?s=100\\\")
![\\\"loj\\\"/](\\\"https://avatars2.githubusercontent.com/u/15157717?v=4?s=100\\\")
![\\\"feilong\\\"/](\\\"https://avatars2.githubusercontent.com/u/2242261?v=4?s=100\\\")
![\\\"jhpoelen\\\"/](\\\"https://avatars2.githubusercontent.com/u/1084872?v=4?s=100\\\")
![\\\"andycon\\\"/](\\\"https://avatars1.githubusercontent.com/u/3965889?v=4?s=100\\\")
![\\\"nicholsn\\\"/](\\\"https://avatars3.githubusercontent.com/u/463344?v=4?s=100\\\")
![\\\"adelavega\\\"/](\\\"https://avatars0.githubusercontent.com/u/2774448?v=4?s=100\\\")
![\\\"kskyten\\\"/](\\\"https://avatars0.githubusercontent.com/u/4163878?v=4?s=100\\\")
![\\\"TheChymera\\\"/](\\\"https://avatars2.githubusercontent.com/u/950524?v=4?s=100\\\")
![\\\"effigies\\\"/](\\\"https://avatars0.githubusercontent.com/u/83442?v=4?s=100\\\")
![\\\"jgors\\\"/](\\\"https://avatars1.githubusercontent.com/u/386585?v=4?s=100\\\")
![\\\"debanjum\\\"/](\\\"https://avatars1.githubusercontent.com/u/6413477?v=4?s=100\\\")
![\\\"nellh\\\"/](\\\"https://avatars3.githubusercontent.com/u/11369795?v=4?s=100\\\")
![\\\"emdupre\\\"/](\\\"https://avatars3.githubusercontent.com/u/15017191?v=4?s=100\\\")
![\\\"aqw\\\"/](\\\"https://avatars0.githubusercontent.com/u/765557?v=4?s=100\\\")
![\\\"vsoch\\\"/](\\\"https://avatars0.githubusercontent.com/u/814322?v=4?s=100\\\")
![\\\"kyleam\\\"/](\\\"https://avatars2.githubusercontent.com/u/1297788?v=4?s=100\\\")
![\\\"driusan\\\"/](\\\"https://avatars0.githubusercontent.com/u/498329?v=4?s=100\\\")
![\\\"overlake333\\\"/](\\\"https://avatars1.githubusercontent.com/u/28018084?v=4?s=100\\\")
![\\\"akeshavan\\\"/](\\\"https://avatars0.githubusercontent.com/u/972008?v=4?s=100\\\")
![\\\"jwodder\\\"/](\\\"https://avatars1.githubusercontent.com/u/98207?v=4?s=100\\\")
![\\\"bpoldrack\\\"/](\\\"https://avatars2.githubusercontent.com/u/10498301?v=4?s=100\\\")
![\\\"yetanothertestuser\\\"/](\\\"https://avatars0.githubusercontent.com/u/19335420?v=4?s=100\\\")
![\\\"Christian](\\\"https://avatars.githubusercontent.com/u/17925232?v=4?s=100\\\")
![\\\"Matt](\\\"https://avatars.githubusercontent.com/u/170026?v=4?s=100\\\")
![\\\"Mika](\\\"https://avatars.githubusercontent.com/u/7226087?v=4?s=100\\\")
![\\\"Robin](\\\"https://avatars.githubusercontent.com/u/1301158?v=4?s=100\\\")
![\\\"Sin](\\\"https://avatars.githubusercontent.com/u/7570456?v=4?s=100\\\")
![\\\"Michael](\\\"https://avatars.githubusercontent.com/u/49207524?v=4?s=100\\\")
![\\\"Remi](\\\"https://avatars.githubusercontent.com/u/6961185?v=4?s=100\\\")
![\\\"Michał](\\\"https://avatars.githubusercontent.com/u/11985212?v=4?s=100\\\")
![\\\"Basile\\\"/](\\\"https://avatars.githubusercontent.com/u/1155388?v=4?s=100\\\")
![\\\"Taylor](\\\"https://avatars.githubusercontent.com/u/28018084?v=4?s=100\\\")
![\\\"James](\\\"https://avatars.githubusercontent.com/u/12564882?v=4?s=100\\\")
![\\\"xgui3783\\\"/](\\\"https://avatars.githubusercontent.com/u/19381783?v=4?s=100\\\")
![\\\"tstoeter\\\"/](\\\"https://avatars.githubusercontent.com/u/4901704?v=4?s=100\\\")
![\\\"Stephan](\\\"https://avatars.githubusercontent.com/u/10141237?v=4?s=100\\\")
![\\\"Matt](\\\"https://avatars.githubusercontent.com/u/25432?v=4?s=100\\\")
![\\\"Vicky](\\\"https://avatars.githubusercontent.com/u/22065437?v=4?s=100\\\")
![\\\"Chris](\\\"https://avatars.githubusercontent.com/u/133209?v=4?s=100\\\")
![\\\"Austin](\\\"https://avatars.githubusercontent.com/u/1028657?v=4?s=100\\\")
![\\\"Yann](\\\"https://avatars.githubusercontent.com/u/19148271?v=4?s=100\\\")
![\\\"Matthias](\\\"https://avatars.githubusercontent.com/u/9308656?v=4?s=100\\\")