예제 #1
0
파일: env.py 프로젝트: csdms/wmt-exe
    def from_dict(clazz, *args, **kwds):
        """Loads WMT environment variables from arguments.

        Parameters
        ----------
        *args
            Variable length argument list.
        *kwds
            Arbitrary keyword arguments.

        Returns
        -------
        WmtEnvironment
            A WmtEnvironment instance.
        
        """
        env = clazz()

        d = dict(*args, **kwds)

        babel = Babel(babel_config=d['babel_config'],
                      cca_spec_babel_config=d['cca_spec_babel_config'])
        python = Python(python=d['python'])

        wmt_prefix = d['wmt_prefix']
        components_prefix = d['components_prefix']

        env._env.update({
            'CURL': d['curl'],
            'TAIL': d['tail'],
            'BASH': d['bash'],
            'PYTHONPATH': pathsep.join([
                python.site_packages(),
                path.join(python.prefix, 'lib', python.version),
                python.site_packages(components_prefix),
                python.site_packages(babel.prefix),
                path.join(babel.libs, python.version, 'site-packages'),
            ]),
            'LD_LIBRARY_PATH': pathsep.join([
                path.join(python.prefix, 'lib'),
                path.join(components_prefix, 'lib'),
                path.join(wmt_prefix, 'lib'),
                path.join(babel.prefix, 'lib'),
            ]),
            'PATH': pathsep.join([
                path.join(python.prefix, 'bin'),
                '/usr/local/bin',
                '/usr/bin',
                '/bin',
            ]),
            'CLASSPATH': pathsep.join([
                path.join(components_prefix, 'lib', 'java'),
            ]),
            'SIDL_DLL_PATH': ';'.join([
                path.join(components_prefix, 'share', 'cca'),
            ]),
        })
        env._env['LD_RUN_PATH'] = env['LD_LIBRARY_PATH']

        return env
예제 #2
0
    def run(self):
        """
        Build the specified files
        """
        from ..core import JDKManager, Macro
        sourcepath = pathsep.join(StateProperty().get_source_folders())
        dependencies = ["."] + [
            dependency[0]
            for dependency
            in DependencyManager().get_dependencies()
        ]
        classpath = pathsep.join(dependencies)
        output_location = Macro().parse(Settings().get("build_output_location"))

        executable = JDKManager().get_executable("build")
        if not executable:
            return

        build_script = "%s -sourcepath %s -classpath %s" % (
            shlex.quote(executable),
            shlex.quote(sourcepath),
            shlex.quote(classpath)
        )
        if output_location:
            if isfile(output_location):
                return
            elif not isdir(output_location):
                try:
                    makedirs(output_location)
                except:
                    pass
            build_script += " -d %s" % (shlex.quote(output_location))

        while self.running and self.files:
            self.builds += 1
            parallel_builds = Settings().get("parallel_builds")
            if parallel_builds > 0:
                files = self.files[:parallel_builds]
                self.files = self.files[parallel_builds:]
            else:
                files = self.files
                self.files = []
            file_list = " ".join([
                shlex.quote(filename) for filename in files
            ])
            actual_build_script = build_script + " %s" % (file_list)
            build_args = Settings().get("build_arguments", "")
            if build_args:
                actual_build_script += " " + build_args

            shell = GenericSilentShell(
                actual_build_script,
                lambda elapse_time, data, ret, params: self.on_build_done(
                    len(files), elapse_time, data, ret
                )
            )
            shell.set_cwd(Macro().parse(Settings().get("build_location")))
            shell.start()
        while self.running and self.builds > 0:
            pass
예제 #3
0
파일: linter.py 프로젝트: xjx79/Javatar
    def cmd(self):
        """
        Returns the command to be used by SublimeLinter
        """

        sourcepath = pathsep.join(StateProperty().get_source_folders())
        dependencies = StateProperty().get_source_folders() + [
            dependency[0]
            for dependency in DependencyManager().get_dependencies()
        ]
        output_location = Macro().parse(
            Settings().get("build_output_location"))
        if output_location:
            if isfile(output_location):
                return
            elif not isdir(output_location):
                try:
                    makedirs(output_location)
                except:
                    pass
            output_location = ["-d", output_location]
        else:
            output_location = []
        if dependencies:
            classpath = ["-classpath", pathsep.join(dependencies)]
        else:
            classpath = []
        return [
            JDKManager().get_executable("lint") or "javac", "-sourcepath",
            sourcepath
        ] + classpath + output_location + [
            sublime.active_window().active_view().file_name(),
            Settings().get("linter_arguments", "")
        ]
예제 #4
0
def setup_3rdparty(lib):

    # Normalize library path
    for name, path in lib.items():
        lib[name] = realpath(expanduser(path))

    # Setup environment variable
    environ['LD_PRELOAD'] = pathsep.join(
        filter(None, [
            getenv('LD_PRELOAD'),
            os.path.join(lib['gcc'], "libgfortran.so"),
            os.path.join(lib['gcc'], "libgcc_s.so"),
            os.path.join(lib['gcc'], "libstdc++.so"),
            os.path.join(lib['gcc'], "libgomp.so"),
        ]))
    environ['PYTHONPATH'] = pathsep.join(
        filter(None, [
            getenv('PYTHON'),
            os.path.join(lib['libsvm'], "python"),
            os.path.join(lib['liblinear'], "python"),
            os.path.join(lib['spams-python']),
        ]))
    environ['MATLABPATH'] = pathsep.join(
        filter(None, [
            getenv('MATLABPATH'),
            os.path.join(lib['liblinear'], "matlab"),
            os.path.join(lib['libsvm'], "matlab"),
            os.path.join(lib['spams-matlab'], "build"),
            os.path.join(lib['spams-matlab'], "src_release"),
            os.path.join(lib['spams-matlab'], "test_release"),
        ]))

    return lib
