def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--root", default=".")
    parser.add_argument("--dest")
    args = parser.parse_args()

    if args.dest is not None:
        dest = args.dest
    else:
        dest = os.path.join(args.root, "virtualenv.pyz")

    bio = io.BytesIO()
    with zipfile.ZipFile(bio, "w") as zipf:
        filenames = ["LICENSE.txt", "virtualenv.py"]
        for whl in os.listdir(os.path.join(args.root, "virtualenv_support")):
            filenames.append(os.path.join("virtualenv_support", whl))

        for filename in filenames:
            zipf.write(os.path.join(args.root, filename), filename)

        zipf.writestr("__main__.py", "import virtualenv; virtualenv.main()")

    bio.seek(0)
    zipapp.create_archive(bio, dest)
    print("zipapp created at {}".format(dest))

 def test_meson_zipapp(self):
     if is_windows():
         raise unittest.SkipTest('NOT IMPLEMENTED')
     source = Path(__file__).resolve().parent.as_posix()
     target = self.tmpdir / 'meson.pyz'
     zipapp.create_archive(source=source, target=target, interpreter=python_command[0], main=None)
     self._run([target.as_posix(), '--help'])

 def run(self):
     with TemporaryDirectory() as tmpdir:
         copytree('unicodemoticon', os.path.join(tmpdir, 'unicodemoticon'))
         fyle = os.path.join(tmpdir, '__main__.py')
         with open(fyle, 'w', encoding='utf-8') as entry:
             entry.write("import runpy\nrunpy.run_module('unicodemoticon')")
         create_archive(tmpdir, 'unicodemoticon.pyz', '/usr/bin/env python3')

 def test_create_archive(self):
     # Test packing a directory.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target))
     self.assertTrue(target.is_file())

 def test_main_and_main_py(self):
     # Test that supplying a main argument with __main__.py fails.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     with self.assertRaises(zipapp.ZipAppError):
         zipapp.create_archive(str(source), str(target), main='pkg.mod:fn')

 def test_read_shebang(self):
     # Test that we can read the shebang line correctly.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), interpreter='python')
     self.assertEqual(zipapp.get_interpreter(str(target)), 'python')

 def test_no_shebang_is_not_executable(self):
     # Test that an archive with no shebang line is not made executable.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), interpreter=None)
     self.assertFalse(target.stat().st_mode & stat.S_IEXEC)

 def test_read_missing_shebang(self):
     # Test that reading the shebang line of a file without one returns None.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target))
     self.assertEqual(zipapp.get_interpreter(str(target)), None)

 def test_create_archive_with_pathlib(self):
     # Test packing a directory using Path objects for source and target.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(source, target)
     self.assertTrue(target.is_file())

 def test_no_main(self):
     # Test that packing a directory with no __main__.py fails.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / 'foo.py').touch()
     target = self.tmpdir / 'source.pyz'
     with self.assertRaises(zipapp.ZipAppError):
         zipapp.create_archive(str(source), str(target))

 def test_pack_to_fileobj(self):
     # Test that we can pack to a file object.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = io.BytesIO()
     zipapp.create_archive(str(source), target, interpreter='python')
     self.assertTrue(target.getvalue().startswith(b'#!python\n'))

 def make_archive(self):
     # Test that an archive with no shebang line is not made executable.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(source, target)
     return target

 def test_create_archive_default_target(self):
     # Test packing a directory to the default name.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     zipapp.create_archive(str(source))
     expected_target = self.tmpdir / 'source.pyz'
     self.assertTrue(expected_target.is_file())

 def test_default_no_shebang(self):
     # Test that no shebang line is written to the target by default.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target))
     with target.open('rb') as f:
         self.assertNotEqual(f.read(2), b'#!')

 def test_remove_shebang(self):
     # Test that we can remove the shebang from a file.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), interpreter='python')
     new_target = self.tmpdir / 'changed.pyz'
     zipapp.create_archive(str(target), str(new_target), interpreter=None)
     self.assertEqual(zipapp.get_interpreter(str(new_target)), None)

 def test_main_written(self):
     # Test that the __main__.py is written correctly.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / 'foo.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), main='pkg.mod:fn')
     with zipfile.ZipFile(str(target), 'r') as z:
         self.assertIn('__main__.py', z.namelist())
         self.assertIn(b'pkg.mod.fn()', z.read('__main__.py'))

 def test_read_from_pathobj(self):
     # Test that we can copy an archive using a pathlib.Path object
     # for the source.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target1 = self.tmpdir / 'target1.pyz'
     target2 = self.tmpdir / 'target2.pyz'
     zipapp.create_archive(source, target1, interpreter='python')
     zipapp.create_archive(target1, target2, interpreter='python2.7')
     self.assertEqual(zipapp.get_interpreter(target2), 'python2.7')

 def test_write_shebang_to_fileobj(self):
     # Test that we can change the shebang of a file, writing the result to a
     # file object.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), interpreter='python')
     new_target = io.BytesIO()
     zipapp.create_archive(str(target), new_target, interpreter='python2.7')
     self.assertTrue(new_target.getvalue().startswith(b'#!python2.7\n'))

 def test_custom_interpreter(self):
     # Test that a shebang line with a custom interpreter is written
     # correctly.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     zipapp.create_archive(str(source), str(target), interpreter='python')
     with target.open('rb') as f:
         self.assertEqual(f.read(2), b'#!')
         self.assertEqual(b'python\n', f.readline())

 def test_read_from_fileobj(self):
     # Test that we can copy an archive using an open file object.
     source = self.tmpdir / 'source'
     source.mkdir()
     (source / '__main__.py').touch()
     target = self.tmpdir / 'source.pyz'
     temp_archive = io.BytesIO()
     zipapp.create_archive(str(source), temp_archive, interpreter='python')
     new_target = io.BytesIO()
     temp_archive.seek(0)
     zipapp.create_archive(temp_archive, new_target, interpreter='python2.7')
     self.assertTrue(new_target.getvalue().startswith(b'#!python2.7\n'))