def TestPlatform( ): print ("----------Operation System--------------------------") # 取得 python 版本 print '取得 python 版本 : ' + platform.python_version() # 取得操作系統可執行結構 : ex('64bit','WindowsPE') print "取得操作系統可執行結構 : ex('64bit','WindowsPE')" print platform.architecture() # 電腦目前網路群組名稱 print '電腦目前網路群組名稱' + platform.node() # 獲取操作系統名稱及版本號,‘Windows-7-6.1.7601-SP1’ print '獲取操作系統名稱及版本號 : ' + platform.platform() # 電腦處理器資訊,’Intel64 Family 6 Model 42 Stepping 7, GenuineIntel’ print '電腦處理器資訊 : ' + platform.processor() # 獲取操作系統中 Python 的構建日期 print "獲取操作系統中 Python 的構建日期" print platform.python_build() # 獲取系統中 python 解釋器的信息 print '獲取系統中 python 解釋器的信息 : ' + platform.python_compiler() if platform.python_branch()=="": print platform.python_implementation() print platform.python_revision() print "platform.release : " + platform.release() print "platform.system : " + platform.system() #print platform.system_alias() # 獲取操作系統版本 print '獲取操作系統版本 : ' + platform.version()
def check_python_version(self, impl=None, version=(), cmp_=operator.ge): """Check for Python version. Very loosely based upon :meth:`waflib.Tools.python.check_python_version()`, but simplified and designed to check the currently running interpreter. :param impl: Python implementation as returned by :func:`platform.python_implementation()` :type impl: :class:`str` :param version: Partial or full version tuple as returned by :func:`platform.python_version_tuple()` :type version: :class:`tuple` of :class:`str` :param cmp_: Comparison operator for the version :type cmp_: :class:`func` """ meets_requirements = ( (impl is None or platform.python_implementation() == impl) and (version == () or cmp_(platform.python_version_tuple(), version))) required_version_string = '.'.join(version) required_name = (impl or 'Python') + (' ' if version else '') + ( required_version_string) found_name = '{0} {1}'.format( platform.python_implementation(), platform.python_version()) self.msg('Checking for ' + required_name, found_name if meets_requirements else False) if not meets_requirements: self.fatal('Expecting {0}, found {1}'.format( required_name, found_name)) # Set the PYTHON configuration variable if successful. It is set as a list # following the lead of find_program() in Waf 1.8. self.env.PYTHON = [sys.executable]
def _get_file_from_object(obj): if platform.python_implementation() == 'Jython': return obj.__file__.split("$py.class")[0] + ".py" if sys.version_info > (3, 0) or platform.python_implementation() == 'PyPy': return obj.__file__ else: return obj.__file__[:-1]
def detect_platform(): _implementation = None _implementation_version = None if "SERVER_SOFTWARE" in os.environ: v = os.environ["SERVER_SOFTWARE"] if v.startswith("Google App Engine/") or v.startswith("Development/"): _implementation = "Google App Engine" else: _implementation = platform.python_implementation() else: _implementation = platform.python_implementation() if _implementation == "CPython": _implementation_version = platform.python_version() elif _implementation == "PyPy": _implementation_version = "%s.%s.%s" % ( sys.pypy_version_info.major, sys.pypy_version_info.minor, sys.pypy_version_info.micro, ) if sys.pypy_version_info.releaselevel != "final": _implementation_version = "".join([_implementation_version, sys.pypy_version_info.releaselevel]) elif _implementation == "Jython": _implementation_version = platform.python_version() # Complete Guess elif _implementation == "IronPython": _implementation_version = platform.python_version() # Complete Guess elif _implementation == "Google App Engine": v = os.environ["SERVER_SOFTWARE"] _implementation_version = v.split("/")[1] else: _implementation_version = "Unknown" return {"implementation": _implementation, "version": _implementation_version}
def get_python_version(): version = "" if platform.python_implementation() == "CPython": version = "Python" else: version = platform.python_implementation() version += " {0}.{1} ".format(sys.version_info[0], sys.version_info[1]) version += "({0})".format(platform.architecture()[0]) return version
def initialize_platform(): """Check the python_implementation and the python_version. Update the global variables __is_iron_python__ and __is_unicode__. """ global __is_iron_python__, __is_unicode__ if platform.python_implementation() == "CPython": if platform.python_version_tuple()[0] >= '3': __is_unicode__ = True elif platform.python_implementation() == "IronPython": __is_iron_python__ = True __is_unicode__ = True
def get_python_version(): """Return the Python version number as a string.""" version = "" if platform.python_implementation() == "CPython": version = "Python" else: version = platform.python_implementation() version += " {0}.{1}.{2} ".format(sys.version_info[0], sys.version_info[1], sys.version_info[2]) version += "({0})".format(platform.architecture()[0]) return version
def python_version_string(): """We use it to generate per python folder name, where we will install all packages. """ if platform.python_implementation() == 'PyPy': version_info = sys.pypy_version_info else: version_info = sys.version_info version_string = '{v.major}.{v.minor}.{v.micro}'.format(v=version_info) build, _ = platform.python_build() build = build.replace(':', '_') # windows do not understand `:` in path return '{}-{}-{}'.format(platform.python_implementation(), version_string, build)
def get_system_info(): if os.name == 'nt': ver, build, sp, type = platform.win32_ver() arch = platform.machine() pyver = platform.python_version() impl = platform.python_implementation() return 'Windows {ver} {sp}, NT {build} on {arch} Python {pyver} ({impl}).'.format(ver=ver, sp=sp, build=build, arch=arch, pyver=pyver, impl=impl) elif os.name == 'posix': distro = platform.linux_distribution() distro = '{0} {2} {1}'.format(*distro) return '{name} ({distro}) {sysver}, Python {pyver} ({impl})'.format(name=platform.system(), distro=distro, sysver=platform.release(), pyver=platform.python_version(), impl=platform.python_implementation())
def test_travis_python_environment(): travis_python_version = environ[TRAVIS_PYTHON_VERSION] travis_python_version = travis_python_version.lower() if travis_python_version == 'pypy': assert platform.python_implementation() == PYPY expected_version = (2, 7) elif travis_python_version == 'pypy3': assert platform.python_implementation() == PYPY expected_version = (3, 2) else: expected_version = tuple([int(part) for part in travis_python_version.split('.')]) from sys import version_info assert expected_version == version_info[:2]
def get(self): retVal = {} retVal["success"] = True retVal["message"] = "OK" retVal["commit"] = os.environ["COMMIT"] if "COMMIT" in os.environ else "dev" retVal["timestamp"] = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ") retVal["lastmod"] = os.environ["LASTMOD"] if "LASTMOD" in os.environ else "dev" retVal["tech"] = "Python %d.%d.%d" % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro) retVal["version"] = "%s (%s)" % (platform.python_version(), platform.python_implementation()) add_if_exists(retVal, "platform.machine()", platform.machine()) add_if_exists(retVal, "platform.node()", platform.node()) #IOError: add_if_exists(retVal, "platform.platform()", platform.platform()) add_if_exists(retVal, "platform.processor()", platform.processor()) add_if_exists(retVal, "platform.python_branch()", platform.python_branch()) add_if_exists(retVal, "platform.python_build()", platform.python_build()) add_if_exists(retVal, "platform.python_compiler()", platform.python_compiler()) add_if_exists(retVal, "platform.python_implementation()", platform.python_implementation()) add_if_exists(retVal, "platform.python_version()", platform.python_version()) add_if_exists(retVal, "platform.python_revision()", platform.python_revision()) add_if_exists(retVal, "platform.release()", platform.release()) add_if_exists(retVal, "platform.system()", platform.system()) add_if_exists(retVal, "platform.version()", platform.version()) add_if_exists(retVal, "platform.uname()", platform.uname()) add_if_exists(retVal, "sysconfig.get_platform()", sysconfig.get_platform()) add_if_exists(retVal, "sysconfig.get_python_version()", sysconfig.get_python_version()) add_if_exists(retVal, "sys.byteorder", sys.byteorder) add_if_exists(retVal, "sys.copyright", sys.copyright) add_if_exists(retVal, "sys.getdefaultencoding()", sys.getdefaultencoding()) add_if_exists(retVal, "sys.getfilesystemencoding()", sys.getfilesystemencoding()) add_if_exists(retVal, "sys.maxint", sys.maxint) add_if_exists(retVal, "sys.maxsize", sys.maxsize) add_if_exists(retVal, "sys.maxunicode", sys.maxunicode) add_if_exists(retVal, "sys.version", sys.version) self.response.headers['Content-Type'] = 'text/plain' callback = self.request.get('callback') if len(callback) == 0 or re.match("[a-zA-Z][-a-zA-Z0-9_]*$", callback) is None: self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.headers['Access-Control-Allow-Methods'] = 'POST, GET' self.response.headers['Access-Control-Max-Age'] = '604800' # 1 week self.response.out.write(json.dumps(retVal, separators=(',', ':'))) else: self.response.out.write(callback) self.response.out.write("(") self.response.out.write(json.dumps(retVal, separators=(',', ':'))) self.response.out.write(");")
def default_user_agent(name="python-requests"): """Return a string representing the default user agent.""" _implementation = platform.python_implementation() if _implementation == 'CPython': _implementation_version = platform.python_version() elif _implementation == 'PyPy': _implementation_version = '%s.%s.%s' % (sys.pypy_version_info.major, sys.pypy_version_info.minor, sys.pypy_version_info.micro) if sys.pypy_version_info.releaselevel != 'final': _implementation_version = ''.join([_implementation_version, sys.pypy_version_info.releaselevel]) elif _implementation == 'Jython': _implementation_version = platform.python_version() # Complete Guess elif _implementation == 'IronPython': _implementation_version = platform.python_version() # Complete Guess else: _implementation_version = 'Unknown' try: p_system = platform.system() p_release = platform.release() except IOError: p_system = 'Unknown' p_release = 'Unknown' return " ".join(['%s/%s' % (name, __version__), '%s/%s' % (_implementation, _implementation_version), '%s/%s' % (p_system, p_release)])
def test_6_cleanup(self): """ verify that when an SSHClient is collected, its transport (and the transport's packetizer) is closed. """ # Unclear why this is borked on Py3, but it is, and does not seem worth # pursuing at the moment. Skipped on PyPy because it fails on travis # for unknown reasons, works fine locally. # XXX: It's the release of the references to e.g packetizer that fails # in py3... if not PY2 or platform.python_implementation() == "PyPy": return threading.Thread(target=self._run).start() self.tc = paramiko.SSHClient() self.tc.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.assertEqual(0, len(self.tc.get_host_keys())) self.tc.connect(**dict(self.connect_kwargs, password='******')) self.event.wait(1.0) self.assertTrue(self.event.is_set()) self.assertTrue(self.ts.is_active()) p = weakref.ref(self.tc._transport.packetizer) self.assertTrue(p() is not None) self.tc.close() del self.tc # force a collection to see whether the SSHClient object is deallocated # correctly. 2 GCs are needed to make sure it's really collected on # PyPy gc.collect() gc.collect() self.assertTrue(p() is None)
def test_linux(self): lib_path = ffi.lib._name env = os.environ.copy() env['LANG'] = 'C' p = subprocess.Popen(["objdump", "-p", lib_path], stdout=subprocess.PIPE, env=env) out, _ = p.communicate() self.assertEqual(0, p.returncode) # Parse library dependencies lib_pat = re.compile(r'^([-_a-zA-Z0-9]+)\.so(?:\.\d+){0,3}$') deps = set() for line in out.decode().splitlines(): parts = line.split() if parts and parts[0] == 'NEEDED': dep = parts[1] m = lib_pat.match(dep) if len(parts) != 2 or not m: self.fail("invalid NEEDED line: %r" % (line,)) deps.add(m.group(1)) # Sanity check that our dependencies were parsed ok if 'libc' not in deps or 'libpthread' not in deps: self.fail("failed parsing dependencies? got %r" % (deps,)) # Ensure all dependencies are expected allowed = set(['librt', 'libdl', 'libpthread', 'libz', 'libm', 'libgcc_s', 'libc', 'ld-linux', 'ld64']) if platform.python_implementation() == 'PyPy': allowed.add('libtinfo') for dep in deps: if not dep.startswith('ld-linux-') and dep not in allowed: self.fail("unexpected dependency %r in %r" % (dep, deps))
def user_agent(): # pragma: no cover """Returns string representation of user-agent""" implementation = platform.python_implementation() if implementation == 'CPython': version = platform.python_version() elif implementation == 'PyPy': version = '%s.%s.%s' % (sys.pypy_version_info.major, sys.pypy_version_info.minor, sys.pypy_version_info.micro) elif implementation == 'Jython': version = platform.python_version() elif implementation == 'IronPython': version = platform.python_version() else: version = 'Unknown' try: system = platform.system() release = platform.release() except IOError: system = 'Unknown' release = 'Unknown' return " ".join([ 'appurify-client/%s' % constants.__version__, 'python-requests/%s' % requests.__version__, '%s/%s' % (implementation, version), '%s/%s' % (system, release) ])
def python_implementation(): if hasattr(sys, 'implementation'): # PEP 421, Python 3.3 name = sys.implementation.name else: name = platform.python_implementation() return name.lower()
def process_files(): """Main processing function.""" # options are byte code for AStyle input option_bytes = b"-A2tOP" files = [ "../test-c/ASBeautifier.cpp", "../test-c/ASFormatter.cpp" , "../test-c/astyle.h" ] #initialization print("ExampleByte", platform.python_implementation(), platform.python_version(), platform.architecture()[0]) initialize_platform() libc = initialize_library() version_bytes = get_astyle_version_bytes(libc) print("Artistic Style Version " + version_bytes.decode('utf-8')) # process the input files for file_path in files: bytes_in = get_source_code_bytes(file_path) formatted_bytes = format_source_bytes(libc, bytes_in, option_bytes) if type(formatted_bytes) is type(None): print("Error in formatting", file_path) continue print("Formatted", file_path) save_source_code_bytes(formatted_bytes, file_path)
def sysinfo(): show_sysinfo = os.environ.get('BORG_SHOW_SYSINFO', 'yes').lower() if show_sysinfo == 'no': return '' python_implementation = platform.python_implementation() python_version = platform.python_version() # platform.uname() does a shell call internally to get processor info, # creating #3732 issue, so rather use os.uname(). try: uname = os.uname() except AttributeError: uname = None if sys.platform.startswith('linux'): try: linux_distribution = platform.linux_distribution() # noqa except: # platform.linux_distribution() is deprecated since py 3.5 and removed in 3.7. linux_distribution = ('Unknown Linux', '', '') else: linux_distribution = None info = [] if uname is not None: info.append('Platform: %s' % (' '.join(uname), )) if linux_distribution is not None: info.append('Linux: %s %s %s' % linux_distribution) info.append('Borg: %s Python: %s %s' % (borg_version, python_implementation, python_version)) info.append('PID: %d CWD: %s' % (os.getpid(), os.getcwd())) info.append('sys.argv: %r' % sys.argv) info.append('SSH_ORIGINAL_COMMAND: %r' % os.environ.get('SSH_ORIGINAL_COMMAND')) info.append('') return '\n'.join(info)
def index(): """ The main Flask entry-point (/) for the Stallion server. """ data = {"breadpath": [Crumb("Main")]} data.update(get_shared_data()) data["menu_home"] = "active" sys_info = { "Python Platform": sys.platform, "Python Version": sys.version, "Python Prefix": sys.prefix, "Machine Type": platform.machine(), "Platform": platform.platform(), "Processor": platform.processor(), } try: sys_info["Python Implementation"] = platform.python_implementation() except: pass sys_info["System"] = platform.system() sys_info["System Arch"] = platform.architecture() data["system_information"] = sys_info return render_template("system_information.html", **data)
def __init__(self, email=None, token=None, organization_id=False, api_root="https://secure.transcriptic.com", organization=False, cookie=False, verbose=False, use_environ=True, analytics=True, user_id="default"): if email is None and use_environ: email = os.environ['USER_EMAIL'] token = os.environ['USER_TOKEN'] organization_id = os.environ['USER_ORGANIZATION'] self.api_root = api_root self.email = email self.token = token self.organization_id = organization_id or organization self.verbose = verbose self.analytics = analytics self.user_id = user_id self.headers = { "X-User-Email": email, "X-User-Token": token, "Content-Type": "application/json", "Accept": "application/json", "User-Agent": "txpy/{} ({}/{}; {}/{}; {}; {})".format(__version__, platform.python_implementation(), platform.python_version(), platform.system(), platform.release(), platform.machine(), platform.architecture()[0]) } # Preload known environment arguments self.env_args = dict(api_root=self.api_root, org_id=self.organization_id) transcriptic.api = self
def runSlice(fileNames): "Run the slicer on the files. If we are running with PyPy then just do the slicing action. If we are running as Python, try to find pypy." pypyExe = getPyPyExe() for fileName in fileNames: if fileName.startswith("#UTF8#"): fileName = unicode(fileName[6:], "utf-8") if platform.python_implementation() == "PyPy": skeinforge_craft.writeOutput(fileName) elif pypyExe == False: if not hasattr(sys, 'frozen'): print("************************************************") print("* Failed to find pypy, so slicing with python! *") print("************************************************") skeinforge_craft.writeOutput(fileName) print("************************************************") print("* Failed to find pypy, so sliced with python! *") print("************************************************") else: print("******************************************************************") print("* Failed to find pypy, we need pypy to slice with a frozen build *") print("* Place pypy in the same directory as Cura so Cura can find it. *") print("******************************************************************") sys.exit(1) else: subprocess.call(getSliceCommand(fileName))
def show_sidebar_button_info(python_input): """ Create `Layout` for the information in the right-bottom corner. (The right part of the status bar.) """ @if_mousedown def toggle_sidebar(cli, mouse_event): " Click handler for the menu. " python_input.show_sidebar = not python_input.show_sidebar token = Token.Toolbar.Status version = sys.version_info tokens = [ (token.Key, '[F2]', toggle_sidebar), (token, ' Menu', toggle_sidebar), (token, ' - '), (token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(), version[0], version[1], version[2])), (token, ' '), ] width = token_list_width(tokens) def get_tokens(cli): # Python version return tokens return ConditionalContainer( content=Window( TokenListControl(get_tokens, default_char=Char(token=token)), height=LayoutDimension.exact(1), width=LayoutDimension.exact(width)), filter=~IsDone() & RendererHeightIsKnown() & Condition(lambda cli: python_input.show_status_bar and not python_input.show_exit_confirmation))
def _cryptography_version(): # pyca/cryptography dropped support for PyPy < 5.4 in 2.5 # https://cryptography.io/en/latest/changelog/#v2-5 if platform.python_implementation() == 'PyPy' and platform.python_version() < '5.4': return 'cryptography < 2.5' return 'cryptography'
def test_large_read_until(self): # Performance test: read_until used to have a quadratic component # so a read_until of 4MB would take 8 seconds; now it takes 0.25 # seconds. server, client = self.make_iostream_pair() try: try: # This test fails on pypy with ssl. I think it's because # pypy's gc defeats moves objects, breaking the # "frozen write buffer" assumption. if (isinstance(server, SSLIOStream) and platform.python_implementation() == 'PyPy'): raise unittest.SkipTest( "pypy gc causes problems with openssl") except AttributeError: # python 2.5 didn't have platform.python_implementation, # but there was no pypy for 2.5 pass NUM_KB = 4096 for i in xrange(NUM_KB): client.write(b("A") * 1024) client.write(b("\r\n")) server.read_until(b("\r\n"), self.stop) data = self.wait() self.assertEqual(len(data), NUM_KB * 1024 + 2) finally: server.close() client.close()
def python_info(): return { 'name': 'Python', 'version': '%s %s' % ( platform.python_implementation(), platform.python_version()), 'path': os.path.dirname(platform.__file__), }
def run_setup(extensions): kw = {'cmdclass': {'doc': DocCommand, 'gevent_nosetests': gevent_nosetests}} if extensions: kw['cmdclass']['build_ext'] = build_extensions kw['ext_modules'] = extensions dependencies = ['futures', 'scales', 'blist'] if platform.python_implementation() != "CPython": dependencies.remove('blist') setup( name='cassandra-driver', version=__version__, description='Python driver for Cassandra', long_description=long_description, url='http://github.com/datastax/python-driver', author='Tyler Hobbs', author_email='*****@*****.**', packages=['cassandra', 'cassandra.io'], include_package_data=True, install_requires=dependencies, tests_require=['nose', 'mock', 'ccm', 'unittest2', 'PyYAML', 'pytz'], classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Topic :: Software Development :: Libraries :: Python Modules' ], **kw)
def test_behave_masking_user_attribute_causes_warning(self): warns = [] def catch_warning(*args, **kwargs): warns.append(args[0]) old_showwarning = warnings.showwarning warnings.showwarning = catch_warning with self.context.use_with_user_mode(): self.context.thing = "stuff" # pylint: disable=protected-access self.context._push() self.context.thing = "other stuff" warnings.showwarning = old_showwarning print(repr(warns)) assert warns, "OOPS: warns is empty, but expected non-empty" warning = warns[0] assert isinstance(warning, runner.ContextMaskWarning), "warning is not a ContextMaskWarning" info = warning.args[0] assert info.startswith("behave runner"), "%r doesn't start with 'behave runner'" % info assert "'thing'" in info, "%r not in %r" % ("'thing'", info) filename = __file__.rsplit(".", 1)[0] if python_implementation() == "Jython": filename = filename.replace("$py", ".py") assert filename in info, "%r not in %r" % (filename, info)
def test_setting_root_attribute_that_masks_existing_causes_warning(self): # pylint: disable=protected-access warns = [] def catch_warning(*args, **kwargs): warns.append(args[0]) old_showwarning = warnings.showwarning warnings.showwarning = catch_warning with self.context.use_with_user_mode(): self.context._push() self.context.thing = "teak" self.context._set_root_attribute("thing", "oak") warnings.showwarning = old_showwarning print(repr(warns)) assert warns warning = warns[0] assert isinstance(warning, runner.ContextMaskWarning) info = warning.args[0] assert info.startswith("behave runner"), "%r doesn't start with 'behave runner'" % info assert "'thing'" in info, "%r not in %r" % ("'thing'", info) filename = __file__.rsplit(".", 1)[0] if python_implementation() == "Jython": filename = filename.replace("$py", ".py") assert filename in info, "%r not in %r" % (filename, info)
def run_tests(self): # For a partial run, we do not need to clutter the output. if (self.ns.verbose or self.ns.header or not (self.ns.pgo or self.ns.quiet or self.ns.single or self.tests or self.ns.args)): # Print basic platform information print("==", platform.python_implementation(), *sys.version.split()) print("== ", platform.platform(aliased=True), "%s-endian" % sys.byteorder) print("== ", "hash algorithm:", sys.hash_info.algorithm, "64bit" if sys.maxsize > 2**32 else "32bit") print("== ", os.getcwd()) print("Testing with flags:", sys.flags) if self.ns.randomize: print("Using random seed", self.ns.random_seed) if self.ns.forever: self.tests = self._test_forever(list(self.selected)) self.test_count = '' self.test_count_width = 3 else: self.tests = iter(self.selected) self.test_count = '/{}'.format(len(self.selected)) self.test_count_width = len(self.test_count) - 1 if self.ns.use_mp: from test.libregrtest.runtest_mp import run_tests_multiprocess run_tests_multiprocess(self) else: self.run_tests_sequential()
def main(): """Application logging.""" config_path = utils.AppUtils().config_path log_file = os.path.join(config_path, f"{const.APP_NAME}.log") # Get the Python architecture py_arch = "x64" if sys.maxsize < 2 ** 32: py_arch = "x86" logging.basicConfig( level=logging.DEBUG, format="%(asctime)s : %(levelname)s : %(message)s", filename=log_file, filemode="a" ) logging.debug(f"Begin logging to {log_file}") logging.debug(f"Timestamp: {datetime.utcnow().isoformat()}") logging.debug("You are running {0} {1} {2} on {3} {4}.".format( platform.python_implementation(), py_arch, platform.python_version(), platform.machine(), platform.platform()) )
with self.assertRaises(errors.RemoteConnectionError) as err_info: with ftp_errors(mem_fs): raise EOFError self.assertEqual(str(err_info.exception), "lost connection to ftp.example.com") with self.assertRaises(errors.RemoteConnectionError) as err_info: with ftp_errors(mem_fs): raise socket.error self.assertEqual(str(err_info.exception), "unable to connect to ftp.example.com") @mark.slow @unittest.skipIf(platform.python_implementation() == "PyPy", "ftp unreliable with PyPy") class TestFTPFS(FSTestCases, unittest.TestCase): user = "******" pasw = "1234" @classmethod def setUpClass(cls): from pyftpdlib.test import ThreadedTestFTPd super(TestFTPFS, cls).setUpClass() cls._temp_dir = tempfile.mkdtemp("ftpfs2tests") cls._temp_path = os.path.join(cls._temp_dir, text_type(uuid.uuid4())) os.mkdir(cls._temp_path)
import warnings try: import xml.etree.cElementTree as ElementTree except ImportError: import xml.etree.ElementTree as ElementTree from unicodedata import east_asian_width from . import six PY26 = six.PY2 and sys.version_info[1] == 6 PY27 = six.PY2 and sys.version_info[1] == 7 LESS_PY26 = six.PY2 and sys.version_info[1] < 6 LESS_PY32 = six.PY3 and sys.version_info[1] < 2 LESS_PY33 = six.PY3 and sys.version_info[1] < 3 LESS_PY34 = six.PY3 and sys.version_info[1] < 4 PYPY = platform.python_implementation().lower() == 'pypy' SEEK_SET = 0 SEEK_CUR = 1 SEEK_END = 2 # Definition of East Asian Width # http://unicode.org/reports/tr11/ # Ambiguous width can be changed by option _EAW_MAP = {'Na': 1, 'N': 1, 'W': 2, 'F': 2, 'H': 1} import decimal DECIMAL_TYPES = [decimal.Decimal, ] import json
local = unittest.skipUnless(CASSANDRA_IP.startswith("127.0.0."), 'Tests only runs against local C*') notprotocolv1 = unittest.skipUnless(PROTOCOL_VERSION > 1, 'Protocol v1 not supported') lessthenprotocolv4 = unittest.skipUnless(PROTOCOL_VERSION < 4, 'Protocol versions 4 or greater not supported') greaterthanprotocolv3 = unittest.skipUnless(PROTOCOL_VERSION >= 4, 'Protocol versions less than 4 are not supported') protocolv5 = unittest.skipUnless(5 in get_supported_protocol_versions(), 'Protocol versions less than 5 are not supported') greaterthancass20 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.1'), 'Cassandra version 2.1 or greater required') greaterthancass21 = unittest.skipUnless(CASSANDRA_VERSION >= Version('2.2'), 'Cassandra version 2.2 or greater required') greaterthanorequalcass30 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.0'), 'Cassandra version 3.0 or greater required') greaterthanorequalcass36 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.6'), 'Cassandra version 3.6 or greater required') greaterthanorequalcass3_10 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.10'), 'Cassandra version 3.10 or greater required') greaterthanorequalcass3_11 = unittest.skipUnless(CASSANDRA_VERSION >= Version('3.11'), 'Cassandra version 3.10 or greater required') greaterthanorequalcass40 = unittest.skipUnless(CASSANDRA_VERSION >= Version('4.0'), 'Cassandra version 4.0 or greater required') lessthanorequalcass40 = unittest.skipIf(CASSANDRA_VERSION >= Version('4.0'), 'Cassandra version 4.0 or greater required') lessthancass30 = unittest.skipUnless(CASSANDRA_VERSION < Version('3.0'), 'Cassandra version less then 3.0 required') pypy = unittest.skipUnless(platform.python_implementation() == "PyPy", "Test is skipped unless it's on PyPy") notpy3 = unittest.skipIf(sys.version_info >= (3, 0), "Test not applicable for Python 3.x runtime") requiresmallclockgranularity = unittest.skipIf("Windows" in platform.system() or "asyncore" in EVENT_LOOP_MANAGER, "This test is not suitible for environments with large clock granularity") requiressimulacron = unittest.skipIf(SIMULACRON_JAR is None or CASSANDRA_VERSION < Version("2.1"), "Simulacron jar hasn't been specified or C* version is 2.0") def wait_for_node_socket(node, timeout): binary_itf = node.network_interfaces['binary'] if not common.check_socket_listening(binary_itf, timeout=timeout): log.warning("Unable to connect to binary socket for node " + node.name) else: log.debug("Node %s is up and listening " % (node.name,)) def check_socket_listening(itf, timeout=60):
import os import platform import sys # Operating systems. WINDOWS = sys.platform == "win32" LINUX = sys.platform.startswith("linux") # Python versions. We amend version_info with one more value, a zero if an # official version, or 1 if built from source beyond an official version. PYVERSION = sys.version_info + (int(platform.python_version()[-1] == "+"), ) PY2 = PYVERSION < (3, 0) PY3 = PYVERSION >= (3, 0) # Python implementations. PYPY = (platform.python_implementation() == 'PyPy') if PYPY: PYPYVERSION = sys.pypy_version_info PYPY2 = PYPY and PY2 PYPY3 = PYPY and PY3 JYTHON = (platform.python_implementation() == 'Jython') IRONPYTHON = (platform.python_implementation() == 'IronPython') # Python behavior class PYBEHAVIOR(object): """Flags indicating this Python's behavior.""" # Is "if __debug__" optimized away?
def version(): """Return a string with various version information.""" lines = ["qutebrowser v{}".format(qutebrowser.__version__)] gitver = _git_str() if gitver is not None: lines.append("Git commit: {}".format(gitver)) lines.append("Backend: {}".format(_backend())) lines += [ '', '{}: {}'.format(platform.python_implementation(), platform.python_version()), 'Qt: {}'.format(earlyinit.qt_version()), 'PyQt: {}'.format(PYQT_VERSION_STR), '', ] lines += _module_versions() lines += [ 'pdf.js: {}'.format(_pdfjs_version()), 'sqlite: {}'.format(sql.version()), 'QtNetwork SSL: {}\n'.format(QSslSocket.sslLibraryVersionString() if QSslSocket.supportsSsl() else 'no'), ] qapp = QApplication.instance() if qapp: style = qapp.style() lines.append('Style: {}'.format(style.metaObject().className())) importpath = os.path.dirname(os.path.abspath(qutebrowser.__file__)) lines += [ 'Platform: {}, {}'.format(platform.platform(), platform.architecture()[0]), ] dist = distribution() if dist is not None: lines += [ 'Linux distribution: {} ({})'.format(dist.pretty, dist.parsed.name) ] lines += [ 'Frozen: {}'.format(hasattr(sys, 'frozen')), "Imported from {}".format(importpath), "Using Python from {}".format(sys.executable), "Qt library executable path: {}, data path: {}".format( QLibraryInfo.location(QLibraryInfo.LibraryExecutablesPath), QLibraryInfo.location(QLibraryInfo.DataPath) ) ] if not dist or dist.parsed == Distribution.unknown: lines += _os_info() lines += [ '', 'Paths:', ] for name, path in sorted(_path_info().items()): lines += ['{}: {}'.format(name, path)] lines += [ '', 'Uptime: {}'.format(_uptime()), ] return '\n'.join(lines)
Rational, strip_context, ) from mathics.core.rules import Pattern, Rule from mathics.builtin.lists import ( python_levelspec, walk_levels, InvalidLevelspecError, List, ) from mathics.builtin.functional import Identity import platform if platform.python_implementation() == "PyPy": bytecount_support = False else: from .pympler.asizeof import asizeof as count_bytes bytecount_support = True class Sort(Builtin): """ <dl> <dt>'Sort[$list$]' <dd>sorts $list$ (or the leaves of any other expression) according to canonical ordering. <dt>'Sort[$list$, $p$]' <dd>sorts using $p$ to determine the order of two elements. </dl>
('architecture', _arch), # Linux kernel version, OSX version, etc. ('version', _ver) ]) else: # Get potential alias (e.g. SunOS 5.11 becomes Solaris 2.11) _aliased = platform.system_alias( platform.system(), platform.release(), platform.version()) _METADATA['os'] = SON([ ('type', platform.system()), ('name', ' '.join([part for part in _aliased[:2] if part])), ('architecture', platform.machine()), ('version', _aliased[2]) ]) if platform.python_implementation().startswith('PyPy'): _METADATA['platform'] = ' '.join( (platform.python_implementation(), '.'.join(imap(str, sys.pypy_version_info)), '(Python %s)' % '.'.join(imap(str, sys.version_info)))) elif sys.platform.startswith('java'): _METADATA['platform'] = ' '.join( (platform.python_implementation(), '.'.join(imap(str, sys.version_info)), '(%s)' % ' '.join((platform.system(), platform.release())))) else: _METADATA['platform'] = ' '.join( (platform.python_implementation(), '.'.join(imap(str, sys.version_info))))
utf_16_csv_rel = DocutilsTestSupport.utils.relative_path(None, utf_16_csv) empty_txt = os.path.join(mydir, 'empty.txt') unichr_exception = DocutilsTestSupport.exception_data(unichr, int("9999999999999", 16))[0] if isinstance(unichr_exception, OverflowError): unichr_exception_string = 'code too large (%s)' % unichr_exception else: unichr_exception_string = str(unichr_exception) # some error messages changed in Python 3.3: # CPython has backported to 2.7.4, PyPy has not # platform.python_implementation is new in 2.6 csv_eod_error_str = 'unexpected end of data' if sys.version_info < (2, 7, 4) or platform.python_implementation() == 'PyPy': csv_eod_error_str = 'newline inside string' # pypy adds a line number if sys.version_info > (2, 6) and platform.python_implementation() == 'PyPy': csv_eod_error_str = 'line 1: ' + csv_eod_error_str csv_unknown_url = "'bogus.csv'" if sys.version_info < (3, 3, 2): csv_unknown_url = "bogus.csv" def null_bytes(): import csv csv_data = open(utf_16_csv, 'rb').read() csv_data = unicode(csv_data, 'latin1').splitlines() reader = csv.reader( [tables.CSVTable.encode_for_csv(line + '\n') for line in csv_data])
except ImportError: from ordereddict import OrderedDict # type: ignore from counter import Counter # type: ignore try: from collections import abc except ImportError: import collections as abc # type: ignore if False: from typing import Type, Tuple # noqa PY2 = sys.version_info[0] == 2 PY3 = sys.version_info[0] == 3 PYPY = platform.python_implementation() == 'PyPy' CAN_UNPACK_BYTE_ARRAY = sys.version_info[:3] >= (2, 7, 4) CAN_PACK_HALF_FLOAT = sys.version_info[:2] >= (3, 6) WINDOWS = platform.system() == 'Windows' if sys.version_info[:2] <= (2, 6): raise ImportError( 'Hypothesis is not supported on Python versions before 2.7' ) def bit_length(n): return n.bit_length()
from __future__ import print_function from compas.cad.rhino.forms import Form try: import scriptcontext as sc import System from System.Drawing import Size from System.Drawing import Point from System.Drawing import Color from System.Windows.Forms import TextBox from System.Windows.Forms import TrackBar except ImportError: import platform if platform.python_implementation() == 'IronPython': raise __author__ = [ 'Tom Van Mele', ] __copyright__ = 'Copyright 2014, BLOCK Research Group - ETH Zurich' __license__ = 'MIT License' __email__ = '*****@*****.**' __all__ = [ 'SliderForm', ] class SliderForm(Form):
""" Run formatter tests """ import platform import sys from pprint import pformat import pytest from py3status.composite import Composite from py3status.formatter import Formatter from py3status.py3 import NoneColor is_pypy = platform.python_implementation() == 'PyPy' f = Formatter() python2 = sys.version_info < (3, 0) param_dict = { 'name': u'Björk', 'number': 42, 'pi': 3.14159265359, 'yes': True, 'no': False, 'empty': '', 'None': None, '?bad name': 'evil', u'☂ Very bad name ': u'☂ extremely evil', 'long_str': 'I am a long string though not too long',
def user_agent(): """ Return a string representing the user agent. """ data = { "installer": { "name": "pip", "version": pip.__version__ }, "python": platform.python_version(), "implementation": { "name": platform.python_implementation(), }, } if data["implementation"]["name"] == 'CPython': data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'PyPy': if sys.pypy_version_info.releaselevel == 'final': pypy_version_info = sys.pypy_version_info[:3] else: pypy_version_info = sys.pypy_version_info data["implementation"]["version"] = ".".join( [str(x) for x in pypy_version_info]) elif data["implementation"]["name"] == 'Jython': # Complete Guess data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'IronPython': # Complete Guess data["implementation"]["version"] = platform.python_version() if sys.platform.startswith("linux"): from pip._vendor import distro distro_infos = dict( filter( lambda x: x[1], zip(["name", "version", "id"], distro.linux_distribution()), )) libc = dict( filter( lambda x: x[1], zip(["lib", "version"], libc_ver()), )) if libc: distro_infos["libc"] = libc if distro_infos: data["distro"] = distro_infos if sys.platform.startswith("darwin") and platform.mac_ver()[0]: data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]} if platform.system(): data.setdefault("system", {})["name"] = platform.system() if platform.release(): data.setdefault("system", {})["release"] = platform.release() if platform.machine(): data["cpu"] = platform.machine() # Python 2.6 doesn't have ssl.OPENSSL_VERSION. if HAS_TLS and sys.version_info[:2] > (2, 6): data["openssl_version"] = ssl.OPENSSL_VERSION return "{data[installer][name]}/{data[installer][version]} {json}".format( data=data, json=json.dumps(data, separators=(",", ":"), sort_keys=True), )
def cli_main(argv): IEDLog.IEDLogToController = False IEDLog.IEDLogToSyslog = True IEDLog.IEDLogToStdOut = True IEDLog.IEDLogToFile = False from IEDCLIController import IEDCLIController clicontroller = IEDCLIController.alloc().init() try: # Initialize user defaults before application starts. defaults = NSUserDefaults.standardUserDefaults() defaultsPath = NSBundle.mainBundle().pathForResource_ofType_( u"Defaults", u"plist") defaultsDict = NSDictionary.dictionaryWithContentsOfFile_(defaultsPath) defaults.registerDefaults_(defaultsDict) p = argparse.ArgumentParser() p.add_argument(u"-v", u"--verbose", action=u"store_true", help=u"Verbose output") p.add_argument(u"-L", u"--log-level", type=int, choices=range(0, 8), default=6, metavar=u"LEVEL", help=u"Log level (0-7), default 6") p.add_argument(u"-l", u"--logfile", help=u"Log to file") p.add_argument(u"-r", u"--root", action=u"store_true", help=u"Allow running as root") sp = p.add_subparsers(title=u"subcommands", dest=u"subcommand") # Populate subparser for each verb. for verb in clicontroller.listVerbs(): verb_method = getattr(clicontroller, u"cmd%s_" % verb.capitalize()) addargs_method = getattr(clicontroller, u"addargs%s_" % verb.capitalize()) parser = sp.add_parser(verb, help=verb_method.__doc__) addargs_method(parser) parser.set_defaults(func=verb_method) args = p.parse_args(argv) if args.verbose: IEDLog.IEDLogStdOutLogLevel = IEDLog.IEDLogLevelInfo else: IEDLog.IEDLogStdOutLogLevel = IEDLog.IEDLogLevelNotice IEDLog.IEDLogFileLogLevel = args.log_level if args.logfile: if args.logfile == u"-": # Redirect log to stdout instead. IEDLog.IEDLogFileHandle = sys.stdout IEDLog.IEDLogToStdOut = False else: try: IEDLog.IEDLogFileHandle = open(args.logfile, u"a", buffering=1) except OSError as e: print >> sys.stderr, (u"Couldn't open %s for writing" % (args.logfile)).encode(u"utf-8") return os.EX_CANTCREAT IEDLog.IEDLogToFile = True # Check if we're running with root. if os.getuid() == 0: if args.root: fm = NSFileManager.defaultManager() url, error = fm.URLForDirectory_inDomain_appropriateForURL_create_error_( NSApplicationSupportDirectory, NSUserDomainMask, None, False, None) LogWarning(u"Running as root, using %@", os.path.join(url.path(), u"AutoDMG")) else: LogError( u"Running as root isn't recommended (use -r to override)") return os.EX_USAGE # Log version info on startup. version, build = IEDUtil.getAppVersion() LogInfo(u"AutoDMG v%@ build %@", version, build) name, version, build = IEDUtil.readSystemVersion_(u"/") LogInfo(u"%@ %@ %@", name, version, build) LogInfo(u"%@ %@ (%@)", platform.python_implementation(), platform.python_version(), platform.python_compiler()) LogInfo(u"PyObjC %@", objc.__version__) return args.func(args) finally: clicontroller.cleanup()
import sys if sys.version_info[0] < 3: from .utils_py2 import * else: from .utils_py3 import * # # configure max recursion #sys.setrecursionlimit(200) try: import platform except ImportError: python_implementation = 'Unknown' else: python_implementation = platform.python_implementation() # can be 'CPython' or 'PyPy' #------------------------------------------------------------------------------# # library wide logging function #------------------------------------------------------------------------------# def log(msg): print(msg) #------------------------------------------------------------------------------# # additional bit list / str functions #------------------------------------------------------------------------------#
def __user_agent(self): python_verison = "{0}.{1}".format(sys.version_info.major, sys.version_info.minor) return 'twitter-ads version: {0} platform: Python {1} ({2}/{3})'.format( get_version(), python_verison, platform.python_implementation(), sys.platform)
def make_vm( self, nodes, thunks, input_storage, output_storage, storage_map, post_thunk_clear, computed, compute_map, updated_vars, ): pre_call_clear = [storage_map[v] for v in self.no_recycling] if ( self.callback is not None or self.callback_input is not None or ((config.profile or config.print_global_stats) and config.profile_memory) or (self.allow_partial_eval and not self.use_cloop) ): if self.use_cloop and ( self.callback is not None or self.callback_input is not None ): logger.warning("CVM does not support callback, using Stack VM.") if self.use_cloop and config.profile_memory: warnings.warn("CVM does not support memory profile, using Stack VM.") if not self.use_cloop and self.allow_partial_eval: warnings.warn( "LoopGC does not support partial evaluation, " "using Stack VM." ) # Needed for allow_gc=True, profiling and storage_map reuse deps = self.compute_gc_dependencies(storage_map) vm = Stack( nodes, thunks, pre_call_clear, storage_map, compute_map, self.fgraph, self.allow_gc, len(updated_vars), dependencies=deps, callback=self.callback, callback_input=self.callback_input, ) elif self.use_cloop: # create a map from nodes to ints and vars to ints nodes_idx = {} vars_idx = {} for i, node in enumerate(nodes): nodes_idx[node] = i for v in node.inputs + node.outputs: vars_idx.setdefault(v, len(vars_idx)) for v in self.fgraph.inputs + self.fgraph.outputs: vars_idx.setdefault(v, len(vars_idx)) nodes_idx_inv = {} vars_idx_inv = {} for (node, i) in nodes_idx.items(): nodes_idx_inv[i] = node for (var, i) in vars_idx.items(): vars_idx_inv[i] = var # put storage_map and compute_map into a int-based scheme storage_map_list = [ storage_map[vars_idx_inv[i]] for i in range(len(vars_idx_inv)) ] compute_map_list = [ compute_map[vars_idx_inv[i]] for i in range(len(vars_idx_inv)) ] if nodes: assert type(storage_map_list[0]) is list assert type(compute_map_list[0]) is list # Needed for allow_gc=True, profiling and storage_map reuse dependency_map = self.compute_gc_dependencies(storage_map) dependency_map_list = [ [vars_idx[d] for d in dependency_map[vars_idx_inv[i]]] for i in range(len(vars_idx_inv)) ] # build the pointers to node inputs and offsets base_input_output_list = [] node_n_inputs = [] node_n_outputs = [] node_input_offset = [] node_output_offset = [] for node in nodes: inputs_idx = [vars_idx[v] for v in node.inputs] outputs_idx = [vars_idx[v] for v in node.outputs] node_n_inputs.append(len(inputs_idx)) node_n_outputs.append(len(outputs_idx)) node_input_offset.append(len(base_input_output_list)) base_input_output_list.extend(inputs_idx) node_output_offset.append(len(base_input_output_list)) base_input_output_list.extend(outputs_idx) # build the var owner array var_owner = [None] * len(vars_idx) for (var, i) in vars_idx.items(): if var.owner: var_owner[i] = nodes_idx[var.owner] is_lazy_list = [int(th.lazy) for th in thunks] output_vars = [vars_idx[v] for v in self.fgraph.outputs] # builds the list of prereqs induced by e.g. destroy_handler ords = self.fgraph.orderings() node_prereqs = [] node_output_size = [] for i, node in enumerate(nodes): node_output_size.append(0) prereq_var_idxs = [] for prereq_node in ords.get(node, []): prereq_var_idxs.extend([vars_idx[v] for v in prereq_node.outputs]) prereq_var_idxs = list(set(prereq_var_idxs)) prereq_var_idxs.sort() # TODO: why sort? node_prereqs.append(prereq_var_idxs) # Builds the list of input storage to update (according to update # rules) when the outputs are computed. # They are in the same order as the second part of output_vars # (output_vars contains first the returned outputs, then the # values of the update expressions). update_storage = [] update_in_from_out = {} for (ivar, ovar) in updated_vars.items(): update_in_from_out[vars_idx[ovar]] = vars_idx[ivar] for oidx in output_vars: if oidx in update_in_from_out: update_storage.append(update_in_from_out[oidx]) # PyPy has no sys.getrefcount, so ignore this check if not running # under CPython. if platform.python_implementation() == "CPython": c0 = sys.getrefcount(node_n_inputs) vm = CVM( nodes, thunks, pre_call_clear, allow_gc=self.allow_gc, call_counts=[0] * len(nodes), call_times=[0.0] * len(nodes), compute_map_list=compute_map_list, storage_map_list=storage_map_list, base_input_output_list=base_input_output_list, node_n_inputs=node_n_inputs, node_n_outputs=node_n_outputs, node_input_offset=node_input_offset, node_output_offset=node_output_offset, var_owner=var_owner, is_lazy_list=is_lazy_list, output_vars=output_vars, node_prereqs=node_prereqs, node_output_size=node_output_size, update_storage=update_storage, dependencies=dependency_map_list, ) if platform.python_implementation() == "CPython": assert c0 == sys.getrefcount(node_n_inputs) else: lazy = self.lazy if lazy is None: lazy = config.vm.lazy if lazy is None: lazy = not all([(not th.lazy) for th in thunks]) if not lazy: # there is no conditional in the graph if self.allow_gc: vm = LoopGC( nodes, thunks, pre_call_clear, post_thunk_clear, ) else: vm = Loop( nodes, thunks, pre_call_clear, ) else: # Needed when allow_gc=True and profiling deps = self.compute_gc_dependencies(storage_map) vm = Stack( nodes, thunks, pre_call_clear, storage_map, compute_map, self.fgraph, self.allow_gc, len(updated_vars), dependencies=deps, ) return vm
def _connect(self, timeout: float) -> None: """The function that runs on the connection thread. This will connect to Vector, and establish the BehaviorControl stream. """ try: if threading.main_thread() is threading.current_thread(): raise Exception( "\n\nConnection._connect must be run outside of the main thread." ) self._loop = asyncio.new_event_loop() asyncio.set_event_loop(self._loop) self._done_signal = asyncio.Event() if not self._requires_behavior_control: self._control_events = _ControlEventManager(self._loop) else: self._control_events = _ControlEventManager( self._loop, priority=CONTROL_PRIORITY_LEVEL.TOP_PRIORITY_AI) trusted_certs = None with open(self.cert_file, 'rb') as cert: trusted_certs = cert.read() # Pin the robot certificate for opening the channel channel_credentials = aiogrpc.ssl_channel_credentials( root_certificates=trusted_certs) # Add authorization header for all the calls call_credentials = aiogrpc.access_token_call_credentials( self._guid) credentials = aiogrpc.composite_channel_credentials( channel_credentials, call_credentials) self._logger.info( f"Connecting to {self.host} for {self.name} using {self.cert_file}" ) self._channel = aiogrpc.secure_channel( self.host, credentials, options=(( "grpc.ssl_target_name_override", self.name, ), )) # Verify the connection to Vector is able to be established (client-side) try: # Explicitly grab _channel._channel to test the underlying grpc channel directly grpc.channel_ready_future(self._channel._channel).result( timeout=timeout) # pylint: disable=protected-access except grpc.FutureTimeoutError as e: raise VectorNotFoundException() from e self._interface = client.ExternalInterfaceStub(self._channel) # Verify Vector and the SDK have compatible protocol versions version = protocol.ProtocolVersionRequest( client_version=CLIENT_VERSION, min_host_version=MIN_HOST_VERSION) protocol_version = self._loop.run_until_complete( self._interface.ProtocolVersion(version)) if protocol_version.result != protocol.ProtocolVersionResponse.SUCCESS or MIN_HOST_VERSION > protocol_version.host_version: # pylint: disable=no-member raise VectorInvalidVersionException(version, protocol_version) self._control_stream_task = self._loop.create_task( self._open_connections()) # Initialze SDK sdk_module_version = __version__ python_version = platform.python_version() python_implementation = platform.python_implementation() os_version = platform.platform() cpu_version = platform.machine() initialize = protocol.SDKInitializationRequest( sdk_module_version=sdk_module_version, python_version=python_version, python_implementation=python_implementation, os_version=os_version, cpu_version=cpu_version) self._loop.run_until_complete( self._interface.SDKInitialization(initialize)) if self._requires_behavior_control: self._loop.run_until_complete( self._request_control(timeout=timeout)) except Exception as e: # pylint: disable=broad-except # Propagate the errors to the calling thread setattr(self._ready_signal, "exception", e) return finally: self._ready_signal.set() async def wait_until_done(): return await self._done_signal.wait() self._loop.run_until_complete(wait_until_done())
def main(): usage = "usage: %prog [-h|--help] [options]" parser = OptionParser(usage=usage) parser.add_option("-t", "--throughput", action="store_true", dest="throughput", default=False, help="run throughput tests") parser.add_option("-l", "--latency", action="store_true", dest="latency", default=False, help="run latency tests") parser.add_option("-b", "--bandwidth", action="store_true", dest="bandwidth", default=False, help="run I/O bandwidth tests") parser.add_option("-i", "--interval", action="store", type="int", dest="check_interval", default=None, help="sys.setcheckinterval() value") parser.add_option("-I", "--switch-interval", action="store", type="float", dest="switch_interval", default=None, help="sys.setswitchinterval() value") parser.add_option("-n", "--num-threads", action="store", type="int", dest="nthreads", default=4, help="max number of threads in tests") # Hidden option to run the pinging and bandwidth clients parser.add_option("", "--latclient", action="store", dest="latclient", default=None, help=SUPPRESS_HELP) parser.add_option("", "--bwclient", action="store", dest="bwclient", default=None, help=SUPPRESS_HELP) options, args = parser.parse_args() if args: parser.error("unexpected arguments") if options.latclient: kwargs = eval(options.latclient) latency_client(**kwargs) return if options.bwclient: kwargs = eval(options.bwclient) bandwidth_client(**kwargs) return if not options.throughput and not options.latency and not options.bandwidth: options.throughput = options.latency = options.bandwidth = True if options.check_interval: sys.setcheckinterval(options.check_interval) if options.switch_interval: sys.setswitchinterval(options.switch_interval) print("== %s %s (%s) ==" % ( platform.python_implementation(), platform.python_version(), platform.python_build()[0], )) # Processor identification often has repeated spaces cpu = ' '.join(platform.processor().split()) print("== %s %s on '%s' ==" % ( platform.machine(), platform.system(), cpu, )) print() if options.throughput: print("--- Throughput ---") print() run_throughput_tests(options.nthreads) if options.latency: print("--- Latency ---") print() run_latency_tests(options.nthreads) if options.bandwidth: print("--- I/O bandwidth ---") print() run_bandwidth_tests(options.nthreads)
def _main(self, args): # type: (List[str]) -> int # Intentionally set as early as possible so globally-managed temporary # directories are available to the rest of the code. self.enter_context(global_tempdir_manager()) options, args = self.parse_args(args) # Set verbosity so that it can be used elsewhere. self.verbosity = options.verbose - options.quiet level_number = setup_logging( verbosity=self.verbosity, no_color=options.no_color, user_log_file=options.log, ) if (sys.version_info[:2] == (2, 7) and not options.no_python_version_warning): message = ( "A future version of pip will drop support for Python 2.7. " "More details about Python 2 support in pip, can be found at " "https://pip.pypa.io/en/latest/development/release-process/#python-2-support" # noqa ) if platform.python_implementation() == "CPython": message = ( "Python 2.7 reached the end of its life on January " "1st, 2020. Please upgrade your Python as Python 2.7 " "is no longer maintained. ") + message deprecated(message, replacement=None, gone_in=None) if options.skip_requirements_regex: deprecated( "--skip-requirements-regex is unsupported and will be removed", replacement=( "manage requirements/constraints files explicitly, " "possibly generating them from metadata"), gone_in="20.1", issue=7297, ) # TODO: Try to get these passing down from the command? # without resorting to os.environ to hold these. # This also affects isolated builds and it should. if options.no_input: os.environ['PIP_NO_INPUT'] = '1' if options.exists_action: os.environ['PIP_EXISTS_ACTION'] = ' '.join(options.exists_action) if options.require_venv and not self.ignore_require_venv: # If a venv is required check if it can really be found if not running_under_virtualenv(): logger.critical( 'Could not find an activated virtualenv (required).') sys.exit(VIRTUALENV_NOT_FOUND) if options.cache_dir: options.cache_dir = normalize_path(options.cache_dir) if not check_path_owner(options.cache_dir): logger.warning( "The directory '%s' or its parent directory is not owned " "or is not writable by the current user. The cache " "has been disabled. Check the permissions and owner of " "that directory. If executing pip with sudo, you may want " "sudo's -H flag.", options.cache_dir, ) options.cache_dir = None try: status = self.run(options, args) # FIXME: all commands should return an exit status # and when it is done, isinstance is not needed anymore if isinstance(status, int): return status except PreviousBuildDirError as exc: logger.critical(str(exc)) logger.debug('Exception information:', exc_info=True) return PREVIOUS_BUILD_DIR_ERROR except (InstallationError, UninstallationError, BadCommand) as exc: logger.critical(str(exc)) logger.debug('Exception information:', exc_info=True) return ERROR except CommandError as exc: logger.critical('%s', exc) logger.debug('Exception information:', exc_info=True) return ERROR except BrokenStdoutLoggingError: # Bypass our logger and write any remaining messages to stderr # because stdout no longer works. print('ERROR: Pipe to stdout was broken', file=sys.stderr) if level_number <= logging.DEBUG: traceback.print_exc(file=sys.stderr) return ERROR except KeyboardInterrupt: logger.critical('Operation cancelled by user') logger.debug('Exception information:', exc_info=True) return ERROR except BaseException: logger.critical('Exception:', exc_info=True) return UNKNOWN_ERROR finally: self.handle_pip_version_check(options) return SUCCESS
"module" % (name,), "The output above " "this warning shows how " "the compilation " "failed.")) kwargs = {} version = "0.1.0" with open('README.rst') as f: kwargs['long_description'] = f.read() if (platform.python_implementation() == "CPython" and os.environ.get('DUROTAR_EXTENSION') != '0'): # This extension builds and works on pypy as well, although pypy's jit # produces equivalent performance. kwargs['ext_modules'] = [ Extension('durotar.cfilters', sources=['durotar/filters.c']), ] if os.environ.get('TORNADO_EXTENSION') != '1': # Unless the user has specified that the extension is mandatory, # fall back to the pure-python implementation on any build failure. kwargs['cmdclass'] = {'build_ext': custom_build_ext} setup( name="durotar",
class ExecutorTest: # Executor.shutdown() and context manager usage is tested by # ExecutorShutdownTest. def test_submit(self): future = self.executor.submit(pow, 2, 8) assert 256 == future.result() def test_submit_keyword(self): future = self.executor.submit(mul, 2, y=8) assert 16 == future.result() def test_map(self): assert list(self.executor.map(pow, range(10), range(10))) == \ list(map(pow, range(10), range(10))) def test_map_exception(self): i = self.executor.map(divmod, [1, 1, 1, 1], [2, 3, 0, 5]) assert next(i), (0 == 1) assert next(i), (0 == 1) with pytest.raises(ZeroDivisionError): next(i) def test_map_timeout(self): results = [] with pytest.raises(futures.TimeoutError): for i in self.executor.map(time.sleep, [0, 0, 5], timeout=1): results.append(i) assert [None, None] == results def test_shutdown_race_issue12456(self): # Issue #12456: race condition at shutdown where trying to post a # sentinel in the call queue blocks (the queue is full while processes # have exited). self.executor.map(str, [2] * (self.worker_count + 1)) self.executor.shutdown() @pytest.mark.skipif( platform.python_implementation() != "CPython" or (sys.version_info >= (3, 8, 0) and sys.version_info < (3, 8, 2)), reason="Underlying bug fixed upstream starting Python 3.8.2") def test_no_stale_references(self): # Issue #16284: check that the executors don't unnecessarily hang onto # references. # This test has to be skipped on early Python 3.8 versions because of a # low-level reference cycle inside the pickle module for early versions # of Python 3.8 preventing stale references from being collected. See # cloudpipe/cloudpickle#327 as well as # https://bugs.python.org/issue39492 my_object = MyObject() collect = threading.Event() _ref = weakref.ref(my_object, lambda obj: collect.set()) # noqa # Deliberately discarding the future. self.executor.submit(my_object.my_method) del my_object collected = False for _ in range(5): if IS_PYPY: gc.collect() collected = collect.wait(timeout=1.0) if collected: return assert collected, "Stale reference not collected within timeout." def test_max_workers_negative(self): for number in (0, -1): with pytest.raises(ValueError) as infos: self.executor_type(max_workers=number) assert infos.value.args[0] == "max_workers must be greater than 0" @pytest.mark.broken_pool def test_killed_child(self): # When a child process is abruptly terminated, the whole pool gets # "broken". future = self.executor.submit(time.sleep, 30) # Get one of the processes, and terminate (kill) it p = next(iter(self.executor._processes.values())) p.terminate() match = filter_match(r"SIGTERM") with pytest.raises(TerminatedWorkerError, match=match): future.result() # Submitting other jobs fails as well. with pytest.raises(TerminatedWorkerError, match=match): self.executor.submit(pow, 2, 8) def test_map_chunksize(self): def bad_map(): list(self.executor.map(pow, range(40), range(40), chunksize=-1)) ref = list(map(pow, range(40), range(40))) assert list(self.executor.map(pow, range(40), range(40), chunksize=6)) == ref assert list(self.executor.map(pow, range(40), range(40), chunksize=50)) == ref assert list(self.executor.map(pow, range(40), range(40), chunksize=40)) == ref with pytest.raises(ValueError): bad_map() @classmethod def _test_traceback(cls): raise RuntimeError(123) # some comment def test_traceback(self): # We want ensure that the traceback from the child process is # contained in the traceback raised in the main process. future = self.executor.submit(self._test_traceback) with pytest.raises(Exception) as cm: future.result() exc = cm.value assert type(exc) is RuntimeError assert exc.args == (123, ) cause = exc.__cause__ assert type(cause) is process_executor._RemoteTraceback assert 'raise RuntimeError(123) # some comment' in cause.tb # # The following tests are new additions to the test suite originally # backported from the Python 3 concurrent.futures package. # def _test_thread_safety(self, thread_idx, results): try: # submit a mix of very simple tasks with map and submit, # cancel some of them and check the results map_future_1 = self.executor.map(sqrt, range(40), timeout=10) if thread_idx % 2 == 0: # Make it more likely for scheduling threads to overtake one # another time.sleep(0.001) submit_futures = [ self.executor.submit(time.sleep, 0.0001) for _ in range(20) ] for i, f in enumerate(submit_futures): if i % 2 == 0: f.cancel() map_future_2 = self.executor.map(sqrt, range(40), timeout=10) assert list(map_future_1) == [sqrt(x) for x in range(40)] assert list(map_future_2) == [sqrt(i) for i in range(40)] for i, f in enumerate(submit_futures): if i % 2 == 1 or not f.cancelled(): assert f.result(timeout=10) is None results[thread_idx] = 'ok' except Exception: # Ensure that py.test can report the content of the exception results[thread_idx] = traceback.format_exc() def test_thread_safety(self): # Check that our process-pool executor can be shared to schedule work # by concurrent threads results = [None] * 10 threads = [ Thread(target=self._test_thread_safety, args=(i, results)) for i in range(len(results)) ] for t in threads: t.start() for t in threads: t.join() for result in results: if result != "ok": raise AssertionError(result) @classmethod def return_inputs(cls, *args): return args def test_submit_from_callback(self): collected = defaultdict(list) executor = self.executor def _collect_and_submit_next(future): name, count = future.result() collected[name].append(count) if count > 0: future = executor.submit(self.return_inputs, name, count - 1) future.add_done_callback(_collect_and_submit_next) # Start 3 concurrent callbacks chains fa = executor.submit(self.return_inputs, 'chain a', 100) fa.add_done_callback(_collect_and_submit_next) fb = executor.submit(self.return_inputs, 'chain b', 50) fb.add_done_callback(_collect_and_submit_next) fc = executor.submit(self.return_inputs, 'chain c', 60) fc.add_done_callback(_collect_and_submit_next) assert fa.result() == ('chain a', 100) assert fb.result() == ('chain b', 50) assert fc.result() == ('chain c', 60) # Wait a maximum of 5s for the asynchronous callback chains to complete patience = 500 while True: if (collected['chain a'] == list(range(100, -1, -1)) and collected['chain b'] == list(range(50, -1, -1)) and collected['chain c'] == list(range(60, -1, -1))): # the recursive callback chains have completed successfully break elif patience < 0: raise AssertionError( f"callback submit chains stalled at: {collected!r}") else: patience -= 1 time.sleep(0.01) @pytest.mark.timeout(60) def test_worker_timeout(self): self.executor.shutdown(wait=True) self.check_no_running_workers(patience=5) timeout = getattr(self, 'min_worker_timeout', .01) try: self.executor = self.executor_type(max_workers=4, context=self.context, timeout=timeout) except NotImplementedError as e: self.skipTest(str(e)) for _ in range(5): # Trigger worker spawn for lazy executor implementations for _ in self.executor.map(id, range(8)): pass # Check that all workers shutdown (via timeout) when waiting a bit: # note that the effictive time for Python process to completely # shutdown can vary a lot especially on loaded CI machines with and # the atexit callbacks that writes test coverage data to disk. # Let's be patient. self.check_no_running_workers(patience=5) @classmethod def reducer_in(cls, obj): return MyObject, (obj.value + 5, ) @classmethod def reducer_out(cls, obj): return MyObject, (7 * obj.value, ) def test_serialization(self): """Test custom serialization for process_executor""" self.executor.shutdown(wait=True) # Use non commutative operation to check correct order job_reducers = {} job_reducers[MyObject] = self.reducer_in result_reducers = {} result_reducers[MyObject] = self.reducer_out # Create a new executor to ensure that we did not mess with the # existing module level serialization executor = self.executor_type(max_workers=2, context=self.context, job_reducers=job_reducers, result_reducers=result_reducers) self.executor = self.executor_type(max_workers=2, context=self.context) obj = MyObject(1) try: ret_obj_custom = executor.submit(self.return_inputs, obj).result()[0] ret_obj = self.executor.submit(self.return_inputs, obj).result()[0] assert ret_obj.value == 1 assert ret_obj_custom.value == 42 finally: executor.shutdown(wait=True) @classmethod def _test_max_depth(cls, max_depth=10, kill_workers=False, ctx=None): if max_depth == 0: return 42 executor = cls.executor_type(1, context=ctx) f = executor.submit(cls._test_max_depth, max_depth - 1, ctx) try: return f.result() finally: executor.shutdown(wait=True, kill_workers=kill_workers) @pytest.mark.parametrize('kill_workers', [True, False]) def test_max_depth(self, kill_workers): from loky.process_executor import MAX_DEPTH if self.context.get_start_method() == 'fork': # For 'fork', we do not allow nested process as the threads ends # up in messy states with pytest.raises(LokyRecursionError): self._test_max_depth(max_depth=2, ctx=self.context) return assert self._test_max_depth(max_depth=MAX_DEPTH, kill_workers=kill_workers, ctx=self.context) == 42 with pytest.raises(LokyRecursionError): self._test_max_depth(max_depth=MAX_DEPTH + 1, kill_workers=kill_workers, ctx=self.context) @pytest.mark.high_memory @pytest.mark.skipif(sys.maxsize < 2**32, reason="Test requires a 64 bit version of Python") @pytest.mark.skipif( sys.version_info < (3, 8), reason= "Python version does not support pickling objects of size > 2 ** 31GB") def test_no_failure_on_large_data_send(self): data = b'\x00' * int(2.2e9) self.executor.submit(id, data).result() @pytest.mark.high_memory @pytest.mark.skipif(sys.maxsize < 2**32, reason="Test requires a 64 bit version of Python") @pytest.mark.skipif( sys.version_info >= (3, 8), reason="Python version supports pickling objects of size > 2 ** 31GB") def test_expected_failure_on_large_data_send(self): data = b'\x00' * int(2.2e9) with pytest.raises(RuntimeError): self.executor.submit(id, data).result() def test_memory_leak_protection(self): self.executor.shutdown(wait=True) executor = self.executor_type(1, context=self.context) def _leak_some_memory(size=int(3e6), delay=0.001): """function that leaks some memory """ from loky import process_executor process_executor._MEMORY_LEAK_CHECK_DELAY = 0.1 if getattr(os, '_loky_leak', None) is None: os._loky_leak = [] os._loky_leak.append(b"\x00" * size) # Leave enough time for the memory leak detector to kick-in: # by default the process does not check its memory usage # more than once per second. time.sleep(delay) leaked_size = sum(len(buffer) for buffer in os._loky_leak) return os.getpid(), leaked_size with pytest.warns(UserWarning, match='memory leak'): # Total run time should be 3s which is way over the 1s cooldown # period between two consecutive memory checks in the worker. futures = [executor.submit(_leak_some_memory) for _ in range(300)] executor.shutdown(wait=True) results = [f.result() for f in futures] # The pid of the worker has changed when restarting the worker first_pid, last_pid = results[0][0], results[-1][0] assert first_pid != last_pid # The restart happened after 100 MB of leak over the # default process size + what has leaked since the last # memory check. for _, leak_size in results: assert leak_size / 1e6 < 650 def test_reference_cycle_collection(self): # make the parallel call create a reference cycle and make # a weak reference to be able to track the garbage collected objects self.executor.shutdown(wait=True) executor = self.executor_type(1, context=self.context) def _create_cyclic_reference(delay=0.001): """function that creates a cyclic reference""" from loky import process_executor process_executor._USE_PSUTIL = False process_executor._MEMORY_LEAK_CHECK_DELAY = 0.1 class A: def __init__(self, size=int(1e6)): self.data = b"\x00" * size self.a = self if getattr(os, '_loky_cyclic_weakrefs', None) is None: os._loky_cyclic_weakrefs = [] a = A() time.sleep(delay) os._loky_cyclic_weakrefs.append(weakref.ref(a)) return sum(1 for r in os._loky_cyclic_weakrefs if r() is not None) # Total run time should be 3s which is way over the 1s cooldown # period between two consecutive memory checks in the worker. futures = [ executor.submit(_create_cyclic_reference) for _ in range(300) ] executor.shutdown(wait=True) max_active_refs_count = max(f.result() for f in futures) assert max_active_refs_count < 150 assert max_active_refs_count != 1 @pytest.mark.broken_pool def test_exited_child(self): # When a child process is abruptly terminated, the whole pool gets # "broken". print(self.context.get_start_method()) match = filter_match(r"EXIT\(42\)") future = self.executor.submit(c_exit, 42) with pytest.raises(TerminatedWorkerError, match=match): future.result() # Submitting other jobs fails as well. with pytest.raises(TerminatedWorkerError, match=match): self.executor.submit(pow, 2, 8) @staticmethod def _test_child_env(var_name): import os return os.environ.get(var_name, "unset") def test_child_env_executor(self): # Test that for loky context, setting argument env correctly overwrite # the environment of the child process. if self.context.get_start_method() != 'loky': pytest.skip(msg="Only work with loky context") var_name = "loky_child_env_executor" var_value = "variable set" executor = self.executor_type(1, env={var_name: var_value}) var_child = executor.submit(self._test_child_env, var_name).result() assert var_child == var_value executor.shutdown(wait=True) def test_viztracer_profiler(self): # Check that viztracer profiler is initialzed in workers when # installed. viztracer = pytest.importorskip("viztracer") def check_viztracer_active(): tracer = viztracer.get_tracer() if tracer is None: return False return tracer.enable active_in_main_process = check_viztracer_active() with self.executor_type(1, context=self.context) as e: active_in_child_process = e.submit(check_viztracer_active).result() assert active_in_main_process == active_in_child_process if not active_in_main_process: tracer = viztracer.VizTracer() try: tracer.start() with self.executor_type(1, context=self.context) as e: assert e.submit(check_viztracer_active).result() finally: tracer.stop() # Once the tracer has been stopped, should be no side effect on # workers started in new executors. with self.executor_type(1, context=self.context) as e: assert not e.submit(check_viztracer_active).result() def test_viztracer_profiler_with_custom_init(self): # Check that viztracer profiler is initialzed in workers when # installed. viztracer = pytest.importorskip("viztracer") # Make sure the auto-viztracer initialization works even when # the call pass their own init. def check_viztracer_active_and_custom_init(): assert loky._custom_global_var == 42 tracer = viztracer.get_tracer() if tracer is None: return False return tracer.enable existing_tracer = viztracer.get_tracer() if existing_tracer is not None and existing_tracer.enable: pytest.skip("Cannot run this test if viztracer is active") tracer = viztracer.VizTracer() try: tracer.start() with self.executor_type(1, context=self.context, initializer=_custom_initializer) as e: assert e.submit( check_viztracer_active_and_custom_init).result() finally: tracer.stop()
# <attrs is used internally by attrs # <__array_function__ is used by numpy IGNORE_BASENAMES_STARTING_WITH = ('<frozen ', '<builtin', '<attrs', '<__array_function__') # Note: <string> has special heuristics to know whether it should be traced or not (it's part of # user code when it's the <string> used in python -c and part of the library otherwise). # Any filename that starts with these strings is considered user (project) code. Note # that files for which we have a source mapping are also considered as a part of the project. USER_CODE_BASENAMES_STARTING_WITH = ('<ipython', ) # Any filename that starts with these strings is considered library code (note: checked after USER_CODE_BASENAMES_STARTING_WITH). LIBRARY_CODE_BASENAMES_STARTING_WITH = ('<', ) IS_CPYTHON = platform.python_implementation() == 'CPython' # Hold a reference to the original _getframe (because psyco will change that as soon as it's imported) IS_IRONPYTHON = sys.platform == 'cli' try: get_frame = sys._getframe if IS_IRONPYTHON: def get_frame(): try: return sys._getframe() except ValueError: pass except AttributeError:
#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (c) 2012-2019 Snowflake Computing Inc. All right reserved. # """ Various constants """ import platform import sys from .compat import TO_UNICODE from .version import VERSION SNOWFLAKE_CONNECTOR_VERSION = u'.'.join(TO_UNICODE(v) for v in VERSION[0:3]) PYTHON_VERSION = u'.'.join(TO_UNICODE(v) for v in sys.version_info[:3]) OPERATING_SYSTEM = platform.system() PLATFORM = platform.platform() IMPLEMENTATION = platform.python_implementation() COMPILER = platform.python_compiler() CLIENT_NAME = u"PythonConnector" # don't change! CLIENT_VERSION = u'.'.join([TO_UNICODE(v) for v in VERSION[:3]])
def main(): # OS X support: allow dylibs to see each other; needed by SWIG from platform import python_implementation if python_implementation() == 'CPython' and platform == 'darwin': from ctypes import RTLD_GLOBAL sys.setdlopenflags(RTLD_GLOBAL) sys.setrecursionlimit(10000) print("PyExZ3 (Python Exploration with Z3)") sys.path = [os.path.abspath(os.path.join(os.path.dirname(__file__))) ] + sys.path usage = "usage: %prog [options] <path to a *.py file>" parser = OptionParser(usage=usage) # Setup setup_group = OptionGroup(parser, "Exploration Setup") setup_group.add_option("-s", "--start", dest="entry", action="store", help="Specify entry point", default="") setup_group.add_option("--cvc", dest="solver", action="store_const", const="cvc", help="Use the CVC SMT solver instead of Z3") setup_group.add_option("--z3str2", dest="solver", action="store_const", const="z3str2", help="Use the Z3-str2 SMT solver instead of Z3") setup_group.add_option("--z3", dest="solver", action="store_const", const="z3", help="Use the Z3 SMT solver") setup_group.add_option( "--multi", dest="solver", action="store_const", const="multi", help="Use as many different solvers as possible simultaneously") parser.add_option_group(setup_group) # Configuration configuration_group = OptionGroup(parser, "Exploration Configuration") configuration_group.add_option( "-n", "--workers", dest="workers", type="int", help="Run specified number of solvers in parallel", default=1) configuration_group.add_option( "-p", "--scheduling-policy", dest="scheduling_policy", type="str", help= "The name of the scheduling policy used to assign solving jobs to solvers.", default="central_queue") parser.add_option_group(configuration_group) # Input Detection input_detection_group = OptionGroup(parser, "Input Detection") input_detection_group.add_option("--argparse", dest="loader", action="store_const", const='argparse') input_detection_group.add_option("--sysargv", dest="loader", action="store_const", const='sysargv') input_detection_group.add_option("--optparse", dest="loader", action="store_const", const='optparse') parser.add_option_group(input_detection_group) # Limits limits_group = OptionGroup(parser, "Exploration Limits") limits_group.add_option( "-t", "--exploration-timeout", dest="explorationtimeout", type="int", help="Time in seconds to terminate the concolic execution", default=None) limits_group.add_option( "--solve-timeout", dest="solvetimeouts", action='append', type=float, help="Time in seconds to terminate a query to the SMT", default=None) limits_group.add_option( "--path-timeout", dest="pathtimeout", type="int", help="Maximum solving time to traverse down a single path", default=None) limits_group.add_option( "-b", "--coverage-pruning", dest="coverage_pruning", type="int", help= "Prune paths after no coverage increase for the specified number of inputs generated.", default=None) limits_group.add_option("-m", "--max-iters", dest="max_iters", type="int", help="Run specified number of iterations", default=0) parser.add_option_group(limits_group) # Serialization and Logging logging_group = OptionGroup(parser, "Serialization and Logging") logging_group.add_option("-l", "--log", dest="logfile", action="store", help="Save log output to a file", default="") logging_group.add_option( "-g", "--graph", dest="execution_graph", action="store", help="The file to save the serialized execution tree") logging_group.add_option( "-d", "--dot", dest="dot_graph", action="store", help="The file to save a DOT graph of execution tree") logging_group.add_option( "-q", "--query-store", dest="query_store", type="str", help="The folder to store generated and the execution graph, " "currently only CVC supports full query serialization") logging_group.add_option('--debug', help="Enables debugging output.", action="store_true", dest="debug") parser.add_option_group(logging_group) (options, args) = parser.parse_args() debuglogging = options.debug if debuglogging: loglevel = logging.DEBUG else: loglevel = logging.INFO if not (options.logfile == ""): logging.basicConfig(filename=options.logfile, level=loglevel, format='%(asctime)s\t%(levelname)s\t%(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') if len(args) == 0 or not os.path.exists(args[0]): parser.error("Missing app to execute") sys.exit(1) solver = options.solver if options.solver is not None else "z3" solvetimeouts = options.solvetimeouts query_store = options.query_store scheduling_policy = options.scheduling_policy starttime_cpu = time.process_time() starttime_wall = time.time() filename = os.path.abspath(args[0]) # Get the object describing the application app = loaderFactory(filename, options.entry, loader=options.loader) if app is None: sys.exit(1) print("Exploring " + app.filename + "." + app.entrypoint) engine = ExplorationEngine(app.createInvocation(), solver=solver, query_store=query_store, solvetimeouts=solvetimeouts, workers=options.workers, scheduling_policy=scheduling_policy, pathtimeout=options.pathtimeout, coverage_pruning=options.coverage_pruning) generatedInputs, return_values, path = engine.explore( options.max_iters, options.explorationtimeout) # check the result result = app.execution_complete(return_values) endtime_cpu = time.process_time() endtime_wall = time.time() print("Execution time: {0:.2f} seconds".format(endtime_wall - starttime_wall)) print("Solver CPU: {0:.2f} seconds".format(engine.total_solve_time)) instrumentation_time = endtime_cpu - starttime_cpu print("Instrumentation CPU: {0:.2f} seconds".format(instrumentation_time)) print("Path coverage: {} paths".format(len(generatedInputs))) total_lines, executed_lines, executed_branches = engine.coverage_statistics( ) print("Line coverage: {}/{} lines ({:.2%})".format( executed_lines, total_lines, (executed_lines / total_lines) if total_lines > 0 else 0)) print("Branch coverage: {} branches".format(executed_branches)) print("Exceptions: {} exceptions raised".format( len({ e for e in return_values if isinstance(e, Exception) and hasattr(e, 'id') }))) print("Triaged exceptions: {} triaged exceptions raised".format( len({ e.id for e in return_values if isinstance(e, Exception) and hasattr(e, 'id') }))) # output DOT graph if options.dot_graph is not None: with open(options.dot_graph, "w") as f: f.write(path.toDot()) # output serialized exploration graph if options.execution_graph is not None: pickle.dump(path, open(options.execution_graph, "wb")) if not result and options.loader == None: sys.exit(1)
def user_agent(): # type: () -> str """ Return a string representing the user agent. """ data = { "installer": { "name": "pip", "version": __version__ }, "python": platform.python_version(), "implementation": { "name": platform.python_implementation(), }, } # type: Dict[str, Any] if data["implementation"]["name"] == 'CPython': data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'PyPy': pypy_version_info = sys.pypy_version_info # type: ignore if pypy_version_info.releaselevel == 'final': pypy_version_info = pypy_version_info[:3] data["implementation"]["version"] = ".".join( [str(x) for x in pypy_version_info]) elif data["implementation"]["name"] == 'Jython': # Complete Guess data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'IronPython': # Complete Guess data["implementation"]["version"] = platform.python_version() if sys.platform.startswith("linux"): from pip._vendor import distro # https://github.com/nir0s/distro/pull/269 linux_distribution = distro.linux_distribution() # type: ignore distro_infos = dict( filter( lambda x: x[1], zip(["name", "version", "id"], linux_distribution), )) libc = dict( filter( lambda x: x[1], zip(["lib", "version"], libc_ver()), )) if libc: distro_infos["libc"] = libc if distro_infos: data["distro"] = distro_infos if sys.platform.startswith("darwin") and platform.mac_ver()[0]: data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]} if platform.system(): data.setdefault("system", {})["name"] = platform.system() if platform.release(): data.setdefault("system", {})["release"] = platform.release() if platform.machine(): data["cpu"] = platform.machine() if has_tls(): import _ssl as ssl data["openssl_version"] = ssl.OPENSSL_VERSION setuptools_dist = get_default_environment().get_distribution("setuptools") if setuptools_dist is not None: data["setuptools_version"] = str(setuptools_dist.version) if shutil.which("rustc") is not None: # If for any reason `rustc --version` fails, silently ignore it try: rustc_output = subprocess.check_output(["rustc", "--version"], stderr=subprocess.STDOUT, timeout=.5) except Exception: pass else: if rustc_output.startswith(b"rustc "): # The format of `rustc --version` is: # `b'rustc 1.52.1 (9bc8c42bb 2021-05-09)\n'` # We extract just the middle (1.52.1) part data["rustc_version"] = rustc_output.split(b" ")[1].decode() # Use None rather than False so as not to give the impression that # pip knows it is not being run under CI. Rather, it is a null or # inconclusive result. Also, we include some value rather than no # value to make it easier to know that the check has been run. data["ci"] = True if looks_like_ci() else None user_data = os.environ.get("PIP_USER_AGENT_USER_DATA") if user_data is not None: data["user_data"] = user_data return "{data[installer][name]}/{data[installer][version]} {json}".format( data=data, json=json.dumps(data, separators=(",", ":"), sort_keys=True), )
# coding: utf-8 """Functional tests for MIMEEval Plugin""" from __future__ import absolute_import import sys import unittest import platform import tests.util IS_PYPY3 = ("pypy" in platform.python_implementation().lower() and sys.version_info.major == 3) PRE_CONFIG = """ loadplugin Mail::SpamAssassin::Plugin::MIMEEval report _SCORE_ report _TESTS_ """ # Define rules for plugin CONFIG = """ body CHECK_MIME_BASE64_COUNT eval:check_for_mime("mime_base64_count") body CHECK_MIME_BASE64_ENCODED_TEXT eval:check_for_mime("mime_base64_encoded_text") body CHECK_MIME_BODY_HTML_COUNT eval:check_for_mime("mime_body_html_count") body CHECK_MIME_BODY_TEXT_COUNT eval:check_for_mime("mime_body_text_count") body CHECK_MIME_FARAWAY_CHARSET eval:check_for_mime("mime_faraway_charset") body CHECK_MIME_MISSING_BOUNDARY eval:check_for_mime("mime_missing_boundary") body CHECK_MIME_MULTIPART_ALTERNATIVE eval:check_for_mime("mime_multipart_alternative") body CHECK_MIME_MULTIPART_RATIO eval:check_for_mime("mime_multipart_ratio")
from pydicom.valuerep import PersonName3 as PersonNameUnicode PersonName = PersonNameUnicode else: from pydicom.valuerep import (PersonName, PersonNameUnicode) try: import cPickle as pickle except ImportError: import pickle badvr_name = get_testdata_files("badVR.dcm")[0] default_encoding = 'iso8859' @pytest.mark.skipif(platform.python_implementation() == 'PyPy', reason="PyPy has trouble with this pickle") class TestTM(object): """Unit tests for pickling TM""" def test_pickling(self): # Check that a pickled TM is read back properly x = pydicom.valuerep.TM("212223") x.original_string = 'hello' assert 'hello' == x.original_string assert time(21, 22, 23) == x data1_string = pickle.dumps(x) x2 = pickle.loads(data1_string) assert x == x2 assert x.original_string == x2.original_string assert str(x) == str(x2)
def _get_software_info(self): return {"python":{"version": pf.python_version(), "implementation": pf.python_implementation()} }
import dramatiq import platform import pytest import time from dramatiq import Message, Middleware, Worker from dramatiq.middleware import SkipMessage _current_platform = platform.python_implementation() def test_actors_can_be_defined(stub_broker): # Given that I've decorated a function with @actor @dramatiq.actor def add(x, y): return x + y # I expect that function to become an instance of Actor assert isinstance(add, dramatiq.Actor) def test_actors_can_be_assigned_predefined_options(stub_broker): # Given that I have a stub broker with the retries middleware # If I define an actor with a max_retries number @dramatiq.actor(max_retries=32) def add(x, y): return x + y # I expect the option to persist assert add.options["max_retries"] == 32
sys.exit( "The folder you are executing pip from can no longer be found." ) # under macOS + virtualenv sys.prefix is not properly resolved # it is something like /path/to/python/bin/.. # Note: using realpath due to tmp dirs on OSX being symlinks src_prefix = os.path.abspath(src_prefix) # FIXME doesn't account for venv linked to global site-packages site_packages = sysconfig.get_path("purelib") # This is because of a bug in PyPy's sysconfig module, see # https://bitbucket.org/pypy/pypy/issues/2506/sysconfig-returns-incorrect-paths # for more information. if platform.python_implementation().lower() == "pypy": site_packages = distutils_sysconfig.get_python_lib() try: # Use getusersitepackages if this is present, as it ensures that the # value is initialised properly. user_site = site.getusersitepackages() except AttributeError: user_site = site.USER_SITE user_dir = expanduser('~') if WINDOWS: bin_py = os.path.join(sys.prefix, 'Scripts') bin_user = os.path.join(user_site, 'Scripts') # buildout uses 'bin' on Windows too? if not os.path.exists(bin_py): bin_py = os.path.join(sys.prefix, 'bin') bin_user = os.path.join(user_site, 'bin')