예제 #5
0
파일: linter.py 프로젝트: Pugio/Javatar
    def cmd(self):
        """
        Returns the command to be used by SublimeLinter
        """

        sourcepath = pathsep.join(StateProperty().get_source_folders())
        dependencies = StateProperty().get_source_folders() + [
            dependency[0]
            for dependency
            in DependencyManager().get_dependencies()
        ]
        output_location = Macro().parse(Settings().get("build_output_location"))
        if output_location:
            if isfile(output_location):
                return
            elif not isdir(output_location):
                try:
                    makedirs(output_location)
                except:
                    pass
            output_location = ["-d", output_location]
        else:
            output_location = []
        if dependencies:
            classpath = ["-classpath", pathsep.join(dependencies)]
        else:
            classpath = []
        return [
            JDKManager().get_executable("lint") or "javac",
            "-sourcepath",
            sourcepath
        ] + classpath + output_location + [
            sublime.active_window().active_view().file_name(),
            Settings().get("linter_arguments", "")
        ]
예제 #6
0
def CheckOde(localOdeInstallDir):
    ldLibraryPath = environ.get('LD_LIBRARY_PATH')
    if ldLibraryPath is None:
        ldLibraryPath = []
    else:
        ldLibraryPath = ldLibraryPath.split(pathsep)
    ldLibraryPath.append(path.join(localOdeInstallDir, 'lib'))
    environ['LD_LIBRARY_PATH'] = pathsep.join(ldLibraryPath)
    environ['LIBRARY_PATH'] = pathsep.join(ldLibraryPath)
    return find_library('ode') is not None
예제 #7
0
class EnvVarTestParamDataComponents:
    TAlias_param_types = Final[list[type]]
    TAlias_param_data_by_type = Final[dict[type:list[Any]]]

    __TAlias_param_data_str = Final[list[str]]
    __TAlias_param_data_path = Final[list[PurePath]]
    __TAlias_invalid_param_data_none = Final[list[type[None]]]
    __TAlias_invalid_param_data_int = Final[list[type[int]]]
    __TAlias_invalid_param_data_bool = Final[list[type[bool]]]
    __TAlias_invalid_param_data_float = Final[list[type[float]]]
    __TAlias_invalid_joined_values_data_path = Final[list[type[PurePath]]]

    valid_key_data_str: __TAlias_param_data_str = [
        '', 'key', 'test', '123', 'KEY', 'key_', '_key', 'z-abc', 'space space'
    ]
    valid_values_windows_path_data_str: __TAlias_param_data_str = [
        'C:\\', 'C:\\Users', 'C:\\Users\\', 'C:\\Users\\Public',
        'C:\\Users\\Public\\', 'C:\\Users\\Public\\wow.doge', '.\\',
        '.\\Users', '.\\Users\\', '.\\Users\\Public', '.\\Users\\Public\\',
        '.\\Users\\Public\\wow.doge'
    ]
    valid_values_unix_path_data_str: __TAlias_param_data_str = [
        '/usr', '/usr/', '/usr/tmp', '/usr/tmp/', '~'
    ]
    valid_values_data_str: __TAlias_param_data_str = \
        valid_key_data_str + \
        [f'%{key_str}%' for key_str in valid_key_data_str] + \
        valid_values_windows_path_data_str + \
        valid_values_unix_path_data_str + \
        ['val1;',
         'val1;val2',
         'val1;val2;',
         'many_postfix_sep;;;;',
         ';;;;;many_prefix_sep']
    valid_values_data_path: __TAlias_param_data_path = \
        [PurePath(values_path_str) for values_path_str in valid_values_windows_path_data_str] + \
        [PurePath(values_path_str) for values_path_str in valid_values_unix_path_data_str]
    valid_joined_values_data_str: __TAlias_param_data_str = [
        pathsep.join(valid_key_data_str),
        pathsep.join(valid_values_windows_path_data_str),
        pathsep.join(valid_values_unix_path_data_str)
    ]

    invalid_param_data_none: __TAlias_invalid_param_data_none = [None]
    invalid_param_data_int: __TAlias_invalid_param_data_int = [
        -52323, -7, -10, -5, -1, 0, 1, 5, 7, 10, 25893
    ]
    invalid_param_data_bool: __TAlias_invalid_param_data_bool = [False, True]
    invalid_param_data_float: __TAlias_invalid_param_data_float = [
        -0.1, -0.000001, -0.4123, -0.00546, -10.9023, -345.245, 0.0, 0.1,
        0.000001, 0.4123, 0.00546, 10.9023, 345.245
    ]
    invalid_joined_values_data_path: __TAlias_invalid_joined_values_data_path = valid_values_data_path
예제 #8
0
    def run(self):
        """
        Build the specified files
        """
        from ..core import JDKManager, Macro
        sourcepath = pathsep.join(StateProperty().get_source_folders())
        dependencies = ["."] + [
            dependency[0]
            for dependency in DependencyManager().get_dependencies()
        ]
        classpath = pathsep.join(dependencies)
        output_location = Macro().parse(
            Settings().get("build_output_location"))

        executable = JDKManager().get_executable("build")
        if not executable:
            return

        build_script = "%s -sourcepath %s -classpath %s" % (shlex.quote(
            executable), shlex.quote(sourcepath), shlex.quote(classpath))
        if output_location:
            if isfile(output_location):
                return
            elif not isdir(output_location):
                try:
                    makedirs(output_location)
                except:
                    pass
            build_script += " -d %s" % (shlex.quote(output_location))

        while self.running and self.files:
            self.builds += 1
            parallel_builds = Settings().get("parallel_builds")
            if parallel_builds > 0:
                files = self.files[:parallel_builds]
                self.files = self.files[parallel_builds:]
            else:
                files = self.files
                self.files = []
            file_list = " ".join([shlex.quote(filename) for filename in files])
            actual_build_script = build_script + " %s" % (file_list)
            build_args = Settings().get("build_arguments", "")
            if build_args:
                actual_build_script += " " + build_args

            shell = GenericSilentShell(
                actual_build_script,
                lambda elapse_time, data, ret, params: self.on_build_done(
                    len(files), elapse_time, data, ret))
            shell.set_cwd(Macro().parse(Settings().get("build_location")))
            shell.start()
        while self.running and self.builds > 0:
            pass
