def __init__(self, **kwargs): Script.__init__(self, **kwargs) self.title = "Gulf of Maine intertidal density/cover (Petraitis et al. 2008)" self.citation = "Peter S. Petraitis, Harrison Liu, and " \ "Erika C. Rhile. 2008. Densities and cover " \ "data for intertidal organisms in the Gulf of " \ "Maine, USA, from 2003 to 2007. Ecology 89:588." self.name = "intertidal-abund-me" self.ref = "https://figshare.com/collections/DENSITIES_AND_COVER_DATA_FOR_INTERTIDAL_ORGANISMS_IN_THE_GULF_OF_MAINE_USA_FROM_2003_TO_2007/3300200" self.description = "The data on densities and percent cover in the " \ "60 experimental plots from 2003 to 2007 and to " \ "update data from 1996 to 2002 that are already " \ "published in Ecological Archives." \ "Includes densities of mussels, " \ "herbivorous limpet, herbivorous snails, " \ "predatory snail, barnacle , fucoid algae and " \ "percent cover by mussels, barnacles, fucoids, " \ "and other sessile organisms." self.retriever_minimum_version = '2.0.dev' self.version = '1.5.3' self.urls = {"main": "https://ndownloader.figshare.com/files/5600831"} self.cleanup_func_table = Cleanup(correct_invalid_value, missing_values=[-999.9]) if parse_version(VERSION) <= parse_version("2.0.0"): self.shortname = self.name self.name = self.title self.cleanup_func_table = Cleanup(correct_invalid_value, nulls=[-999.9]) self.tables = {"main": Table("main", cleanup=self.cleanup_func_table)}
def check_api_version(self): """Checks the API version on the server to determine which to use.""" try: root_resource = self.api_get('api/') rsp = self.api_get(root_resource['links']['info']['href']) self.rb_version = rsp['info']['product']['package_version'] if parse_version(self.rb_version) >= parse_version('1.5.2'): self.deprecated_api = False self.root_resource = root_resource debug('Using the new web API') return True except APIError, e: if e.http_status not in (401, 404): # We shouldn't reach this. If there's a permission denied # from lack of logging in, then the basic auth handler # should have hit it. # # However in some versions it wants you to be logged in # and returns a 401 from the application after you've # done your http basic auth die("Unable to access the root /api/ URL on the server.") return False
def check_for_updates(request): """Check if a new version of Modoboa is available.""" local_config = models.LocalConfig.objects.first() client = ModoAPIClient() extensions = exts_pool.list_all() extensions = [{ "label": "Modoboa", "name": "modoboa", "description": _("The core part of Modoboa"), "version": client.local_core_version }] + extensions update_avail = False for extension in extensions: pkgname = extension["name"].replace("_", "-") for api_extension in local_config.api_versions: if api_extension["name"] != pkgname: continue extension["last_version"] = api_extension["version"] if ( parse_version(api_extension["version"]) > parse_version(extension["version"]) ): extension["update"] = True extension["changelog_url"] = api_extension["url"] update_avail = True break return update_avail, extensions
def from_pandas(X): """A simple wrapper for H2OFrame.from_python. This takes a pandas dataframe and returns an H2OFrame with all the default args (generally enough) plus named columns. Parameters ---------- X : pd.DataFrame The dataframe to convert. Returns ------- H2OFrame """ pd, _ = validate_is_pd(X, None) # older version of h2o are super funky with this if parse_version(h2o.__version__) < parse_version('3.10.0.7'): h = 1 else: h = 0 # if h2o hasn't started, we'll let this fail through return H2OFrame.from_python(X, header=h, column_names=X.columns.tolist())
def do_reset(): """ Reset and wait. Returns True on failure. """ if not args.quiet: print "Checking ECME versions..." results, errors = run_command(args, nodes, "get_versions") if errors: print "ERROR: MC reset aborted. Backup partitions not updated." return True for result in results.values(): version = result.ecme_version.lstrip("v") if parse_version(version) < parse_version("1.2.0"): print "ERROR: MC reset is unsafe on ECME version v%s" % version print "Please power cycle the system and start a new fwupdate." return True if not args.quiet: print "Resetting nodes..." results, errors = run_command(args, nodes, "mc_reset", True) if errors: print "ERROR: MC reset failed. Backup partitions not updated." return True return False
def version_compare(a, b): aStrippedFromStartingV = ''.join(a.split('v', 1)) bStrippedFromStartingV = ''.join(b.split('v', 1)) if parse_version(aStrippedFromStartingV) < parse_version(bStrippedFromStartingV): return 1 else: return -1
def exists(env): icecc = env.get('ICECC', False) if not icecc: return False icecc = env.WhereIs(icecc) pipe = SCons.Action._subproc(env, SCons.Util.CLVar(icecc) + ['--version'], stdin = 'devnull', stderr = 'devnull', stdout = subprocess.PIPE) if pipe.wait() != 0: return False validated = False for line in pipe.stdout: if validated: continue # consume all data version_banner = re.search(r'^ICECC ', line) if not version_banner: continue icecc_version = re.split('ICECC (.+)', line) if len(icecc_version) < 2: continue icecc_version = parse_version(icecc_version[1]) needed_version = parse_version(icecream_version_min) if icecc_version >= needed_version: validated = True return validated
def assertInterfacesImplemented(self, cls): "Given a class, assert that the zope.interface.Interfaces are implemented to specification." # see if this version of zope.interface is too old to run these tests zi_vers = pkg_resources.working_set.find( pkg_resources.Requirement.parse('zope.interface')).version if pkg_resources.parse_version(zi_vers) < pkg_resources.parse_version('4.1.1'): raise unittest.SkipTest("zope.interfaces is too old to run this test") import zope.interface.interface for interface in zope.interface.implementedBy(cls): for attr, template_argspec in interface.namesAndDescriptions(): if not hasattr(cls, attr): msg = "Expected: %r; to implement: %s as specified in %r" % ( cls, attr, interface) self.fail(msg) actual_argspec = getattr(cls, attr) while hasattr(actual_argspec, 'func_original'): actual_argspec = actual_argspec.func_original actual_argspec = zope.interface.interface.fromMethod(actual_argspec) if actual_argspec.getSignatureInfo() != template_argspec.getSignatureInfo(): msg = "%s: expected: %s; got: %s" % ( attr, template_argspec.getSignatureString(), actual_argspec.getSignatureString()) self.fail(msg)
def has_environment_marker_range_operators_support(): """Code extracted from 'pytest/setup.py' https://github.com/pytest-dev/pytest/blob/7538680c/setup.py#L31 The first known release to support environment marker with range operators it is 17.1, see: https://setuptools.readthedocs.io/en/latest/history.html#id113 """ return parse_version(setuptools_version) >= parse_version('17.1')
def add_version_section(self, version, date, contents): ''' Adds a version section :param version: ``str`` version as a string :param date: ``datetime.datetime`` version date :param contents: ``list(list([str|Reference]))``` contents as a list of lists which contain a combination of ``str`` and ``Reference`` objects :returns: None ''' if version in self.__versions: raise DuplicateVersionsException(version) self.__parsed_versions.append(pkg_resources.parse_version(version)) self.__parsed_versions = sorted(self.__parsed_versions) # Cannot go parsed -> str, so sorting must be done by comparison new_versions = [None] * len(self.__parsed_versions) for v in self.__versions + [version]: parsed_v = pkg_resources.parse_version(v) index = self.__parsed_versions.index(parsed_v) if index == -1: raise RuntimeError("Inconsistent internal version storage state") new_versions[index] = v self.__versions = new_versions self.__dates[version] = date self.__content[version] = contents
def process(cmd, opts): """ Creates a process. Adds options (provided as keyword args) to the given cmd. Parameters ---------- cmd: str the command to add options opts: dict the options to add """ if opts is None: opts = {} cmd = 'dat ' + cmd for key, val in opts.items(): if (len(key) == 1): cmd += " -{0} {1}".format(key, val) else: cmd += " --{0}={1}".format(key, val) current_version = subprocess.check_output(['dat -v'], shell=True).decode().strip() if parse_version(current_version) < parse_version(COMPATIBLE_DAT_VERSION): raise DatException("Please update the dat version with npm install -g dat.", "Your version is {0}, this datpy requires {1}".format(current_version, COMPATIBLE_DAT_VERSION)) return subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
def compare_pypi_repos(reference_repo, other_repo): upgrade_table = PrettyTable(["Package", reference_repo.server, other_repo.server]) downgrade_table = PrettyTable(["Package", reference_repo.server, other_repo.server]) skipped_table = PrettyTable(["Package", reference_repo.server, other_repo.server]) skipped_packages = get_skipped_packages() reference_repo_versions = get_versions_from_reference(reference_repo) packages_to_check = list(reference_repo_versions.keys()) for name in sorted(packages_to_check): try: reference_repo_version = reference_repo_versions[name] other_repo_version = other_repo.get_latest_version(name) except PackageNotFound: continue if other_repo_version != reference_repo_version: if name in skipped_packages or any(x in other_repo_version for x in ['a', 'b', 'dev', 'post', 'rc']): skipped_table.add_row([name, reference_repo_version, other_repo_version]) elif parse_version(reference_repo_version) < parse_version(other_repo_version): upgrade_table.add_row([name, reference_repo_version, other_repo_version]) else: downgrade_table.add_row([name, reference_repo_version, other_repo_version]) print("Upgradable Packages:") print(upgrade_table) print() print("Downgradable Packages:") print(downgrade_table) print() print("Skipped Packages:") print(skipped_table)
def manage_nap_firmware_update(self, check_version=False): # Flash NAP if out of date. try: local_nap_version = parse_version( self.settings['system_info']['nap_version'].value) remote_nap_version = parse_version(self.newest_nap_vers) nap_out_of_date = local_nap_version != remote_nap_version except KeyError: nap_out_of_date = True if nap_out_of_date or check_version==False: text = "Updating NAP" self._write(text) self.create_flash("M25") nap_n_ops = self.pk_flash.ihx_n_ops(self.nap_fw.ihx) progress_dialog = PulsableProgressDialog(nap_n_ops, True) progress_dialog.title = text GUI.invoke_later(progress_dialog.open) self.pk_flash.write_ihx(self.nap_fw.ihx, self.stream, mod_print=0x40, \ elapsed_ops_cb = progress_dialog.progress) self.stop_flash() self._write("") progress_dialog.close() return True else: text = "NAP is already to latest version, not updating!" self._write(text) self._write("") return False
def __lt__(self, other): if self.context != other.context: raise TypeError("{0}.context != {1}.context".format(self, other)) return self._sort_key < other._sort_key # XXX prune sn = self.parsed_filename.group('name') on = other.parsed_filename.group('name') if sn != on: return sn < on sv = parse_version(self.parsed_filename.group('ver')) ov = parse_version(other.parsed_filename.group('ver')) if sv != ov: return sv < ov # Compatibility if self.context != other.context: raise TypeError("{0}.context != {1}.context".format(self, other)) sc = self.rank oc = other.rank if sc is not None and oc is not None and sc != oc: # Smaller compatibility ranks are "better" than larger ones, # so we have to reverse the sense of the comparison here! return sc > oc elif sc is None and oc is not None: return False return self.filename < other.filename
def _has_updated_kernel(self): if os.path.isdir('/lib/modules/'): for k_version in next(os.walk('/lib/modules/'))[1]: if parse_version(os.uname()[2]) < parse_version(k_version): return True return False return False
def test_simple(self): r"""simple test of version (to confirm we got right)""" import signet self.assertGreaterEqual( pkg_resources.parse_version(signet.__version__), pkg_resources.parse_version("1.0.2"))
def list_available_extensions(index_url=None, show_details=False): index_data = get_index_extensions(index_url=index_url) if show_details: return index_data installed_extensions = get_extensions() installed_extension_names = [e.name for e in installed_extensions] results = [] for name, items in OrderedDict(sorted(index_data.items())).items(): # exclude extensions/versions incompatible with current CLI version items = [item for item in items if ext_compat_with_cli(item['metadata'])[0]] if not items: continue latest = max(items, key=lambda c: parse_version(c['metadata']['version'])) installed = False if name in installed_extension_names: installed = True ext_version = get_extension(name).version if ext_version and parse_version(latest['metadata']['version']) > parse_version(ext_version): installed = str(True) + ' (upgrade available)' results.append({ 'name': name, 'version': latest['metadata']['version'], 'summary': latest['metadata']['summary'], 'preview': latest['metadata'].get(EXT_METADATA_ISPREVIEW, False), 'installed': installed }) return results
def _modify_qchem_according_to_version(cls, qchem_cmd): cmd2 = copy.deepcopy(qchem_cmd) try: from rubicon.utils.qchem_info import get_qchem_version cur_version = get_qchem_version() except: cur_version = parse_version("4.3.0") if cmd2 is not None: if cur_version >= parse_version("4.3.0"): if cmd2[0] == "qchem": if "-seq" in cmd2: cmd2.remove("-seq") if "NERSC_HOST" in os.environ and \ os.environ["NERSC_HOST"] in ["cori", "edison"]: if "-dbg" not in cmd2: cmd2.insert(1, "-dbg") if "-seq" in cmd2: cmd2.remove("-seq") elif "NERSC_HOST" in os.environ and \ os.environ["NERSC_HOST"] == "matgen": if "-dbg" not in cmd2: cmd2.insert(1, "-dbg") if "-seq" in cmd2: cmd2.remove("-seq") else: if "-dbg" in cmd2: cmd2.remove("-dbg") if "-pbs" in cmd2: cmd2.remove("-pbs") return cmd2
def fix_code(code, directory): """Formats Python code to conform to the PEP 8 style guide. """ if not black: raise Fault("black not installed", code=400) # Get black config from pyproject.toml line_length = black.DEFAULT_LINE_LENGTH string_normalization = True parser = configparser.ConfigParser() pyproject_path = os.path.join(directory, "pyproject.toml") if parser.read(pyproject_path): if parser.has_option("tool.black", "line-length"): line_length = parser.getint("tool.black", "line-length") if parser.has_option("tool.black", "skip-string-normalization"): string_normalization = not parser.getboolean( "tool.black", "skip-string-normalization" ) try: if parse_version(black.__version__) < parse_version("19.0"): reformatted_source = black.format_file_contents( src_contents=code, line_length=line_length, fast=False ) else: fm = black.FileMode( line_length=line_length, string_normalization=string_normalization ) reformatted_source = black.format_file_contents( src_contents=code, fast=False, mode=fm ) return reformatted_source except black.NothingChanged: return code except Exception as e: raise Fault("Error during formatting: {}".format(e), code=400)
def _scan_dirs(self): """ Build up a dictionary (self.packages) of the latest versions of each RPM found in the local directories. The keys are the package names, and the values are dictionaries containing the version and the path. """ for dir_name in self.dir_list: for file_name in os.listdir(dir_name): m = self._re_match(file_name) if not m: continue name = m.group(1) version = m.group(2) release = m.group(3) # arch = m.group(4) parsed_version = parse_version(version) parsed_release = parse_version(release) if self.debug: print "considering name=%s version=%s release=%s:" % (name, version, release) if (name not in self.packages or ((parsed_version, parsed_release) > (self.packages[name]["parsed_version"], self.packages[name]["parsed_release"]))): if self.debug: print " best so far" path = os.path.join(dir_name, file_name) self.packages[name] = {"version": version, "parsed_version": parsed_version, "release": release, "parsed_release": parsed_release, "path": path} elif self.debug: print (" ignoring - already have version %s release %s" % (self.packages[name]["version"], self.packages[name]["release"]))
def _check_placement(self): """Checks to see if the placement API is ready for scheduling. Checks to see that the placement API service is registered in the service catalog and that we can make requests against it. """ try: # TODO(efried): Use ksa's version filtering in _placement_get versions = self._placement_get("/") max_version = pkg_resources.parse_version( versions["versions"][0]["max_version"]) needs_version = pkg_resources.parse_version( MIN_PLACEMENT_MICROVERSION) if max_version < needs_version: msg = (_('Placement API version %(needed)s needed, ' 'you have %(current)s.') % {'needed': needs_version, 'current': max_version}) return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) except ks_exc.MissingAuthPlugin: msg = _('No credentials specified for placement API in nova.conf.') return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) except ks_exc.Unauthorized: msg = _('Placement service credentials do not work.') return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) except ks_exc.EndpointNotFound: msg = _('Placement API endpoint not found.') return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) except ks_exc.DiscoveryFailure: msg = _('Discovery for placement API URI failed.') return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) except ks_exc.NotFound: msg = _('Placement API does not seem to be running.') return UpgradeCheckResult(UpgradeCheckCode.FAILURE, msg) return UpgradeCheckResult(UpgradeCheckCode.SUCCESS)
def legendBoxProperties(): """Legend properties dictionary with keys consistent with MPL version. The argument names have changed in matplotlib 0.98.5. Old arguments do not work with later versions of matplotlib. Return dictionary of legend properties. """ global _lbp # return immediately if properties have already been cached if len(_lbp) > 0: return _lbp # figure out matplotlib version and appropriate names from pkg_resources import parse_version from matplotlib import __version__ as mplver if parse_version(mplver) >= parse_version('0.98.5'): _lbp = { 'loc' : 'upper right', 'numpoints' : 3, # number of points in the legend line 'borderpad' : 0.25, # whitespace in the legend border 'labelspacing' : 0, # space between legend entries 'handlelength' : 1.5, # the length of the legend lines 'handletextpad' : 0.5, # separation between line and text 'prop' : FontProperties(size='medium'), } else: _lbp = { 'loc' : 'upper right', 'numpoints' : 3, # number of points in the legend line 'pad' : 0.20, # whitespace in the legend border 'labelsep' : 0.005, # space between legend entries 'handlelen' : 0.03, # the length of the legend lines 'handletextsep' : 0.02, # separation between line and text 'prop' : FontProperties(size='medium'), } return _lbp
def _checkparams(clevel, shuffle, cname, quantize): if clevel is not None: if not isinstance(clevel, int): raise ValueError("`clevel` must be an int.") if clevel < 0: raise ValueError("`clevel` must be 0 or a positive integer.") if shuffle is not None: if not isinstance(shuffle, (bool, int)): raise ValueError("`shuffle` must be an int.") if shuffle not in [bcolz.NOSHUFFLE, bcolz.SHUFFLE, bcolz.BITSHUFFLE]: raise ValueError("`shuffle` value not allowed.") if (shuffle == bcolz.BITSHUFFLE and parse_version(bcolz.blosc_version()[0]) < parse_version("1.8.0")): raise ValueError("You need C-Blosc 1.8.0 or higher for using " "BITSHUFFLE.") # Store the cname as bytes object internally if cname is not None: list_cnames = bcolz.blosc_compressor_list() if cname not in list_cnames: raise ValueError( "Compressor '%s' is not available in this build" % cname) if quantize is not None: if not isinstance(quantize, int): raise ValueError("`quantize` must be an int.") if quantize < 0: raise ValueError("`quantize` must be 0 or a positive integer.") return clevel, shuffle, cname, quantize
def version_check(version: str, exact: bool = False, compiled: bool = True) -> bool: """Check if the Qt runtime version is the version supplied or newer. Args: version: The version to check against. exact: if given, check with == instead of >= compiled: Set to False to not check the compiled version. """ # Catch code using the old API for this assert exact not in [operator.gt, operator.lt, operator.ge, operator.le, operator.eq], exact if compiled and exact: raise ValueError("Can't use compiled=True with exact=True!") parsed = pkg_resources.parse_version(version) op = operator.eq if exact else operator.ge result = op(pkg_resources.parse_version(qVersion()), parsed) if compiled and result: # qVersion() ==/>= parsed, now check if QT_VERSION_STR ==/>= parsed. result = op(pkg_resources.parse_version(QT_VERSION_STR), parsed) if compiled and result: # FInally, check PYQT_VERSION_STR as well. result = op(pkg_resources.parse_version(PYQT_VERSION_STR), parsed) return result
def _set_model(self, model): import tensorflow as tf import keras.backend.tensorflow_backend as KTF self.model = model self.sess = KTF.get_session() if self.histogram_freq and self.merged is None: layers = self.model.layers for layer in layers: if hasattr(layer, 'W'): tf.histogram_summary('{}_W'.format(layer), layer.W) if hasattr(layer, 'b'): tf.histogram_summary('{}_b'.format(layer), layer.b) if hasattr(layer, 'output'): tf.histogram_summary('{}_out'.format(layer), layer.output) self.merged = tf.merge_all_summaries() if self.write_graph: if parse_version(tf.__version__) >= parse_version('0.8.0'): self.writer = tf.train.SummaryWriter(self.log_dir, self.sess.graph) else: self.writer = tf.train.SummaryWriter(self.log_dir, self.sess.graph_def) else: self.writer = tf.train.SummaryWriter(self.log_dir)
def equals(first, other): """ Compares two params.Version objects @param first: version first to compare @param other: version two to compare @return: 0 if equals -1 if first > other 1 if first < other """ if VersionUtils.__isVersionObject(first) and \ VersionUtils.__isVersionObject(other): left = pkg_resources.parse_version( VersionUtils.__toString(first) ) right = pkg_resources.parse_version( VersionUtils.__toString(other) ) if left == right: return 0 if left > right: return -1 return 1
def _parse_old_style_extra_args(self, *args): """Returns the post-0.3.0 style args if the pre-0.3.0 style args are passed in. The pre-0.3.0 style args always have three args: (x, t, d) where d is is a dictionary which should always at least contain the key 'constants'. It may also contain a key 'specified'.""" # DEPRECATED : Remove before 0.4.0 release. if parse_version(pydy.__version__) > parse_version('0.4.0'): msg = ("The old style args, i.e. {'constants': , 'specified'}, " "for the generated function is no longer supported as " "of PyDy 0.4.0. Please remove this function.") last_arg = args[-1] try: constants = last_arg['constants'] # ValueError is needed for older NumPy versions. except (KeyError, IndexError, ValueError): return args else: warnings.warn("The old style args, i.e. {'constants': , " "'specified'}, for the generated function will be " "removed in PyDy 0.4.0.", PyDyDeprecationWarning) new_args = list(args[:-1]) # gets x and t if self.specifieds is not None: new_args.append(last_arg['specified']) new_args.append(constants) return tuple(new_args)
def check_for_update(self): """ Check if a newer version is available online and offer to update """ # TODO: just return True or False, and let the caller call show_update_dialog() logging.info("Retrieving version info...") web_version = self.get_remote_version() if web_version is None: logging.info("Could not retrieve remote version, will not update") return logging.info("Found remote version %s", web_version) lv = pkg_resources.parse_version(odemis.get_version_simplified()) rv = pkg_resources.parse_version(web_version) if rv <= lv: wx.MessageBox( u"You are already using the most recent version of Odemis.", u"Odemis Updater", style=wx.OK | wx.CENTER | wx.ICON_ASTERISK ) return logging.info("Newer version found, suggesting update...") self.show_update_dialog(web_version)
def match_api_version(self, request_version, allowed_version): """ :param request_version: :param allowed_version: may be represented in following forms: 1. ``VERSION`` 2. ``==VERSION`` (the same as above) 3. ``>VERSION`` 4. ``<VERSION`` 5. ``>=VERSION`` 6. ``<=Version`` 7. Comma-separated list of 1-7 evaluated as AND :return: :raise ValueError: """ distinct_versions = {version.strip() for version in allowed_version.split(',')} for distinct_version in distinct_versions: operation = self.OPERATORS.get(distinct_version[:2]) if operation: # prepare cases #2, #5, #6 compare_with = distinct_version[2:] else: operation = self.OPERATORS.get(distinct_version[0]) if operation: # prepare cases #3, #4 compare_with = distinct_version[1:] else: # prepare case #1 compare_with = distinct_version operation = self.OPERATORS['=='] # evaluate the case matched = operation(parse_version(request_version), parse_version(compare_with)) if not matched: return False return True
def get_version_info(url): out_stream = StringIO() pkg_maxlen = 0 version_maxlen = 0 version_sections = extract_versions_section(url) for pkg_name, version_infos in version_sections.items(): pkg_maxlen = max(len(pkg_name), pkg_maxlen) for version_info in version_infos: version_maxlen = max(len(version_info.version), version_maxlen) outfmt = ('{{pkg_name:{pkg_maxlen}}} = {{color}}{{version_info.version:{version_maxlen}}}{reset} {{index}} {{version_info.origin}}\n' # NOQA .format(pkg_maxlen=pkg_maxlen, version_maxlen=version_maxlen, reset=colorama.Fore.RESET)) for pkg_name, version_infos in sorted(version_sections.items()): if (max((parse_version(version_info.version) for version_info in version_infos)) != parse_version(version_infos[0].version)): color = colorama.Fore.RED else: color = colorama.Fore.RESET for index, version_info in enumerate(version_infos): pkg_name_to_show = pkg_name if not index else '' out_stream.write(outfmt.format(pkg_name=pkg_name_to_show, version_info=version_info, color=color, index=index)) out_stream.seek(0) return out_stream
# Contains all the support functions/modules required by Vidgear # import the necessary packages import os, sys, requests, platform, errno import numpy as np from pkg_resources import parse_version from colorlog import ColoredFormatter from tqdm import tqdm import logging as log try: # import OpenCV Binaries import cv2 # check whether OpenCV Binaries are 3.x+ if parse_version(cv2.__version__) < parse_version("3"): raise ImportError( "[Vidgear:ERROR] :: Installed OpenCV API version(< 3.0) is not supported!" ) except ImportError: raise ImportError( "[Vidgear:ERROR] :: Failed to detect correct OpenCV executables, install it with `pip3 install opencv-python` command." ) def logger_handler(): """ returns logger handler """ # logging formatter formatter = ColoredFormatter(
from pkg_resources import parse_version from .ray_util import contains_points from .. import util from .. import caching from .. import intersections # the factor of geometry.scale to offset a ray from a triangle # to reliably not hit its origin triangle _ray_offset_factor = 1e-4 # we want to clip our offset to a sane distance _ray_offset_floor = 1e-8 # see if we're using a newer version of the pyembree wrapper _embree_new = parse_version(_ver) >= parse_version('0.1.4') # both old and new versions require exact but different type _embree_dtype = [np.float64, np.float32][int(_embree_new)] class RayMeshIntersector(object): def __init__(self, geometry, scale_to_box=True): """ Do ray- mesh queries. Parameters ------------- geometry : Trimesh object
# Initialize options self.without_leveldb = None def run(self): # Use options if self.without_leveldb: with suppress(ValueError): idx = list(map(lambda i: "plyvel" in i, self.distribution.install_requires)).index(True) self.distribution.install_requires.pop(idx) super().run() try: from pip._internal.req import parse_requirements from pip import __version__ as __pip_version pip_version = parse_version(__pip_version) if (pip_version >= parse_version("20")): from pip._internal.network.session import PipSession elif (pip_version >= parse_version("10")): from pip._internal.download import PipSession except ImportError: # pip version < 10.0 from pip.req import parse_requirements from pip.download import PipSession with open('README.rst') as readme_file: readme = readme_file.read() leveldb_requirements = ["plyvel==1.3.0" if sys.platform in ["darwin", "linux"] else "plyvel-win32"] # get the requirements from requirements.txt
def astra_cuda_bp_scaling_factor(proj_space, reco_space, geometry): """Volume scaling accounting for differing adjoint definitions. ASTRA defines the adjoint operator in terms of a fully discrete setting (transposed "projection matrix") without any relation to physical dimensions, which makes a re-scaling necessary to translate it to spaces with physical dimensions. Behavior of ASTRA changes slightly between versions, so we keep track of it and adapt the scaling accordingly. """ # Angular integration weighting factor # angle interval weight by approximate cell volume angle_extent = float(geometry.motion_partition.extent) num_angles = float(geometry.motion_partition.size) scaling_factor = angle_extent / num_angles # Correct in case of non-weighted spaces proj_extent = float(proj_space.partition.extent.prod()) proj_size = float(proj_space.partition.size) proj_weighting = proj_extent / proj_size scaling_factor *= (proj_space.weighting.const / proj_weighting) scaling_factor /= (reco_space.weighting.const / reco_space.cell_volume) if parse_version(ASTRA_VERSION) < parse_version('1.8rc1'): if isinstance(geometry, Parallel2dGeometry): # Scales with 1 / cell_volume scaling_factor *= float(reco_space.cell_volume) elif isinstance(geometry, FanFlatGeometry): # Scales with 1 / cell_volume scaling_factor *= float(reco_space.cell_volume) # Additional magnification correction src_radius = geometry.src_radius det_radius = geometry.det_radius scaling_factor *= ((src_radius + det_radius) / src_radius) elif isinstance(geometry, Parallel3dAxisGeometry): # Scales with voxel stride # In 1.7, only cubic voxels are supported voxel_stride = reco_space.cell_sides[0] scaling_factor /= float(voxel_stride) elif isinstance(geometry, HelicalConeFlatGeometry): # Scales with 1 / cell_volume # In 1.7, only cubic voxels are supported voxel_stride = reco_space.cell_sides[0] scaling_factor /= float(voxel_stride) # Magnification correction src_radius = geometry.src_radius det_radius = geometry.det_radius scaling_factor *= ((src_radius + det_radius) / src_radius)**2 else: if isinstance(geometry, Parallel2dGeometry): # Scales with 1 / cell_volume scaling_factor *= float(reco_space.cell_volume) elif isinstance(geometry, FanFlatGeometry): # Scales with 1 / cell_volume scaling_factor *= float(reco_space.cell_volume) # Magnification correction src_radius = geometry.src_radius det_radius = geometry.det_radius scaling_factor *= ((src_radius + det_radius) / src_radius) elif isinstance(geometry, Parallel3dAxisGeometry): # Scales with cell volume # currently only square voxels are supported scaling_factor /= reco_space.cell_volume elif isinstance(geometry, HelicalConeFlatGeometry): # Scales with cell volume scaling_factor /= reco_space.cell_volume # Magnification correction src_radius = geometry.src_radius det_radius = geometry.det_radius scaling_factor *= ((src_radius + det_radius) / src_radius)**2 # Correction for scaled 1/r^2 factor in ASTRA's density weighting det_px_area = geometry.det_partition.cell_volume scaling_factor *= (src_radius**2 * det_px_area**2 / reco_space.cell_volume**2) # TODO: add case with new ASTRA release return scaling_factor
RETURN = ''' obj: description: IpamDnsProviderProfile (api/ipamdnsproviderprofile) object returned: success, changed type: dict ''' from ansible.module_utils.basic import AnsibleModule try: from avi.sdk.utils.ansible_utils import avi_common_argument_spec from pkg_resources import parse_version import avi.sdk sdk_version = getattr(avi.sdk, '__version__', None) if ((sdk_version is None) or (sdk_version and (parse_version(sdk_version) < parse_version('17.1')))): # It allows the __version__ to be '' as that value is used in development builds raise ImportError from avi.sdk.utils.ansible_utils import avi_ansible_api HAS_AVI = True except ImportError: HAS_AVI = False def main(): argument_specs = dict( state=dict(default='present', choices=['absent', 'present']), avi_api_update_method=dict(default='put', choices=['put', 'patch']), avi_api_patch_op=dict(choices=['add', 'replace', 'delete']), allocate_ip_in_vrf=dict(type='bool', ), aws_profile=dict(type='dict', ),
def atleast_ncver(ver): from pkg_resources import parse_version import netCDF4 return parse_version(netCDF4.__version__) >= parse_version(ver)
CFLAGS = tuple(EXTRA_COMPILE_ARGS) if "linux" in sys.platform or "darwin" in sys.platform: pymodinit_type = 'PyObject*' if PY3 else 'void' pymodinit = 'extern "C" __attribute__((visibility ("default"))) {}'.format( pymodinit_type) DEFINE_MACROS += (('PyMODINIT_FUNC', pymodinit),) DEFINE_MACROS += (('GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK', 1),) # By default, Python3 distutils enforces compatibility of # c plugins (.so files) with the OSX version Python was built with. # We need OSX 10.10, the oldest which supports C++ thread_local. # Python 3.9: Mac OS Big Sur sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') returns int (11) if 'darwin' in sys.platform: mac_target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET') if mac_target: mac_target = pkg_resources.parse_version(str(mac_target)) if mac_target < pkg_resources.parse_version('10.10.0'): os.environ['MACOSX_DEPLOYMENT_TARGET'] = '10.10' os.environ['_PYTHON_HOST_PLATFORM'] = re.sub( r'macosx-[0-9]+\.[0-9]+-(.+)', r'macosx-10.10-\1', util.get_platform()) def cython_extensions_and_necessity(): cython_module_files = [ os.path.join(PYTHON_STEM, name.replace('.', '/') + '.pyx') for name in CYTHON_EXTENSION_MODULE_NAMES ] config = os.environ.get('CONFIG', 'opt') prefix = 'libs/' + config + '/'
from pathlib import Path from pkg_resources import parse_version version_file = Path(__file__).parent / "support/VERSION" __version__ = version_file.read_text().strip() __parsed_version__ = parse_version(__version__)
assert_almost_equal(dm, np.hypot(1, 2), 2) # Variance of the candidate sample does not affect answer. x = randn(0, 1, (n, d)) y = randn([1, 2], 2, (m, d)) dm = xca.seuclidean(x, y) assert_almost_equal(dm, np.hypot(1, 2), 2) def test_compare_with_matlab(self): x, y = matlab_sample() dm = xca.seuclidean(x, y) assert_almost_equal(dm, 2.8463, 4) @pytest.mark.skipif( parse_version(__scipy_version__) < parse_version("1.6.0"), reason="Not supported in scipy<1.6.0", ) class TestNN: def test_simple(self): d = 2 n, m = 200, 200 np.random.seed(1) x = np.random.randn(n, d) y = np.random.randn(m, d) # Almost identical samples dm = xca.nearest_neighbor(x + 0.001, x) assert_almost_equal(dm, 0, 2) # Same distribution but mixed
async def query(self, filters, options): """ Query available chart releases. `query-options.extra.retrieve_resources` is a boolean when set will retrieve existing kubernetes resources in the chart namespace. `query-options.extra.history` is a boolean when set will retrieve all chart version upgrades for a chart release. `query-options.extra.include_chart_schema` is a boolean when set will retrieve the schema being used by the chart release in question. """ if not await self.middleware.call('service.started', 'kubernetes'): # We use filter_list here to ensure that `options` are respected, options like get: true return filter_list([], filters, options) update_catalog_config = {} catalogs = await self.middleware.call( 'catalog.query', [], {'extra': { 'item_details': True }}) container_images = {} for image in await self.middleware.call('container.image.query'): for tag in image['repo_tags']: if not container_images.get(tag): container_images[tag] = image for catalog in catalogs: update_catalog_config[catalog['label']] = {} for train in catalog['trains']: train_data = {} for catalog_item in catalog['trains'][train]: versions = { k: v for k, v in catalog['trains'][train][catalog_item] ['versions'].items() if v['healthy'] } max_version = max([parse_version(v) for v in versions], default=parse_version('0.0.0')) app_version = None if str(max_version) in versions: app_version = versions[str( max_version)]['chart_metadata'].get('appVersion') train_data[catalog_item] = { 'chart_version': max_version, 'app_version': app_version, } update_catalog_config[catalog['label']][train] = train_data k8s_config = await self.middleware.call('kubernetes.config') k8s_node_ip = await self.middleware.call('kubernetes.node_ip') options = options or {} extra = copy.deepcopy(options.get('extra', {})) retrieve_schema = extra.get('include_chart_schema') get_resources = extra.get('retrieve_resources') get_history = extra.get('history') if retrieve_schema: questions_context = await self.middleware.call( 'catalog.get_normalised_questions_context') else: questions_context = None if filters and len(filters) == 1 and filters[0][:2] == ['id', '=']: extra['namespace_filter'] = [ 'metadata.namespace', '=', f'{CHART_NAMESPACE_PREFIX}{filters[0][-1]}' ] resources_filters = [extra['namespace_filter']] else: resources_filters = [[ 'metadata.namespace', '^', CHART_NAMESPACE_PREFIX ]] ports_used = collections.defaultdict(list) for node_port_svc in await self.middleware.call( 'k8s.service.query', [['spec.type', '=', 'NodePort']] + resources_filters): release_name = node_port_svc['metadata']['namespace'][ len(CHART_NAMESPACE_PREFIX):] ports_used[release_name].extend([{ 'port': p['node_port'], 'protocol': p['protocol'] } for p in node_port_svc['spec']['ports']]) storage_classes = collections.defaultdict(lambda: None) for storage_class in await self.middleware.call( 'k8s.storage_class.query'): storage_classes[storage_class['metadata']['name']] = storage_class persistent_volumes = collections.defaultdict(list) # If the chart release was consuming any PV's, they would have to be manually removed from k8s database # because of chart release reclaim policy being retain for pv in await self.middleware.call('k8s.pv.query', [[ 'spec.csi.volume_attributes.openebs\\.io/poolname', '^', f'{os.path.join(k8s_config["dataset"], "releases")}/' ]]): dataset = pv['spec']['csi']['volume_attributes'][ 'openebs.io/poolname'] rl = dataset.split('/', 4) if len(rl) > 4: persistent_volumes[rl[3]].append(pv) resources = {r.value: collections.defaultdict(list) for r in Resources} workload_status = collections.defaultdict(lambda: { 'desired': 0, 'available': 0 }) for resource in Resources: for r_data in await self.middleware.call( f'k8s.{resource.name.lower()}.query', resources_filters): release_name = r_data['metadata']['namespace'][ len(CHART_NAMESPACE_PREFIX):] resources[resource.value][release_name].append(r_data) if resource in (Resources.DEPLOYMENT, Resources.STATEFULSET): workload_status[release_name]['desired'] += ( r_data['status']['replicas'] or 0) workload_status[release_name]['available'] += ( r_data['status']['ready_replicas'] or 0) release_secrets = await self.middleware.call( 'chart.release.releases_secrets', extra) releases = [] for name, release in release_secrets.items(): config = {} release_data = release['releases'].pop(0) cur_version = release_data['chart_metadata']['version'] for rel_data in filter( lambda r: r['chart_metadata']['version'] == cur_version, itertools.chain(reversed(release['releases']), [release_data])): config.update(rel_data['config']) pods_status = workload_status[name] pod_diff = pods_status['available'] - pods_status['desired'] status = 'ACTIVE' if pod_diff == 0 and pods_status['desired'] == 0: status = 'STOPPED' elif pod_diff < 0: status = 'DEPLOYING' # We will retrieve all host ports being used for pod in filter(lambda p: p['status']['phase'] == 'Running', resources[Resources.POD.value][name]): for container in pod['spec']['containers']: ports_used[name].extend([{ 'port': p['host_port'], 'protocol': p['protocol'] } for p in (container['ports'] or []) if p['host_port']]) release_data.update({ 'path': os.path.join('/mnt', k8s_config['dataset'], 'releases', name), 'dataset': os.path.join(k8s_config['dataset'], 'releases', name), 'config': config, 'status': status, 'used_ports': ports_used[name], 'pod_status': pods_status, }) release_resources = { 'storage_class': storage_classes[get_storage_class_name(name)], 'persistent_volumes': persistent_volumes[name], 'host_path_volumes': await self.host_path_volumes(resources[Resources.POD.value][name]), **{r.value: resources[r.value][name] for r in Resources}, } release_resources = { **release_resources, 'container_images': { i_name: { 'id': image_details.get('id'), 'update_available': image_details.get('update_available', False) } for i_name, image_details in map( lambda i: (i, container_images.get(i, {})), list( set(c['image'] for workload_type in ('deployments', 'statefulsets') for workload in release_resources[workload_type] for c in workload['spec']['template']['spec'] ['containers']))) }, 'truenas_certificates': [ v['id'] for v in release_data['config'].get( 'ixCertificates', {}).values() ], 'truenas_certificate_authorities': [ v['id'] for v in release_data['config'].get( 'ixCertificateAuthorities', {}).values() ], } if get_resources: release_data['resources'] = release_resources if get_history: release_data['history'] = release['history'] current_version = parse_version( release_data['chart_metadata']['version']) catalog_version_dict = update_catalog_config.get( release_data['catalog'], {}).get(release_data['catalog_train'], {}).get(release_data['chart_metadata']['name'], {}) latest_version = catalog_version_dict.get('chart_version', current_version) latest_app_version = catalog_version_dict.get('app_version') release_data['update_available'] = latest_version > current_version app_version = None if release_data['chart_metadata']['name'] == 'ix-chart': image_config = release_data['config'].get('image') or {} if all(k in image_config for k in ('tag', 'repository')): # TODO: Let's see if we can find sane versioning for `latest` from upstream if image_config['tag'] == 'latest': app_version = f'{image_config["repository"]}:{image_config["tag"]}' else: app_version = image_config['tag'] # Latest app version for ix-chart remains same latest_app_version = app_version else: app_version = release_data['chart_metadata'].get('appVersion') for key, app_v, c_v in ( ('human_version', app_version, current_version), ('human_latest_version', latest_app_version, latest_version), ): if app_v: release_data[key] = f'{app_v}_{c_v}' else: release_data[key] = str(c_v) if retrieve_schema: chart_path = os.path.join( release_data['path'], 'charts', release_data['chart_metadata']['version']) if os.path.exists(chart_path): release_data['chart_schema'] = await self.middleware.call( 'catalog.item_version_details', chart_path, questions_context) else: release_data['chart_schema'] = None release_data['container_images_update_available'] = any( details['update_available'] for details in release_resources['container_images'].values()) release_data['chart_metadata']['latest_chart_version'] = str( latest_version) release_data['portals'] = await self.middleware.call( 'chart.release.retrieve_portals_for_chart_release', release_data, k8s_node_ip) if 'icon' not in release_data['chart_metadata']: release_data['chart_metadata']['icon'] = None releases.append(release_data) return filter_list(releases, filters, options)
('index', 'buildbot', u'BuildBot Documentation', [u'Brian Warner'], 1) ] # Monkey-patch Sphinx to treat unhiglighted code as error. from sphinx.errors import SphinxWarning import sphinx import sphinx.highlighting from pkg_resources import parse_version # Versions of Sphinx below changeset 1860:19b394207746 (before v0.6.6 release) # won't work due to different PygmentsBridge interface. required_sphinx_version = '0.6.6' sphinx_version_supported = \ parse_version(sphinx.__version__) >= parse_version(required_sphinx_version) # This simple monkey-patch allows either fail on first unhighlighted block or # print all unhighlighted blocks and don't fail at all. # First behaviour is useful for testing that all code is highlighted, second --- # for fixing lots of unhighlighted code. fail_on_first_unhighlighted = True class UnhighlightedError(SphinxWarning): pass # PygmentsBridge.unhighlighted() added in Sphinx in changeset 574:f1c885fdd6ad # (0.5 release). def patched_unhighlighted(self, source): indented_source = ' ' + '\n '.join(source.split('\n'))
def _get_version_class(): modern_version = parse_version("1.0") if isinstance(modern_version, tuple): return None else: return type(modern_version)
from pkg_resources import parse_version from snapcraft.internal import ( common, errors, os_release, repo, ) logger = logging.getLogger(__name__) # Old pyelftools uses byte strings for section names. Some data is # also returned as bytes, which is handled below. if parse_version(elftools.__version__) >= parse_version('0.24'): _DYNAMIC = '.dynamic' # type: Union[str, bytes] _GNU_VERSION_R = '.gnu.version_r' # type: Union[str, bytes] _INTERP = '.interp' # type: Union[str, bytes] else: _DYNAMIC = b'.dynamic' _GNU_VERSION_R = b'.gnu.version_r' _INTERP = b'.interp' class SonameCache: """A cache for sonames.""" def __getitem__(self, key): return self._soname_paths[key] def __setitem__(self, key, item):
import os here = os.path.abspath(os.path.dirname(__file__)) import sys if sys.version_info[:2] < (2, 6) or (3, 0) <= sys.version_info[0:2] < (3, 2): raise RuntimeError("Python version 2.6, 2.7, or 3.2+ required.") # Get the long description from the relevant file with open(os.path.join(here, 'README.rst')) as f: long_description = f.read() # Get the version from the relevant file with open(os.path.join(here, 'modred/_version.py')) as f: exec(f.read()) # Get the development status from the version string parsed_version = str(parse_version(__version__)) if any(w in ['*a', '*alpha'] for w in parsed_version): devstatus = 'Development Status :: 3 - Alpha' elif any(w in ['*b', '*beta'] for w in parsed_version): devstatus = 'Development Status :: 4 - Beta' else: devstatus = 'Development Status :: 5 - Production/Stable' # OKID_test_data_files = list() # for c in ['SISO', 'SIMO', 'MISO', 'MIMO']: # OKID_test_data_files.append((os.path.join('modred', 'tests', 'OKID_files' , c), # glob.glob(os.path.join('modred', 'tests', 'OKID_files', c, '*')))) setup( name='modred', version=__version__, description=('Compute modal decompositions and reduced-order models, '
def v(versiontext): import pkg_resources return pkg_resources.parse_version(versiontext)
# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild from pkg_resources import parse_version import kaitaistruct from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO from enum import Enum import collections if parse_version(kaitaistruct.__version__) < parse_version('0.9'): raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__)) class MicrosoftPe(KaitaiStruct): """ .. seealso:: Source - https://docs.microsoft.com/en-us/windows/win32/debug/pe-format """ class PeFormat(Enum): rom_image = 263 pe32 = 267 pe32_plus = 523 SEQ_FIELDS = ["mz"] def __init__(self, _io, _parent=None, _root=None): self._io = _io self._parent = _parent self._root = _root if _root else self self._debug = collections.defaultdict(dict) def _read(self): self._debug['mz']['start'] = self._io.pos()
import pkg_resources import pytest from _pytest.runner import runtestprotocol HAS_RESULTLOG = False try: from _pytest.resultlog import ResultLog HAS_RESULTLOG = True except ImportError: # We have a pytest >= 6.1 pass PYTEST_GTE_54 = pkg_resources.parse_version( pytest.__version__) >= pkg_resources.parse_version("5.4") def works_with_current_xdist(): """Returns compatibility with installed pytest-xdist version. When running tests in parallel using pytest-xdist < 1.20.0, the first report that is logged will finish and terminate the current node rather rerunning the test. Thus we must skip logging of intermediate results under these circumstances, otherwise no test is rerun. """ try: d = pkg_resources.get_distribution("pytest-xdist") return d.parsed_version >= pkg_resources.parse_version("1.20") except pkg_resources.DistributionNotFound:
from __future__ import absolute_import, print_function from builtins import str from builtins import super from builtins import range from psychopy import logging import wx import numpy import os from psychopy.localization import _translate from pkg_resources import parse_version OK = wx.ID_OK thisVer = parse_version(wx.__version__) def ensureWxApp(): # make sure there's a wxApp prior to showing a gui, e.g., for expInfo # dialog try: wx.Dialog(None, -1) # not shown; FileDialog gives same exception return True except wx._core.PyNoAppError: if thisVer < parse_version('2.9'): return wx.PySimpleApp() elif thisVer >= parse_version('4.0') and thisVer < parse_version( '4.1'): raise Exception( "wx>=4.0 clashes with pyglet and making it unsafe "
) as mock_version: mock_version.side_effect = [min_bq_version, pandas_version] try: gbq.to_gbq( DataFrame([[1]]), "dataset.tablename", project_id="my-project", verbose=True, ) except gbq.TableCreationError: pass assert len(recwarn) == 0 @pytest.mark.skipif( pandas_installed_version < pkg_resources.parse_version("0.24.0"), reason="Requires pandas 0.24+", ) def test_to_gbq_with_private_key_new_pandas_warns_deprecation( min_bq_version, monkeypatch): import pkg_resources from pandas_gbq import auth monkeypatch.setattr(auth, "get_credentials", mock_get_credentials) pandas_version = pkg_resources.parse_version("0.24.0") with pytest.warns(FutureWarning), mock.patch( "pkg_resources.Distribution.parsed_version", new_callable=mock.PropertyMock, ) as mock_version: mock_version.side_effect = [min_bq_version, pandas_version]
# pip<1.4 doesn't have the --pre flag, and will thus attempt to install alpha # and beta versions of Buildbot. Prevent that from happening. VERSION_MSG = """ This is a pre-release version of Buildbot, which can only be installed with pip-1.4 or later Try installing the latest stable version of Buildbot instead: pip install buildbot==0.8.12 See https://pypi.python.org/pypi/buildbot to verify the current stable version. """ if 'a' in version or 'b' in version: try: pip_dist = pkg_resources.get_distribution('pip') except pkg_resources.DistributionNotFound: pip_dist = None if pip_dist: if parse_version(pip_dist.version) < parse_version('1.4'): raise RuntimeError(VERSION_MSG) twisted_ver = ">= 17.9.0" autobahn_ver = ">= 0.16.0" txaio_ver = ">= 2.2.2" bundle_version = version.split("-")[0] # dependencies setup_args['install_requires'] = [ 'setuptools >= 8.0', 'Twisted ' + twisted_ver, 'Jinja2 >= 2.1', # required for tests, but Twisted requires this anyway 'zope.interface >= 4.1.1',
# for complete details. from __future__ import absolute_import, division, print_function import os import platform import sys from distutils.command.build import build import pkg_resources import setuptools from setuptools import find_packages, setup from setuptools.command.install import install if (pkg_resources.parse_version(setuptools.__version__) < pkg_resources.parse_version("18.5")): raise RuntimeError( "cryptography requires setuptools 18.5 or newer, please upgrade to a " "newer version of setuptools") base_dir = os.path.dirname(__file__) src_dir = os.path.join(base_dir, "src") # When executing the setup.py, we need to be able to import ourselves, this # means that we need to add the src/ directory to the sys.path. sys.path.insert(0, src_dir) about = {} with open(os.path.join(src_dir, "cryptography", "__about__.py")) as f: exec(f.read(), about)
def min_bq_version(): import pkg_resources return pkg_resources.parse_version("1.9.0")
def testVersionHashable(self): """ Ensure that our versions stay hashable even though we've subclassed them and added some shim code to them. """ assert (hash(parse_version("1.0")) == hash(parse_version("1.0")))
output_dir = os.path.join(__location__, "api") module_dir = os.path.join(__location__, "../src/geolomas") try: shutil.rmtree(output_dir) except FileNotFoundError: pass try: import sphinx from pkg_resources import parse_version cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}" cmd_line = cmd_line_template.format(outputdir=output_dir, moduledir=module_dir) args = cmd_line.split(" ") if parse_version(sphinx.__version__) >= parse_version('1.7'): args = args[1:] apidoc.main(args) except Exception as e: print("Running `sphinx-apidoc` failed!\n{}".format(e)) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.autosummary', 'sphinx.ext.viewcode', 'sphinx.ext.coverage',
def testVersionIndexable(self): """ Some projects were doing things like parse_version("v")[0], so we'll support indexing the same as we support iterating. """ assert parse_version("1.0")[0] == "00000001"
DEFAULT_CALLBACKS, Linker, ) from bleach.sanitizer import ( ALLOWED_ATTRIBUTES, ALLOWED_PROTOCOLS, ALLOWED_STYLES, ALLOWED_TAGS, Cleaner, ) # yyyymmdd __releasedate__ = '20200311' # x.y.z or x.y.z.dev0 -- semver __version__ = '3.1.2' VERSION = parse_version(__version__) __all__ = ['clean', 'linkify'] def clean(text, tags=ALLOWED_TAGS, attributes=ALLOWED_ATTRIBUTES, styles=ALLOWED_STYLES, protocols=ALLOWED_PROTOCOLS, strip=False, strip_comments=True): """Clean an HTML fragment of malicious content and return it This function is a security-focused function whose sole purpose is to remove malicious content from a string such that it can be displayed as
def init(self, inventory, config, initial_limit=None): # Config validation # # If no config, create one using the defaults if config is None: config = Config() # Error if our min version is not met if config.MIN_PYINFRA_VERSION is not None: if config.REQUIRE_PYINFRA_VERSION is None: config.REQUIRE_PYINFRA_VERSION = '>={0}'.format( config.MIN_PYINFRA_VERSION) logger.warning( '`MIN_PYINFRA_VERSION` is deprecated, please use `REQUIRE_PYINFRA_VERSION`.', ) else: logger.warning( 'Ignoring legacy `MIN_PYINFRA_VERSION` because ' '`REQUIRE_PYINFRA_VERSION` also exists.', ) if config.REQUIRE_PYINFRA_VERSION is not None: running_version = parse_version(__version__) required_versions = Requirement.parse( 'pyinfra{0}'.format(config.REQUIRE_PYINFRA_VERSION), ) if running_version not in required_versions: raise PyinfraError(('pyinfra version requirement not met ' '(requires {0}, running {1})').format( config.REQUIRE_PYINFRA_VERSION, __version__, )) if not config.PARALLEL: # TODO: benchmark this # In my own tests the optimum number of parallel SSH processes is # ~20 per CPU core - no science here yet, needs benchmarking! cpus = cpu_count() ideal_parallel = cpus * 20 config.PARALLEL = (min(ideal_parallel, len(inventory), MAX_PARALLEL) if MAX_PARALLEL is not None else min(ideal_parallel, len(inventory))) # If explicitly set, just issue a warning elif MAX_PARALLEL is not None and config.PARALLEL > MAX_PARALLEL: logger.warning(( 'Parallel set to {0}, but this may hit the open files limit of {1}.\n' ' Max recommended value: {2}').format( config.PARALLEL, nofile_limit, MAX_PARALLEL)) # Actually initialise the state object # self.callback_handlers = [] # Setup greenlet pools self.pool = Pool(config.PARALLEL) self.fact_pool = Pool(config.PARALLEL) # Connection storage self.ssh_connections = {} self.sftp_connections = {} # Private keys self.private_keys = {} # Facts storage self.facts = {} self.fact_locks = {} # Assign inventory/config self.inventory = inventory self.config = config # Hosts we've activated at any time self.activated_hosts = set() # Active hosts that *haven't* failed yet self.active_hosts = set() # Hosts that are ready to be deployed to self.ready_hosts = set() # Hosts that have failed self.failed_hosts = set() # Limit hosts changes dynamically to limit operations to a subset of hosts self.limit_hosts = initial_limit # Op basics self.op_line_numbers_to_hash = {} self.op_meta = {} # maps operation hash -> names/etc self.ops_run = set() # list of ops which have been started/run # Op dict for each host self.ops = {host: {} for host in inventory} # Facts dict for each host self.facts = {host: {} for host in inventory} # Meta dict for each host self.meta = { host: { 'ops': 0, # one function call in a deploy file 'commands': 0, # actual # of commands to run 'op_hashes': set(), } for host in inventory } # Results dict for each host self.results = { host: { 'ops': 0, # success_ops + failed ops w/ignore_errors 'success_ops': 0, 'error_ops': 0, 'commands': 0, } for host in inventory } # Assign state back references to inventory & config inventory.state = config.state = self for host in inventory: host.state = self self.initialised = True # Flag to track added users (via `server.user` operation calls). This is # specifically to address users not existing during fact gathering phase # causing failures with su_user/sudo_user. If we expect to add the user # those facts should not fail but default. self.will_add_users = []
def testVersionTupleSort(self): """ Some projects expected to be able to sort tuples against the return value of parse_version. So again we'll add a warning enabled shim to make this possible. """ assert parse_version("1.0") < tuple(parse_version("2.0")) assert parse_version("1.0") <= tuple(parse_version("2.0")) assert parse_version("1.0") == tuple(parse_version("1.0")) assert parse_version("3.0") > tuple(parse_version("2.0")) assert parse_version("3.0") >= tuple(parse_version("2.0")) assert parse_version("3.0") != tuple(parse_version("2.0")) assert not (parse_version("3.0") != tuple(parse_version("3.0")))
# Translation of filters to strings filters = { NOSHUFFLE: "noshuffle", SHUFFLE: "shuffle", BITSHUFFLE: "bitshuffle" } min_numexpr_version = '2.5.2' # the minimum version of Numexpr needed numexpr_here = False try: import numexpr except ImportError: pass else: if parse_version( numexpr.__version__) >= parse_version(min_numexpr_version): numexpr_here = True # Check for dask (as another virtual machine for chunked eval) min_dask_version = '0.9.0' # the minimum version of Numexpr needed dask_here = False try: import dask except ImportError: pass else: if parse_version(dask.__version__) >= parse_version(min_dask_version): dask_here = True # Check for pandas (for data container conversion purposes) pandas_here = False
def c(s1, s2): p1, p2 = parse_version(s1), parse_version(s2) assert p1 < p2, (s1, s2, p1, p2)