memoize call to get_key
[keymanager.git] / versioneer.py
1 #! /usr/bin/python
2
3 """versioneer.py
4
5 (like a rocketeer, but for versions)
6
7 * https://github.com/warner/python-versioneer
8 * Brian Warner
9 * License: Public Domain
10 * Version: 0.7+
11
12 This file helps distutils-based projects manage their version number by just
13 creating version-control tags.
14
15 For developers who work from a VCS-generated tree (e.g. 'git clone' etc),
16 each 'setup.py version', 'setup.py build', 'setup.py sdist' will compute a
17 version number by asking your version-control tool about the current
18 checkout. The version number will be written into a generated _version.py
19 file of your choosing, where it can be included by your __init__.py
20
21 For users who work from a VCS-generated tarball (e.g. 'git archive'), it will
22 compute a version number by looking at the name of the directory created when
23 te tarball is unpacked. This conventionally includes both the name of the
24 project and a version number.
25
26 For users who work from a tarball built by 'setup.py sdist', it will get a
27 version number from a previously-generated _version.py file.
28
29 As a result, loading code directly from the source tree will not result in a
30 real version. If you want real versions from VCS trees (where you frequently
31 update from the upstream repository, or do new development), you will need to
32 do a 'setup.py version' after each update, and load code from the build/
33 directory.
34
35 You need to provide this code with a few configuration values:
36
37  versionfile_source:
38     A project-relative pathname into which the generated version strings
39     should be written. This is usually a _version.py next to your project's
40     main __init__.py file. If your project uses src/myproject/__init__.py,
41     this should be 'src/myproject/_version.py'. This file should be checked
42     in to your VCS as usual: the copy created below by 'setup.py
43     update_files' will include code that parses expanded VCS keywords in
44     generated tarballs. The 'build' and 'sdist' commands will replace it with
45     a copy that has just the calculated version string.
46
47  versionfile_build:
48     Like versionfile_source, but relative to the build directory instead of
49     the source directory. These will differ when your setup.py uses
50     'package_dir='. If you have package_dir={'myproject': 'src/myproject'},
51     then you will probably have versionfile_build='myproject/_version.py' and
52     versionfile_source='src/myproject/_version.py'.
53
54  tag_prefix: a string, like 'PROJECTNAME-', which appears at the start of all
55              VCS tags. If your tags look like 'myproject-1.2.0', then you
56              should use tag_prefix='myproject-'. If you use unprefixed tags
57              like '1.2.0', this should be an empty string.
58
59  parentdir_prefix: a string, frequently the same as tag_prefix, which
60                    appears at the start of all unpacked tarball filenames. If
61                    your tarball unpacks into 'myproject-1.2.0', this should
62                    be 'myproject-'.
63
64 To use it:
65
66  1: include this file in the top level of your project
67  2: make the following changes to the top of your setup.py:
68      import versioneer
69      versioneer.versionfile_source = 'src/myproject/_version.py'
70      versioneer.versionfile_build = 'myproject/_version.py'
71      versioneer.tag_prefix = '' # tags are like 1.2.0
72      versioneer.parentdir_prefix = 'myproject-' # dirname like 'myproject-1.2.0'
73  3: add the following arguments to the setup() call in your setup.py:
74      version=versioneer.get_version(),
75      cmdclass=versioneer.get_cmdclass(),
76  4: run 'setup.py update_files', which will create _version.py, and will
77     modify your __init__.py to define __version__ (by calling a function
78     from _version.py)
79  5: modify your MANIFEST.in to include versioneer.py
80  6: add both versioneer.py and the generated _version.py to your VCS
81 """
82
83 import os, sys, re
84 from distutils.core import Command
85 from distutils.command.sdist import sdist as _sdist
86 from distutils.command.build import build as _build
87
88 versionfile_source = None
89 versionfile_build = None
90 tag_prefix = None
91 parentdir_prefix = None
92
93 VCS = "git"
94 IN_LONG_VERSION_PY = False
95
96
97 LONG_VERSION_PY = '''
98 IN_LONG_VERSION_PY = True
99 # This file helps to compute a version number in source trees obtained from
100 # git-archive tarball (such as those provided by githubs download-from-tag
101 # feature). Distribution tarballs (build by setup.py sdist) and build
102 # directories (produced by setup.py build) will contain a much shorter file
103 # that just contains the computed version number.
104
105 # This file is released into the public domain. Generated by
106 # versioneer-0.7+ (https://github.com/warner/python-versioneer)
107
108 # these strings will be replaced by git during git-archive
109 git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s"
110 git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s"
111
112
113 import subprocess
114 import sys
115
116 def run_command(args, cwd=None, verbose=False):
117     try:
118         # remember shell=False, so use git.cmd on windows, not just git
119         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
120     except EnvironmentError:
121         e = sys.exc_info()[1]
122         if verbose:
123             print("unable to run %%s" %% args[0])
124             print(e)
125         return None
126     stdout = p.communicate()[0].strip()
127     if sys.version >= '3':
128         stdout = stdout.decode()
129     if p.returncode != 0:
130         if verbose:
131             print("unable to run %%s (error)" %% args[0])
132         return None
133     return stdout
134
135
136 import sys
137 import re
138 import os.path
139
140 def get_expanded_variables(versionfile_source):
141     # the code embedded in _version.py can just fetch the value of these
142     # variables. When used from setup.py, we don't want to import
143     # _version.py, so we do it with a regexp instead. This function is not
144     # used from _version.py.
145     variables = {}
146     try:
147         f = open(versionfile_source,"r")
148         for line in f.readlines():
149             if line.strip().startswith("git_refnames ="):
150                 mo = re.search(r'=\s*"(.*)"', line)
151                 if mo:
152                     variables["refnames"] = mo.group(1)
153             if line.strip().startswith("git_full ="):
154                 mo = re.search(r'=\s*"(.*)"', line)
155                 if mo:
156                     variables["full"] = mo.group(1)
157         f.close()
158     except EnvironmentError:
159         pass
160     return variables
161
162 def versions_from_expanded_variables(variables, tag_prefix, verbose=False):
163     refnames = variables["refnames"].strip()
164     if refnames.startswith("$Format"):
165         if verbose:
166             print("variables are unexpanded, not using")
167         return {} # unexpanded, so not in an unpacked git-archive tarball
168     refs = set([r.strip() for r in refnames.strip("()").split(",")])
169     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
170     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
171     TAG = "tag: "
172     tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
173     if not tags:
174         # Either we're using git < 1.8.3, or there really are no tags. We use
175         # a heuristic: assume all version tags have a digit. The old git %%d
176         # expansion behaves like git log --decorate=short and strips out the
177         # refs/heads/ and refs/tags/ prefixes that would let us distinguish
178         # between branches and tags. By ignoring refnames without digits, we
179         # filter out many common branch names like "release" and
180         # "stabilization", as well as "HEAD" and "master".
181         tags = set([r for r in refs if re.search(r'\d', r)])
182         if verbose:
183             print("discarding '%%s', no digits" %% ",".join(refs-tags))
184     if verbose:
185         print("likely tags: %%s" %% ",".join(sorted(tags)))
186     for ref in sorted(tags):
187         # sorting will prefer e.g. "2.0" over "2.0rc1"
188         if ref.startswith(tag_prefix):
189             r = ref[len(tag_prefix):]
190             if verbose:
191                 print("picking %%s" %% r)
192             return { "version": r,
193                      "full": variables["full"].strip() }
194     # no suitable tags, so we use the full revision id
195     if verbose:
196         print("no suitable tags, using full revision id")
197     return { "version": variables["full"].strip(),
198              "full": variables["full"].strip() }
199
200 def versions_from_vcs(tag_prefix, versionfile_source, verbose=False):
201     # this runs 'git' from the root of the source tree. That either means
202     # someone ran a setup.py command (and this code is in versioneer.py, so
203     # IN_LONG_VERSION_PY=False, thus the containing directory is the root of
204     # the source tree), or someone ran a project-specific entry point (and
205     # this code is in _version.py, so IN_LONG_VERSION_PY=True, thus the
206     # containing directory is somewhere deeper in the source tree). This only
207     # gets called if the git-archive 'subst' variables were *not* expanded,
208     # and _version.py hasn't already been rewritten with a short version
209     # string, meaning we're inside a checked out source tree.
210
211     try:
212         here = os.path.abspath(__file__)
213     except NameError:
214         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
215         return {} # not always correct
216
217     # versionfile_source is the relative path from the top of the source tree
218     # (where the .git directory might live) to this file. Invert this to find
219     # the root from __file__.
220     root = here
221     if IN_LONG_VERSION_PY:
222         for i in range(len(versionfile_source.split("/"))):
223             root = os.path.dirname(root)
224     else:
225         root = os.path.dirname(here)
226     if not os.path.exists(os.path.join(root, ".git")):
227         if verbose:
228             print("no .git in %%s" %% root)
229         return {}
230
231     GIT = "git"
232     if sys.platform == "win32":
233         GIT = "git.cmd"
234     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
235                          cwd=root)
236     if stdout is None:
237         return {}
238     if not stdout.startswith(tag_prefix):
239         if verbose:
240             print("tag '%%s' doesn't start with prefix '%%s'" %% (stdout, tag_prefix))
241         return {}
242     tag = stdout[len(tag_prefix):]
243     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=root)
244     if stdout is None:
245         return {}
246     full = stdout.strip()
247     if tag.endswith("-dirty"):
248         full += "-dirty"
249     return {"version": tag, "full": full}
250
251
252 def versions_from_parentdir(parentdir_prefix, versionfile_source, verbose=False):
253     if IN_LONG_VERSION_PY:
254         # We're running from _version.py. If it's from a source tree
255         # (execute-in-place), we can work upwards to find the root of the
256         # tree, and then check the parent directory for a version string. If
257         # it's in an installed application, there's no hope.
258         try:
259             here = os.path.abspath(__file__)
260         except NameError:
261             # py2exe/bbfreeze/non-CPython don't have __file__
262             return {} # without __file__, we have no hope
263         # versionfile_source is the relative path from the top of the source
264         # tree to _version.py. Invert this to find the root from __file__.
265         root = here
266         for i in range(len(versionfile_source.split("/"))):
267             root = os.path.dirname(root)
268     else:
269         # we're running from versioneer.py, which means we're running from
270         # the setup.py in a source tree. sys.argv[0] is setup.py in the root.
271         here = os.path.abspath(sys.argv[0])
272         root = os.path.dirname(here)
273
274     # Source tarballs conventionally unpack into a directory that includes
275     # both the project name and a version string.
276     dirname = os.path.basename(root)
277     if not dirname.startswith(parentdir_prefix):
278         if verbose:
279             print("guessing rootdir is '%%s', but '%%s' doesn't start with prefix '%%s'" %%
280                   (root, dirname, parentdir_prefix))
281         return None
282     return {"version": dirname[len(parentdir_prefix):], "full": ""}
283
284 tag_prefix = "%(TAG_PREFIX)s"
285 parentdir_prefix = "%(PARENTDIR_PREFIX)s"
286 versionfile_source = "%(VERSIONFILE_SOURCE)s"
287
288 def get_versions(default={"version": "unknown", "full": ""}, verbose=False):
289     variables = { "refnames": git_refnames, "full": git_full }
290     ver = versions_from_expanded_variables(variables, tag_prefix, verbose)
291     if not ver:
292         ver = versions_from_vcs(tag_prefix, versionfile_source, verbose)
293     if not ver:
294         ver = versions_from_parentdir(parentdir_prefix, versionfile_source,
295                                       verbose)
296     if not ver:
297         ver = default
298     return ver
299
300 '''
301
302
303 import subprocess
304 import sys
305
306 def run_command(args, cwd=None, verbose=False):
307     try:
308         # remember shell=False, so use git.cmd on windows, not just git
309         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
310     except EnvironmentError:
311         e = sys.exc_info()[1]
312         if verbose:
313             print("unable to run %s" % args[0])
314             print(e)
315         return None
316     stdout = p.communicate()[0].strip()
317     if sys.version >= '3':
318         stdout = stdout.decode()
319     if p.returncode != 0:
320         if verbose:
321             print("unable to run %s (error)" % args[0])
322         return None
323     return stdout
324
325
326 import sys
327 import re
328 import os.path
329
330 def get_expanded_variables(versionfile_source):
331     # the code embedded in _version.py can just fetch the value of these
332     # variables. When used from setup.py, we don't want to import
333     # _version.py, so we do it with a regexp instead. This function is not
334     # used from _version.py.
335     variables = {}
336     try:
337         f = open(versionfile_source,"r")
338         for line in f.readlines():
339             if line.strip().startswith("git_refnames ="):
340                 mo = re.search(r'=\s*"(.*)"', line)
341                 if mo:
342                     variables["refnames"] = mo.group(1)
343             if line.strip().startswith("git_full ="):
344                 mo = re.search(r'=\s*"(.*)"', line)
345                 if mo:
346                     variables["full"] = mo.group(1)
347         f.close()
348     except EnvironmentError:
349         pass
350     return variables
351
352 def versions_from_expanded_variables(variables, tag_prefix, verbose=False):
353     refnames = variables["refnames"].strip()
354     if refnames.startswith("$Format"):
355         if verbose:
356             print("variables are unexpanded, not using")
357         return {} # unexpanded, so not in an unpacked git-archive tarball
358     refs = set([r.strip() for r in refnames.strip("()").split(",")])
359     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
360     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
361     TAG = "tag: "
362     tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
363     if not tags:
364         # Either we're using git < 1.8.3, or there really are no tags. We use
365         # a heuristic: assume all version tags have a digit. The old git %d
366         # expansion behaves like git log --decorate=short and strips out the
367         # refs/heads/ and refs/tags/ prefixes that would let us distinguish
368         # between branches and tags. By ignoring refnames without digits, we
369         # filter out many common branch names like "release" and
370         # "stabilization", as well as "HEAD" and "master".
371         tags = set([r for r in refs if re.search(r'\d', r)])
372         if verbose:
373             print("discarding '%s', no digits" % ",".join(refs-tags))
374     if verbose:
375         print("likely tags: %s" % ",".join(sorted(tags)))
376     for ref in sorted(tags):
377         # sorting will prefer e.g. "2.0" over "2.0rc1"
378         if ref.startswith(tag_prefix):
379             r = ref[len(tag_prefix):]
380             if verbose:
381                 print("picking %s" % r)
382             return { "version": r,
383                      "full": variables["full"].strip() }
384     # no suitable tags, so we use the full revision id
385     if verbose:
386         print("no suitable tags, using full revision id")
387     return { "version": variables["full"].strip(),
388              "full": variables["full"].strip() }
389
390 def versions_from_vcs(tag_prefix, versionfile_source, verbose=False):
391     # this runs 'git' from the root of the source tree. That either means
392     # someone ran a setup.py command (and this code is in versioneer.py, so
393     # IN_LONG_VERSION_PY=False, thus the containing directory is the root of
394     # the source tree), or someone ran a project-specific entry point (and
395     # this code is in _version.py, so IN_LONG_VERSION_PY=True, thus the
396     # containing directory is somewhere deeper in the source tree). This only
397     # gets called if the git-archive 'subst' variables were *not* expanded,
398     # and _version.py hasn't already been rewritten with a short version
399     # string, meaning we're inside a checked out source tree.
400
401     try:
402         here = os.path.abspath(__file__)
403     except NameError:
404         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
405         return {} # not always correct
406
407     # versionfile_source is the relative path from the top of the source tree
408     # (where the .git directory might live) to this file. Invert this to find
409     # the root from __file__.
410     root = here
411     if IN_LONG_VERSION_PY:
412         for i in range(len(versionfile_source.split("/"))):
413             root = os.path.dirname(root)
414     else:
415         root = os.path.dirname(here)
416     if not os.path.exists(os.path.join(root, ".git")):
417         if verbose:
418             print("no .git in %s" % root)
419         return {}
420
421     GIT = "git"
422     if sys.platform == "win32":
423         GIT = "git.cmd"
424     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
425                          cwd=root)
426     if stdout is None:
427         return {}
428     if not stdout.startswith(tag_prefix):
429         if verbose:
430             print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
431         return {}
432     tag = stdout[len(tag_prefix):]
433     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=root)
434     if stdout is None:
435         return {}
436     full = stdout.strip()
437     if tag.endswith("-dirty"):
438         full += "-dirty"
439     return {"version": tag, "full": full}
440
441
442 def versions_from_parentdir(parentdir_prefix, versionfile_source, verbose=False):
443     if IN_LONG_VERSION_PY:
444         # We're running from _version.py. If it's from a source tree
445         # (execute-in-place), we can work upwards to find the root of the
446         # tree, and then check the parent directory for a version string. If
447         # it's in an installed application, there's no hope.
448         try:
449             here = os.path.abspath(__file__)
450         except NameError:
451             # py2exe/bbfreeze/non-CPython don't have __file__
452             return {} # without __file__, we have no hope
453         # versionfile_source is the relative path from the top of the source
454         # tree to _version.py. Invert this to find the root from __file__.
455         root = here
456         for i in range(len(versionfile_source.split("/"))):
457             root = os.path.dirname(root)
458     else:
459         # we're running from versioneer.py, which means we're running from
460         # the setup.py in a source tree. sys.argv[0] is setup.py in the root.
461         here = os.path.abspath(sys.argv[0])
462         root = os.path.dirname(here)
463
464     # Source tarballs conventionally unpack into a directory that includes
465     # both the project name and a version string.
466     dirname = os.path.basename(root)
467     if not dirname.startswith(parentdir_prefix):
468         if verbose:
469             print("guessing rootdir is '%s', but '%s' doesn't start with prefix '%s'" %
470                   (root, dirname, parentdir_prefix))
471         return None
472     return {"version": dirname[len(parentdir_prefix):], "full": ""}
473
474 import sys
475
476 def do_vcs_install(versionfile_source, ipy):
477     GIT = "git"
478     if sys.platform == "win32":
479         GIT = "git.cmd"
480     run_command([GIT, "add", "versioneer.py"])
481     run_command([GIT, "add", versionfile_source])
482     run_command([GIT, "add", ipy])
483     present = False
484     try:
485         f = open(".gitattributes", "r")
486         for line in f.readlines():
487             if line.strip().startswith(versionfile_source):
488                 if "export-subst" in line.strip().split()[1:]:
489                     present = True
490         f.close()
491     except EnvironmentError:
492         pass    
493     if not present:
494         f = open(".gitattributes", "a+")
495         f.write("%s export-subst\n" % versionfile_source)
496         f.close()
497         run_command([GIT, "add", ".gitattributes"])
498     
499
500 SHORT_VERSION_PY = """
501 # This file was generated by 'versioneer.py' (0.7+) from
502 # revision-control system data, or from the parent directory name of an
503 # unpacked source archive. Distribution tarballs contain a pre-generated copy
504 # of this file.
505
506 version_version = '%(version)s'
507 version_full = '%(full)s'
508 def get_versions(default={}, verbose=False):
509     return {'version': version_version, 'full': version_full}
510
511 """
512
513 DEFAULT = {"version": "unknown", "full": "unknown"}
514
515 def versions_from_file(filename):
516     versions = {}
517     try:
518         f = open(filename)
519     except EnvironmentError:
520         return versions
521     for line in f.readlines():
522         mo = re.match("version_version = '([^']+)'", line)
523         if mo:
524             versions["version"] = mo.group(1)
525         mo = re.match("version_full = '([^']+)'", line)
526         if mo:
527             versions["full"] = mo.group(1)
528     f.close()
529     return versions
530
531 def write_to_version_file(filename, versions):
532     f = open(filename, "w")
533     f.write(SHORT_VERSION_PY % versions)
534     f.close()
535     print("set %s to '%s'" % (filename, versions["version"]))
536
537
538 def get_best_versions(versionfile, tag_prefix, parentdir_prefix,
539                       default=DEFAULT, verbose=False):
540     # returns dict with two keys: 'version' and 'full'
541     #
542     # extract version from first of _version.py, 'git describe', parentdir.
543     # This is meant to work for developers using a source checkout, for users
544     # of a tarball created by 'setup.py sdist', and for users of a
545     # tarball/zipball created by 'git archive' or github's download-from-tag
546     # feature.
547
548     variables = get_expanded_variables(versionfile_source)
549     if variables:
550         ver = versions_from_expanded_variables(variables, tag_prefix)
551         if ver:
552             if verbose: print("got version from expanded variable %s" % ver)
553             return ver
554
555     ver = versions_from_file(versionfile)
556     if ver:
557         if verbose: print("got version from file %s %s" % (versionfile, ver))
558         return ver
559
560     ver = versions_from_vcs(tag_prefix, versionfile_source, verbose)
561     if ver:
562         if verbose: print("got version from git %s" % ver)
563         return ver
564
565     ver = versions_from_parentdir(parentdir_prefix, versionfile_source, verbose)
566     if ver:
567         if verbose: print("got version from parentdir %s" % ver)
568         return ver
569
570     if verbose: print("got version from default %s" % ver)
571     return default
572
573 def get_versions(default=DEFAULT, verbose=False):
574     assert versionfile_source is not None, "please set versioneer.versionfile_source"
575     assert tag_prefix is not None, "please set versioneer.tag_prefix"
576     assert parentdir_prefix is not None, "please set versioneer.parentdir_prefix"
577     return get_best_versions(versionfile_source, tag_prefix, parentdir_prefix,
578                              default=default, verbose=verbose)
579 def get_version(verbose=False):
580     return get_versions(verbose=verbose)["version"]
581
582 class cmd_version(Command):
583     description = "report generated version string"
584     user_options = []
585     boolean_options = []
586     def initialize_options(self):
587         pass
588     def finalize_options(self):
589         pass
590     def run(self):
591         ver = get_version(verbose=True)
592         print("Version is currently: %s" % ver)
593
594
595 class cmd_build(_build):
596     def run(self):
597         versions = get_versions(verbose=True)
598         _build.run(self)
599         # now locate _version.py in the new build/ directory and replace it
600         # with an updated value
601         target_versionfile = os.path.join(self.build_lib, versionfile_build)
602         print("UPDATING %s" % target_versionfile)
603         os.unlink(target_versionfile)
604         f = open(target_versionfile, "w")
605         f.write(SHORT_VERSION_PY % versions)
606         f.close()
607
608 class cmd_sdist(_sdist):
609     def run(self):
610         versions = get_versions(verbose=True)
611         self._versioneer_generated_versions = versions
612         # unless we update this, the command will keep using the old version
613         self.distribution.metadata.version = versions["version"]
614         return _sdist.run(self)
615
616     def make_release_tree(self, base_dir, files):
617         _sdist.make_release_tree(self, base_dir, files)
618         # now locate _version.py in the new base_dir directory (remembering
619         # that it may be a hardlink) and replace it with an updated value
620         target_versionfile = os.path.join(base_dir, versionfile_source)
621         print("UPDATING %s" % target_versionfile)
622         os.unlink(target_versionfile)
623         f = open(target_versionfile, "w")
624         f.write(SHORT_VERSION_PY % self._versioneer_generated_versions)
625         f.close()
626
627 INIT_PY_SNIPPET = """
628 from ._version import get_versions
629 __version__ = get_versions()['version']
630 del get_versions
631 """
632
633 class cmd_update_files(Command):
634     description = "modify __init__.py and create _version.py"
635     user_options = []
636     boolean_options = []
637     def initialize_options(self):
638         pass
639     def finalize_options(self):
640         pass
641     def run(self):
642         ipy = os.path.join(os.path.dirname(versionfile_source), "__init__.py")
643         print(" creating %s" % versionfile_source)
644         f = open(versionfile_source, "w")
645         f.write(LONG_VERSION_PY % {"DOLLAR": "$",
646                                    "TAG_PREFIX": tag_prefix,
647                                    "PARENTDIR_PREFIX": parentdir_prefix,
648                                    "VERSIONFILE_SOURCE": versionfile_source,
649                                    })
650         f.close()
651         try:
652             old = open(ipy, "r").read()
653         except EnvironmentError:
654             old = ""
655         if INIT_PY_SNIPPET not in old:
656             print(" appending to %s" % ipy)
657             f = open(ipy, "a")
658             f.write(INIT_PY_SNIPPET)
659             f.close()
660         else:
661             print(" %s unmodified" % ipy)
662         do_vcs_install(versionfile_source, ipy)
663
664 def get_cmdclass():
665     return {'version': cmd_version,
666             'update_files': cmd_update_files,
667             'build': cmd_build,
668             'sdist': cmd_sdist,
669             }