def _spawn(script, outputFD):
    """
    Start a script that is a peer of this test as a subprocess.

    @param script: the module name of the script in this directory (no
        package prefix, no '.py')
    @type script: C{str}

    @rtype: L{StartStopProcessProtocol}
    """
    pyExe = FilePath(sys.executable).asBytesMode().path
    env = bytesEnviron()
    env[b"PYTHONPATH"] = FilePath(
        pathsep.join(sys.path)).asBytesMode().path
    sspp = StartStopProcessProtocol()
    reactor.spawnProcess(
        sspp, pyExe, [
            pyExe,
            FilePath(__file__).sibling(script + ".py").asBytesMode().path,
            intToBytes(outputFD),
        ],
        env=env,
        childFDs={0: "w", 1: "r", 2: "r", outputFD: outputFD}
    )
    return sspp
예제 #10
0
 async def cont(path: PurePath, bin: str,
                pkg: ScriptSpec) -> _SortOfMonoid:
     env = {
         "PATH":
         pathsep.join((
             normcase(INSTALL_SCRIPTS_DIR),
             environ["PATH"],
         )),
         "ARCH":
         sys.machine,
         "OS":
         sys.system,
         "BIN":
         normcase(BIN_DIR / bin),
         "LIB":
         normcase(LIB_DIR / bin),
     }
     p = await call(
         path,
         env={
             **env,
             **pkg.env
         },
         cwd=TMP_DIR,
         check_returncode=set(),
     )
     return (("", p), )
예제 #11
0
    def _build_paths(self, name, spec_path_lists, exists):
        """
        Given an environment variable name and specified paths,
        return a pathsep-separated string of paths containing
        unique, extant, directories from those paths and from
        the environment variable. Raise an error if no paths
        are resolved.

        Parameters
        ----------
        name: str
            Environment variable name
        spec_path_lists: list of str
            Paths
        exists: bool
            It True, only return existing paths.

        Return
        ------
        str
            Pathsep-separated paths
        """
        # flatten spec_path_lists
        spec_paths = itertools.chain.from_iterable(spec_path_lists)
        env_paths = environ.get(name, '').split(pathsep)
        paths = itertools.chain(spec_paths, env_paths)
        extant_paths = list(filter(isdir, paths)) if exists else paths
        if not extant_paths:
            msg = "%s environment variable is empty" % name.upper()
            raise distutils.errors.DistutilsPlatformError(msg)
        unique_paths = self._unique_everseen(extant_paths)
        return pathsep.join(unique_paths)
예제 #12
0
def _spawn(script, outputFD):
    """
    Start a script that is a peer of this test as a subprocess.

    @param script: the module name of the script in this directory (no
        package prefix, no '.Dockerfile.bak')
    @type script: C{str}

    @rtype: L{StartStopProcessProtocol}
    """
    pyExe = FilePath(sys.executable).asBytesMode().path
    env = bytesEnviron()
    env[b"PYTHONPATH"] = FilePath(pathsep.join(sys.path)).asBytesMode().path
    sspp = StartStopProcessProtocol()
    reactor.spawnProcess(
        sspp,
        pyExe, [
            pyExe,
            FilePath(__file__).sibling(script +
                                       ".Dockerfile.bak").asBytesMode().path,
            intToBytes(outputFD),
        ],
        env=env,
        childFDs={
            0: "w",
            1: "r",
            2: "r",
            outputFD: outputFD
        })
    return sspp
예제 #13
0
def _spawn(script, outputFD):
    """
    Start a script that is a peer of this test as a subprocess.

    @param script: the module name of the script in this directory (no
        package prefix, no '.py')
    @type script: C{str}

    @rtype: L{StartStopProcessProtocol}
    """
    pyExe = FilePath(sys.executable).asTextMode().path
    env = dict(os.environ)
    env["PYTHONPATH"] = FilePath(pathsep.join(sys.path)).asTextMode().path
    sspp = StartStopProcessProtocol()
    reactor.spawnProcess(
        sspp,
        pyExe,
        [
            pyExe,
            FilePath(__file__).sibling(script + ".py").asTextMode().path,
            b"%d" % (outputFD, ),
        ],
        env=env,
        childFDs={
            0: "w",
            1: "r",
            2: "r",
            outputFD: outputFD
        },
    )
    return sspp
예제 #14
0
파일: save_plots.py 프로젝트: jmmcd/PonyGE2
def save_plot_from_file(filename, stat_name):
    """
    Saves a plot of a given stat from the stats file.

    :param filename: a full specified path to a .csv stats file.
    :param stat_name: the stat of interest for plotting.
    :return: Nothing.
    """

    # Read in the data
    data = pd.read_csv(filename, sep="\t")
    try:
        stat = list(data[stat_name])
    except KeyError:
        s = "utilities.stats.save_plots.save_plot_from_file\n" \
            "Error: stat %s does not exist" % stat_name
        raise Exception(s)

        # Set up the figure.
    fig = plt.figure()
    ax1 = fig.add_subplot(1, 1, 1)

    # Plot the data.
    ax1.plot(stat)

    # Plot title.
    plt.title(stat_name)

    # Get save path
    save_path = pathsep.join(filename.split(pathsep)[:-1])

    # Save plot and close.
    plt.savefig(path.join(save_path, (stat_name + '.pdf')))
    plt.close()
