def check_evoque_qpy(): try: import evoque except ImportError: prompt='Goliat uses evoque as template engine.\n\n'+\ 'Would you like to install evoque now?' if userquery(prompt)=="Yes": currdir=os.getcwd() os.chdir('evoque-0.4') from subprocess import Popen, PIPE p=Popen('python2.6 setup.py {0}'.format(args[0]).split(' '), stdout=PIPE, stderr=PIPE) print '\n{0}ing Goliat Evoque\n'.format(args[0].capitalize()) ret=p.communicate() if len(ret[1]): print ret[1] print '\nQuitting.' sys.exit(1) print ret[0] print '\nContinue.\n' os.chdir(currdir) #from setuptools.command.easy_install import main #main(['evoque']) #print '\nContinue.\n' try: import qpy except ImportError: prompt='Goliat uses qpy with evoque.\n\n'+\ 'Would you like to install qpy now?' if userquery(prompt)=="Yes": from setuptools.command.easy_install import main main(['qpy']) print '\nContinue.\n'
def DoEasyUninstall(name): """ Execute the easy_install command to unlink the given egg. What this is really doing is switching the egg to be in multiple-version mode, however this is the first step in deleting an egg as described here: http://peak.telecommunity.com/DevCenter/EasyInstall#uninstalling-packages """ from setuptools.command import easy_install args = ['--site-dirs', zenPath('ZenPacks'), '-d', zenPath('ZenPacks'), #'--record', tempPath, '--quiet', '-m', name] #Try to run the easy install command. If this fails with an attribute #error, then we know that easy_install doesn't know about this ZenPack and #we can continue normally try: easy_install.main(args) except AttributeError: log.info("%s not found by easy_install. Continuing to remove." % name) pass
def win_install_deps(options): """ Install all Windows Binary automatically This can be removed as wheels become available for these packages """ download_dir = path('downloaded').abspath() if not download_dir.exists(): download_dir.makedirs() win_packages = { #required by transifex-client "Py2exe": "http://superb-dca2.dl.sourceforge.net/project/py2exe/py2exe/0.6.9/py2exe-0.6.9.win32-py2.7.exe", "Nose": "https://s3.amazonaws.com/geonodedeps/nose-1.3.3.win32-py2.7.exe", #the wheel 1.9.4 installs but pycsw wants 1.9.3, which fails to compile #when pycsw bumps their pyproj to 1.9.4 this can be removed. "PyProj": "https://pyproj.googlecode.com/files/pyproj-1.9.3.win32-py2.7.exe" } failed = False for package, url in win_packages.iteritems(): tempfile = download_dir / os.path.basename(url) grab_winfiles(url, tempfile, package) try: easy_install.main([tempfile]) except Exception, e: failed = True print "install failed with error: ", e os.remove(tempfile)
def install_extension(self, install_url, package_name): """Install an extension from a remote source. Installs an extension from a remote URL containing the extension egg. Installation may fail if a malformed install_url or package_name is passed, which will cause an InstallExtensionError exception to be raised. It is also assumed that the extension is not already installed. """ try: easy_install.main(["-U", install_url]) # Update the entry points. dist = pkg_resources.get_distribution(package_name) dist.activate() pkg_resources.working_set.add(dist) except pkg_resources.DistributionNotFound: raise InstallExtensionError(_("Invalid package name.")) except SystemError: raise InstallExtensionError( _('Installation failed (probably malformed URL).')) # Refresh the extension manager. self.load(True)
def test_no_setup_cfg(self): # makes sure easy_install as a command (main) # doesn't use a setup.cfg file that is located # in the current working directory dir = tempfile.mkdtemp() setup_cfg = open(os.path.join(dir, "setup.cfg"), "w") setup_cfg.write("[easy_install]\nfind_links = http://example.com") setup_cfg.close() setup_py = open(os.path.join(dir, "setup.py"), "w") setup_py.write(SETUP_PY) setup_py.close() from setuptools.dist import Distribution def _parse_command_line(self): msg = "Error: a local setup.cfg was used" opts = self.command_options if "easy_install" in opts: assert "find_links" not in opts["easy_install"], msg return self._old_parse_command_line() Distribution._old_parse_command_line = Distribution.parse_command_line Distribution.parse_command_line = _parse_command_line old_wd = os.getcwd() try: os.chdir(dir) main([]) finally: os.chdir(old_wd) shutil.rmtree(dir) Distribution.parse_command_line = Distribution._old_parse_command_line
def win_install_deps(options): """ Install all Windows Binary automatically """ download_dir = path('downloaded').abspath() if not download_dir.exists(): download_dir.makedirs() win_packages = { "PIL": "https://pypi.python.org/packages/2.7/P/Pillow/Pillow-2.5.1.win32-py2.7.exe", "Py2exe": "http://superb-dca2.dl.sourceforge.net/project/py2exe/py2exe/0.6.9/py2exe-0.6.9.win32-py2.7.exe", "Nose": "https://s3.amazonaws.com/geonodedeps/nose-1.3.3.win32-py2.7.exe", "LXML": "https://pypi.python.org/packages/2.7/l/lxml/lxml-3.3.5.win32-py2.7.exe", "GDAL": "https://s3.amazonaws.com/geonodedeps/GDAL-1.11.0.win32-py2.7.exe", "PyProj": "https://pyproj.googlecode.com/files/pyproj-1.9.3.win32-py2.7.exe", "Shapely": "https://pypi.python.org/packages/2.7/S/Shapely/Shapely-1.3.0.win32-py2.7.exe", "Psycopg2": "http://www.stickpeople.com/projects/python/win-psycopg/psycopg2-2.4.5.win32-py2.7-pg9.1.3-release.exe" } for package, url in win_packages.iteritems(): tempfile = download_dir / os.path.basename(url) grab_winfiles(url, tempfile, package) try: easy_install.main([tempfile]) except: print "install failed" os.remove(tempfile) print "Windows dependencies now complete. Run pip install -e geonode --use-mirrors"
def win_install_deps(options): """ Install all Windows Binary automatically This can be removed as wheels become available for these packages """ download_dir = path('downloaded').abspath() if not download_dir.exists(): download_dir.makedirs() win_packages = { # required by transifex-client "Py2exe": dev_config['WINDOWS']['py2exe'], "Nose": dev_config['WINDOWS']['nose'], # the wheel 1.9.4 installs but pycsw wants 1.9.3, which fails to compile # when pycsw bumps their pyproj to 1.9.4 this can be removed. "PyProj": dev_config['WINDOWS']['pyproj'], "lXML": dev_config['WINDOWS']['lxml'] } failed = False for package, url in win_packages.iteritems(): tempfile = download_dir / os.path.basename(url) print "Installing file ... " + tempfile grab_winfiles(url, tempfile, package) try: easy_install.main([tempfile]) except Exception, e: failed = True print "install failed with error: ", e os.remove(tempfile)
def win_install_deps(options): """ Install all Windows Binary automatically This can be removed as wheels become available for these packages """ download_dir = path('downloaded').abspath() if not download_dir.exists(): download_dir.makedirs() win_packages = { # required by transifex-client "Py2exe": dev_config['WINDOWS']['py2exe'], "Nose": dev_config['WINDOWS']['nose'], # the wheel 1.9.4 installs but pycsw wants 1.9.3, which fails to compile # when pycsw bumps their pyproj to 1.9.4 this can be removed. "PyProj": dev_config['WINDOWS']['pyproj'], "lXML": dev_config['WINDOWS']['lxml'] } failed = False for package, url in win_packages.iteritems(): tempfile = download_dir / os.path.basename(url) print "Installing file ... " + tempfile grab_winfiles(url, tempfile, package) try: easy_install.main([tempfile]) except Exception as e: failed = True print "install failed with error: ", e os.remove(tempfile) if failed and sys.maxsize > 2**32: print "64bit architecture is not currently supported" print "try finding the 64 binaries for py2exe, nose, and pyproj" elif failed: print "install failed for py2exe, nose, and/or pyproj" else: print "Windows dependencies now complete. Run pip install -e geonode --use-mirrors"
def install(name): sys.stdout = sys.stderr = ei_stdout = StringIO() try: easy_install.main(["--install-dir", packages_dir, "--exclude-scripts", name]) except SystemExit as e: output = ei_stdout.getvalue() tb = StringIO() traceback.print_exc(8, tb) return { "success": False, "error": unicode(e), "traceback": tb.getvalue(), "output": output, } finally: sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ for name in os.listdir(packages_dir): path = os.path.join(packages_dir, name) if path not in sys.path: sys.path.insert(0, path) return { "success": True, "output": ei_stdout.getvalue(), }
def easyInstall(package): """ Generic method to install a package using the easy_install module, only if required. """ sys.stdout.write('\nSearching for installed %s ... ' % package) sys.stdout.flush() notFound = False try: __import__(package) sys.stdout.write('[FOUND]') except ImportError: sys.stdout.write('[NOT FOUND]') notFound = True if notFound: sys.stdout.write('\nInstalling %s:\n' % package) try: easy_install.main( ["-U", package] ) sys.stdout.write('[OK]\n') except: print "\nUnexpected error when trying to easy_install %s:\n" % (package), sys.exc_info()[0], sys.exc_info()[1] raise sys.stdout.flush()
def FetchZenPack(dmd, zenPackName): """ Use easy_install to retrieve the given zenpack and any dependencies. easy_install will install the eggs, but does not install them into Zenoss as ZenPacks. Return a list of distributions just installed that appear to be ZenPacks. NB: This should be refactored. It shares most of its code with DoEasyInstall() """ from setuptools.command import easy_install # Make sure $ZENHOME/ZenPacks exists CreateZenPacksDir() # Create the proper package index URL. index_url = "%s/%s/%s/" % (ZENPACKS_BASE_URL, dmd.uuid, ZVersion.VERSION) # Create temp file for easy_install to write results to _, tempPath = tempfile.mkstemp(prefix="zenpackcmd-easyinstall") # eggPaths is a set of paths to eggs that were installed. We need to # add them to the current workingset so we can discover their # entry points. eggPaths = set() try: # Execute the easy_install args = [ "--site-dirs", zenPath("ZenPacks"), "-d", zenPath("ZenPacks"), "-i", index_url, "--allow-hosts", urlparse(index_url).hostname, "--record", tempPath, "--quiet", zenPackName, ] easy_install.main(args) # Collect the paths for eggs that were installed f = open(tempPath, "r") marker = ".egg/" markerOffset = len(marker) - 1 for l in f.readlines(): i = l.find(marker) if i > 0: eggPaths.add(l[: i + markerOffset]) finally: os.remove(tempPath) # Add any installed eggs to the current working set zpDists = [] for path in eggPaths: zpDists += AddDistToWorkingSet(path) return zpDists
def run(self): # Workaround for problem in six that prevents installation when part of # of some package requirements _easy_install.main(['-U', 'six']) _install.run(self) self.execute( _post_install, (self.install_lib,), msg="\nRunning post install tasks...")
def installModule(self, module): try: easy_install.main([module]) except: print colored('''[%s] [-] Error installing %s module. Possibly setuptools module is not installed. Please visit https://pypi.python.org/pypi/setuptools to download setuptools, and try again. Exiting...''' % (time.strftime('%H:%M:%S'), module), 'red') exit() else: print colored('[%s] [+] %s module has been sucessfully installed' %(time.strftime('%H:%M:%S'), module), 'green')
def install_with_easyinstall(package): try: __import__(package) in_system.append(package) except ImportError: print 'Installing ' + package + '...' try: easy_install.main(['-U', package]) installed.append(package) except Exception: problematic.append(package)
def easy(eas=easy_pack): color="BLUE" message = forma.line("Install i moduli di Python: ") print (colorstr(message, color)) for i in eas: temp_message= "Installazione di "+i+" in corso: " message = forma.line(temp_message) print (colorstr(message, color)) easy_install.main(["-U", i]) message = forma.line("moduuli installati correttamente!!") print (colorstr(message, color))
def run(self): develop.develop.run(self) # create symlink to legacy MaKaC dir # this is so that the ".egg-link" created by the "develop" command works if sys.platform in ["linux2", "darwin"] and not os.path.exists('MaKaC'): os.symlink('indico/MaKaC', 'MaKaC') # install dev dependencies env = pkg_resources.Environment() easy_install.main(read_requirements_file(os.path.join(os.path.dirname(__file__), 'requirements.dev.txt'))) env.scan()
def find_module(self, fullname, path=None): if fullname in self.domain_modules: return self if fullname in self.tried_modules: return None else: self.tried_modules.add(fullname) try: main([fullname]) return self except: return None
def install_dependencies(): from setuptools.command import easy_install import pkg_resources easy_install.main( ['setuptools', 'sqlalchemy', 'alembic', 'tornado >= 3.1', 'simplejson >= 1.9.2', 'WTForms >= 2.0', 'WTForms-Components', 'pillow' ])
def run(self): dirs = ["~", ".local", "share", "kupfer", "plugins"] install_path = path.expanduser(path.join(*dirs)) print("mkdir {}".format(install_path)) call("mkdir -p {}".format(install_path), shell=True) plugin_file = path.join(plugin_path, plugin_module + '.py') print("Copy {} to {}".format(plugin_file, install_path)) call("cp -p {} {}".format(plugin_file, install_path), shell=True) print("Install dependency") easy_install.main(['--user', 'pip'] )
def run(self): develop.develop.run(self) # create symlink to legacy MaKaC dir # this is so that the ".egg-link" created by the "develop" command works if sys.platform in ["linux2", "darwin"] and not os.path.exists('MaKaC'): os.symlink('indico/MaKaC', 'MaKaC') # install dev dependencies env = pkg_resources.Environment() easy_install.main(DEVELOP_REQUIRES) env.scan()
def install_dependencies(): from setuptools.command import easy_install easy_install.main( ['setuptools', 'django == 1.4', 'django-tastypie == 0.9.11', 'django-tables2', 'simplejson >= 1.9.2', 'httplib2 >= 0.6.0', 'Distutils2', 'CherryPy >= 3.2.2', 'south', 'manifesto', 'requests'])
def test(): print('Running UBC Sailbot Control Tests') nose_installed = True try: import nose except ImportError: easy_install.main(['nose']) nose_installed = False if (nose_installed): suite_1 = nose.loader.TestLoader().loadTestsFromName(TEST_PACKAGE) nose.run(suite=suite_1) else: print("\n Installed missing dependencies. Rerun test script \n")
def tryLibrary(importname, textname, url): try: exec('import ' + importname) print "[OK] ",textname,"library present.\n" except: print "[!!] Unable to open the",textname,"library." print "[!!] Trying to use easy_install to install it now..." try: easy_install.main( ["-U",importname] ) print "[OK] ",textname,"library installed.\n" except: print "[!!] Could not install ",textname,"library with easy_install." print "[!!] Library available at:" print " ",url
def install_pkg(name): """ Install package with alea_install """ from pkg_resources import require require('openalea.deploy') from openalea.deploy.alea_install import main try: print 'Installing ' + name main(['-f', ALEA_PI_URL, name]) print '%s installed' % name except: print "Cannot install %s. Do you have root permission ?" % name print "Add sudo before your python command, or use --install-dir."
def setUp(self): TestCase.setUp(self) try: import webtest except ImportError: import setuptools.command.easy_install as easy_install easy_install.main(["WebTest"]) exit() self.test_app = webtest.TestApp(_wsgi_application) from google.appengine.ext.testbed import Testbed self.testbed = Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_memcache_stub()
def DoEasyInstall(eggPath): """ Use easy_install to install an egg from the filesystem. easy_install will install the egg, but does not install it into Zenoss as ZenPacks. Returns a list of distributions that were installed that appear to be ZenPacks. """ from setuptools.command import easy_install # Make sure $ZENHOME/ZenPacks exists CreateZenPacksDir() # Create temp file for easy_install to write results to _, tempPath = tempfile.mkstemp(prefix="zenpackcmd-easyinstall") # eggPaths is a set of paths to eggs that were installed. We need to # add them to the current workingset so we can discover their # entry points. eggPaths = set() try: # Execute the easy_install args = [ "--site-dirs", zenPath("ZenPacks"), "-d", zenPath("ZenPacks"), "--allow-hosts", "None", "--record", tempPath, "--quiet", eggPath, ] easy_install.main(args) # Collect the paths for eggs that were installed f = open(tempPath, "r") marker = ".egg/" markerOffset = len(marker) - 1 for l in f.readlines(): i = l.find(marker) if i > 0: eggPaths.add(l[: i + markerOffset]) finally: os.remove(tempPath) # Add any installed eggs to the current working set zpDists = [] for path in eggPaths: zpDists += AddDistToWorkingSet(path) return zpDists
def install_with_easyinstall(package): try: if package == 'PyWavelets': __import__('pywt') elif package == 'PIL': __import__('Image') else: __import__(package) in_system.append(package) except ImportError: print 'Installing ' + package try: easy_install.main(['-U', package]) installed.append(package) except Exception: problematic.append(package)
def run(self): # easy_install from urls install_urls = [ "https://github.com/pyfarm/pyfarm-core/archive/master.zip", "https://github.com/pyfarm/pyfarm-agent/archive/master.zip", "https://github.com/pyfarm/pyfarm-master/archive/master.zip", "https://github.com/pyfarm/pyfarm-models/archive/master.zip", "https://github.com/pyfarm/pyfarm-jobtypes/archive/master.zip"] easy_install.main(install_urls) # regular install command if self.old_and_unmanageable or self.single_version_externally_managed: _install.run(self) else: self.do_egg_install()
def module_installer(package): """ Install a package given via PIP or easy_install. :param package: str the name of the package. """ global on_pip global on_easy_install print('Setting up: ' + package) if on_pip: pip.main(['install', package]) # PIP command elif on_easy_install: easy_install.main(['-U', package]) # easy_install command else: return None
def get_long_description(): readme_file = 'README.md' if not os.path.isfile(readme_file): return '' # Try to transform the README from Markdown to reStructuredText. try: easy_install.main(['-U', 'pyandoc==0.0.1']) import pandoc pandoc.core.PANDOC_PATH = 'pandoc' doc = pandoc.Document() doc.markdown = open(readme_file).read() description = doc.rst except Exception: description = open(readme_file).read() return description
def install_package(pkg_name): import setuptools, pkg_resources, site, sysconfig from setuptools.command import easy_install if sys.platform.startswith('java'): from distutils.command.install import INSTALL_SCHEMES INSTALL_SCHEMES['java_user'] = { 'purelib': '$usersite', 'platlib': '$usersite', 'headers': '$userbase/include/python$py_version_short/$dist_name', 'scripts': '$userbase/bin', 'data': '$userbase', } import setuptools from setuptools import ssl_support ssl_support.is_available = False from java.net import URL from java.io import BufferedInputStream from jarray import zeros org_urlopen = urllib2.urlopen class Headers(dict): def getheaders(self, key): value = self.get(key.lower()) if (value == None): return list() else: return list(value) class ConnReader: def __init__(self, conn): self.conn = conn self.url = conn.getURL().toExternalForm() fields = self.conn.getHeaderFields() self.headers = Headers() for key in fields: if key != None: self.headers[key.lower()] = conn.getHeaderField(key) self.bs = BufferedInputStream(self.conn.getInputStream()) def read(self, *args): if len(args) == 1: size = args[0] buf = zeros(size, 'b') off = 0 while size > 0: count = self.bs.read(buf, off, size) if count == -1: buf = buf[:off] break off += count size -= count return buf.tostring() else: return self.read(int(self.headers['content-length'])) def info(self): return Headers(self.headers) def close(self): self.bs.close() def new_urlopen(req): if isinstance(req, str): full_url = req else: full_url = req.get_full_url() if full_url.startswith('https'): u = URL(full_url) conn = u.openConnection() return ConnReader(conn) else: org_urlopen(req) urllib2.urlopen = new_urlopen old_rmtree = easy_install.rmtree def new_rmtree(path, ignore_errors=False, onerror=easy_install.auto_chmod): try: old_rmtree(path, ignore_errors, onerror) except: sys.stderr.write( "Unable to remove temporary directory : %s\n" % ((path))) sys.stderr.flush() easy_install.rmtree = new_rmtree try: dist = pkg_resources.get_distribution(pkg_name) except: log.warn("Downloading package %s...", pkg_name) mkdir_p(site.USER_SITE) easy_install.main(argv=['--user', '-U', pkg_name]) site.addsitedir(sysconfig.get_path('platlib', os.name + '_user')) reload(pkg_resources) dist = pkg_resources.get_distribution(pkg_name) dist.activate() if sys.platform.startswith('java'): urllib2.urlopen = org_urlopen easy_install.rmtree = old_rmtree return dist.version
# for installing magic IPython stuff # In ipython run this # %load https://raw.github.com/jkitchin/pycse/master/install-pycse.py from setuptools.command import easy_install easy_install.main(["-U", "pycse"]) # my customized pyreport package = 'https://github.com/jkitchin/pyreport/archive/master.zip' easy_install.main(["-U", package]) import IPython, os IPydir = os.path.join(IPython.utils.path.get_ipython_dir(), 'profile_default', 'startup') print 'Installing ipython magic to : ', IPydir if not os.path.exists(IPydir): raise Exception('No ipython directory found') url = 'https://raw.github.com/jkitchin/pycse/master/pycse/00-pycse-magic.py' import urllib urllib.urlretrieve(url, os.path.join(IPydir, '00-pycse-magic.py')) print 'Ipython magic installed now!' # extra packages easy_install.main(["-U", "quantities"])
# -*- coding: utf-8 -*- from setuptools.command import easy_install import importlib import pkg_resources # If pip is not installed, install it try: import pip except ImportError: easy_install.main(['-U', 'pip']) finally: pkg_resources.require('pip') import pip # Install external packages packages = ['musicbrainzngs', 'soundcloud', 'mutagen'] for package in packages: try: importlib.import_module(package) except ImportError: pip.main(['install', package])
"...Okay...I mean that's cool, I'm not mad or anything but I really\n" "would have preferred for you to selected your own choice but here\n" "we are.\nUmm...\nSoooo....\nI guess this one will do...Have fun..." ) sleep(7) break if gselect == 'm': typewrite( "Awesome! Now lets go ahead and get a voice you like selected!") if gselect == 'f': typewrite( "Awesome! Now lets go ahead and get a voice you like selected!") # elif gselect != 'm' or 'f': # typewrite("Hey I also like to just press random keys, but to make sure " # "you get a voice you like. Please enter 'M' or 'F', and if you " # "don't want to press the shift key it's okay, I promise.") if maxAttempts == 0: engine = pyttsx3.init() rate = engine.getProperty('rate') engine.setProperty('rate', 300) volume = engine.getProperty('volume') engine.setProperty('volume', 0.95) voices = engine.getProperty('voices') engine.setProperty('voice', voices[0].id) sleep(0.4) questionOne() main()
# # See also: http://docs.astropy.org/en/stable/install.html#installing-astropy-into-casa # # but withouth the --user, so it installs for all users in the current python that casa used # # Note with casa6 may not be needed anymore. # from setuptools.command import easy_install easy_install.main(['pip']) import pip pip.main(['install', 'astropy'])
# https://github.com/ninjaaron/fast-entry_points # workaround for slow 'pkg_resources' import # # NOTE: this only has effect on console_scripts and no speed-up for commands # under scripts/. Consider stop using scripts and use console_scripts instead # # https://stackoverflow.com/questions/18787036/difference-between-entry-points-console-scripts-and-scripts-in-setup-py try: import fastentrypoints except ImportError: from setuptools.command import easy_install import pkg_resources easy_install.main(['fastentrypoints']) pkg_resources.require('fastentrypoints') import fastentrypoints import glob from setuptools import setup import unittest def get_test_suite(): test_loader = unittest.TestLoader() test_suite = test_loader.discover('sonic-utilities-tests', pattern='*.py') return test_suite setup( name='sonic-utilities', version='1.2', description='Command-line utilities for SONiC',
def stage1(tmpdir, sourcepath): """STAGE 1: temporary install EasyBuild using distribute's easy_install.""" info( "\n\n+++ STAGE 1: installing EasyBuild in temporary dir with easy_install...\n\n" ) # determine locations of source tarballs, if sources path is specified source_tarballs = {} if sourcepath is not None: info("Fetching sources from %s..." % sourcepath) for pkg in EASYBUILD_PACKAGES: pkg_tarball_glob = os.path.join(sourcepath, '%s*.tar.gz' % pkg) pkg_tarball_paths = glob.glob(pkg_tarball_glob) if len(pkg_tarball_paths) > 1: error("Multiple tarballs found for %s: %s" % (pkg, pkg_tarball_paths)) elif len(pkg_tarball_paths) == 0: if pkg != VSC_BASE: # vsc-base package is not strictly required # it's only a dependency since EasyBuild v2.0; # with EasyBuild v2.0, it will be pulled in from PyPI when installing easybuild-framework error("Missing source tarball: %s" % pkg_tarball_glob) else: info("Found %s for %s package" % (pkg_tarball_paths[0], pkg)) source_tarballs.update({pkg: pkg_tarball_paths[0]}) from setuptools.command import easy_install # prepare install dir targetdir_stage1 = os.path.join(tmpdir, 'eb_stage1') prep(targetdir_stage1) # set PATH, Python search path # install latest EasyBuild with easy_install from PyPi cmd = [] cmd.append('--upgrade') # make sure the latest version is pulled from PyPi cmd.append('--prefix=%s' % targetdir_stage1) if source_tarballs: # install provided source tarballs (order matters) cmd.extend([ source_tarballs[pkg] for pkg in EASYBUILD_PACKAGES if pkg in source_tarballs ]) else: # install meta-package easybuild from PyPI cmd.append('easybuild') if not print_debug: cmd.insert(0, '--quiet') info("installing EasyBuild with 'easy_install %s'" % (' '.join(cmd))) easy_install.main(cmd) # clear the Python search path, we only want the individual eggs dirs to be in the PYTHONPATH (see below) # this is needed to avoid easy-install.pth controlling what Python packages are actually used os.environ['PYTHONPATH'] = '' # template string to inject in template easyconfig templates = {} for pkg in EASYBUILD_PACKAGES: templates.update({pkg: ''}) pkg_egg_dir = find_egg_dir_for(targetdir_stage1, pkg) if pkg_egg_dir is None: if pkg == VSC_BASE: # vsc-base is optional in older EasyBuild versions continue # prepend EasyBuild egg dirs to Python search path, so we know which EasyBuild we're using sys.path.insert(0, pkg_egg_dir) pythonpaths = [ x for x in os.environ.get('PYTHONPATH', '').split(os.pathsep) if len(x) > 0 ] os.environ['PYTHONPATH'] = os.pathsep.join([pkg_egg_dir] + pythonpaths) if source_tarballs: if pkg in source_tarballs: templates.update( {pkg: "'%s'," % os.path.basename(source_tarballs[pkg])}) else: # determine per-package versions based on egg dirs, to use them in easyconfig template version_regex = re.compile('%s-([0-9a-z.-]*)-py[0-9.]*.egg' % pkg.replace('-', '_')) pkg_egg_dirname = os.path.basename(pkg_egg_dir) res = version_regex.search(pkg_egg_dirname) if res is not None: pkg_version = res.group(1) debug("Found version for easybuild-%s: %s" % (pkg, pkg_version)) templates.update({pkg: "'%s-%s.tar.gz'," % (pkg, pkg_version)}) else: tup = (pkg, pkg_egg_dirname, version_regex.pattern) error( "Failed to determine version for easybuild-%s package from %s with %s" % tup) # figure out EasyBuild version via eb command line # note: EasyBuild uses some magic to determine the EasyBuild version based on the versions of the individual packages pattern = "This is EasyBuild (?P<version>%(v)s) \(framework: %(v)s, easyblocks: %(v)s\)" % { 'v': '[0-9.]*[a-z0-9]*' } version_re = re.compile(pattern) version_out_file = os.path.join(tmpdir, 'eb_version.out') eb_version_cmd = 'from easybuild.tools.version import this_is_easybuild; print(this_is_easybuild())' cmd = "python -c '%s' > %s 2>&1" % (eb_version_cmd, version_out_file) debug("Determining EasyBuild version using command '%s'" % cmd) os.system(cmd) txt = open(version_out_file, "r").read() res = version_re.search(txt) if res: eb_version = res.group(1) debug("installing EasyBuild v%s" % eb_version) else: error( "Stage 1 failed, could not determine EasyBuild version (txt: %s)." % txt) templates.update({'version': eb_version}) # clear PYTHONPATH before we go to stage2 # PYTHONPATH doesn't need to (and shouldn't) include the stage1 egg dirs os.environ['PYTHONPATH'] = '' # make sure we're getting the expected EasyBuild packages import easybuild.framework if tmpdir not in easybuild.framework.__file__: error("Found another easybuild-framework than expected: %s" % easybuild.framework.__file__) else: debug("Found easybuild-framework in expected path, good!") import easybuild.easyblocks if tmpdir not in easybuild.easyblocks.__file__: error("Found another easybuild-easyblocks than expected: %s" % easybuild.easyblocks.__file__) else: debug("Found easybuild-easyblocks in expected path, good!") debug("templates: %s" % templates) return templates
from setuptools.command import easy_install # install python packages easy_install.main( ['genshi==0.7', 'sqlalchemy==0.7.6', 'psycopg2==2.4.5', 'pytz==2015.07', 'pandas==0.13.0.dev0', 'bcrypt==0.4', 'markdown==2.3.1', 'matplotlib==1.3.1', 'configparser==3.3.0.post2', 'xlrd==0.9.4']) # install linux software # TODO: add linux software dep # TODO: SETUP.PY script # python -- # # genshi # sqlalchemy # psycopg2 # pytz # pandas # bcrypt # markdown # matplotlib # [ #linux software
# Using easy_install inside a python script? from setuptools.command import easy_install easy_install.main( ["-U","py2app"] )
import os try: import shodan except ImportError: try: print('[-] Shodan isn`t found. Try to install it...') from setuptools.command import easy_install easy_install.main(["-U", "shodan"]) print('[+] Shodan was installed') import shodan except ImportError: print('[-] Oops. Something went wrong!') print('[-] Couldn`t install shodan') exit(-1) from math import ceil import argparse parser = argparse.ArgumentParser(description='Console search in Shodan') parser.add_argument('-o', dest='out_file', action='store', help='Output file for results') parser.add_argument('-q', dest='query', action='store', help='Search query') parser.add_argument('-k', dest='shodan_key', action='store', help='Shodan API key') args = parser.parse_args()
if __name__ == '__main__': import sys from setuptools.command.easy_install import main sys.exit(main())
def install_with_easyinstall(package): """Install the specified packages (in dry-run).""" easy_install.main(["-U", package])
sys.exit(2) #TGEND req = "setuptools>=" + version import pkg_resources try: pkg_resources.require(req) except pkg_resources.VersionConflict: try: from setuptools.command.easy_install import main except ImportError: from easy_install import main #TGBEGIN install_command() #TGEND main(list(argv)+[download_setuptools(delay=0)]) sys.exit(0) # try to force an exit else: from setuptools.command.easy_install import main #TGBEGIN install_command() #TGEND main(argv) def update_md5(filenames): """Update our built-in md5 registry""" import re for name in filenames: base = os.path.basename(name)
def install_addon(self, url, distribution): print "Installing", distribution, "from", url easy_install.main(["-U", "-f", url, distribution])
data = [" %r: %r,\n" % it for it in md5_data.items()] data.sort() repl = "".join(data) import inspect srcfile = inspect.getsourcefile(sys.modules[__name__]) f = open(srcfile, 'rb'); src = f.read(); f.close() match = re.search("\nmd5_data = {\n([^}]+)}", src) if not match: print >>sys.stderr, "Internal error!" sys.exit(2) src = src[:match.start(1)] + repl + src[match.end(1):] f = open(srcfile,'w') f.write(src) f.close() if __name__=='__main__': if len(sys.argv)>2 and sys.argv[1]=='--md5update': update_md5(sys.argv[2:]) else: main(sys.argv[1:])
def _installMissing(self, dist): env = pkg_resources.Environment() print dist, EXTRA_RESOURCES_URL easy_install.main(["-f", EXTRA_RESOURCES_URL, "-U", str(dist)]) env.scan() return env[str(dist)][0]
# How can I install Python modules programmatically / through a Python script? from setuptools.command import easy_install easy_install.main(["pythonModule"])
def install_with_easyinstall(package): for key, value in package.items(): easy_install.main([key + '==' + value])
def magic_easy_install(self, package): easy_install.main([args, package])
def onInstallPluginsEvent(self, event): patterns = "%s|*.tar.gz;*.tar|%s (*.*)|*.*" % (_(u"tar archives"), _(u"All files")) dlg = wx.FileDialog(None, _(u"Install Plugin"), "", "", patterns, wx.OPEN) if dlg.ShowModal() == wx.ID_OK: archive = dlg.GetPath() else: archive = None dlg.Destroy() if archive is not None: options = Globals.options # find writable path on options.pluginPath # it is assumed that, unless the user changed the defaults, # that pluginPath contains at least a path relative to CHANDLERHOME # and another relative to the user's PROFILEDIR, in that order, # so that plugins are installed in a shared directory (when # CHANDLERHOME is shared) by default. for pluginsDir in options.pluginPath: try: if not os.path.exists(pluginsDir): os.makedirs(pluginsDir) except OSError: continue if os.access(pluginsDir, os.W_OK): break else: raise ValueError, ('no writable path in pluginPath', options.pluginPath) try: from setuptools.command.easy_install import main from distutils.log import _global_log from util.string_utils import nocase_replace # patch distutils' logger with logging's # distutils logging levels happen to be one tenth of logging's # Also ensure that we don't write full profileDir to log, # which would be a security issue. def log(level, msg, args): if msg: if wx.Platform == '__WXMSW__': msg = nocase_replace(msg, Globals.options.profileDir, '$PROFILEDIR') else: msg = msg.replace(Globals.options.profileDir, '$PROFILEDIR') logger.log(level * 10, msg, *args) _log = _global_log._log _global_log._log = log try: main([ '--multi-version', '--install-dir', pluginsDir, archive ]) except: logger.exception("Plugin installation failed") # Could be a SystemExit exception, since we called a # main() directly. finally: _global_log._log = _log env, eggs = Utility.initPluginEnv(options, options.pluginPath) prefs = Utility.initPlugins(options, self.itsView, env, eggs) # Update the menus self.widget.GetSubMenu().pluginPrefs = prefs.get('plugins', {}) self.synchronizeWidget() self.refreshMenus(self.itsView)
def stage1(tmpdir): """STAGE 1: temporary install EasyBuild using distribute's easy_install.""" info( "\n\n+++ STAGE 1: installing EasyBuild in temporary dir with easy_install...\n\n" ) from setuptools.command import easy_install # prepare install dir targetdir_stage1 = os.path.join(tmpdir, 'eb_stage1') prep(targetdir_stage1) # set PATH, Python search path # install latest EasyBuild with easy_install from PyPi cmd = [] cmd.append('--upgrade') # make sure the latest version is pulled from PyPi cmd.append('--prefix=%s' % targetdir_stage1) cmd.append('easybuild') if not print_debug: cmd.insert(0, '--quiet') debug("installing EasyBuild with 'easy_install %s'" % (" ".join(cmd))) easy_install.main(cmd) # clear the Python search path, we only want the individual eggs dirs to be in the PYTHONPATH (see below) # this is needed to avoid easy-install.pth controlling what Python packages are actually used os.environ['PYTHONPATH'] = '' versions = {} pkg_egg_dir_framework = None for pkg in ['easyconfigs', 'easyblocks', 'framework']: pkg_egg_dir = find_egg_dir_for(targetdir_stage1, 'easybuild-%s' % pkg) # prepend EasyBuild egg dirs to Python search path, so we know which EasyBuild we're using sys.path.insert(0, pkg_egg_dir) pythonpaths = [ x for x in os.environ.get('PYTHONPATH', '').split(os.pathsep) if len(x) > 0 ] os.environ['PYTHONPATH'] = os.pathsep.join([pkg_egg_dir] + pythonpaths) # determine per-package versions based on egg dirs version_regex = re.compile('easybuild_%s-([0-9a-z.-]*)-py[0-9.]*.egg' % pkg) pkg_egg_dirname = os.path.basename(pkg_egg_dir) res = version_regex.search(pkg_egg_dirname) if res is not None: pkg_version = res.group(1) versions.update({'%s_version' % pkg: pkg_version}) debug("Found version for easybuild-%s: %s" % (pkg, pkg_version)) else: error( "Failed to determine version for easybuild-%s package from %s with %s" % (pkg, pkg_egg_dirname, version_regex.pattern)) if pkg == 'framework': pkg_egg_dir_framework = pkg_egg_dir # figure out EasyBuild version via eb command line # NOTE: EasyBuild uses some magic to determine the EasyBuild version based on the versions of the individual packages version_re = re.compile( "This is EasyBuild (?P<version>[0-9.]*[a-z0-9]*) \(framework: [0-9.]*[a-z0-9]*, easyblocks: [0-9.]*[a-z0-9]*\)" ) version_out_file = os.path.join(tmpdir, 'eb_version.out') os.system("python -S %s/easybuild/main.py --version > %s 2>&1" % (pkg_egg_dir_framework, version_out_file)) txt = open(version_out_file, "r").read() res = version_re.search(txt) if res: eb_version = res.group(1) debug("installing EasyBuild v%s" % eb_version) else: error( "Stage 1 failed, could not determine EasyBuild version (txt: %s)." % txt) versions.update({'version': eb_version}) # clear PYTHONPATH before we go to stage2 # PYTHONPATH doesn't need to (and shouldn't) include the stage1 egg dirs os.environ['PYTHONPATH'] = '' # make sure we're getting the expected EasyBuild packages import easybuild.framework if not tmpdir in easybuild.framework.__file__: error("Found another easybuild-framework than expected: %s" % easybuild.framework.__file__) else: debug("Found easybuild-framework in expected path, good!") import easybuild.easyblocks if not tmpdir in easybuild.easyblocks.__file__: error("Found another easybuild-easyblocks than expected: %s" % easybuild.easyblocks.__file__) else: debug("Found easybuild-easyblocks in expected path, good!") return versions
#!/usr/bin/python from setuptools.command import easy_install easy_install.main(["-U", "virtualenv"]) easy_install.main(["-U", "gdata"]) easy_install.main(["-U", "flask"]) easy_install.main(["-U", "pyparsing"]) easy_install.main(["-U", "google-api-python-client"])
import json import boto3 from botocore.vendored import requests from awsglue.utils import getResolvedOptions import logging import sys import os import site from setuptools.command import easy_install install_path = os.environ['GLUE_INSTALLATION'] easy_install.main([ "--install-dir", install_path, "https://files.pythonhosted.org/packages/83/03/10902758730d5cc705c0d1dd47072b6216edc652bc2e63a078b58c0b32e6/pg8000-1.12.5.tar.gz" ]) reload(site) import pg8000 from urlparse import urlparse logging.basicConfig() logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) #Required Parameters args = getResolvedOptions(sys.argv, [ 'UserName', 'UserPassword', 'Database', 'HostName', 'Port', 'SQLScript', 'Role' ]) user = args['UserName'] password = args['UserPassword'] database = args['Database']
def install_with_easyinstall(package): easy_install.main(["-U", package])
import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.dynamicframe import DynamicFrame from awsglue.job import Job # install nltk import os import site from importlib import reload from setuptools.command import easy_install install_path = site.getsitepackages()[0] easy_install.main( ["--install-dir", "/home/spark/.local/lib/python3.7/site-packages", "https://files.pythonhosted.org/packages/92/75/ce35194d8e3022203cca0d2f896dbb88689f9b3fce8e9f9cff942913519d/nltk-3.5.zip"] ) reload(site) import nltk from pyspark.sql import functions as F from pyspark.sql.types import * import bla as alb ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ## @type: DataSource
limitations under the License. E-mail the developers: [email protected] """ print "=== Harwell Automatic Recon Processor (HARP) ===\n" print "Downloading dependencies..." # easy_install first try: from setuptools.command import easy_install dependencies = ["six," "numpy", "scikit-image", "pyyaml", "PIL", "SimpleITK"] for dep in dependencies: try: print "Installing {0}...".format(dep), mod = __import__(dep) # try to import module print " already installed.".format(dep) except ImportError: # If it fails, try to easy install it easy_install.main(["--user", dep]) print "done." except ImportError: print "Couldn't locate 'easy_install'. Do you have setuptools installed on your machine? Try sudo apt-get install python-setuptools (Linux) or use Homebrew (Mac)."
def run(self): # dependencies, links, etc... develop_indico.run(self) env = pkg_resources.Environment() easy_install.main(DEVELOP_REQUIRES) env.scan() local = 'etc/indico.conf' if os.path.exists(local): print 'Upgrading existing etc/indico.conf..' upgrade_indico_conf(local, 'etc/indico.conf.sample') else: print 'Creating new etc/indico.conf..' shutil.copy('etc/indico.conf.sample', local) for f in [ x for x in ('etc/zdctl.conf', 'etc/zodb.conf', 'etc/logging.conf') if not os.path.exists(x) ]: shutil.copy('%s.sample' % f, f) print """\nIndico needs to store some information in the filesystem (database, cache, temporary files, logs...) Please specify the directory where you'd like it to be placed. (Note that putting it outside of your sourcecode tree is recommended)""" prefixDirDefault = os.path.dirname(os.getcwd()) prefixDir = raw_input('[%s]: ' % prefixDirDefault).strip() if prefixDir == '': prefixDir = prefixDirDefault directories = dict((d, os.path.join(prefixDir, d)) for d in ['db', 'log', 'tmp', 'cache', 'archive']) print 'Creating directories...', for d in directories.values(): if not os.path.exists(d): os.makedirs(d) print 'Done!' directories['htdocs'] = os.path.join(os.getcwd(), 'indico', 'htdocs') directories['bin'] = os.path.join(os.getcwd(), 'bin') directories['etc'] = os.path.join(os.getcwd(), 'etc') directories['doc'] = os.path.join(os.getcwd(), 'doc') self._update_conf_dir_paths(local, directories) # avoid modifying the htdocs folder permissions (it brings problems with git) directories.pop('htdocs') from MaKaC.consoleScripts.installBase import _databaseText, _findApacheUserGroup, _checkDirPermissions, \ _updateDbConfigFiles, _updateMaKaCEggCache user = '' sourcePath = os.getcwd() # find the apache user/group user, group = _findApacheUserGroup(self.www_uid, self.www_gid) _checkDirPermissions(directories, dbInstalledBySetupPy=directories['db'], accessuser=user, accessgroup=group) _updateDbConfigFiles(directories['db'], directories['log'], os.path.join(sourcePath, 'etc'), directories['tmp'], user) _updateMaKaCEggCache( os.path.join(os.path.dirname(__file__), 'indico', 'MaKaC', '__init__.py'), directories['tmp']) updateIndicoConfPathInsideMaKaCConfig( os.path.join(os.path.dirname(__file__), ''), 'indico/MaKaC/common/MaKaCConfig.py') compileAllLanguages(self) print ''' %s ''' % _databaseText('etc')
import sys import time if not hasattr(sys, 'argv'): sys.argv = [''] time.sleep(5) from setuptools.command import easy_install #easy_install.main( ["-U","scipy==0.9.0"] ) time.sleep(3) easy_install.main(["-U", "-v", "sources/PyGObject-3.27.1.tar.gz"]) time.sleep(5) #easy_install.main( ["-U","pyserial==3.4"] )
url_address = 'http://feeds.bbci.co.uk/news/rss.xml' max_sentence_chars = 140 #for twitter ofc hours_to_tweet_news = [8, 12, 18, 22] #time at which to tweet number_of_stories number_of_stories = 5 gmt_offset = +1 #so that hours are valid try: import twitter except ImportError: try: print 'twitter module not found, trying to install...' from setuptools.command import easy_install easy_install.main(['-U', 'twitter']) import twitter except ImportError: print 'please download module from:' print 'http://mike.verdone.ca/twitter/#install' print 'easy_install not present :(' def postToTwitter(message): try: twit = twitter.Twitter( auth=twitter.OAuth(token, token_key, con_key, con_secret)) if len(message) <= 140: try: twit.statuses.update(status=message) except twitter.TwitterHTTPError:
.. _Chapter 5: chapter05.html .. _Chapter 6: chapter06.html .. _Chapter 7: chapter07.html .. _Chapter 8: chapter08.html .. _Chapter 9: chapter09.html .. _Chapter 10: chapter10.html .. _Chapter 11: chapter11.html .. _Chapter 12: chapter12.html .. _Chapter 13: chapter13.html .. _Chapter 14: chapter14.html .. _Chapter 15: chapter15.html .. _Chapter 16: chapter16.html .. _Chapter 17: chapter17.html .. _Chapter 18: chapter18.html .. _Chapter 19: chapter19.html .. _Chapter 20: chapter20.html """ on_rtd = os.environ.get('READTHEDOCS', None) == 'True' # On RTD we can't import sphinx_rtd_theme, but it will be applied by # default anyway. This block will use the same theme when building locally # as on RTD. if not on_rtd: try: import sphinx_rtd_theme except ImportError: easy_install.main(["sphinx_rtd_theme"]) html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]