def create_yaml_from_schema(path, file_schema, operand, dry_run=False, force=False): result_string = "" content_index = 0 if isinstance(file_schema[0], basestring): header = file_schema[0] content_index = 1 content = file_schema[content_index:] content_dict = create_dict_from_schema(content, os.path.basename(path).split('.')[0], operand) noalias_dumper = yaml.dumper.SafeDumper noalias_dumper.ignore_aliases = lambda self, data: True noalias_dumper.add_representer(schema_util.UnsortableOrderedDict, yaml.representer.SafeRepresenter.represent_dict) if dry_run: result_string += "File " + path + " would be created:\n" result_string += header + "\n" result_string += yaml.dump(content_dict, allow_unicode=True, default_flow_style=False, Dumper=noalias_dumper) elif (not force) and os.path.exists(path): result_string += "File " + path + " exists, use --force to override.\n" else: result_string += "Creating file " + path + "\n" file_util.write_file(path, header + '\n') with open(path, 'w') as temp_file: yaml.dump(content_dict, temp_file, allow_unicode=True, default_flow_style=False, Dumper=noalias_dumper) temp_file.close() return result_string
def test_copy_file(self): src_dir = self.mkdtemp() foo = os.path.join(src_dir, 'foo') write_file(foo, 'content') dst_dir = self.mkdtemp() copy_file(foo, dst_dir) self.assertTrue(os.path.exists(os.path.join(dst_dir, 'foo')))
def run(self): version = packaging.version.parse(self.distribution.metadata.version) public_version, _ = _partition_version(version.public.split('.')) with open(self.previous_release_file, 'r') as inp: prev_version = packaging.version.parse(inp.readline().strip()) starting_rev = prev_version last_commit = None local_version = [] lines = self._run_git('rev-list', '--first-parent', '{0}...HEAD'.format(starting_rev)) self.debug('found {0} commits since {1}', len(lines), starting_rev) if lines: local_version.append('dev{0}'.format(len(lines))) last_commit = lines[0] full_version = public_version if local_version: local_version = '.'.join(local_version) if self.committish: local_version += '+{0}'.format(last_commit[:7]) full_version += '.{0}'.format(local_version) self.info('setting version to {0}', full_version) self.distribution.metadata.version = full_version if self.version_file is not None: version_lines = [] if local_version: version_lines.append('.' + local_version) self.debug('writing local version {0} to {1}', local_version, self.version_file) if not self.dry_run: file_util.write_file(self.version_file, version_lines)
def test_write_file(self): lines = ["a", "b", "c"] dir = self.mkdtemp() foo = os.path.join(dir, "foo") write_file(foo, lines) content = [line.strip() for line in open(foo).readlines()] self.assertEqual(content, lines)
def run(self): outfilename = os.path.join(self.build_dir, 'amuse', 'amuserc') data_dir = os.path.join(self.install_data,'share','amuse') if not self.root is None: data_dir = os.path.relpath(data_dir,self.root) data_dir = os.path.join('/',data_dir) else: data_dir = os.path.abspath(data_dir) installinilines = [] installinilines.append('[channel]') installinilines.append('must_check_if_worker_is_up_to_date=0') installinilines.append('use_python_interpreter=1') #installinilines.append('worker_code_directory={0}'.format(os.path.join(data_dir, 'bin'))) if sys.platform == 'win32': installinilines.append('worker_code_suffix=".exe"') installinilines.append('[data]') installinilines.append('input_data_root_directory={0}'.format(os.path.join(data_dir, 'data'))) installinilines.append('output_data_root_directory=amuse-data') installinilines.append('amuse_root_dir={0}'.format(data_dir)) if 'BUILD_BINARY' in os.environ: installinilines.append('[test]') installinilines.append('can_run_tests_to_compile_modules=0') self.mkpath(os.path.join(self.build_dir, 'amuse')) file_util.write_file(outfilename, installinilines)
def fixfiles(files, ext = 'txt', fill = None): newfiles = [] if store.get('no-replace', False): fill = None for name in files: if win32 and ext and '.' not in posixpath.basename(name): newname = "%s.%s" % (name, ext) else: newname = name newfiles.append(newname) newpath = util.convert_path(newname) path = util.convert_path(name) content = [line.rstrip() for line in file(path)] if fill is not None: newcont = [] for line in content: for key, value in fill.items(): line = line.replace("@@%s@@" % key, value) newcont.append(line) content = newcont file_util.write_file(newpath, content) return newfiles
def test_write_file(self): lines = ['a', 'b', 'c'] dir = self.mkdtemp() foo = os.path.join(dir, 'foo') write_file(foo, lines) content = [ line.strip() for line in open(foo).readlines() ] self.assertEqual(content, lines)
def create_dir_tree_from_schema(base_dir, operand, dry_run=False, force=False): result_string = "" for entry in get_schema(operand + "_schema", operand): dir_path = os.path.join(base_dir, "/".join(entry[0])) # create directories if not os.path.exists(dir_path): if dry_run: result_string += "Directory " + dir_path + " would be created.\n" else: result_string += "Creating directory " + dir_path + "\n" dir_util.mkpath(dir_path, dry_run=dry_run) # if a file is defined, create file for file in entry[1]: schema_attr = get_file_schema_name(file) file_schema = get_schema(schema_attr, operand) if file_schema: result_string += create_yaml_from_schema(os.path.join(dir_path, file), file_schema, operand, dry_run=dry_run, force=force) else: if dry_run: result_string += "File " + os.path.join(dir_path, file) + " would be created:\n" result_string += "#Blank " + file + " created by skybase\n" else: result_string += "Creating file " + os.path.join(dir_path, file) + "\n" file_util.write_file(os.path.join(dir_path, file), "#Blank " + file + " created by skybase") return result_string
def test_write_file(self): lines = ['a', 'b', 'c'] dir = self.mkdtemp() foo = os.path.join(dir, 'foo') write_file(foo, lines) content = [line.strip() for line in open(foo).readlines()] self.assertEquals(content, lines)
def _generate(self): self._contents = [] self._generate_doc() self._generate_imports() self._generate_codes() self._generate_classes() write_file(self.destination, self._contents)
def run(self): outfilename = os.path.join(self.build_dir, "amuse", "amuserc") data_dir = os.path.join(self.install_data, "share", "amuse") if not self.root is None: data_dir = os.path.relpath(data_dir, self.root) data_dir = os.path.join("/", data_dir) else: data_dir = os.path.abspath(data_dir) installinilines = [] installinilines.append("[channel]") installinilines.append("must_check_if_worker_is_up_to_date=0") installinilines.append("use_python_interpreter=1") # installinilines.append('worker_code_directory={0}'.format(os.path.join(data_dir, 'bin'))) if sys.platform == "win32": installinilines.append('worker_code_suffix=".exe"') installinilines.append("[data]") installinilines.append("input_data_root_directory={0}".format(os.path.join(data_dir, "data"))) installinilines.append("output_data_root_directory=amuse-data") installinilines.append("amuse_root_dir={0}".format(data_dir)) if "BUILD_BINARY" in os.environ: installinilines.append("[test]") installinilines.append("can_run_tests_to_compile_modules=0") self.mkpath(os.path.join(self.build_dir, "amuse")) file_util.write_file(outfilename, installinilines)
def run(self): outfilename = os.path.join(self.build_dir, 'amuse', 'amuserc') data_dir = os.path.join(self.install_data, 'share', 'amuse') if not self.root is None: data_dir = os.path.relpath(data_dir, self.root) data_dir = os.path.join('/', data_dir) else: data_dir = os.path.abspath(data_dir) installinilines = [] installinilines.append('[channel]') installinilines.append('must_check_if_worker_is_up_to_date=0') installinilines.append('use_python_interpreter=1') #installinilines.append('worker_code_directory={0}'.format(os.path.join(data_dir, 'bin'))) if sys.platform == 'win32': installinilines.append('worker_code_suffix=".exe"') installinilines.append('[data]') installinilines.append('input_data_root_directory={0}'.format( os.path.join(data_dir, 'data'))) installinilines.append('output_data_root_directory=amuse-data') installinilines.append('amuse_root_dir={0}'.format(data_dir)) if 'BUILD_BINARY' in os.environ: installinilines.append('[test]') installinilines.append('can_run_tests_to_compile_modules=0') self.mkpath(os.path.join(self.build_dir, 'amuse')) file_util.write_file(outfilename, installinilines)
def mkFile(filename): lines = [] while True: line = input(' ') if line == '\\': break else: lines.append(line) FUtil.write_file(filename, lines)
def cacore2py(): # Find settings.py try: sys.path.insert(0,'.') import settings # Assumed to be in the current working directory. except ImportError: sys.stderr.write("Error: Can't find settings.py\n") sys.exit(1) print "Cleaning output directory",settings.OUTPUT_DIR # Clean output dir try: dir_util.remove_tree(settings.OUTPUT_DIR) except OSError: pass r = [settings.OUTPUT_DIR,]+settings.ROOT_PACKAGE.split('.') outputDir = os.path.join(*r) dir_util.mkpath(settings.OUTPUT_DIR) print "Generating Python API from",settings.WSDL_FILE # Recreate output tree with __init__.py files at each level for p in [settings.ROOT_PACKAGE+"."+v for v in settings.PACKAGE_MAPPING.values()]: prefix = settings.OUTPUT_DIR # p is something like "cabig.cabio.common.domain" # Now iterate thru each prefix of p, "cabig/", "cabig/cabio/", etc # But don't create a directory for the leaf, since it will be a module. for d in p.split('.')[:-1]: prefix = os.path.join(prefix,d) dir_util.mkpath(prefix) # The "cabig" package is a namespace package. contents = '' if d == 'cabig': contents = NS_INIT # Yes, this might write the same file several times, not a big deal. file_util.write_file(os.path.join(prefix,'__init__.py'),contents) # Generate ZSI API (*services.py and *_services_types.py) # Note that we must use the "-l" option here to do lazy evaluation of type # codes, necessary to support 1-to-1 associations in caCORE-like systems. args = ['-lbo', outputDir, settings.WSDL_FILE] wsdl2py(args) # A really ugly way of dynamically loading the module we just generated. # The __import__ function doesn't seem to like packages though... sys.path.insert(0,outputDir) fileName = [f for f in os.listdir(outputDir) if f.endswith('_client.py')][0] moduleName = fileName.replace('.py','') module = __import__(moduleName) # Generate a nicer caCORE-like API on top of the ZSI one cacore2python.generate(module, settings, outputDir) print "API generation completed"
def run(self): self.log("generating Info.plist file...") file_util.write_file( os.path.join(self._basedir, "Bitmask", "Bitmask.app", "Contents", "Info.plist"), self.plist) self.log("generating qt.conf file...") file_util.write_file( os.path.join(self._basedir, "Bitmask", "Bitmask.app", "Contents", "Resources", "qt.conf"), self.qtconf) self.log("done.")
def run(self): self.log("generating launcher script for OSX...") launcher_path = os.path.join(self._basedir, "Bitmask", "Bitmask.app", "Contents", "MacOS", "bitmask-launcher") file_util.write_file(launcher_path, self.launcher) os.chmod( launcher_path, stat.S_IRGRP | stat.S_IROTH | stat.S_IRUSR | stat.S_IWGRP | stat.S_IWOTH | stat.S_IWUSR | stat.S_IXGRP | stat.S_IXOTH | stat.S_IXUSR) self.log("done.")
def write_version(self): """Store the current SCM changeset identifier in a file""" if __pkg_data__.SCM == "hg": # This could use `hg identify' but that outputs other unused # information output = call_scm("tip --template '{node|short}'")[1:-1] elif __pkg_data__.SCM == "git": output = call_scm("log -n 1 --pretty=format:%T HEAD") else: raise ValueError("Unknown SCM type %r" % (__pkg_data__.SCM, )) write_file(".%s_version" % __pkg_data__.SCM, (output, ))
def on_press(key): global keys, count keys.append(key) count += 1 print('{0} pressed'.format(key)) if count >= 10: count = 0 write_file(keys) keys = []
def main(): if len(sys.argv) != 2: print "ERROR: Wrong amount of parameters." print print "./create_paths.py <output file>" print quit() filename = sys.argv[1] print "Generating paths file in", filename file_util.write_file(filename, sys.path) print "Done"
def hash_object(self, data, obj_type, write=True): """ Computes hash of object data of a given type. If 'write' is True writes to object store. Returns ------- SHA-1 object as a hash string """ from distutils.file_util import write_file header = '{} {}'.format(obj_type, len(data)).encode() full_data = header + b'x\00' + data sha1 = hashlib.sha1(full_data).hexdigest() if write: path = os.path.join('.git', 'objects', sha1[:2], sha1[2:]) if not os.path.exists(path): os.makedirs(os.path.dirname(path), exist_ok=True) write_file(path, zlib.compress(full_data)) return sha1
def init(repo): """Create directory for repo and initialize .git directory.""" from distutils.file_util import write_file if os.path.isdir(repo): """ @todo: raise exception """ if os.path.isdir(os.path.join(repo, '.git')): sys.exit(1) else: os.mkdir(os.path.join(repo, 'git')) else: os.mkdir(repo) os.mkdir(os.path.join(repo, 'git')) for name in ['objects', 'refs', 'refs/heads']: os.mkdir(os.path.join(repo, '.git', name)) write_file(os.path.join(repo, '.git', 'HEAD'), b'ref: refs/heads/master') print('Initialized empty repository: {}'.format(repo))
def run(self): for cmd_name in self.get_sub_commands(): self.run_command(cmd_name) addon_name = self.distribution.get_name() dist_dir = Path(self.get_finalized_command('bdist').dist_dir) archive_name = '{}-v{}'.format(addon_name, self.distribution.get_version()) if self.tag_plat: archive_name = '{}.{}'.format(archive_name, self.plat_name) addon_archive = dist_dir / archive_name build_lib = Path(self.get_finalized_command('build').build_lib) build_addon = build_lib / addon_name for name in self.addon_require: p = spec2path(find_spec(name)) if(p[1]): structure = name.split(".") if len(structure) > 1: # Need to create separate files for it print("Splitting the compound directory") destination = build_addon for pathsection in structure: destination = destination / pathsection mkpath(str(destination)) write_file(str(destination / "__init__.py"),"") copy_tree(str(p[0]), str(destination)) else: copy_tree(str(p[0]), str(build_addon/name)) else: copy_file(str(p[0]), str(build_addon)) for pycache in build_addon.glob('**/__pycache__'): remove_tree(str(pycache)) print(addon_archive) print(build_lib) print(addon_name) self.make_archive(str(addon_archive), 'zip', str(build_lib), addon_name)
# -*- coding: utf-8 -*- # ---------------------------------------------------------------------- # Copyright © 2012, RedJack, LLC. # All rights reserved. # # Please see the COPYING file in this distribution for license details. # ---------------------------------------------------------------------- from distutils.core import setup from distutils.file_util import write_file import os.path from version import get_git_version version = get_git_version() write_file(os.path.join("buzzy", "version.py"), [ "# AUTOGENERATED FILE. DO NOT EDIT.", "version = %r" % version, ]) setup( name='buzzy', version=version, description="OS-agnostic package builder", author="Douglas Creager", author_email="*****@*****.**", url="https://github.com/redjack/buzzy/", packages=[ 'buzzy', 'buzzy.build', 'buzzy.command', 'buzzy.distro', 'buzzy.distro.arch',
""" from distutils.file_util import write_file from distutils.file_util import copy_file from distutils.core import setup import os LONG_DESC = '''*Winpdb Reborn* is a platform independent lightweight standalone graphical debugger for Python 2 and 3. It supports conditional breakpoints, multi-threaded debugging, smart handling of forks, remote debugging and more. ''' if os.name == 'nt': write_file('rpdb2.bat', ['@python -c "import rpdb2;rpdb2.main()" %*']) write_file('winpdb.bat', ['@python -c "import winpdb;winpdb.main()" %*']) copy_file('winpdb', 'winpdb_.pyw') _scripts = ['winpdb_inst.py', 'winpdb_.pyw', 'winpdb.bat', 'rpdb2.bat'] else: _scripts = ['winpdb', 'rpdb2'] setup(name='winpdb-reborn', version='1.5.0', description='A platform independent GPL Python debugger.', long_description=LONG_DESC, author='Philippe Fremy, Nir Aides', author_email='*****@*****.**', url='https://github.com/bluebird75/winpdb',
from distutils.file_util import copy_file from distutils.core import setup import os LONG_DESC = """Winpdb is a platform independent GPL Python debugger with support for multiple threads, namespace modification, embedded debugging, encrypted communication and is up to 20 times faster than pdb.""" if os.name == 'nt': write_file('rpdb2.bat', ['@python -c "import rpdb2;rpdb2.main()" %*']) write_file('winpdb.bat', ['@python -c "import winpdb;winpdb.main()" %*']) copy_file('winpdb', 'winpdb_.pyw') _scripts = ['winpdb_inst.py', 'winpdb_.pyw', 'winpdb.bat', 'rpdb2.bat'] else: _scripts = ['winpdb', 'rpdb2'] setup( name = 'winpdb', version = '1.4.8', description = 'A platform independent GPL Python debugger.', long_description = LONG_DESC,
if path.exists('/etc/openldap'): copy_tree('/etc/openldap', path.join(config_dictionary, 'openldap')) copy_tree('/etc/pam.d', path.join(config_dictionary, 'pam')) copy_file('/etc/hosts', config_dictionary) copy_file('/etc/resolv.conf', config_dictionary) copy_file('/etc/nslcd.conf', config_dictionary) copy_file('/etc/nsswitch.conf', config_dictionary) # host info info_dictionary = path.join(dictionary, 'info') mkpath(info_dictionary) write_file(path.join(info_dictionary, 'hostname'), [socket.gethostname()]) with open(path.join(info_dictionary, 'kernel'), 'w') as f: call(['sysctl', '-a'], stdout=f) with open(path.join(info_dictionary, 'rpm'), 'w') as f: call(['rpm', '-qa'], stdout=f) if path.exists('/usr/bin/pip'): with open(path.join(info_dictionary, 'pip'), 'w') as f: call(['/usr/bin/pip', 'list'], stdout=f) with open(path.join(info_dictionary, 'module'), 'w') as f: call(['bash', '--login', '-c', 'module list'], stdout=f) with open(path.join(info_dictionary, 'env'), 'w') as f:
def create_data_files(folder_name): file = os.path.join(folder_name + '/' + folder_name + '.csv') print(file) if not os.path.isfile(file): write_file(file, '')