예제 #15
0
def save_plot_from_file(filename, stat_name):
    """
    Saves a plot of a given stat from the stats file.
    
    :param filename: a full specified path to a .csv stats file.
    :param stat_name: the stat of interest for plotting.
    :return: Nothing.
    """

    # Read in the data
    data = pd.read_csv(filename, sep="\t")
    try:
        stat = list(data[stat_name])
    except KeyError:
        s = "utilities.stats.save_plots.save_plot_from_file\n" \
            "Error: stat %s does not exist" % stat_name
        raise Exception(s)

    # Plot the data
    fig = plt.figure()
    ax1 = fig.add_subplot(1, 1, 1)
    ax1.plot(stat)
    plt.title(stat_name)

    # Get save path
    save_path = pathsep.join(filename.split(pathsep)[:-1])

    # Save plot
    plt.savefig(path.join(save_path, (stat_name + '.pdf')))
    plt.close()
예제 #16
0
def setup_path(root, paths):
    paths = [os.path.join(root, path) for path in paths]
    paths.append(root)
    if getenv('MATLABPATH') is not None:
        paths.insert(0, getenv('MATLABPATH'))

    environ['MATLABPATH'] = pathsep.join(paths)
예제 #17
0
def call_brazil_path(command):
    # add some apollo-specific paths
    paths = pathsep.join([
        environ["PATH"], environ["HOME"] + '/.toolbox/bin',
        "/apollo/env/BrazilCLI/bin", "/apollo/env/SDETools/bin"
    ])
    # Check $PATH for the tool
    brazil_tool_path = distutils.spawn.find_executable("brazil-path",
                                                       path=paths)
    if brazil_tool_path is None:
        raise FileNotFoundError("Failed to find brazil-path in any of " +
                                paths)
    print("Using brazil-path located at " + brazil_tool_path + " for " +
          command)
    # defaults to locale.getpreferredencoding(False) by setting universal_newlines=True
    proc = subprocess.Popen(
        [brazil_tool_path, command],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        # if universal_newlines=True is removed, the output will be in bytes rather than an encoded str.
        universal_newlines=True)
    (brazil_path_out, err) = proc.communicate()
    if proc.returncode != 0:
        print("Error while determining the current workspace-root \
            from brazil-path \nOutput: %s \nError: %s" %
              (brazil_path_out, err))
        return None
    else:
        return brazil_path_out.strip()
예제 #18
0
def remove_value(name, values):
    paths = get_key(name).split(pathsep)
    remove(paths, '')
    for value in values:
        paths = unique(paths)
        remove(paths, value)
    set_key(name, pathsep.join(paths))
예제 #19
0
def StripPath(path):
    collected = []
    for p in path.split(pathsep):
        rp = realpath(p)
        if exists(rp) and isdir(rp):
            if len(listdir(rp)) != 0:
                collected.append(p)     
    return pathsep.join(collected)
예제 #20
0
    def _overwrite_environment(self, environment):
        # type: (MutableMapping[str, str]) -> None
        if not self._overwrite:
            return

        for variable, overwrite_values in self._overwrite.items():
            overwrite_value = pathsep.join(overwrite_values)
            environment[variable] = overwrite_value
예제 #21
0
def prepend_value(name, values):
    paths = get_key(name).split(pathsep)
    for value in values:
        remove(paths, '')
        paths = unique(paths)
        remove(paths, value)
        paths.insert(0, value)
    set_key(name, pathsep.join(paths))
예제 #22
0
def setup_env():
    from os import environ as env, pathsep
    from os.path import join

    conda_path = get_conda_path()
    assert conda_path is not None
    conda_path = [conda_path, join(conda_path, "Scripts")]
    env["PATH"] = pathsep.join(conda_path) + pathsep + env["PATH"]
예제 #23
0
def __GetDrawstuffLib():
    ldLibraryPath = environ.get('LD_LIBRARY_PATH')
    if ldLibraryPath is None:
        ldLibraryPath = []
    else:
        ldLibraryPath = ldLibraryPath.split(pathsep)
    localOdeInstallLibDir = path.join(environ.get('HOME'), '.odepy', 'lib')
    ldLibraryPath.append(localOdeInstallLibDir)
    environ['LD_LIBRARY_PATH'] = pathsep.join(ldLibraryPath)
    environ['LIBRARY_PATH'] = pathsep.join(ldLibraryPath)
    drawstuffLibName = find_library('drawstuff')
    if drawstuffLibName is None:
        raise DrawstuffPyError('drawstuff library not found.')
    if path.exists(path.join(localOdeInstallLibDir, drawstuffLibName)):
        return CDLL(path.join(localOdeInstallLibDir, drawstuffLibName),
                    use_errno=True)
    return CDLL(drawstuffLibName, use_errno=True)
예제 #24
0
파일: env.py 프로젝트: mdpiper/wmt-exe
    def from_dict(clazz, *args, **kwds):
        env = clazz()

        d = dict(*args, **kwds)

        babel = Babel(babel_config=d['babel_config'],
                      cca_spec_babel_config=d['cca_spec_babel_config'])
        python = Python(python=d['python'])

        wmt_prefix = d['wmt_prefix']
        components_prefix = d['components_prefix']

        env._env.update({
            'CURL': d['curl'],
            'TAIL': d['tail'],
            'BASH': d['bash'],
            'PYTHONPATH': pathsep.join([
                python.site_packages(),
                path.join(python.prefix, 'lib', python.version),
                python.site_packages(components_prefix),
                python.site_packages(babel.prefix),
                path.join(babel.libs, python.version, 'site-packages'),
            ]),
            'LD_LIBRARY_PATH': pathsep.join([
                path.join(python.prefix, 'lib'),
                path.join(components_prefix, 'lib'),
                path.join(wmt_prefix, 'lib'),
                path.join(babel.prefix, 'lib'),
            ]),
            'PATH': pathsep.join([
                path.join(python.prefix, 'bin'),
                '/usr/local/bin',
                '/usr/bin',
                '/bin',
            ]),
            'CLASSPATH': pathsep.join([
                path.join(components_prefix, 'lib', 'java'),
            ]),
            'SIDL_DLL_PATH': ';'.join([
                path.join(components_prefix, 'share', 'cca'),
            ]),
        })
        env._env['LD_RUN_PATH'] = env['LD_LIBRARY_PATH']

        return env
