def _send_changes(self, users): """Sends changes to users if bot have configured, Also, this method increments version number in the bot's state. """ if self.changelog_notifications: changes = changelog.load() new_version = V(__version__) old_version = V(self.state['version']) if old_version < new_version: post = [ 'Bot was upgraded to a new version %s.' % __version__, 'Compared with the previous version it has following changes:' ] for version, version_string, messages in changes: if version <= old_version: break post.append('\nVersion %s:' % version_string) for line in messages: post.append(' * ' + line) for user in users: self.send_message(user.jid, '\n'.join(post), mfrom=self.jid, mtype='chat') self.state['version'] = __version__
def _loose_compare(v1, v2, fn): v1_parts = len(v1.split('.')) v2_parts = len(v2.split('.')) parts_to_keep = min(v1_parts, v2_parts) v1 = '.'.join(v1.split('.')[:parts_to_keep]) v2 = '.'.join(v2.split('.')[:parts_to_keep]) return fn(V(v1), V(v2))
def getFastToc(self, runner, toc_pickle, device): """ Retrieve the normal TOC table from a toc pickle or the drive. Also retrieves the cdrdao version @rtype: tuple of L{table.Table}, str """ def function(r, t): r.run(t) ptoc = cache.Persister(toc_pickle or None) if not ptoc.object: from pkg_resources import parse_version as V version = cdrdao.getCDRDAOVersion() if V(version) < V('1.2.3rc2'): sys.stdout.write( 'Warning: cdrdao older than 1.2.3 has a ' 'pre-gap length bug.\n' 'See http://sourceforge.net/tracker/?func=detail' '&aid=604751&group_id=2171&atid=102171\n') t = cdrdao.ReadTOCTask(device) ptoc.persist(t.table) toc = ptoc.object assert toc.hasTOC() return toc
def check(self, package_name, package_version, **extra_data): """Return a UpdateResult object if there is a newer version.""" data = extra_data data['package_name'] = package_name data['package_version'] = package_version data['python_version'] = sys.version.split()[0] data['platform'] = platform.platform(True) try: headers = {'content-type': 'application/json'} response = requests.put(self.url, json.dumps(data), timeout=1, headers=headers) data = response.json() except (requests.exceptions.RequestException, ValueError): return None if not data or not data.get('success') or (V(package_version) >= V( data['data']['version'])): return None return UpdateResult(package_name, running=package_version, available=data['data']['version'], release_date=data['data']['upload_time'])
def supported(package, version): """Determine if version +version+ of +package+ is still supported. Returns True if it is; False otherwise. """ versions = all()[package] return any([V(version) >= V(v) for v in versions])
def test_pyqt4(): from PyQt4.QtCore import QT_VERSION_STR from PyQt4.Qt import PYQT_VERSION_STR from sip import SIP_VERSION_STR print("Qt version:", QT_VERSION_STR) print("SIP version:", SIP_VERSION_STR) print("PyQt version:", PYQT_VERSION_STR) assert V(PYQT_VERSION_STR) >= V('4.10.0')
def check_matplotlib_version(requiredversion): matplotlibversion = matplotlib.__version__ from pkg_resources import parse_version as V # nice if V(matplotlibversion) < V(requiredversion): print( f"Matplotlib version {requiredversion} is required but version {matplotlibversion} is installed." ) print("I'm sorry, but you'll have to update matplotlib.") sys.exit(1)
def getFastToc(self, runner, device): """Retrieve the normal TOC table from the drive. Also warn about buggy cdrdao versions. """ from pkg_resources import parse_version as V version = cdrdao.getCDRDAOVersion() if V(version) < V('1.2.3rc2'): logger.warning('cdrdao older than 1.2.3 has a pre-gap length bug.' ' See http://sourceforge.net/tracker/?func=detail&aid=604751&group_id=2171&atid=102171') # noqa: E501 toc = cdrdao.ReadTOCTask(device).table assert toc.hasTOC() return toc
def get_git_sha1(): try: import git required_version = '0.3.7' if V(git.__version__) < V(required_version): raise ImportError('could not import gitpython>=%s' % required_version) except ImportError as e: print >> sys.stderr, e return None repo = git.Repo(os.path.dirname(__file__)) sha1 = repo.iter_commits().next().hexsha return sha1
def setUp(self): super(self.__class__, self).setUp() self.client = Client(self.env.host, dbname=self.env.dbname, user=self.env.user, pwd=self.env.password, protocol=self.env.protocol, port=self.env.port) if self.client.server_version == V('7.0'): self.report_name = 'sale.order' elif self.client.server_version >= V('11.0'): raise unittest.SkipTest( 'reports service was removed in Odoo 11.0+') else: # >7.0 self.report_name = 'sale.report_saleorder'
def workflow_signal(self, obj_id, signal): """ Triggers specified signal for object's workflow """ assert self.client.server_version < V('11.0'), ( "Not supported for Odoo 11.0+") assert isinstance(obj_id, numbers.Integral), "obj_id must be integer" assert isinstance(signal, six.string_types), "signal must be string" return self.client.execute_wkf(self.name, signal, obj_id)
def get_version(self): with open('Makefile', 'r') as f: for line in f: if line.startswith('VERSION = '): version = line.split('=')[1].strip() elif line.startswith('PATCHLEVEL = '): patchlevel = line.split('=')[1].strip() break self.verstr = version + '.' + patchlevel # With v2014.04 the u-boot Makefile knows the 'tools-only' target. if V(self.verstr) < V('2014.04'): TUI.printf("Only U-Boot >= 2014.04 is supported.\n" "This is version '%s'" % self.verstr) if V(self.verstr) >= V('2017.09'): self.deb['envtools'] = 'envtools' else: self.deb['envtools'] = 'env'
def getFastToc(self, runner, toc_pickle, device): """ Retrieve the normal TOC table from a toc pickle or the drive. Also retrieves the cdrdao version @rtype: tuple of L{table.Table}, str """ def function(r, t): r.run(t) ptoc = cache.Persister(toc_pickle or None) if not ptoc.object: tries = 0 while True: tries += 1 t = cdrdao.ReadTOCTask(device=device) try: function(runner, t) break except: if tries > 3: raise self.debug('failed to read TOC after %d tries, retrying' % tries) version = t.tasks[1].parser.version from pkg_resources import parse_version as V # we've built a cdrdao 1.2.3rc2 modified package with the patch if V(version) < V('1.2.3rc2p1'): self.stdout.write( 'Warning: cdrdao older than 1.2.3 has a ' 'pre-gap length bug.\n' 'See http://sourceforge.net/tracker/?func=detail' '&aid=604751&group_id=2171&atid=102171\n') ptoc.persist(t.table) toc = ptoc.object assert toc.hasTOC() return toc
def workflow(self): """ Returns Record instance of "workflow" object related to this Object If there are no workflow for an object then False will be returned """ if self._workflow is None and self.client.server_version < V('11.0'): wkf_obj = self.service.get_obj('workflow') # TODO: implement correct behavior for situations with few # workflows for same model. wkf_records = wkf_obj.search_records([('osv', '=', self.name)]) if wkf_records and len(wkf_records) > 1: # pragma: no cover raise ObjectException( "More then one workflow per model not supported " "be current version of openerp_proxy!") self._workflow = wkf_records and wkf_records[0] or False return self._workflow
def setUp(self): super(Test_32_ExtWorkFlow, self).setUp() self.client = Client(self.env.host, dbname=self.env.dbname, user=self.env.user, pwd=self.env.password, protocol=self.env.protocol, port=self.env.port) if self.client.server_version >= V('9.0'): self.skipTest('No workflow tests for Odoo version 9.0') self.object = self.client.get_obj('sale.order') self.record = self.object.browse(1) self.obj_ids = self.object.search([], limit=10) self.recordlist = self.object.read_records(self.obj_ids) self.object_no_wkf = self.client.get_obj('res.partner') self.record_no_wkf = self.object_no_wkf.browse(1) self.obj_ids_no_wkf = self.object_no_wkf.search([], limit=10) self.recordlist_no_wkf = self.object_no_wkf.read_records(self.obj_ids_no_wkf)
print_cache = CACHE.print_cache clear_cache = CACHE.clear_cache from .compatibility import lru_cache from functools import update_wrapper try: import fastcache from warnings import warn # the version attribute __version__ is not present for all versions if not hasattr(fastcache, "__version__"): warn("fastcache version >= 0.4.0 required", UserWarning) raise ImportError # ensure minimum required version of fastcache is present if V(fastcache.__version__) < V("0.4.0"): warn( "fastcache version >= 0.4.0 required, detected {}".format( fastcache.__version__ ), UserWarning, ) raise ImportError # Do not use fastcache if running under pypy import platform if platform.python_implementation() == "PyPy": raise ImportError except ImportError:
def test_numpy(): numpy_meta = GD("numpy") assert numpy_meta.parsed_version >= V('1.9.0')
def test_pyparsing(): pyparsing_meta = GD("pyparsing") assert pyparsing_meta.parsed_version == V('2.0.3')
def test_traits(): traits_meta = GD("traits") assert traits_meta.parsed_version >= V('4.4.0')
def do(self, args): prog = program.Program(record=self.getRootCommand().record) runner = task.SyncRunner() def function(r, t): r.run(t) # if the device is mounted (data session), unmount it device = self.parentCommand.options.device self.stdout.write('Checking device %s\n' % device) prog.loadDevice(device) prog.unmountDevice(device) version = None # first, read the normal TOC, which is fast ptoc = common.Persister(self.options.toc_pickle or None) if not ptoc.object: t = cdrdao.ReadTOCTask(device=device) function(runner, t) version = t.tasks[1].parser.version from pkg_resources import parse_version as V # we've built a cdrdao 1.2.3rc2 modified package with the patch if V(version) < V('1.2.3rc2p1'): self.stdout.write(''' Warning: cdrdao older than 1.2.3 has a pre-gap length bug. See http://sourceforge.net/tracker/?func=detail&aid=604751&group_id=2171&atid=102171 ''') ptoc.persist(t.table) ittoc = ptoc.object assert ittoc.hasTOC() # already show us some info based on this prog.getRipResult(ittoc.getCDDBDiscId()) self.stdout.write("CDDB disc id: %s\n" % ittoc.getCDDBDiscId()) mbdiscid = ittoc.getMusicBrainzDiscId() self.stdout.write("MusicBrainz disc id %s\n" % mbdiscid) self.stdout.write("MusicBrainz lookup URL %s\n" % ittoc.getMusicBrainzSubmitURL()) prog.metadata = prog.getMusicBrainz(ittoc, mbdiscid, self.options.release) if not prog.metadata: # fall back to FreeDB for lookup cddbid = ittoc.getCDDBValues() cddbmd = prog.getCDDB(cddbid) if cddbmd: self.stdout.write('FreeDB identifies disc as %s\n' % cddbmd) if not self.options.unknown: prog.ejectDevice(device) return -1 # now, read the complete index table, which is slower itable = prog.getTable(runner, ittoc.getCDDBDiscId(), device) assert itable.getCDDBDiscId() == ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( itable.getCDDBDiscId(), ittoc.getCDDBDiscId()) assert itable.getMusicBrainzDiscId() == ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( itable.getMusicBrainzDiscId(), ittoc.getMusicBrainzDiscId()) assert itable.getAccurateRipURL() == ittoc.getAccurateRipURL(), \ "full table's AR URL %s differs from toc AR URL %s" % ( itable.getAccurateRipURL(), ittoc.getAccurateRipURL()) prog.outdir = (self.options.output_directory or os.getcwd()) prog.outdir = prog.outdir.decode('utf-8') # here to avoid import gst eating our options from morituri.common import encode profile = encode.PROFILES[self.options.profile]() # result prog.result.cdrdao_version = version prog.result.cdparanoia_version = cdparanoia.ParanoiaVersion() prog.result.offset = int(self.options.offset) prog.result.artist = prog.metadata and prog.metadata.artist \ or 'Unknown Artist' prog.result.title = prog.metadata and prog.metadata.title \ or 'Unknown Title' # cdio is optional for now try: import cdio _, prog.result.vendor, prog.result.model, prog.result.release = \ cdio.Device(device).get_hwinfo() except ImportError: self.stdout.write( 'WARNING: pycdio not installed, cannot identify drive\n') prog.result.vendor = 'Unknown' prog.result.model = 'Unknown' prog.result.release = 'Unknown' # FIXME: turn this into a method def ripIfNotRipped(number): # we can have a previous result trackResult = prog.result.getTrackResult(number) if not trackResult: trackResult = result.TrackResult() prog.result.tracks.append(trackResult) path = prog.getPath(prog.outdir, self.options.track_template, mbdiscid, number) + '.' + profile.extension trackResult.number = number assert type(path) is unicode, "%r is not unicode" % path trackResult.filename = path if number > 0: trackResult.pregap = itable.tracks[number - 1].getPregap() # FIXME: optionally allow overriding reripping if os.path.exists(path): self.stdout.write('Verifying track %d of %d: %s\n' % (number, len(itable.tracks), os.path.basename(path).encode('utf-8'))) if not prog.verifyTrack(runner, trackResult): self.stdout.write('Verification failed, reripping...\n') os.unlink(path) if not os.path.exists(path): tries = 0 self.stdout.write('Ripping track %d of %d: %s\n' % (number, len(itable.tracks), os.path.basename(path).encode('utf-8'))) while tries < MAX_TRIES: tries += 1 try: self.debug('ripIfNotRipped: track %d, try %d', number, tries) prog.ripTrack(runner, trackResult, offset=int(self.options.offset), device=self.parentCommand.options.device, profile=profile, taglist=prog.getTagList(number), what='track %d of %d' % (number, len(itable.tracks))) break except Exception, e: self.debug('Got exception %r on try %d', e, tries) if tries == MAX_TRIES: self.error('Giving up on track %d after %d times' % (number, tries)) if trackResult.testcrc == trackResult.copycrc: self.stdout.write('Checksums match for track %d\n' % number) else: self.stdout.write( 'ERROR: checksums did not match for track %d\n' % number) raise self.stdout.write('Peak level: %.2f %%\n' % (math.sqrt(trackResult.peak) * 100.0, )) self.stdout.write('Rip quality: %.2f %%\n' % (trackResult.quality * 100.0, )) # overlay this rip onto the Table if number == 0: # HTOA goes on index 0 of track 1 itable.setFile(1, 0, trackResult.filename, ittoc.getTrackStart(1), number) else: itable.setFile(number, 1, trackResult.filename, ittoc.getTrackLength(number), number) prog.saveRipResult()
def load(): changes = yaml.load( open(os.path.join(os.path.dirname(__file__), 'changelog.yml'))) changes = [(V(key), key, value) for key, value in changes.iteritems()] return sorted(changes, key=lambda x: x[0], reverse=True)
def test_xlrd(): xlrd_meta = GD("xlrd") assert xlrd_meta.parsed_version >= V('0.9.2')
from pkg_resources import parse_version as V import sys try: import scipy enable_sparse = V(scipy.__version__) >= V('0.7') if not enable_sparse: sys.stderr.write( "WARNING: scipy version = %s." " We request version >=0.7.0 for the sparse code as it has" " bugs fixed in the sparse matrix code.\n" % scipy.__version__) except ImportError: enable_sparse = False sys.stderr.write("WARNING: scipy can't be imported." " We disable the sparse matrix code.") if enable_sparse: from basic import * import sharedvar from sharedvar import sparse_constructor as shared
# Created on Wed Oct 29 16:55:39 2014 # Author: XiaoTao Wang # Organization: HuaZhong Agricultural University import xmlrpc.client from pkg_resources import parse_version as V __author__ = 'XiaoTao Wang' __version__ = '0.4.2' __license__ = 'GPLv3+' ## Check for update try: pypi = xmlrpc.client.ServerProxy('http://pypi.python.org/pypi') available = pypi.package_releases('TADLib') if V(__version__) < V(available[0]): print('*' * 75) print('Version {0} is out of date, Version {1} is available.'.format( __version__, available[0])) print() print('*' * 75) except: pass
# -*- coding: utf-8 -*- from __future__ import unicode_literals import cms from django.db import migrations, models from pkg_resources import parse_version as V # Django CMS 3.3.1 is oldest release where the change affects. # Refs https://github.com/divio/django-cms/commit/871a164 if V(cms.__version__) >= V('3.3.1'): field_kwargs = {'related_name': 'form_designer_form_cmsformdefinition'} else: field_kwargs = {} class Migration(migrations.Migration): dependencies = [ ('cms', '0001_initial'), ('form_designer', '0001_initial'), ] operations = [ migrations.CreateModel( name='CMSFormDefinition', fields=[ ('cmsplugin_ptr', models.OneToOneField( serialize=False, auto_created=True, primary_key=True, to='cms.CMSPlugin',
def get_max_version(versions_list): curr_max = versions_list[0] for version in versions_list: if V(version) > V(curr_max): curr_max = version return curr_max
def test_openpyxl(): openpyxl_meta = GD("openpyxl") assert openpyxl_meta.parsed_version >= V('1.8.5')
def test_pandas(): pandas_meta = GD("pandas") assert pandas_meta.parsed_version >= V('0.14.0')
def test_pyper(): '''version 1.1.2: the row index is not importet to Pandas DataFrames''' pyper_meta = GD("pyper") assert pyper_meta.parsed_version >= V('1.1.1')
def test_colormath(): color_meta = GD("colormath") assert color_meta.parsed_version == V('2.1.0')