git.oblomov.eu Git - git/blob - contrib/remote-helpers/git-remote-hg

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2012 Felipe Contreras
   4 #
   5
   6 # Inspired by Rocco Rutte's hg-fast-export
   7
   8 # Just copy to your ~/bin, or anywhere in your $PATH.
   9 # Then you can clone with:
  10 # git clone hg::/path/to/mercurial/repo/
  11
  12 from mercurial import hg, ui, bookmarks, context, util, encoding
  13
  14 import re
  15 import sys
  16 import os
  17 import json
  18 import shutil
  19 import subprocess
  20 import urllib
  21
  22 #
  23 # If you want to switch to hg-git compatibility mode:
  24 # git config --global remote-hg.hg-git-compat true
  25 #
  26 # git:
  27 # Sensible defaults for git.
  28 # hg bookmarks are exported as git branches, hg branches are prefixed
  29 # with 'branches/', HEAD is a special case.
  30 #
  31 # hg:
  32 # Emulate hg-git.
  33 # Only hg bookmarks are exported as git branches.
  34 # Commits are modified to preserve hg information and allow bidirectionality.
  35 #
  36
  37 NAME_RE = re.compile('^([^<>]+)')
  38 AUTHOR_RE = re.compile('^([^<>]+?)? ?<([^<>]*)>$')
  39 AUTHOR_HG_RE = re.compile('^(.*?) ?<(.*?)(?:>(.+)?)?$')
  40 RAW_AUTHOR_RE = re.compile('^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
  41
  42 def die(msg, *args):
  43     sys.stderr.write('ERROR: %s\n' % (msg % args))
  44     sys.exit(1)
  45
  46 def warn(msg, *args):
  47     sys.stderr.write('WARNING: %s\n' % (msg % args))
  48
  49 def gitmode(flags):
  50     return 'l' in flags and '120000' or 'x' in flags and '100755' or '100644'
  51
  52 def gittz(tz):
  53     return '%+03d%02d' % (-tz / 3600, -tz % 3600 / 60)
  54
  55 def hgmode(mode):
  56     m = { '100755': 'x', '120000': 'l' }
  57     return m.get(mode, '')
  58
  59 def get_config(config):
  60     cmd = ['git', 'config', '--get', config]
  61     process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  62     output, _ = process.communicate()
  63     return output
  64
  65 class Marks:
  66
  67     def __init__(self, path):
  68         self.path = path
  69         self.tips = {}
  70         self.marks = {}
  71         self.rev_marks = {}
  72         self.last_mark = 0
  73
  74         self.load()
  75
  76     def load(self):
  77         if not os.path.exists(self.path):
  78             return
  79
  80         tmp = json.load(open(self.path))
  81
  82         self.tips = tmp['tips']
  83         self.marks = tmp['marks']
  84         self.last_mark = tmp['last-mark']
  85
  86         for rev, mark in self.marks.iteritems():
  87             self.rev_marks[mark] = int(rev)
  88
  89     def dict(self):
  90         return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark }
  91
  92     def store(self):
  93         json.dump(self.dict(), open(self.path, 'w'))
  94
  95     def __str__(self):
  96         return str(self.dict())
  97
  98     def from_rev(self, rev):
  99         return self.marks[str(rev)]
 100
 101     def to_rev(self, mark):
 102         return self.rev_marks[mark]
 103
 104     def get_mark(self, rev):
 105         self.last_mark += 1
 106         self.marks[str(rev)] = self.last_mark
 107         return self.last_mark
 108
 109     def new_mark(self, rev, mark):
 110         self.marks[str(rev)] = mark
 111         self.rev_marks[mark] = rev
 112         self.last_mark = mark
 113
 114     def is_marked(self, rev):
 115         return self.marks.has_key(str(rev))
 116
 117     def get_tip(self, branch):
 118         return self.tips.get(branch, 0)
 119
 120     def set_tip(self, branch, tip):
 121         self.tips[branch] = tip
 122
 123 class Parser:
 124
 125     def __init__(self, repo):
 126         self.repo = repo
 127         self.line = self.get_line()
 128
 129     def get_line(self):
 130         return sys.stdin.readline().strip()
 131
 132     def __getitem__(self, i):
 133         return self.line.split()[i]
 134
 135     def check(self, word):
 136         return self.line.startswith(word)
 137
 138     def each_block(self, separator):
 139         while self.line != separator:
 140             yield self.line
 141             self.line = self.get_line()
 142
 143     def __iter__(self):
 144         return self.each_block('')
 145
 146     def next(self):
 147         self.line = self.get_line()
 148         if self.line == 'done':
 149             self.line = None
 150
 151     def get_mark(self):
 152         i = self.line.index(':') + 1
 153         return int(self.line[i:])
 154
 155     def get_data(self):
 156         if not self.check('data'):
 157             return None
 158         i = self.line.index(' ') + 1
 159         size = int(self.line[i:])
 160         return sys.stdin.read(size)
 161
 162     def get_author(self):
 163         global bad_mail
 164
 165         ex = None
 166         m = RAW_AUTHOR_RE.match(self.line)
 167         if not m:
 168             return None
 169         _, name, email, date, tz = m.groups()
 170         if name and 'ext:' in name:
 171             m = re.match('^(.+?) ext:\((.+)\)$', name)
 172             if m:
 173                 name = m.group(1)
 174                 ex = urllib.unquote(m.group(2))
 175
 176         if email != bad_mail:
 177             if name:
 178                 user = '%s <%s>' % (name, email)
 179             else:
 180                 user = '<%s>' % (email)
 181         else:
 182             user = name
 183
 184         if ex:
 185             user += ex
 186
 187         tz = int(tz)
 188         tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
 189         return (user, int(date), -tz)
 190
 191 def export_file(fc):
 192     d = fc.data()
 193     print "M %s inline %s" % (gitmode(fc.flags()), fc.path())
 194     print "data %d" % len(d)
 195     print d
 196
 197 def get_filechanges(repo, ctx, parent):
 198     modified = set()
 199     added = set()
 200     removed = set()
 201
 202     cur = ctx.manifest()
 203     prev = repo[parent].manifest().copy()
 204
 205     for fn in cur:
 206         if fn in prev:
 207             if (cur.flags(fn) != prev.flags(fn) or cur[fn] != prev[fn]):
 208                 modified.add(fn)
 209             del prev[fn]
 210         else:
 211             added.add(fn)
 212     removed |= set(prev.keys())
 213
 214     return added | modified, removed
 215
 216 def fixup_user_git(user):
 217     name = mail = None
 218     user = user.replace('"', '')
 219     m = AUTHOR_RE.match(user)
 220     if m:
 221         name = m.group(1)
 222         mail = m.group(2).strip()
 223     else:
 224         m = NAME_RE.match(user)
 225         if m:
 226             name = m.group(1).strip()
 227     return (name, mail)
 228
 229 def fixup_user_hg(user):
 230     def sanitize(name):
 231         # stole this from hg-git
 232         return re.sub('[<>\n]', '?', name.lstrip('< ').rstrip('> '))
 233
 234     m = AUTHOR_HG_RE.match(user)
 235     if m:
 236         name = sanitize(m.group(1))
 237         mail = sanitize(m.group(2))
 238         ex = m.group(3)
 239         if ex:
 240             name += ' ext:(' + urllib.quote(ex) + ')'
 241     else:
 242         name = sanitize(user)
 243         if '@' in user:
 244             mail = name
 245         else:
 246             mail = None
 247
 248     return (name, mail)
 249
 250 def fixup_user(user):
 251     global mode, bad_mail
 252
 253     if mode == 'git':
 254         name, mail = fixup_user_git(user)
 255     else:
 256         name, mail = fixup_user_hg(user)
 257
 258     if not name:
 259         name = bad_name
 260     if not mail:
 261         mail = bad_mail
 262
 263     return '%s <%s>' % (name, mail)
 264
 265 def get_repo(url, alias):
 266     global dirname, peer
 267
 268     myui = ui.ui()
 269     myui.setconfig('ui', 'interactive', 'off')
 270
 271     if hg.islocal(url):
 272         repo = hg.repository(myui, url)
 273     else:
 274         local_path = os.path.join(dirname, 'clone')
 275         if not os.path.exists(local_path):
 276             peer, dstpeer = hg.clone(myui, {}, url, local_path, update=False, pull=True)
 277             repo = dstpeer.local()
 278         else:
 279             repo = hg.repository(myui, local_path)
 280             peer = hg.peer(myui, {}, url)
 281             repo.pull(peer, heads=None, force=True)
 282
 283     return repo
 284
 285 def rev_to_mark(rev):
 286     global marks
 287     return marks.from_rev(rev)
 288
 289 def mark_to_rev(mark):
 290     global marks
 291     return marks.to_rev(mark)
 292
 293 def export_ref(repo, name, kind, head):
 294     global prefix, marks, mode
 295
 296     ename = '%s/%s' % (kind, name)
 297     tip = marks.get_tip(ename)
 298
 299     # mercurial takes too much time checking this
 300     if tip and tip == head.rev():
 301         # nothing to do
 302         return
 303     revs = xrange(tip, head.rev() + 1)
 304     count = 0
 305
 306     revs = [rev for rev in revs if not marks.is_marked(rev)]
 307
 308     for rev in revs:
 309
 310         c = repo[rev]
 311         (manifest, user, (time, tz), files, desc, extra) = repo.changelog.read(c.node())
 312         rev_branch = extra['branch']
 313
 314         author = "%s %d %s" % (fixup_user(user), time, gittz(tz))
 315         if 'committer' in extra:
 316             user, time, tz = extra['committer'].rsplit(' ', 2)
 317             committer = "%s %s %s" % (user, time, gittz(int(tz)))
 318         else:
 319             committer = author
 320
 321         parents = [p for p in repo.changelog.parentrevs(rev) if p >= 0]
 322
 323         if len(parents) == 0:
 324             modified = c.manifest().keys()
 325             removed = []
 326         else:
 327             modified, removed = get_filechanges(repo, c, parents[0])
 328
 329         desc += '\n'
 330
 331         if mode == 'hg':
 332             extra_msg = ''
 333
 334             if rev_branch != 'default':
 335                 extra_msg += 'branch : %s\n' % rev_branch
 336
 337             renames = []
 338             for f in c.files():
 339                 if f not in c.manifest():
 340                     continue
 341                 rename = c.filectx(f).renamed()
 342                 if rename:
 343                     renames.append((rename[0], f))
 344
 345             for e in renames:
 346                 extra_msg += "rename : %s => %s\n" % e
 347
 348             for key, value in extra.iteritems():
 349                 if key in ('author', 'committer', 'encoding', 'message', 'branch', 'hg-git'):
 350                     continue
 351                 else:
 352                     extra_msg += "extra : %s : %s\n" % (key, urllib.quote(value))
 353
 354             if extra_msg:
 355                 desc += '\n--HG--\n' + extra_msg
 356
 357         if len(parents) == 0 and rev:
 358             print 'reset %s/%s' % (prefix, ename)
 359
 360         print "commit %s/%s" % (prefix, ename)
 361         print "mark :%d" % (marks.get_mark(rev))
 362         print "author %s" % (author)
 363         print "committer %s" % (committer)
 364         print "data %d" % (len(desc))
 365         print desc
 366
 367         if len(parents) > 0:
 368             print "from :%s" % (rev_to_mark(parents[0]))
 369             if len(parents) > 1:
 370                 print "merge :%s" % (rev_to_mark(parents[1]))
 371
 372         for f in modified:
 373             export_file(c.filectx(f))
 374         for f in removed:
 375             print "D %s" % (f)
 376         print
 377
 378         count += 1
 379         if (count % 100 == 0):
 380             print "progress revision %d '%s' (%d/%d)" % (rev, name, count, len(revs))
 381             print "#############################################################"
 382
 383     # make sure the ref is updated
 384     print "reset %s/%s" % (prefix, ename)
 385     print "from :%u" % rev_to_mark(rev)
 386     print
 387
 388     marks.set_tip(ename, rev)
 389
 390 def export_tag(repo, tag):
 391     export_ref(repo, tag, 'tags', repo[tag])
 392
 393 def export_bookmark(repo, bmark):
 394     head = bmarks[bmark]
 395     export_ref(repo, bmark, 'bookmarks', head)
 396
 397 def export_branch(repo, branch):
 398     tip = get_branch_tip(repo, branch)
 399     head = repo[tip]
 400     export_ref(repo, branch, 'branches', head)
 401
 402 def export_head(repo):
 403     global g_head
 404     export_ref(repo, g_head[0], 'bookmarks', g_head[1])
 405
 406 def do_capabilities(parser):
 407     global prefix, dirname
 408
 409     print "import"
 410     print "export"
 411     print "refspec refs/heads/branches/*:%s/branches/*" % prefix
 412     print "refspec refs/heads/*:%s/bookmarks/*" % prefix
 413     print "refspec refs/tags/*:%s/tags/*" % prefix
 414
 415     path = os.path.join(dirname, 'marks-git')
 416
 417     if os.path.exists(path):
 418         print "*import-marks %s" % path
 419     print "*export-marks %s" % path
 420
 421     print
 422
 423 def get_branch_tip(repo, branch):
 424     global branches
 425
 426     heads = branches.get(branch, None)
 427     if not heads:
 428         return None
 429
 430     # verify there's only one head
 431     if (len(heads) > 1):
 432         warn("Branch '%s' has more than one head, consider merging" % branch)
 433         # older versions of mercurial don't have this
 434         if hasattr(repo, "branchtip"):
 435             return repo.branchtip(branch)
 436
 437     return heads[0]
 438
 439 def list_head(repo, cur):
 440     global g_head, bmarks
 441
 442     head = bookmarks.readcurrent(repo)
 443     if head:
 444         node = repo[head]
 445     else:
 446         # fake bookmark from current branch
 447         head = cur
 448         node = repo['.']
 449         if not node:
 450             node = repo['tip']
 451         if not node:
 452             return
 453         if head == 'default':
 454             head = 'master'
 455         bmarks[head] = node
 456
 457     print "@refs/heads/%s HEAD" % head
 458     g_head = (head, node)
 459
 460 def do_list(parser):
 461     global branches, bmarks, mode, track_branches
 462
 463     repo = parser.repo
 464     for bmark, node in bookmarks.listbookmarks(repo).iteritems():
 465         bmarks[bmark] = repo[node]
 466
 467     cur = repo.dirstate.branch()
 468
 469     list_head(repo, cur)
 470
 471     if track_branches:
 472         for branch in repo.branchmap():
 473             heads = repo.branchheads(branch)
 474             if len(heads):
 475                 branches[branch] = heads
 476
 477         for branch in branches:
 478             print "? refs/heads/branches/%s" % branch
 479
 480     for bmark in bmarks:
 481         print "? refs/heads/%s" % bmark
 482
 483     for tag, node in repo.tagslist():
 484         if tag == 'tip':
 485             continue
 486         print "? refs/tags/%s" % tag
 487
 488     print
 489
 490 def do_import(parser):
 491     repo = parser.repo
 492
 493     path = os.path.join(dirname, 'marks-git')
 494
 495     print "feature done"
 496     if os.path.exists(path):
 497         print "feature import-marks=%s" % path
 498     print "feature export-marks=%s" % path
 499     sys.stdout.flush()
 500
 501     tmp = encoding.encoding
 502     encoding.encoding = 'utf-8'
 503
 504     # lets get all the import lines
 505     while parser.check('import'):
 506         ref = parser[1]
 507
 508         if (ref == 'HEAD'):
 509             export_head(repo)
 510         elif ref.startswith('refs/heads/branches/'):
 511             branch = ref[len('refs/heads/branches/'):]
 512             export_branch(repo, branch)
 513         elif ref.startswith('refs/heads/'):
 514             bmark = ref[len('refs/heads/'):]
 515             export_bookmark(repo, bmark)
 516         elif ref.startswith('refs/tags/'):
 517             tag = ref[len('refs/tags/'):]
 518             export_tag(repo, tag)
 519
 520         parser.next()
 521
 522     encoding.encoding = tmp
 523
 524     print 'done'
 525
 526 def parse_blob(parser):
 527     global blob_marks
 528
 529     parser.next()
 530     mark = parser.get_mark()
 531     parser.next()
 532     data = parser.get_data()
 533     blob_marks[mark] = data
 534     parser.next()
 535     return
 536
 537 def get_merge_files(repo, p1, p2, files):
 538     for e in repo[p1].files():
 539         if e not in files:
 540             if e not in repo[p1].manifest():
 541                 continue
 542             f = { 'ctx' : repo[p1][e] }
 543             files[e] = f
 544
 545 def parse_commit(parser):
 546     global marks, blob_marks, bmarks, parsed_refs
 547     global mode
 548
 549     from_mark = merge_mark = None
 550
 551     ref = parser[1]
 552     parser.next()
 553
 554     commit_mark = parser.get_mark()
 555     parser.next()
 556     author = parser.get_author()
 557     parser.next()
 558     committer = parser.get_author()
 559     parser.next()
 560     data = parser.get_data()
 561     parser.next()
 562     if parser.check('from'):
 563         from_mark = parser.get_mark()
 564         parser.next()
 565     if parser.check('merge'):
 566         merge_mark = parser.get_mark()
 567         parser.next()
 568         if parser.check('merge'):
 569             die('octopus merges are not supported yet')
 570
 571     files = {}
 572
 573     for line in parser:
 574         if parser.check('M'):
 575             t, m, mark_ref, path = line.split(' ', 3)
 576             mark = int(mark_ref[1:])
 577             f = { 'mode' : hgmode(m), 'data' : blob_marks[mark] }
 578         elif parser.check('D'):
 579             t, path = line.split(' ')
 580             f = { 'deleted' : True }
 581         else:
 582             die('Unknown file command: %s' % line)
 583         files[path] = f
 584
 585     def getfilectx(repo, memctx, f):
 586         of = files[f]
 587         if 'deleted' in of:
 588             raise IOError
 589         if 'ctx' in of:
 590             return of['ctx']
 591         is_exec = of['mode'] == 'x'
 592         is_link = of['mode'] == 'l'
 593         rename = of.get('rename', None)
 594         return context.memfilectx(f, of['data'],
 595                 is_link, is_exec, rename)
 596
 597     repo = parser.repo
 598
 599     user, date, tz = author
 600     extra = {}
 601
 602     if committer != author:
 603         extra['committer'] = "%s %u %u" % committer
 604
 605     if from_mark:
 606         p1 = repo.changelog.node(mark_to_rev(from_mark))
 607     else:
 608         p1 = '\0' * 20
 609
 610     if merge_mark:
 611         p2 = repo.changelog.node(mark_to_rev(merge_mark))
 612     else:
 613         p2 = '\0' * 20
 614
 615     #
 616     # If files changed from any of the parents, hg wants to know, but in git if
 617     # nothing changed from the first parent, nothing changed.
 618     #
 619     if merge_mark:
 620         get_merge_files(repo, p1, p2, files)
 621
 622     if mode == 'hg':
 623         i = data.find('\n--HG--\n')
 624         if i >= 0:
 625             tmp = data[i + len('\n--HG--\n'):].strip()
 626             for k, v in [e.split(' : ') for e in tmp.split('\n')]:
 627                 if k == 'rename':
 628                     old, new = v.split(' => ', 1)
 629                     files[new]['rename'] = old
 630                 elif k == 'branch':
 631                     extra[k] = v
 632                 elif k == 'extra':
 633                     ek, ev = v.split(' : ', 1)
 634                     extra[ek] = urllib.unquote(ev)
 635             data = data[:i]
 636
 637     ctx = context.memctx(repo, (p1, p2), data,
 638             files.keys(), getfilectx,
 639             user, (date, tz), extra)
 640
 641     tmp = encoding.encoding
 642     encoding.encoding = 'utf-8'
 643
 644     node = repo.commitctx(ctx)
 645
 646     encoding.encoding = tmp
 647
 648     rev = repo[node].rev()
 649
 650     parsed_refs[ref] = node
 651
 652     marks.new_mark(rev, commit_mark)
 653
 654 def parse_reset(parser):
 655     ref = parser[1]
 656     parser.next()
 657     # ugh
 658     if parser.check('commit'):
 659         parse_commit(parser)
 660         return
 661     if not parser.check('from'):
 662         return
 663     from_mark = parser.get_mark()
 664     parser.next()
 665
 666     node = parser.repo.changelog.node(mark_to_rev(from_mark))
 667     parsed_refs[ref] = node
 668
 669 def parse_tag(parser):
 670     name = parser[1]
 671     parser.next()
 672     from_mark = parser.get_mark()
 673     parser.next()
 674     tagger = parser.get_author()
 675     parser.next()
 676     data = parser.get_data()
 677     parser.next()
 678
 679     # nothing to do
 680
 681 def do_export(parser):
 682     global parsed_refs, bmarks, peer
 683
 684     parser.next()
 685
 686     for line in parser.each_block('done'):
 687         if parser.check('blob'):
 688             parse_blob(parser)
 689         elif parser.check('commit'):
 690             parse_commit(parser)
 691         elif parser.check('reset'):
 692             parse_reset(parser)
 693         elif parser.check('tag'):
 694             parse_tag(parser)
 695         elif parser.check('feature'):
 696             pass
 697         else:
 698             die('unhandled export command: %s' % line)
 699
 700     for ref, node in parsed_refs.iteritems():
 701         if ref.startswith('refs/heads/branches'):
 702             pass
 703         elif ref.startswith('refs/heads/'):
 704             bmark = ref[len('refs/heads/'):]
 705             if bmark in bmarks:
 706                 old = bmarks[bmark].hex()
 707             else:
 708                 old = ''
 709             if not bookmarks.pushbookmark(parser.repo, bmark, old, node):
 710                 continue
 711         elif ref.startswith('refs/tags/'):
 712             tag = ref[len('refs/tags/'):]
 713             parser.repo.tag([tag], node, None, True, None, {})
 714         else:
 715             # transport-helper/fast-export bugs
 716             continue
 717         print "ok %s" % ref
 718
 719     print
 720
 721     if peer:
 722         parser.repo.push(peer, force=False)
 723
 724 def fix_path(alias, repo, orig_url):
 725     repo_url = util.url(repo.url())
 726     url = util.url(orig_url)
 727     if str(url) == str(repo_url):
 728         return
 729     cmd = ['git', 'config', 'remote.%s.url' % alias, "hg::%s" % repo_url]
 730     subprocess.call(cmd)
 731
 732 def main(args):
 733     global prefix, dirname, branches, bmarks
 734     global marks, blob_marks, parsed_refs
 735     global peer, mode, bad_mail, bad_name
 736     global track_branches
 737
 738     alias = args[1]
 739     url = args[2]
 740     peer = None
 741
 742     hg_git_compat = False
 743     track_branches = True
 744     try:
 745         if get_config('remote-hg.hg-git-compat') == 'true\n':
 746             hg_git_compat = True
 747             track_branches = False
 748         if get_config('remote-hg.track-branches') == 'false\n':
 749             track_branches = False
 750     except subprocess.CalledProcessError:
 751         pass
 752
 753     if hg_git_compat:
 754         mode = 'hg'
 755         bad_mail = 'none@none'
 756         bad_name = ''
 757     else:
 758         mode = 'git'
 759         bad_mail = 'unknown'
 760         bad_name = 'Unknown'
 761
 762     if alias[4:] == url:
 763         is_tmp = True
 764         alias = util.sha1(alias).hexdigest()
 765     else:
 766         is_tmp = False
 767
 768     gitdir = os.environ['GIT_DIR']
 769     dirname = os.path.join(gitdir, 'hg', alias)
 770     branches = {}
 771     bmarks = {}
 772     blob_marks = {}
 773     parsed_refs = {}
 774
 775     repo = get_repo(url, alias)
 776     prefix = 'refs/hg/%s' % alias
 777
 778     if not is_tmp:
 779         fix_path(alias, peer or repo, url)
 780
 781     if not os.path.exists(dirname):
 782         os.makedirs(dirname)
 783
 784     marks_path = os.path.join(dirname, 'marks-hg')
 785     marks = Marks(marks_path)
 786
 787     parser = Parser(repo)
 788     for line in parser:
 789         if parser.check('capabilities'):
 790             do_capabilities(parser)
 791         elif parser.check('list'):
 792             do_list(parser)
 793         elif parser.check('import'):
 794             do_import(parser)
 795         elif parser.check('export'):
 796             do_export(parser)
 797         else:
 798             die('unhandled command: %s' % line)
 799         sys.stdout.flush()
 800
 801     if not is_tmp:
 802         marks.store()
 803     else:
 804         shutil.rmtree(dirname)
 805
 806 sys.exit(main(sys.argv))