예제 #25
0
def _load_library():
    # We assume the DLL is next to the driver, the build (setup.py) should take
    # care of it (it currently doesn't)
    old_path = environ["PATH"]
    environ["PATH"] = pathsep.join([environ["PATH"], abspath(dirname(__file__))])
    try:
        return ctypes.cdll.LoadLibrary("InternetExplorerDriver.dll")
    finally:
        environ["PATH"] = old_path
    def _create_python_path(self):
        python_path = pathsep.join(sys.path)

        if "PYTHONPATH" in environ:
            python_path += pathsep + environ["PYTHONPATH"]

        python_path += pathsep + abspath(join("..", "hostexpand", "src", "main", "python"))
        python_path += pathsep + abspath(join("src", "main", "python"))
        return python_path
예제 #27
0
파일: Utils.py 프로젝트: mystilleef/scribes
def update_python_environment_with(module_path):
    from os.path import dirname
    module_folder = dirname(module_path)
    from sys import path
    if not (module_folder in path): path.insert(0, module_folder)
    from os import environ, pathsep, putenv
    python_path = pathsep.join(path)
    environ["PYTHONPATH"] = python_path
    putenv("PYTHONPATH", python_path)
    return
예제 #28
0
파일: Utils.py 프로젝트: mystilleef/scribes
def update_python_environment_with(module_path):
	from os.path import dirname
	module_folder = dirname(module_path)
	from sys import path
	if not (module_folder in path): path.insert(0, module_folder)
	from os import environ, pathsep, putenv
	python_path = pathsep.join(path)
	environ["PYTHONPATH"] = python_path
	putenv("PYTHONPATH", python_path)
	return
    def _create_python_path(self):
        python_path = pathsep.join(sys.path)

        if 'PYTHONPATH' in environ:
            python_path += pathsep + environ['PYTHONPATH']

        python_path += pathsep + \
            abspath(join('..', 'hostexpand', 'src', 'main', 'python'))
        python_path += pathsep + abspath(join('src', 'main', 'python'))
        return python_path
예제 #30
0
def _check_linter_path():
    if getattr(_check_linter_path, 'skip', False):
        return

    LOCAL_BIN = '/usr/local/bin'
    PATH = environ['PATH'].split(pathsep)

    if platform == 'posix' and LOCAL_BIN not in PATH:
        environ['PATH'] = pathsep.join([LOCAL_BIN] + PATH)
    _check_linter_path.skip = True
def _append_run_path():
    """
    添加Qt的环境变量\n
    :return:
    """
    if getattr(sys, 'frozen', False):
        path_list = [sys._MEIPASS]
        _main_app_path = path.dirname(sys.executable)
        path_list.append(_main_app_path)
        environ["PATH"] += pathsep + pathsep.join(path_list)
예제 #32
0
def has_valid_kerberos_ticket():
    paths = pathsep.join([
        environ["PATH"], environ["HOME"] + "/.toolbox/bin",
        "/usr/kerberos/bin", "/usr/bin"
    ])
    klist_path = distutils.spawn.find_executable("klist", path=paths)
    if klist_path is None:
        raise FileNotFoundError("Failed to find klist in any of " + paths)
    print("using klist from " + str(klist_path))
    return True if subprocess.call([klist_path, "-s"]) == 0 else False
    def _create_python_path(self):
        python_path = pathsep.join(sys.path)

        if 'PYTHONPATH' in environ:
            python_path += pathsep + environ['PYTHONPATH']

        python_path += pathsep + \
            abspath(join('..', 'hostexpand', 'src', 'main', 'python'))
        python_path += pathsep + abspath(join('src', 'main', 'python'))
        return python_path
예제 #34
0
def main(argv=None):
    from os.path import join, isfile, dirname
    from tempfile import mkstemp
    from os import chdir, close, environ, pathsep
    import os  # So we can look kill up later
    from subprocess import Popen, call
    import sys
    import signal
    from time import sleep
    from optparse import OptionParser

    argv = argv or sys.argv

    parser = OptionParser("%prog")
    opts, args = parser.parse_args(argv[1:])
    if args:
        parser.error("wrong number of arguments")  # Will exit

    chdir(dirname(__file__))
    jarfile = join("..", "..", "..", "build", "selenium-server-standalone.jar")
    if not isfile(jarfile):
        raise SystemExit("error: can't find selenium jar at %s" % jarfile)
    corefile = join("..", "..", "..", "build", "selenium-core.jar")
    if not isfile(corefile):
        raise SystemExit("error: can't find selenium jar at %s" % corefile)

    fd, name = mkstemp()
    close(fd)
    fo = open(name, "w")

    server = Popen([
        "java", "-cp", jarfile + pathsep + corefile,
        "org.openqa.selenium.server.SeleniumServer"
    ],
                   shell=False,
                   stdout=fo)
    srcdir = join("..", "..", "src", "py")

    # we should really be waiting for the server to be up and running
    sleep(5)

    try:
        env = environ.copy()
        env["PYTHONPATH"] = pathsep.join([env.get("PYTHONPATH", ""), srcdir])
        ok = call([sys.executable, "selenium_test_suite.py"], env=env)
    except AttributeError:
        pass

    # try the python 2.6 way of killing the task
    try:
        server.kill
    except:
        os.kill(server.pid, signal.SIGTERM)

    raise SystemExit(ok)
    def __init__(self):
        tree = ET.parse(pathsep.join([
            file_location, file_name
        ])) if file_location else ET.parse(file_name)
        root = tree.getroot()

        self.library = root.findtext("metadata_displays/library_name")
        self.library_message = root.findtext(
            "metadata_displays/library_message")
        self.title = root.findtext("metadata_displays/page_title")
        self.displays = [Display(d) for d in root.findall("display")]
예제 #36
0
    def _set_environment_defaults(self, environment):
        # type: (MutableMapping[str, str]) -> None
        if not self._default:
            return

        for variable, default_values in self._default.items():
            if variable in environment:
                continue

            default_value = pathsep.join(default_values)
            environment[variable] = default_value
예제 #37
0
def StripPath(path):
    collected = []
    for p in path.split(pathsep):
        rp = realpath(p)
        # We keep the entry if it is a directory not empty or a zipfile
        try :
            if exists(rp) and ((isdir(rp) and listdir(rp)) 
                               or is_zipfile(rp)) and p not in collected:
                collected.append(p)
        except OSError :
            pass
    return pathsep.join(collected)
예제 #38
0
def StripPath(path):
    collected = []
    for p in path.split(pathsep):
        rp = realpath(p)
        np = normpath(p)
        # We keep the entry if it is a directory not empty or a zipfile
        try :
            if exists(rp) and ((isdir(rp) and listdir(rp))
                          or is_zipfile(rp)) and np not in collected:
                collected.append(np)
        except OSError :
            pass
    return pathsep.join(collected)
예제 #39
0
def populate_idf_env_vars(idf_env):
    idf_env["IDF_PATH"] = env.subst("$FRAMEWORK_DIR") #platform.get_package_dir("framework-espidf")

    additional_packages = [
        join(platform.get_package_dir("toolchain-xtensa-lx106-elf"), "bin"),
        platform.get_package_dir("tool-ninja"),
        join(platform.get_package_dir("tool-cmake"), "bin"),
    ]

    if "windows" in get_systype():
        additional_packages.append(platform.get_package_dir("tool-mconf"))

    idf_env["PATH"] = pathsep.join(additional_packages + [idf_env["PATH"]])
예제 #40
0
def find_tool(tool, env):
    """Part of the public API"""

    path = env["PATH"]
    paths = path.split(pathsep)
    ctinker_path = env[CTINKER_PATH]

    # We need PATH without our shim for real tool execution
    idx = paths.index(ctinker_path)
    del paths[idx]
    tool_path_env = pathsep.join(paths)

    return shutil.which(tool, path=tool_path_env)
예제 #41
0
def expand_classpath():

    from os import pathsep
    from glob import glob

    paths = []
    # deal with wildcards
    for path in get_classpath():
        if not path.endswith("*"):
            paths.append(path)
        else:
            paths.extend(glob(path + ".[Jj][Aa][Rr]"))
    return pathsep.join(paths)
예제 #42
0
def main(argv=None):
    from os.path import join, isfile, dirname
    from tempfile import mkstemp
    from os import chdir, close, environ, pathsep
    import os # So we can look kill up later
    from subprocess import Popen, call
    import sys
    import signal
    from time import sleep
    from optparse import OptionParser

    argv = argv or sys.argv

    parser = OptionParser("%prog")
    opts, args = parser.parse_args(argv[1:])
    if args:
        parser.error("wrong number of arguments") # Will exit

    chdir(dirname(__file__))
    jarfile = join("..", "..", "..", "build", "selenium-server-standalone.jar")
    if not isfile(jarfile):
        raise SystemExit("error: can't find selenium jar at %s" % jarfile)
    corefile = join("..", "..", "..", "build", "selenium-core.jar")
    if not isfile(corefile):
        raise SystemExit("error: can't find selenium jar at %s" % corefile)


    fd, name = mkstemp()
    close(fd)
    fo = open(name, "w")

    server = Popen(["java", "-cp", jarfile + pathsep + corefile, "org.openqa.selenium.server.SeleniumServer"], shell=False, stdout=fo)
    srcdir = join("..", "..", "src", "py")

    # we should really be waiting for the server to be up and running
    sleep(5)

    try:
        env = environ.copy()
        env["PYTHONPATH"] = pathsep.join([env.get("PYTHONPATH", ""), srcdir])
        ok = call([sys.executable, "selenium_test_suite.py"], env=env)
    except AttributeError:
        pass

    # try the python 2.6 way of killing the task
    try:
        server.kill
    except:
        os.kill(server.pid, signal.SIGTERM)
        
    raise SystemExit(ok)
예제 #43
0
def _load_library():
    # We assume the DLL is next to the driver, the build (setup.py) should take
    # care of it
    old_path = environ["PATH"]
    environ["PATH"] = pathsep.join([environ["PATH"], abspath(dirname(__file__))])
    try:
        # We first try the platform specific dll and then the general one
        for suffix in (_num_bits(), ""):
            dll = "InternetExplorerDriver%s.dll" % suffix
            try:
                return ctypes.cdll.LoadLibrary(dll)
            except WindowsError:
                pass
    finally:
        environ["PATH"] = old_path
예제 #44
0
def man_replacements():
    # XXX: We should use conda-api for this, but it's currently annoying to set the
    # root prefix with.
    info = json.loads(str_check_output(['conda', 'info', '--json']))
    # We need to use an ordered dict because the root prefix should be
    # replaced last, since it is typically a substring of the default prefix
    r = OrderedDict([
        (info['default_prefix'], 'default prefix'),
        (pathsep.join(info['envs_dirs']), 'envs dirs'),
        # For whatever reason help2man won't italicize these on its own
        # Note these require conda > 3.7.1
        (info['user_rc_path'], r'\fI\,user .condarc path\/\fP'),
        (info['sys_rc_path'], r'\fI\,system .condarc path\/\fP'),

        (info['root_prefix'], r'root prefix'),
    ])

    return r
예제 #45
0
파일: path.py 프로젝트: rgrig/hacks
def main():
  if argv[1:] == []:
    process(abspath(getcwd()))
    for e, ds in executables.items():
      if len(set(ds)) > 1:
        stderr.write('Warning: using {0} from {1}; ignoring {0} from {2}\n'.
            format(e, ds[0], ' and '.join(list(set(ds[1:])))))
    for d in getenv('PATH').split(pathsep):
      add_to_path(d)
  elif argv[1:] == ['-remove']:
    collect(abspath(getcwd()))
    for d in getenv('PATH').split(pathsep):
      if abspath(d) not in all_dirs:
        add_to_path(d)
  else:
    stderr.write('Error: Bad usage. I am just removing duplicates.\n')
    for d in getenv('PATH').split(pathsep):
      add_to_path(d)
  stdout.write(pathsep.join(new_path))
예제 #46
0
파일: HexBot.py 프로젝트: hexid/HexBot
def updateEnviron():
    oper = platform
    if oper.startswith("win32"):
        oper = "windows"
    elif oper.startswith("darwin"):
        oper = "macosx"
    elif oper.startswith("linux"):
        oper = "linux-" + ("amd64" if arch() == "x86_64" else "i386")

    libs = path.join(base, "libs")
    casper = path.join(libs, "casperjs", ("bin" if oper is not "windows" else "batchbin"))
    phantom = path.join(libs, "phantomjs")
    phantomBin = path.join(phantom, "bin")

    if oper.startswith("cygwin"):
        oper = "windows"

    phantomBinOS = path.join(phantomBin, oper)

    environ["PATH"] += pathsep + pathsep.join([casper, phantomBinOS, phantom, phantomBin])
예제 #47
0
def fix_binpath(paths):
    if paths is not None:
        if isinstance(paths, basestring):
            environ['PATH'] = paths
        elif isinstance(paths, list):
            environ['PATH'] = pathsep.join(paths)
예제 #48
0
                   filterdict_pop, \
                   filterdict_remove, \
                   hybridproperty, \
                   tuplist
from .utils_2to3 import StandardError, filter_u, foreach_u  #, iter_values
from .utils_func import apply_intercalate
from .utils_prog import ProtectedDict, cli_decor, getenv_namespaced

log = getLogger(__name__)
module_ext = dict((t, s) for s, m, t in get_suffixes())[PY_SOURCE]

here = dirname(abspath(__file__))

EXTPLUGINS = tuple(e if isabs(e) else join(here, e) for e in
    map(str.strip, getenv_namespaced(
        'EXTPLUGINS', pathsep.join(('ext-plugins', EXTPLUGINS_SHARED))
    ).rstrip(pathsep).split(pathsep))
)


class MetaPlugin(object):
    """For use in the internal meta-hierarchy as "do not register me" mark"""


class PluginRegistry(type):
    """Core of simple plugin framework

    This ``superclass'' serves two roles:

    (1) metaclass for plugins (and its class hierarchy)
        - only a tiny wrapper on top of `type`
예제 #49
0
def main(argv = None):
    if argv is None:
        argv = sys.argv

    version = __doc__.split ('\n')[0]

    parser = OptionParser (usage = '%prog', version = version, 
                           description = __doc__)
    
    parser.add_option('--showops', action = 'store_true',
                      dest = 'showops', default = False,
                      help = 'show operations')

    parser.add_option('--modules', action = 'store_true',
                      dest = 'modules', default = False,
                      help = 'generate module dependencies')

    parser.add_option('--calls', action = 'store_true',
                      dest = 'calls', default = False,
                      help = 'generate callgraph')

    parser.add_option('--files', action = 'store_true',
                      dest = 'files', default = False,
                      help = 'generate file dependencies')

    parser.add_option('--debug', action = 'store_true',
                      dest = 'debug', default = False,
                      help = 'enable debugging')

    parser.add_option('--exclude', dest = 'exclude',
                      default = '',
                      help = 'files to exclude')

    parser.add_option('--objext', dest = 'objext',
                      default = '.o',
                      help = 'object file extension')

    parser.add_option('--exeext', dest = 'exeext',
                      default = '.out',
                      help = 'executable file extension')

    parser.add_option('--cc', dest = 'cc',
                      default = 'gcc',
                      help = 'compiler name')

    parser.add_option('--cflags', dest = 'cflags',
                      default = '',
                      help = 'CFLAGS')

    parser.add_option('--relpath', action = 'store_true',
                      dest = 'relpath', default = False,
                      help = 'use relative paths')

    parser.add_option('--outfile',  dest = 'outfilename',
                      default = None,
                      help = 'output filename')

    parser.add_option('--builddir',  dest = 'builddir',
                      default = '',
                      help = 'build dirname')

    parser.add_option('--template',  dest = 'template',
                      default = None,
                      help = 'template filename')

    (options, args) = parser.parse_args ()

    if len (args) < 1:
        print __doc__
        sys.exit (0)


    if ',' in options.exclude:
        options.exclude = options.exclude.split(',')
    else:
        options.exclude = options.exclude.split()

    maincfilename = args[0]

    search_list = []
    if len (args) > 1:
        search_list.extend (args[1:len (args)])

    search_path = pathsep.join (search_list)

    includes = '-I' + ' -I'.join (search_list)
    options.compile = options.cc + ' ' + options.cflags + ' ' + includes

    if options.debug:
        print >> sys.stderr, search_list
        print >> sys.stderr, 'template', options.template
        print >> sys.stderr, 'cfile', maincfilename
        print >> sys.stderr, 'search_path', search_path
        print >> sys.stderr, 'CWD = ', os.getcwd()
        print >> sys.stderr, options.compile

    if os.path.isdir (maincfilename):
        if options.debug:
            print >> sys.stderr, 'Searching ' + maincfilename
        maincfilename = maincfilename_find (maincfilename)
        if not maincfilename:
            sys.exit (1)

        if options.debug:
            print >> sys.stderr, 'Found C file ' + maincfilename


    # Search main c file looking for header files included with #include
    # and any header files included by the header files    

    filedeps = {}
    moduledeps = {}
    files_find (maincfilename, search_path, filedeps, moduledeps, '', options.debug)
    
    cfilelist = cfiles_get_all (filedeps)
    ofilelist = [cfile[:-2] + options.objext for cfile in cfilelist]
    outfile = maincfilename[:-2] + options.exeext
    filedeps[outfile] = ofilelist
    for ofile in ofilelist:
        deps = []
        deps.append (ofile[:-2] + '.c')
        filedeps[ofile] = deps

    if options.calls:
        functiondeps = {}
        functions = {}
        for cfile in cfilelist:
            functions_find (cfile, functiondeps, functions, options)
        callgraph_print ('main', functiondeps, functions, options)

    if options.files:
        deps_print (outfile, filedeps, options)

    if options.modules:
        target, ext = os.path.splitext (os.path.basename (maincfilename))
        deps_print (target, moduledeps, options)

    if options.template:
        makefile_print (options, options.template, maincfilename, filedeps,
                        search_list)

    return 0
예제 #50
0
def makefile_print (options, template, maincfilename, filedeps, 
                    search_list):
    
    cfilelist = cfiles_get_all (filedeps)
    cfilelist.sort ()
    basecfilelist = [os.path.basename (cfile) for cfile in cfilelist]

    project = os.path.splitext (os.path.basename (maincfilename))
    project = project[0]

    file = open (template, 'r')

    text = file.read ()
    file.close ()

    hfilelist = hfiles_get_all (filedeps)

    includedirs = paths_prune (hfilelist)
    moduledirs = paths_prune (cfilelist)

    vpath = ' '.join (moduledirs)
    includes = '-I' + ' -I'.join (includedirs)
    src = ' '.join (basecfilelist)
    obj = src

    if options.builddir != '':
        objfilelist = [os.path.join (options.builddir, obj1) for obj1 in basecfilelist]
        objfilelist.sort ()
        obj = ' '.join (objfilelist)
        project = os.path.join (options.builddir, project)

    obj = re.sub (r'([a-zA-Z0-9/.-_]*)[.]c', r'\1' + options.objext, obj) 

    text = re.sub (r'@PROJECT@', project, text)
    text = re.sub (r'@VPATH@', vpath, text)
    text = re.sub (r'@CC@', options.cc, text)
    text = re.sub (r'@CFLAGS@', options.cflags, text)
    text = re.sub (r'@INCLUDES@', includes, text)
    text = re.sub (r'@SRC@', src, text)

    text = re.sub (r'@OBJ@', obj, text)

    if re.search (r'@CCRULES@', text) != None:

        search_path = pathsep.join (search_list)

        rules = ''
        for cfile in cfilelist:
            cfilebase = os.path.basename (cfile)

            if options.relpath:
                cfile1 = os.path.relpath (cfile)
            else:
                cfile1 = cfilebase

            if options.builddir != '':
                rules = rules + os.path.join (options.builddir, '')

            rules = rules + re.sub ('([a-zA-Z0-9/.-_]*)[.]c', r'\1' + options.objext, cfilebase) + ': ' + cfile1
            

            hfilelist = hfiles_get (cfile, filedeps, options)
            hfilelist.sort ()

            if options.debug:
                print >> sys.stderr, 'Need hfiles', hfilelist, 'for', cfile

            for hfile in hfilelist:
                rules = rules + ' ' + hfile

            rules = rules + '\n'
            rules = rules + '\t$(CC) -c $(CFLAGS) $< -o $@\n\n'

        text = re.sub (r'@CCRULES@', rules, text)


    print text
예제 #51
0
def ld_lib_path():
  global ld_lib_path_original
  global ld_lib_path_settings

  # concatenations with platform specific path separator (eg ':' colon on UNIX, ';' semicolon on windows)
  environ[ld_path_env_name()] = pathsep.join(ld_lib_path_settings.get("ld_library_path_items", []))
예제 #52
0
 def java_classpath(current_workdir):
     return pathsep.join([antlr, current_workdir])
예제 #53
0
import shutil
from os import chmod, environ, pathsep
from pathlib import Path

build_root = Path(environ['MESON_BUILD_ROOT'])
source_root = Path(environ['MESON_SOURCE_ROOT'])
install_prefix = Path(environ['MESON_INSTALL_DESTDIR_PREFIX'])

args = sys.argv[1:]

macos_lib_paths = filter(None, (Path(x) for x in args.pop(0).split(pathsep)))
macos_tool_paths = filter(None, (Path(x) for x in args.pop(0).split(pathsep)))
macos_tool_prefix = args.pop(0)

if macos_tool_paths:
    environ['PATH'] = pathsep.join(itertools.chain((str(p) for p in macos_tool_paths), [environ['PATH']]))

exe_path = install_prefix / 'Taisei.app' / 'Contents' / 'MacOS' / 'Taisei'
dylib_dir_path = exe_path.parent / 'dylibs'
dylib_dir_path.mkdir(mode=0o755, parents=True, exist_ok=True)


def tool(name):
    def func(*args):
        cmd = [macos_tool_prefix + name] + list(args)
        print(' '.join(('{0!r}' if ' ' in str(s) else '{0}').format(str(s)) for s in cmd))
        return subprocess.check_output(cmd, universal_newlines=True)
    return func

otool = tool('otool')
install_name_tool = tool('install_name_tool')
예제 #54
0
파일: vx.py 프로젝트: fish2000/Praxa
def _sequence_to_path(seq):
    return PATHSEP.join(seq)