def test_01_upgrade_jail(
invoke_cli, jail, skip_test, release,
freebsd_download_server, dhcp, jail_ip, resource_selector
):
# This scenario should work in most cases
# We can take the value of release specified, go down one version
# Create a jail for this version and then upgrade to release
# If it passes as desired, we can mark this as resolved
req = requests.get(freebsd_download_server)
assert req.status_code == 200
releases = [
StrictVersion(r) for r in re.findall(
r'href="(\d.*)-RELEASE/"', req.content.decode('utf-8')
)
]
releases.sort()
release = StrictVersion(release.split('-')[0])
skip_test(release not in releases, f'{releases} does contain {release}')
skip_test(releases.index(release) == 0, f'Cannot execute upgrade test')
jails = resource_selector.jails_with_prop('ip4_addr', jail_ip)
if not jails:
jails = resource_selector.jails_with_prop('dhcp', 'on')
skip_test(not jails)
invoke_cli(
['upgrade', jail.name, '-r', release]
)
def test_version_mismatch(self):
"""Test handling of configuration files from different rosrepo versions"""
os.makedirs(os.path.join(self.wsdir, ".rosrepo"))
cfg_file = os.path.join(self.wsdir, ".rosrepo", "config")
with open(cfg_file, "w") as f:
f.write("version: %s" % rosrepo_version)
cfg = Config(self.wsdir)
self.assertEqual(cfg.get("version"), rosrepo_version)
with open(cfg_file, "w") as f:
f.write("version: 3.0.0a0")
cfg = Config(self.wsdir)
self.assertEqual(cfg.get("version"), rosrepo_version)
# revisions may change without affecting config compatibility
v = StrictVersion(rosrepo_version)
v.version = tuple([v.version[0], v.version[1], v.version[2] + 1])
with open(cfg_file, "w") as f:
f.write('version: "%s"' % str(v))
cfg = Config(self.wsdir)
self.assertEqual(cfg.get("version"), str(v))
# major or minor version number change means incompatible configurations
v.version = tuple([v.version[0], v.version[1] + 1, 0])
with open(cfg_file, "w") as f:
f.write('version: "%s"' % str(v))
self.assertRaises(ConfigError, lambda: Config(self.wsdir))
v.version = tuple([v.version[0] + 1, 0, 0])
with open(cfg_file, "w") as f:
f.write('version: "%s"' % str(v))
self.assertRaises(ConfigError, lambda: Config(self.wsdir))
def dipy_version():
import dipy
dipy_ver = dipy.__version__
from distutils.version import StrictVersion
dipy_ver = StrictVersion(dipy_ver.split('.dev')[0])
return dipy_ver
def __init__(self):
StrictVersion.__init__(self)
tversion = '0.0.0'
ccp4_major_minor = os.path.join(os.environ["CCP4"], "lib", "ccp4", "MAJOR_MINOR")
if os.path.isfile(ccp4_major_minor):
with open(ccp4_major_minor, "r") as f_in:
tversion = f_in.read().strip()
self.parse(tversion)
def validate_version(version):
validator = StrictVersion()
try:
validator.parse(version)
except:
raise ValidationError('invalid version {}'.format(version))
return version
def version_init(self, s):
'''Chcek if valid version string, using distutils.StrictVersion
:param s:
:return:
'''
VersionChecker = StrictVersion()
VersionChecker.parse(s) # raises ValueError if no agreement
return s
def run(self):
if self.set:
newver = str(self.set)
else:
try:
oldver = self.distribution.metadata.version
oldver = StrictVersion(oldver)
except ValueError as err:
print("Error: setup.py", err, file=sys.stderr)
sys.exit(errno.EINVAL)
major, minor, patch = oldver.version
pre = oldver.prerelease
if self.alpha:
if pre is None or pre[0] != 'a':
pre = ('a', 0)
else:
pre = (pre[0], pre[1] + 1)
elif self.beta:
if pre is None or pre[0] != 'b':
pre = ('b', 0)
else:
pre = (pre[0], pre[1] + 1)
elif self.release:
pre = None
elif self.patch:
patch = patch + 1
pre = None
elif self.minor:
minor = minor + 1
patch = 0
pre = None
elif self.major:
major = major + 1
minor = 0
patch = 0
pre = None
else:
return
newver = StrictVersion()
newver.version = (major, minor, patch)
newver.prerelease = pre
newver = str(newver)
for dirpath, dirnames, filenames in os.walk(os.curdir):
for filename in (f for f in filenames if os.path.splitext(f)[1] == '.py'):
inpath = os.path.join(dirpath, filename)
outpath = inpath + '.tmp'
with open(inpath) as fin, open(outpath, 'w') as fout:
for line in fin:
if line.startswith("__version__"):
line = "__version__ = '{0}'\n".format(newver)
fout.write(line)
shutil.copystat(inpath, outpath)
os.replace(outpath, inpath)
def __cmp__(self, other):
if self.version is None or other.version is None:
# cannot compare None version
raise Exception("Unable to compare None versions")
try:
sv = StrictVersion()
sv.parse(self.version)
return sv.__cmp__(other.version)
except Exception:
return LooseVersion(self.version).__cmp__(LooseVersion(other.version))
def check_llvm_version(context):
context.Message('Checking for LLVM version...')
success, output = context.TryAction('$LLVM_CONFIG --version >$TARGET')
# some releases of LLVM 3.2 shipped as version 3.2svn
output = output.replace('svn', '')
if(not output):
context.Result("No LLVM version could be found")
exit(1)
output = StrictVersion(output.rstrip())
context.Result(str(output))
context.env['LLVM_version'] = output
def load_translations(lang, version=1, commcare_version=None):
# pt => por: hack for backwards compatibility
if lang == 'pt':
lang = 'por'
try:
str(lang)
except UnicodeEncodeError:
return {}
paths_to_try = []
if commcare_version == 'latest':
files = listdir(normpath(join(__file__, "../historical-translations-by-version/")))
if len(files):
files.sort()
files.reverse()
paths_to_try.append(
'../historical-translations-by-version/{file}'
.format(file=files[0])
)
commcare_version = None
elif commcare_version:
try:
commcare_version = StrictVersion(commcare_version)
except ValueError:
commcare_version = None
if version == 2 and lang == 'en' and commcare_version:
# the earliest version we have is 2.23
if commcare_version < StrictVersion('2.23'):
commcare_version = StrictVersion('2.23')
major, minor, bugfix = commcare_version.version
while bugfix >= 0:
commcare_version.version = major, minor, bugfix
paths_to_try.append(
'../historical-translations-by-version/{commcare_version}-messages_{lang}-{version}.txt'
.format(commcare_version=commcare_version, lang=lang, version=version)
)
bugfix -= 1
while version:
paths_to_try.append('../messages_{lang}-{version}.txt'
.format(lang=lang, version=version))
version -= 1
for rel_path in paths_to_try:
path = normpath(join(__file__, rel_path))
try:
with open(path, encoding='utf-8') as f:
return load(f)
except IOError:
pass
return {}
def test_update_testsuites(self):
v = StrictVersion(self.testsuites['MTBC/test'].version)
# load by full name
testsuites = {}
update_testsuites(testsuites,
{'MTBC/test': str(v)},
self.testsuite_paths
)
assert testsuites.keys() == ['MTBC/test']
# load by short name
update_testsuites(testsuites,
{'test': str(v)},
self.testsuite_paths
)
assert set(testsuites.keys()) == set(['MTBC/test', 'test'])
assert testsuites['test'] == testsuites['MTBC/test']
# load compatible
vv = list(v.version)
vv[1] -= 1
v.version = vv
update_testsuites(testsuites,
{'test': str(v)},
self.testsuite_paths
)
assert set(testsuites.keys()) == set(['MTBC/test', 'test'])
# load incompatbile 1/2
vv[1] += 2
v.version = vv
try:
update_testsuites(testsuites,
{'test': str(v)},
self.testsuite_paths
)
assert False, 'future minor version specified; should fail'
except TestsuiteVersionConflictException:
pass
# load incompatbile 1/2
vv[1] -= 1
vv[0] -= 1
v.version = vv
try:
update_testsuites(testsuites,
{'test': str(v)},
self.testsuite_paths
)
assert False, 'different major version specified; should fail'
except TestsuiteVersionConflictException:
pass
def parse_version(vstring):
"""
StrictVersion / LooseVersion decorator method
@type vstring: str
@return: StrictVersion if possible, otherwise LooseVersion
@rtype: StrictVersion or LooseVersion
"""
try:
version = StrictVersion(vstring)
except ValueError:
logging.getLogger('ipvs.common.debug').info('Strict parsing failed, falling back to LooseVersion instead')
version = LooseVersion(vstring)
version.version = tuple(version.version)
return version
def checkRequirements(self):
RenderChanModule.checkRequirements(self)
if self.active:
# The CLI features depend on the version
with tempfile.TemporaryDirectory() as tmpPath:
# The exporting of a fake file is a workaround for older versions which just start the program when passed only -v
proc = subprocess.Popen([self.conf['binary'], "-v", "--export-sequence", os.path.join(tmpPath,"test")], stdout=subprocess.PIPE)
try:
outs, errs = proc.communicate(timeout=5)
except TimeoutExpired:
proc.kill()
outs, errs = proc.communicate()
rc = proc.poll()
if rc == 0:
try:
# Get the version from stdout. An example of the output: "Pencil2D 0.6.0\n"
self.version = outs.rstrip().decode("utf-8").split(" ")[-1]
self.version = ".".join(self.version.split(".")[0:3])
self.version = StrictVersion(self.version)
except:
self.active = False
else:
self.active = False
if self.active == False:
print("WARNING: Failed to initialize Pencil2D module. The possible reasons for that could be: missing X connection, or the version of Pencil2D on your system is unsupported (too old?). In latter case please consider to get latest version at https://www.pencil2d.org/.")
return self.active
def __init__(self):
StrictVersion.__init__(self)
ccp4_major_minor = os.path.join(os.environ["CCP4"], "lib", "ccp4", "MAJOR_MINOR")
if os.path.isfile(ccp4_major_minor):
with open(ccp4_major_minor, "r") as f_in:
tversion = f_in.read().strip()
else:
logger = logging.getLogger(__name__)
logger.debug("Detecting CCP4 version via executing pdbcur")
stdout = cexec(['pdbcur' + EXE_EXT], permit_nonzero=True)
tversion = None
for line in stdout.split(os.linesep):
if line.startswith(' ### CCP4'):
tversion = line.split()[2].rstrip(':')
if tversion is None:
raise RuntimeError("Cannot determine CCP4 version")
self.parse(tversion)
def match_brlcad_version(brlcad_options, brlcad_installations, logger):
"""
Iterate the brlcad installations in the order found, and try to match it
to a set of configuration options.
"""
for version in brlcad_options:
min_version = version.get("min-brlcad-version", None)
if min_version:
min_version = StrictVersion(min_version.strip())
max_version = version.get("max-brlcad-version", None)
if max_version:
max_version = StrictVersion(max_version.strip())
logger.debug("Checking {0}: {1} -> {2}".format(version["section"], min_version, max_version))
for brlcad_info in brlcad_installations:
if min_version and min_version > brlcad_info["version"]:
continue
if max_version and max_version < brlcad_info["version"]:
continue
logger.debug("Found matching brlcad installation: {0}".format(brlcad_info["prefix"]))
yield version, brlcad_info
def __init__(self):
RenderChanModule.__init__(self)
if os.name == 'nt':
self.conf['binary']=os.path.join(os.path.dirname(__file__),"..\\..\\..\\packages\\pencil2d\\pencil2d.exe")
else:
self.conf['binary']="pencil2d"
self.conf["packetSize"]=0
# Extra params
self.extraParams["transparency"]="0"
self.extraParams["width"]="-1"
self.extraParams["height"]="-1"
self.extraParams["startFrame"]="1"
self.extraParams["endFrame"]="last"
self.version=StrictVersion('0.5.4') #default value
def main():
# Change to SWIG path
os.chdir(swig_path)
# Check SWIG version
for line in io.StringIO(subprocess.check_output(swig_version).decode('utf-8')):
if line.startswith('SWIG Version '):
*init, version = line.split('SWIG Version ')
version = StrictVersion(version.strip())
if version >= StrictVersion(swig_required_version):
print('SWIG Version:', version)
break
else:
fail('SWIG Version >= {} required'.format(swig_required_version), 2)
# Map namespaces to function names
functions = {}
namespace = 'default'
print('Mapping namespaces to functions')
with open(natives_h) as natives:
for line in natives:
line = line.strip()
# Namespace
if line.startswith('namespace'):
head, namespace, *tail = line.split(' ')
namespace = namespace.lower()
# Function
if line.startswith('static'):
*init, last = line.split(' ', maxsplit=2)
name, *tail = last.split('(', maxsplit=1)
functions.setdefault(namespace, set())
functions[namespace].add(name)
# Generate wrapper
print('Generating wrapper')
try:
subprocess.check_call(swig_generate)
except subprocess.CalledProcessError as exc:
fail(exc, 3)
# Rewrite Python wrapper
last_namespace = None
function_found = False
skip = 0
indent = ' ' * 4
init = []
middle = []
tail = []
def add_normal(_line):
if function_found:
tail.append(_line)
else:
init.append(_line)
def add_class_assignment():
if last_namespace is not None:
middle.append('{} = _{}\n\n\n'.format(
last_namespace, last_namespace.capitalize()))
def maybe_add_method(_line):
nonlocal last_namespace, function_found
for _namespace, names in functions.items():
for _name in names:
if _line.startswith('def {}'.format(_name)):
function_found = True
if _namespace != last_namespace:
# Insert class assignment at the end of a namespace
add_class_assignment()
# Insert class declaration at the start of a namespace
middle.append('class _{}(_object):\n'.format(_namespace.capitalize()))
last_namespace = _namespace
# Insert staticmethod and function definition
*_, _last = _line.split('(', maxsplit=1)
middle.append(indent + '@staticmethod\n')
middle.append(indent + 'def {}({}'.format(
_name if _name.startswith('_') else _name.lower(),
_last
))
return 3
add_normal(_line)
return 0
# Parse generated Python wrapper
print('Parsing generated Python wrapper')
with open(gta_native_py_in) as natives_in:
for line in natives_in:
if skip > 0:
# Return statement
if skip == 3:
middle.append('{}{}\n'.format(indent, line))
elif skip == 1 and len(line.strip()) > 0:
add_normal(line)
skip -= 1
elif line.startswith('def '):
# Function
skip = maybe_add_method(line)
else:
# Something else
add_normal(line)
add_class_assignment()
# Write new Python wrapper
print('Writing new Python wrapper')
with open(gta_native_py_out, 'w') as natives_out:
natives_out.writelines(init + middle + tail)
# Remove originally generated Python wrapper
print('Removing originally generated Python wrapper')
os.remove(gta_native_py_in)
# Done
print('Done')
sys.exit(0)
from django.conf import settings
from django.contrib.auth.models import Group
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import ImproperlyConfigured
from django.db import models
from django.db.models.query import QuerySet
from django.utils import timezone
from jsonfield.fields import JSONField
from model_utils import Choices
from notifications import settings as notifications_settings
from notifications.signals import notify
from notifications.utils import id2slug
from swapper import load_model
if StrictVersion(get_version()) >= StrictVersion('1.8.0'):
from django.contrib.contenttypes.fields import GenericForeignKey # noqa
else:
from django.contrib.contenttypes.generic import GenericForeignKey # noqa
EXTRA_DATA = notifications_settings.get_config()['USE_JSONFIELD']
def is_soft_delete():
return notifications_settings.get_config()['SOFT_DELETE']
def assert_soft_delete():
if not is_soft_delete():
# msg = """To use 'deleted' field, please set 'SOFT_DELETE'=True in settings.
# Otherwise NotificationQuerySet.unread and NotificationQuerySet.read do NOT filter by 'deleted' field.
from distutils.version import StrictVersion
VERSION = StrictVersion('3.1.0')
class RenderChanPencil2dModule(RenderChanModule):
def __init__(self):
RenderChanModule.__init__(self)
if os.name == 'nt':
self.conf['binary']=os.path.join(os.path.dirname(__file__),"..\\..\\..\\packages\\pencil2d\\pencil2d.exe")
else:
self.conf['binary']="pencil2d"
self.conf["packetSize"]=0
# Extra params
self.extraParams["transparency"]="0"
self.extraParams["width"]="-1"
self.extraParams["height"]="-1"
self.extraParams["startFrame"]="1"
self.extraParams["endFrame"]="last"
self.version=StrictVersion('0.5.4') #default value
def checkRequirements(self):
RenderChanModule.checkRequirements(self)
if self.active:
# The CLI features depend on the version
with tempfile.TemporaryDirectory() as tmpPath:
# The exporting of a fake file is a workaround for older versions which just start the program when passed only -v
proc = subprocess.Popen([self.conf['binary'], "-v", "--export-sequence", os.path.join(tmpPath,"test")], stdout=subprocess.PIPE)
try:
outs, errs = proc.communicate(timeout=5)
except TimeoutExpired:
proc.kill()
outs, errs = proc.communicate()
rc = proc.poll()
if rc == 0:
try:
# Get the version from stdout. An example of the output: "Pencil2D 0.6.0\n"
self.version = outs.rstrip().decode("utf-8").split(" ")[-1]
self.version = ".".join(self.version.split(".")[0:3])
self.version = StrictVersion(self.version)
except:
self.active = False
else:
self.active = False
if self.active == False:
print("WARNING: Failed to initialize Pencil2D module. The possible reasons for that could be: missing X connection, or the version of Pencil2D on your system is unsupported (too old?). In latter case please consider to get latest version at https://www.pencil2d.org/.")
return self.active
def analyze(self, filename):
info={ "dependencies":[] }
if filename.endswith(".pcl"):
with open(filename, 'r') as f:
tree = ElementTree.parse(f)
root = tree.getroot()
info["dependencies"].extend((os.path.join(filename + ".data", element.get("src")) for element in root.findall(".//*[@src]")))
else:
# We don't actually have to do anything here because there are no dependencies and the default values
# automatically update for changes in the internal width, height, camera etc.
# This is how we would open it if we needed to
"""with ZipFile(filename) as zipdir:
with zipdir.open('main.xml') as mainfile:
tree = ElementTree.parse(mainfile)
root = tree.getroot()"""
return info
def getInputFormats(self):
if self.version >= StrictVersion('0.6.0'):
return ["pcl", "pclx"]
else:
return ["pcl"]
def getOutputFormats(self):
if self.version > StrictVersion('0.6.0'):
return ["png", "jpg", "jpeg", "tif", "tiff", "bmp", "mp4", "avi", "gif", "webm"]
elif self.version == StrictVersion('0.6.0'):
return ["png", "jpg", "jpeg", "tif", "tiff", "bmp"]
else:
return ["png"]
def render(self, filename, outputPath, startFrame, endFrame, format, updateCompletion, extraParams={}):
comp = 0.0
updateCompletion(comp)
output = os.path.join(outputPath,"file")
if not os.path.exists(outputPath):
os.mkdir(outputPath)
if self.version > StrictVersion('0.6.0'):
commandline=[self.conf['binary'], filename, "-o", output, "--width", extraParams['width'], "--height", extraParams['height'], "--start", startFrame, "--end", endFrame]
if is_true_string(extraParams['transparency']):
commandline.append("--transparency")
if extraParams['camera']:
commandline.extend(["--camera", extraParams['camera']])
elif self.version == StrictVersion('0.6.0'):
commandline=[self.conf['binary'], filename, "--export-sequence", output, "--width", extraParams['width'], "--height", extraParams['height']]
if is_true_string(extraParams['transparency']):
commandline.append("--transparency")
else:
commandline=[self.conf['binary'], filename, "--export-sequence", output]
print(commandline)
subprocess.check_call(commandline)
updateCompletion(1.0)
def _cmp(self, other):
if isinstance(other, str):
other = OmicronVersion(other)
return StrictVersion._cmp(self, other)
class TestGLMRegressorConverter(unittest.TestCase):
def test_model_linear_regression(self):
model, X = fit_regression_model(linear_model.LinearRegression())
model_onnx = convert_sklearn(
model, "linear regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearRegression-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
@unittest.skipIf(
StrictVersion(ort_version) <= StrictVersion("0.5.0"),
reason="old onnxruntime does not support double")
def test_model_linear_regression_multi(self):
model, X = fit_regression_model(linear_model.LinearRegression(),
n_targets=2)
model_onnx = convert_sklearn(
model, "linear regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearRegressionMulti-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
@unittest.skipIf(
StrictVersion(ort_version) <= StrictVersion("0.5.0"),
reason="old onnxruntime does not support double")
def test_model_linear_regression64(self):
model, X = fit_regression_model(linear_model.LinearRegression())
model_onnx = convert_sklearn(model, "linear regression",
[("input", DoubleTensorType(X.shape))])
self.assertIsNotNone(model_onnx)
self.assertIn("elem_type: 11", str(model_onnx))
dump_data_and_model(
X.astype(numpy.float64),
model,
model_onnx,
basename="SklearnLinearRegression64-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
@unittest.skipIf(
StrictVersion(ort_version) <= StrictVersion("0.5.0"),
reason="old onnxruntime does not support double")
def test_model_linear_regression64_multiple(self):
model, X = fit_regression_model(linear_model.LinearRegression(),
n_targets=2)
model_onnx = convert_sklearn(model, "linear regression",
[("input", DoubleTensorType(X.shape))])
self.assertIsNotNone(model_onnx)
self.assertIn("elem_type: 11", str(model_onnx))
dump_data_and_model(
X.astype(numpy.float64),
model,
model_onnx,
basename="SklearnLinearRegression64Multi-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_regression_int(self):
model, X = fit_regression_model(
linear_model.LinearRegression(), is_int=True)
model_onnx = convert_sklearn(
model, "linear regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearRegressionInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_regression_nointercept(self):
model, X = fit_regression_model(
linear_model.LinearRegression(fit_intercept=False))
model_onnx = convert_sklearn(
model, "linear regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearRegressionNoIntercept-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_regression_bool(self):
model, X = fit_regression_model(
linear_model.LinearRegression(), is_bool=True)
model_onnx = convert_sklearn(
model, "linear regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearRegressionBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_svr(self):
model, X = fit_regression_model(LinearSVR())
model_onnx = convert_sklearn(
model, "linear SVR",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearSvr-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_svr_int(self):
model, X = fit_regression_model(LinearSVR(), is_int=True)
model_onnx = convert_sklearn(
model, "linear SVR",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearSvrInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_linear_svr_bool(self):
model, X = fit_regression_model(LinearSVR(), is_bool=True)
model_onnx = convert_sklearn(
model, "linear SVR",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLinearSVRBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ridge(self):
model, X = fit_regression_model(linear_model.Ridge())
model_onnx = convert_sklearn(
model, "ridge regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnRidge-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ridge_int(self):
model, X = fit_regression_model(linear_model.Ridge(), is_int=True)
model_onnx = convert_sklearn(
model, "ridge regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnRidgeInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ridge_bool(self):
model, X = fit_regression_model(linear_model.Ridge(), is_bool=True)
model_onnx = convert_sklearn(
model, "ridge regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnRidgeBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_sgd_regressor(self):
model, X = fit_regression_model(linear_model.SGDRegressor())
model_onnx = convert_sklearn(
model,
"scikit-learn SGD regression",
[("input", FloatTensorType([None, X.shape[1]]))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnSGDRegressor-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_sgd_regressor_int(self):
model, X = fit_regression_model(
linear_model.SGDRegressor(), is_int=True)
model_onnx = convert_sklearn(
model, "SGD regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnSGDRegressorInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_sgd_regressor_bool(self):
model, X = fit_regression_model(
linear_model.SGDRegressor(), is_bool=True)
model_onnx = convert_sklearn(
model, "SGD regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnSGDRegressorBool-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_elastic_net_regressor(self):
model, X = fit_regression_model(linear_model.ElasticNet())
model_onnx = convert_sklearn(
model,
"scikit-learn elastic-net regression",
[("input", FloatTensorType([None, X.shape[1]]))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnElasticNet-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_elastic_net_cv_regressor(self):
model, X = fit_regression_model(linear_model.ElasticNetCV())
model_onnx = convert_sklearn(
model,
"scikit-learn elastic-net regression",
[("input", FloatTensorType([None, X.shape[1]]))],
)
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnElasticNetCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_elastic_net_regressor_int(self):
model, X = fit_regression_model(linear_model.ElasticNet(), is_int=True)
model_onnx = convert_sklearn(
model, "elastic net regression",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnElasticNetRegressorInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_elastic_net_regressor_bool(self):
model, X = fit_regression_model(
linear_model.ElasticNet(), is_bool=True)
model_onnx = convert_sklearn(
model, "elastic net regression",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnElasticNetRegressorBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lars(self):
model, X = fit_regression_model(linear_model.Lars())
model_onnx = convert_sklearn(
model, "lars",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLars-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lars_cv(self):
model, X = fit_regression_model(linear_model.LarsCV())
model_onnx = convert_sklearn(
model, "lars",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLarsCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_lars(self):
model, X = fit_regression_model(linear_model.LassoLars(alpha=0.01))
model_onnx = convert_sklearn(
model, "lasso lars",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLars-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_lars_cv(self):
model, X = fit_regression_model(linear_model.LassoLarsCV())
model_onnx = convert_sklearn(
model, "lasso lars cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLarsCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_lars_ic(self):
model, X = fit_regression_model(linear_model.LassoLarsIC())
model_onnx = convert_sklearn(
model, "lasso lars cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLarsIC-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_cv(self):
model, X = fit_regression_model(linear_model.LassoCV())
model_onnx = convert_sklearn(
model, "lasso cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_lars_int(self):
model, X = fit_regression_model(linear_model.LassoLars(), is_int=True)
model_onnx = convert_sklearn(
model, "lasso lars",
[("input", Int64TensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLarsInt-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_lasso_lars_bool(self):
model, X = fit_regression_model(
linear_model.LassoLars(), is_bool=True)
model_onnx = convert_sklearn(
model, "lasso lars",
[("input", BooleanTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnLassoLarsBool",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_multi_linear_regression(self):
model, X = fit_regression_model(linear_model.LinearRegression(),
n_targets=2)
model_onnx = convert_sklearn(
model, "linear regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnMultiLinearRegression-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ard_regression(self):
model, X = fit_regression_model(
linear_model.ARDRegression(), factor=0.001)
model_onnx = convert_sklearn(
model, "ard regression",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnARDRegression-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_theilsen(self):
model, X = fit_regression_model(linear_model.TheilSenRegressor())
model_onnx = convert_sklearn(
model, "thiel-sen regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnTheilSen-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_bayesian_ridge(self):
model, X = fit_regression_model(linear_model.BayesianRidge())
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnBayesianRidge-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_bayesian_ridge_return_std(self):
model, X = fit_regression_model(linear_model.BayesianRidge(),
n_features=2, n_samples=20)
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", FloatTensorType([None, X.shape[1]]))],
options={linear_model.BayesianRidge: {'return_std': True}})
self.assertIsNotNone(model_onnx)
sess = InferenceSession(model_onnx.SerializeToString())
outputs = sess.run(None, {'input': X})
pred, std = model.predict(X, return_std=True)
assert_almost_equal(pred, outputs[0].ravel(), decimal=4)
assert_almost_equal(std, outputs[1].ravel(), decimal=4)
@unittest.skipIf(StrictVersion(ort_version) < StrictVersion("1.3.0"),
reason="output type")
def test_model_bayesian_ridge_return_std_double(self):
model, X = fit_regression_model(linear_model.BayesianRidge(),
n_features=2, n_samples=100,
n_informative=1)
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", DoubleTensorType([None, X.shape[1]]))],
options={linear_model.BayesianRidge: {'return_std': True}})
self.assertIsNotNone(model_onnx)
X = X.astype(numpy.float64)
sess = InferenceSession(model_onnx.SerializeToString())
outputs = sess.run(None, {'input': X})
pred, std = model.predict(X, return_std=True)
assert_almost_equal(pred, outputs[0].ravel())
assert_almost_equal(std, outputs[1].ravel(), decimal=4)
def test_model_bayesian_ridge_return_std_normalize(self):
model, X = fit_regression_model(
linear_model.BayesianRidge(normalize=True),
n_features=2, n_samples=50)
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", FloatTensorType([None, X.shape[1]]))],
options={linear_model.BayesianRidge: {'return_std': True}})
self.assertIsNotNone(model_onnx)
sess = InferenceSession(model_onnx.SerializeToString())
outputs = sess.run(None, {'input': X})
pred, std = model.predict(X, return_std=True)
assert_almost_equal(pred, outputs[0].ravel(), decimal=4)
assert_almost_equal(std, outputs[1].ravel(), decimal=4)
@unittest.skipIf(StrictVersion(ort_version) < StrictVersion("1.3.0"),
reason="output type")
def test_model_bayesian_ridge_return_std_normalize_double(self):
model, X = fit_regression_model(
linear_model.BayesianRidge(normalize=True),
n_features=2, n_samples=50)
model_onnx = convert_sklearn(
model, "bayesian ridge",
[("input", DoubleTensorType([None, X.shape[1]]))],
options={linear_model.BayesianRidge: {'return_std': True}})
self.assertIsNotNone(model_onnx)
X = X.astype(numpy.float64)
sess = InferenceSession(model_onnx.SerializeToString())
outputs = sess.run(None, {'input': X})
pred, std = model.predict(X, return_std=True)
assert_almost_equal(pred, outputs[0].ravel())
assert_almost_equal(std, outputs[1].ravel(), decimal=4)
def test_model_huber_regressor(self):
model, X = fit_regression_model(linear_model.HuberRegressor())
model_onnx = convert_sklearn(
model, "huber regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
basename="SklearnHuberRegressor-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_multi_task_lasso(self):
model, X = fit_regression_model(linear_model.MultiTaskLasso(),
n_targets=2)
model_onnx = convert_sklearn(
model, "multi-task lasso",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnMultiTaskLasso-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_multi_task_lasso_cv(self):
model, X = fit_regression_model(linear_model.MultiTaskLassoCV(),
n_targets=2)
model_onnx = convert_sklearn(
model, "mutli-task lasso cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnMultiTaskLassoCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_multi_task_elasticnet(self):
model, X = fit_regression_model(linear_model.MultiTaskElasticNet(),
n_targets=2)
model_onnx = convert_sklearn(
model, "multi-task elasticnet",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnMultiTaskElasticNet-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_orthogonal_matching_pursuit(self):
model, X = fit_regression_model(
linear_model.OrthogonalMatchingPursuit())
model_onnx = convert_sklearn(
model, "orthogonal matching pursuit",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnOrthogonalMatchingPursuit-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_passive_aggressive_regressor(self):
model, X = fit_regression_model(
linear_model.PassiveAggressiveRegressor())
model_onnx = convert_sklearn(
model, "passive aggressive regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnPassiveAggressiveRegressor-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ransac_regressor_default(self):
model, X = fit_regression_model(
linear_model.RANSACRegressor())
model_onnx = convert_sklearn(
model, "ransac regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnRANSACRegressor-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ransac_regressor_mlp(self):
model, X = fit_regression_model(
linear_model.RANSACRegressor(
base_estimator=MLPRegressor(solver='lbfgs')))
model_onnx = convert_sklearn(
model, "ransac regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnRANSACRegressorMLP-Dec3",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_ransac_regressor_tree(self):
model, X = fit_regression_model(
linear_model.RANSACRegressor(
base_estimator=GradientBoostingRegressor()))
model_onnx = convert_sklearn(
model, "ransac regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnRANSACRegressorTree-Dec3",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_multi_task_elasticnet_cv(self):
model, X = fit_regression_model(linear_model.MultiTaskElasticNetCV(),
n_targets=2)
model_onnx = convert_sklearn(
model, "multi-task elasticnet cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnMultiTaskElasticNetCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
def test_model_orthogonal_matching_pursuit_cv(self):
model, X = fit_regression_model(
linear_model.OrthogonalMatchingPursuitCV())
model_onnx = convert_sklearn(
model, "orthogonal matching pursuit cv",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(
X,
model,
model_onnx,
verbose=False,
basename="SklearnOrthogonalMatchingPursuitCV-Dec4",
allow_failure="StrictVersion("
"onnxruntime.__version__)"
"<= StrictVersion('0.2.1')",
)
# Architekturen entwerfen und testen
# Importe
import os
import time
import random
from distutils.version import StrictVersion
import sklearn
from sklearn.model_selection import train_test_split
assert StrictVersion(sklearn.__version__) >= StrictVersion('0.18.1')
# Import des Tensorflow-Backend Framework
import tensorflow as tf
tf.logging.set_verbosity(tf.logging.ERROR)
assert StrictVersion(tf.__version__) >= StrictVersion('1.1.0')
# Importe aus dem Keras Framework
import keras
assert StrictVersion(keras.__version__) >= StrictVersion('2.0.0')
from keras.models import Model, Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, Input
from keras.layers import Convolution2D, MaxPooling2D, Conv2D
from keras.utils.np_utils import to_categorical
from keras.backend.tensorflow_backend import set_session
# Zusaetzliche Importe fuer die Verarbeitung von Daten und Zahlen
import matplotlib.pylab as plt
import matplotlib.pyplot as pyplot
import numpy as np
import matplotlib
import weewx.engine
import weewx.units
import weeutil.config
from knxip.ip import KNXIPTunnel
from knxip.conversion import float_to_knx2, knx2_to_float, \
knx_to_time, time_to_knx, knx_to_date, date_to_knx, datetime_to_knx,\
knx_to_datetime
from knxip.core import KNXException, parse_group_address
VERSION = "0.1"
REQUIRED_WEEWX = "3.6.1"
REQUIRED_KNXIP = "0.3.2"
if StrictVersion(weewx.__version__) < StrictVersion(REQUIRED_WEEWX):
raise weewx.UnsupportedFeature(
"weewx %s or greater is required, found %s" %
(REQUIRED_WEEWX, weewx.__version__))
#if StrictVersion(knxip.__version__) < StrictVersion(REQUIRED_KNXIP):
# raise weewx.UnsupportedFeature("knxip %s or greater is required, found %s"
# % (REQUIRED_KNXIP, knxip.__version__))
try:
# Test for new-style weewx logging by trying to import weeutil.logger
import weeutil.logger
import logging
log = logging.getLogger(__name__)
def logdbg(msg):
def ensure_xcode(self):
if self.os_version < StrictVersion('10.7'):
if not os.path.exists('/Developer/Applications/Xcode.app'):
print(XCODE_REQUIRED_LEGACY)
subprocess.check_call(['open', XCODE_LEGACY])
sys.exit(1)
# OS X 10.7 have Xcode come from the app store. However, users can
# still install Xcode into any arbitrary location. We honor the
# location of Xcode as set by xcode-select. This should also pick up
# developer preview releases of Xcode, which can be installed into
# paths like /Applications/Xcode5-DP6.app.
elif self.os_version >= StrictVersion('10.7'):
select = self.which('xcode-select')
try:
output = self.check_output([select, '--print-path'],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
# This seems to appear on fresh OS X machines before any Xcode
# has been installed. It may only occur on OS X 10.9 and later.
if b'unable to get active developer directory' in e.output:
print(XCODE_NO_DEVELOPER_DIRECTORY)
self._install_xcode_app_store()
assert False # Above should exit.
output = e.output
# This isn't the most robust check in the world. It relies on the
# default value not being in an application bundle, which seems to
# hold on at least Mavericks.
if b'.app/' not in output:
print(XCODE_REQUIRED)
self._install_xcode_app_store()
assert False # Above should exit.
# Once Xcode is installed, you need to agree to the license before you can
# use it.
try:
output = self.check_output(['/usr/bin/xcrun', 'clang'],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
if b'license' in e.output:
xcodebuild = self.which('xcodebuild')
try:
self.check_output([xcodebuild, '-license'],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e:
if b'requires admin privileges' in e.output:
self.run_as_root([xcodebuild, '-license'])
# Even then we're not done! We need to install the Xcode command line tools.
# As of Mountain Lion, apparently the only way to do this is to go through a
# menu dialog inside Xcode itself. We're not making this up.
if self.os_version >= StrictVersion('10.7'):
if not os.path.exists('/usr/bin/clang'):
print(XCODE_COMMAND_LINE_TOOLS_MISSING)
print(INSTALL_XCODE_COMMAND_LINE_TOOLS_STEPS)
sys.exit(1)
output = self.check_output(['/usr/bin/clang', '--version'])
match = RE_CLANG_VERSION.search(output)
if match is None:
raise Exception('Could not determine Clang version.')
version = StrictVersion(match.group(1))
if version < APPLE_CLANG_MINIMUM_VERSION:
print(UPGRADE_XCODE_COMMAND_LINE_TOOLS)
print(INSTALL_XCODE_COMMAND_LINE_TOOLS_STEPS)
sys.exit(1)
XCODE_LEGACY = ('https://developer.apple.com/downloads/download.action?path=Developer_Tools/'
'xcode_3.2.6_and_ios_sdk_4.3__final/xcode_3.2.6_and_ios_sdk_4.3.dmg')
MACPORTS_URL = {
'13': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.13-HighSierra.pkg',
'12': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.12-Sierra.pkg',
'11': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.11-ElCapitan.pkg',
'10': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.10-Yosemite.pkg',
'9': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.9-Mavericks.pkg',
'8': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.8-MountainLion.pkg',
'7': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.7-Lion.pkg',
'6': 'https://distfiles.macports.org/MacPorts/MacPorts-2.5.3-10.6-SnowLeopard.pkg', }
RE_CLANG_VERSION = re.compile('Apple (?:clang|LLVM) version (\d+\.\d+)')
APPLE_CLANG_MINIMUM_VERSION = StrictVersion('4.2')
XCODE_REQUIRED = '''
Xcode is required to build Firefox. Please complete the install of Xcode
through the App Store.
It's possible Xcode is already installed on this machine but it isn't being
detected. This is possible with developer preview releases of Xcode, for
example. To correct this problem, run:
`xcode-select --switch /path/to/Xcode.app`.
e.g. `sudo xcode-select --switch /Applications/Xcode.app`.
'''
XCODE_REQUIRED_LEGACY = '''
from collections import OrderedDict
import networkx as nx
import pandas as pd
import numpy as np
import re
import inspect
import logging
logger = logging.getLogger(__name__)
from distutils.version import StrictVersion, LooseVersion
try:
_nx_version = StrictVersion(nx.__version__)
except ValueError:
_nx_version = LooseVersion(nx.__version__)
if _nx_version >= '1.12':
class OrderedGraph(nx.MultiGraph):
node_dict_factory = OrderedDict
adjlist_dict_factory = OrderedDict
elif _nx_version >= '1.10':
class OrderedGraph(nx.MultiGraph):
node_dict_factory = OrderedDict
adjlist_dict_factory = OrderedDict
def __init__(self, data=None, **attr):
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(
self.settings.value("geometry", type=QtCore.QByteArray))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
self.message = message = list(ord(i) for i in '123456789')
##################################################
# Blocks
##################################################
self.comsys_pn9_whitening_0_0 = comsys.pn9_whitening(False)
self.comsys_pn9_whitening_0 = comsys.pn9_whitening(False)
self.comsys_crc_tagged_stream_0_0 = comsys.crc_tagged_stream(
True, "packet_len")
self.comsys_crc_tagged_stream_0 = comsys.crc_tagged_stream(
False, "packet_len")
self.blocks_vector_source_x_0_0 = blocks.vector_source_b(
message, True, 1, [])
self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(message), "packet_len")
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char * 1,
'/dev/pts/0', False)
self.blocks_file_sink_0.set_unbuffered(True)
##################################################
# Connections
##################################################
self.connect((self.blocks_stream_to_tagged_stream_0, 0),
(self.comsys_crc_tagged_stream_0, 0))
self.connect((self.blocks_vector_source_x_0_0, 0),
(self.blocks_stream_to_tagged_stream_0, 0))
self.connect((self.comsys_crc_tagged_stream_0, 0),
(self.comsys_pn9_whitening_0_0, 0))
self.connect((self.comsys_crc_tagged_stream_0_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.comsys_pn9_whitening_0, 0),
(self.comsys_crc_tagged_stream_0_0, 0))
self.connect((self.comsys_pn9_whitening_0_0, 0),
(self.comsys_pn9_whitening_0, 0))
def domain(domain_name):
# Validate the domain existing in the local DB
domain = Domain.query.filter(Domain.name == domain_name).first()
if not domain:
abort(404)
# Query domain's rrsets from PowerDNS API
rrsets = Record().get_rrsets(domain.name)
current_app.logger.debug("Fetched rrests: \n{}".format(
pretty_json(rrsets)))
# API server might be down, misconfigured
if not rrsets and domain.type != 'Slave':
abort(500)
quick_edit = Setting().get('record_quick_edit')
records_allow_to_edit = Setting().get_records_allow_to_edit()
forward_records_allow_to_edit = Setting(
).get_forward_records_allow_to_edit()
reverse_records_allow_to_edit = Setting(
).get_reverse_records_allow_to_edit()
ttl_options = Setting().get_ttl_options()
records = []
# Render the "records" to display in HTML datatable
#
# BUG: If we have multiple records with the same name
# and each record has its own comment, the display of
# [record-comment] may not consistent because PDNS API
# returns the rrsets (records, comments) has different
# order than its database records.
# TODO:
# - Find a way to make it consistent, or
# - Only allow one comment for that case
if StrictVersion(Setting().get('pdns_version')) >= StrictVersion('4.0.0'):
for r in rrsets:
if r['type'] in records_allow_to_edit:
r_name = r['name'].rstrip('.')
# If it is reverse zone and pretty_ipv6_ptr setting
# is enabled, we reformat the name for ipv6 records.
if Setting().get('pretty_ipv6_ptr') and r[
'type'] == 'PTR' and 'ip6.arpa' in r_name and '*' not in r_name:
r_name = dns.reversename.to_address(
dns.name.from_text(r_name))
# Create the list of records in format that
# PDA jinja2 template can understand.
index = 0
for record in r['records']:
if (len(r['comments']) > index):
c = r['comments'][index]['content']
else:
c = ''
record_entry = RecordEntry(
name=r_name,
type=r['type'],
status='Disabled' if record['disabled'] else 'Active',
ttl=r['ttl'],
data=record['content'],
comment=c,
is_allowed_edit=True)
index += 1
records.append(record_entry)
else:
# Unsupported version
abort(500)
if not re.search(r'ip6\.arpa|in-addr\.arpa$', domain_name):
editable_records = forward_records_allow_to_edit
else:
editable_records = reverse_records_allow_to_edit
return render_template('domain.html',
domain=domain,
records=records,
editable_records=editable_records,
quick_edit=quick_edit,
ttl_options=ttl_options,
current_user=current_user)
def changelog(domain_name):
g.user = current_user
login_manager.anonymous_user = Anonymous
domain = Domain.query.filter(Domain.name == domain_name).first()
if not domain:
abort(404)
# Query domain's rrsets from PowerDNS API
rrsets = Record().get_rrsets(domain.name)
current_app.logger.debug("Fetched rrests: \n{}".format(
pretty_json(rrsets)))
# API server might be down, misconfigured
if not rrsets and domain.type != 'Slave':
abort(500)
records_allow_to_edit = Setting().get_records_allow_to_edit()
records = []
# get all changelogs for this domain, in descening order
if current_user.role.name in ['Administrator', 'Operator']:
histories = History.query.filter(
History.domain_id == domain.id).order_by(
History.created_on.desc()).all()
else:
# if the user isn't an administrator or operator,
# allow_user_view_history must be enabled to get here,
# so include history for the domains for the user
histories = db.session.query(History) \
.join(Domain, History.domain_id == Domain.id) \
.outerjoin(DomainUser, Domain.id == DomainUser.domain_id) \
.outerjoin(Account, Domain.account_id == Account.id) \
.outerjoin(AccountUser, Account.id == AccountUser.account_id) \
.order_by(History.created_on.desc()) \
.filter(
db.and_(db.or_(
DomainUser.user_id == current_user.id,
AccountUser.user_id == current_user.id
),
History.domain_id == domain.id
)
).all()
if StrictVersion(Setting().get('pdns_version')) >= StrictVersion('4.0.0'):
for r in rrsets:
if r['type'] in records_allow_to_edit:
r_name = r['name'].rstrip('.')
# If it is reverse zone and pretty_ipv6_ptr setting
# is enabled, we reformat the name for ipv6 records.
if Setting().get('pretty_ipv6_ptr') and r[
'type'] == 'PTR' and 'ip6.arpa' in r_name and '*' not in r_name:
r_name = dns.reversename.to_address(
dns.name.from_text(r_name))
# Create the list of records in format that
# PDA jinja2 template can understand.
index = 0
for record in r['records']:
if (len(r['comments']) > index):
c = r['comments'][index]['content']
else:
c = ''
record_entry = RecordEntry(
name=r_name,
type=r['type'],
status='Disabled' if record['disabled'] else 'Active',
ttl=r['ttl'],
data=record['content'],
comment=c,
is_allowed_edit=True)
index += 1
records.append(record_entry)
else:
# Unsupported version
abort(500)
changes_set = dict()
for i in range(len(histories)):
extract_changelogs_from_a_history_entry(changes_set, histories[i], i)
if i in changes_set and len(
changes_set[i]) == 0: # if empty, then remove the key
changes_set.pop(i)
return render_template('domain_changelog.html',
domain=domain,
allHistoryChanges=changes_set)
eventlet.hubs.use_hub(utils.get_hub())
eventlet.patcher.monkey_patch(all=False, socket=True)
eventlet.debug.hub_exceptions(False)
from swiftclient import get_auth, http_connection
has_insecure = False
try:
from swiftclient import __version__ as client_version
# Prevent a ValueError in StrictVersion with '2.0.3.68.ga99c2ff'
client_version = '.'.join(client_version.split('.')[:3])
except ImportError:
# Pre-PBR we had version, not __version__. Anyhow...
client_version = '1.2'
from distutils.version import StrictVersion
if StrictVersion(client_version) >= StrictVersion('2.0'):
has_insecure = True
config = {}
web_front_end = None
normalized_urls = None
# If no config was read, we will fall back to old school env vars
swift_test_auth_version = None
swift_test_auth = os.environ.get('SWIFT_TEST_AUTH')
swift_test_user = [os.environ.get('SWIFT_TEST_USER'), None, None, '', '', '']
swift_test_key = [os.environ.get('SWIFT_TEST_KEY'), None, None, '', '', '']
swift_test_tenant = ['', '', '', '', '', '']
swift_test_perm = ['', '', '', '', '', '']
swift_test_domain = ['', '', '', '', '', '']
#
# Any use of this code is strictly unauthorized without the written consent
# by Voxmeter A/S. This code is proprietary of Voxmeter A/S.
#
################################################################################
import shutil, datetime, os.path, copy, operator, math, sys
from distutils.version import StrictVersion
from openpyxl import load_workbook
from openpyxl.utils import coordinate_from_string, column_index_from_string, get_column_letter
#from openpyxl.styles import PatternFill, Border, Side, Alignment, Protection, Font
from openpyxl.styles import Font, PatternFill, Border
# Check version
from openpyxl import __version__
test_version = StrictVersion(__version__) < StrictVersion("2.5.0")
if test_version:
print("You need to have openpyxl version 2.5.0. You have %s"%__version__)
sys.exit()
# Set standards
SKIP_THESE = [
'[+] og [-] = signifikant forskel på 95% eller mere',
]
Col_width_max = 177 # 100+50+20+5+2
# Map number to danish month
month_dic = {'1':'januar','2':'februar','3':'marts','4':'april','5':'maj','6':'juni',
'7':'juli','8':'august','9':'september','10':'oktober','11':'november','12':'december'}
def create_app(config='CTFd.config.Config'):
app = CTFdFlask(__name__)
with app.app_context():
app.config.from_object(config)
theme_loader = ThemeLoader(os.path.join(app.root_path, 'themes'),
followlinks=True)
app.jinja_loader = theme_loader
from CTFd.models import db, Teams, Solves, Challenges, Fails, Flags, Tags, Files, Tracking
url = create_database()
# This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in
# This is mostly so we can force MySQL's charset
app.config['SQLALCHEMY_DATABASE_URI'] = str(url)
# Register database
db.init_app(app)
# Register Flask-Migrate
migrations.init_app(app, db)
# Alembic sqlite support is lacking so we should just create_all anyway
if url.drivername.startswith('sqlite'):
db.create_all()
stamp()
else:
# This creates tables instead of db.create_all()
# Allows migrations to happen properly
upgrade()
from CTFd.models import ma
ma.init_app(app)
app.db = db
app.VERSION = __version__
from CTFd.cache import cache
cache.init_app(app)
app.cache = cache
# If you have multiple workers you must have a shared cache
socketio.init_app(app,
async_mode=app.config.get('SOCKETIO_ASYNC_MODE'),
message_queue=app.config.get('CACHE_REDIS_URL'))
if app.config.get('REVERSE_PROXY'):
app.wsgi_app = ProxyFix(app.wsgi_app)
version = utils.get_config('ctf_version')
# Upgrading from an older version of CTFd
if version and (StrictVersion(version) < StrictVersion(__version__)):
if confirm_upgrade():
run_upgrade()
else:
exit()
if not version:
utils.set_config('ctf_version', __version__)
if not utils.get_config('ctf_theme'):
utils.set_config('ctf_theme', 'core')
update_check(force=True)
init_request_processors(app)
init_template_filters(app)
init_template_globals(app)
# Importing here allows tests to use sensible names (e.g. api instead of api_bp)
from CTFd.views import views
from CTFd.teams import teams
from CTFd.users import users
from CTFd.challenges import challenges
from CTFd.scoreboard import scoreboard
from CTFd.auth import auth
from CTFd.admin import admin
from CTFd.api import api
from CTFd.events import events
from CTFd.errors import page_not_found, forbidden, general_error, gateway_error
app.register_blueprint(views)
app.register_blueprint(teams)
app.register_blueprint(users)
app.register_blueprint(challenges)
app.register_blueprint(scoreboard)
app.register_blueprint(auth)
app.register_blueprint(api)
app.register_blueprint(events)
app.register_blueprint(admin)
app.register_error_handler(404, page_not_found)
app.register_error_handler(403, forbidden)
app.register_error_handler(500, general_error)
app.register_error_handler(502, gateway_error)
init_logs(app)
init_plugins(app)
return app
import sys
import tarfile
import tensorflow as tf
import zipfile
from distutils.version import StrictVersion
from collections import defaultdict
from io import StringIO
from matplotlib import pyplot as plt
from PIL import Image
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
from object_detection.utils import ops as utils_ops
if StrictVersion(tf.__version__) < StrictVersion('1.9.0'):
raise ImportError('Please upgrade your TensorFlow installation to v1.9.* or later!')
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as vis_util
MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
MODEL_FILE = MODEL_NAME + '.tar.gz'
DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'
# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb'
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
#
# opener = urllib.request.URLopener()
SECRET_KEY = 'o)04)%_us9ed1l7*cv&5@t(2*r#$^r7o(q^4p@y9@b20_ay_jv'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin', 'django.contrib.auth',
'django.contrib.contenttypes', 'django.contrib.sessions', 'tests.testapp'
]
# Django 1.8 requires that abstract model app is in INSTALLED_APPS
if StrictVersion('1.8') <= StrictVersion(
django.__version__) < StrictVersion('1.9'):
INSTALLED_APPS.append('django_lifecycle')
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'tests.urls'
def __init__(self, v):
print v
if v.endswith('a'):
v += '0'
StrictVersion.__init__(self, v)
def __init__(self, version):
match = re.match("dlib-(\d+).(\d+).*", version)
major = match.group(1)
minor = match.group(2)
StrictVersion.__init__(self, major + "." + minor)
def __init__(self, vstring):
StrictVersion.__init__(self, vstring)
self.prerelease = None
newHTML = html.replace("</td>", string2Inject, 1)
node.text = newHTML
except:
arcpy.AddWarning("No attachment match for ID: {}".format(idVal))
tree.write(docKML)
del tree
del docKML
if __name__ == '__main__':
prodInfo = arcpy.GetInstallInfo()
if prodInfo['ProductName'] == "Desktop":
if StrictVersion(prodInfo['Version']) >= StrictVersion('10.5'):
arcpy.AddWarning("The KML to Layer tool was enhanced to automatically include attachments \
at the 10.5 release, effectively making this tool obsolete.")
elif prodInfo['ProductName'] == "ArcGISPro":
if StrictVersion(prodInfo['Version']) >= StrictVersion('1.4'):
arcpy.AddWarning("The KML to Layer tool was enhanced to automatically include attachments \
at the 1.4 release, effectively making this tool obsolete.")
inputFeatures = arcpy.GetParameterAsText(0)
outputKML = arcpy.GetParameterAsText(1)
outputScale = arcpy.GetParameterAsText(2)
clamped = arcpy.GetParameterAsText(3)
uniqueID = arcpy.GetParameterAsText(4)
height = arcpy.GetParameterAsText(5)
width = arcpy.GetParameterAsText(6)
from mgr_util import get_default_addr
from rbd import RBD
# Defaults for the Prometheus HTTP server. Can also set in config-key
# see https://github.com/prometheus/prometheus/wiki/Default-port-allocations
# for Prometheus exporter port registry
DEFAULT_PORT = 9283
# When the CherryPy server in 3.2.2 (and later) starts it attempts to verify
# that the ports its listening on are in fact bound. When using the any address
# "::" it tries both ipv4 and ipv6, and in some environments (e.g. kubernetes)
# ipv6 isn't yet configured / supported and CherryPy throws an uncaught
# exception.
if cherrypy is not None:
v = StrictVersion(cherrypy.__version__)
# the issue was fixed in 3.2.3. it's present in 3.2.2 (current version on
# centos:7) and back to at least 3.0.0.
if StrictVersion("3.1.2") <= v < StrictVersion("3.2.3"):
# https://github.com/cherrypy/cherrypy/issues/1100
from cherrypy.process import servers
servers.wait_for_occupied_port = lambda host, port: None
# cherrypy likes to sys.exit on error. don't let it take us down too!
def os_exit_noop(*args, **kwargs):
pass
os._exit = os_exit_noop
def is_osx_10_10_or_greater(cls):
import platform
release = platform.mac_ver()[0]
return release and StrictVersion(release) >= StrictVersion('10.10')
class TestCompiler(TestCase):
def setUp(self):
self.proto_dir = TemporaryDirectory()
self.out_dir = TemporaryDirectory()
def add_proto_file(self, content, name='test.proto'):
file_name = path.join(self.proto_dir.name, name)
dir_name = path.dirname(file_name)
if not path.exists(dir_name):
makedirs(dir_name, exist_ok=True)
with open(file_name, 'w') as proto_file:
proto_file.write(content)
def run_compiler(self, files='test.proto'):
if not isinstance(files, list):
files = [files]
files = map(lambda name: path.join(self.proto_dir.name, name), files)
new_env = environ.copy()
new_env['PATH'] += ':' + path.normpath(
path.join(path.dirname(__file__), '..', 'bin'))
if 'PYTHONPATH' in new_env:
new_env['PYTHONPATH'] += ':' + path.normpath(
path.join(path.dirname(__file__), '..'))
else:
new_env['PYTHONPATH'] = path.normpath(
path.join(path.dirname(__file__), '..'))
args = [
'protoc',
'--python3_out=' + self.out_dir.name,
'--proto_path=' + self.proto_dir.name,
]
args.extend(files)
proc = Popen(args, stderr=PIPE, env=new_env)
proc.wait()
if proc.returncode:
value = proc.stderr.readline()
while value:
print(value)
value = proc.stderr.readline()
raise ValueError
def return_module(self, name='test'):
file_name = path.join(self.out_dir.name, name + '.py')
sys_path.append(self.out_dir.name)
loader = SourceFileLoader(self._testMethodName, file_name)
module = loader.load_module(self._testMethodName)
sys_path.remove(self.out_dir.name)
return module
def test_simple_fields(self):
msg_code = '''
message TestMsg {
optional bool a = 1;
optional string b = 2;
}'''
self.add_proto_file(msg_code)
self.run_compiler()
msgs = self.return_module()
msg = msgs.TestMsg()
msg.parse_from_bytes(b'\x08\x01\x12\x07\x74\x65\x73\x74\x69\x6E\x67')
self.assertEqual(msg.a, True)
self.assertEqual(msg.b, 'testing')
def test_embedded_messages(self):
msg_code = '''
message TestA {
message Foo {
optional int32 a = 1;
}
optional Foo b = 3;
}
message Bar {
optional int32 a = 1;
}
message TestB {
optional Bar b = 3;
}
message TestC {
optional TestA.Foo b = 3;
}'''
self.add_proto_file(msg_code)
self.run_compiler()
msgs = self.return_module()
self.assertEqual(type(msgs.TestA.Foo), type)
msgA = msgs.TestA()
msgA.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msgA.b.a, 150)
msgB = msgs.TestB()
msgB.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msgB.b.a, 150)
msgC = msgs.TestC()
msgC.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msgC.b.a, 150)
def test_enums(self):
msg_code = '''
message TestA {
enum Foo {
Opt1 = 1;
Opt2 = 2;
Opt3 = 3;
}
optional Foo a = 1;
}
enum Bar {
Opt1 = 1;
Opt2 = 2;
}
message TestB {
optional Bar a = 1;
}'''
self.add_proto_file(msg_code)
self.run_compiler()
msgs = self.return_module()
self.assertTrue(isinstance(msgs.TestA.Foo, type))
self.assertTrue(issubclass(msgs.TestA.Foo, Enum))
msg_a = msgs.TestA()
msg_a.parse_from_bytes(b'\x08\x02')
self.assertEqual(msg_a.a, msgs.TestA.Foo.Opt2)
msg_b = msgs.TestB()
msg_b.parse_from_bytes(b'\x08\x02')
self.assertEqual(msg_b.a, msgs.Bar.Opt2)
def test_default_option(self):
msg_code = '''
enum Foo {
Opt1 = 1;
Opt2 = 2;
}
message TestA {
optional bool a = 1 [default = true];
optional string b = 2 [default = 'asd'];
optional bytes c = 3 [default = 'q\x08e'];
optional Foo d = 4 [default = Opt2];
optional int32 e = 5 [default = 1];
}'''
self.add_proto_file(msg_code)
self.run_compiler()
msgs = self.return_module()
msg_a = msgs.TestA()
self.assertEqual(msg_a.a, True)
self.assertEqual(msg_a.b, 'asd')
self.assertEqual(msg_a.c, b'q\x08e')
self.assertEqual(msg_a.d, msgs.Foo.Opt2)
self.assertEqual(msg_a.e, 1)
def test_message_without_fields(self):
msg_code = '''
message Foo {
}'''
self.add_proto_file(msg_code)
self.run_compiler()
self.assertEqual(type(self.return_module()), ModuleType)
@skipIf(protoc_version < StrictVersion("2.5.0"),
"allow_alias requires protoc >= 2.5.0")
def test_enum_alias(self):
msg_code = '''
enum EnumAllowingAlias {
option allow_alias = true;
UNKNOWN = 0;
STARTED = 1;
RUNNING = 1;
}'''
# Compile without warnings
self.add_proto_file(msg_code)
self.run_compiler()
self.assertEqual(type(self.return_module()), ModuleType)
msg_code = '''
enum EnumForciblyNotAllowingAlias {
option allow_alias = false;
UNKNOWN = 0;
STARTED = 1;
RUNNING = 1;
}'''
# Protoc will crash with non-zero return code
self.add_proto_file(msg_code)
self.assertRaises(ValueError, self.run_compiler)
def test_extend_message(self):
msg_code = '''
message Foo {
message Bar {
extensions 100 to 199;
}
extend Foo {
optional int32 test = 104;
}
extensions 100 to 199;
}
extend Foo {
optional int32 foo = 101;
}
extend Foo.Bar {
optional int32 bar = 102;
}'''
self.add_proto_file(msg_code)
self.run_compiler()
msgs = self.return_module()
msg_foo = msgs.Foo()
msg_foo.parse_from_bytes(b'\xa8\x06{\xc0\x06\x95\x06')
self.assertTrue(hasattr(msg_foo, 'foo'))
self.assertEqual(msg_foo.foo, 123)
self.assertTrue(hasattr(msg_foo, 'test'))
self.assertEqual(msg_foo.test, 789)
msg_bar = msgs.Foo.Bar()
msg_bar.parse_from_bytes(b'\xb0\x06\xc8\x03')
self.assertTrue(hasattr(msg_bar, 'bar'))
self.assertEqual(msg_bar.bar, 456)
def test_import(self):
foo_code = '''
message Foo {
optional int32 a = 1;
}'''
bar_code = '''
import "foo.proto";
message Bar {
optional Foo b = 3;
}'''
self.add_proto_file(foo_code, 'foo.proto')
self.add_proto_file(bar_code, 'bar.proto')
self.run_compiler('bar.proto')
bar = self.return_module('bar')
msg = bar.Bar()
self.assertEqual(type(msg.b), bar.Foo)
msg.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msg.b.a, 150)
def test_import_from_subdirectory(self):
foo_code = '''
message Foo {
optional int32 a = 1;
}'''
bar_code = '''
import "dir/foo.proto";
message Bar {
optional Foo b = 3;
}'''
self.add_proto_file(foo_code, 'dir/foo.proto')
self.add_proto_file(bar_code, 'bar.proto')
self.run_compiler('bar.proto')
bar = self.return_module('bar')
msg = bar.Bar()
self.assertEqual(type(msg.b), bar.Foo)
msg.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msg.b.a, 150)
@skipIf(protoc_version < StrictVersion("2.5.0"),
"public import requires protoc >= 2.5.0")
def test_public_import(self):
foo_code = '''
message Foo {
optional int32 a = 1;
}'''
bar_code = '''
import public "foo.proto";
'''
final_code = '''
import "bar.proto";
message Bar {
optional Foo b = 3;
}'''
self.add_proto_file(foo_code, 'foo.proto')
self.add_proto_file(bar_code, 'bar.proto')
self.add_proto_file(final_code, 'final.proto')
self.run_compiler('final.proto')
final = self.return_module('final')
msg = final.Bar()
self.assertEqual(type(msg.b), final.Foo)
msg.parse_from_bytes(b'\x1a\x03\x08\x96\x01')
self.assertEqual(msg.b.a, 150)
def test_package(self):
package_code = '''
package tutorial;
enum PhoneType {
MOBILE = 0;
HOME = 1;
WORK = 2;
}
message Foo {
optional PhoneType a = 1;
}'''
self.add_proto_file(package_code)
self.run_compiler()
self.assertEqual(type(self.return_module()), ModuleType)
def test_packages_import(self):
foo_code = '''
package foo;
message Foo {
optional int32 a = 1;
}'''
bar_code = '''
package test1;
import "foo.proto";
message Bar {
optional foo.Foo b = 3;
}'''
self.add_proto_file(foo_code, 'foo.proto')
self.add_proto_file(bar_code, 'bar.proto')
self.run_compiler('foo.proto')
from distutils.version import StrictVersion
from enum import Enum
from importlib.machinery import SourceFileLoader
from os import environ, makedirs, path
from subprocess import check_output, Popen, PIPE
from sys import path as sys_path
from tempfile import TemporaryDirectory
from types import ModuleType
from unittest import TestCase, skipIf
protoc_version = StrictVersion(
check_output("protoc --version || true", shell=True)[10:-1].decode())
class TestCompiler(TestCase):
def setUp(self):
self.proto_dir = TemporaryDirectory()
self.out_dir = TemporaryDirectory()
def add_proto_file(self, content, name='test.proto'):
file_name = path.join(self.proto_dir.name, name)
dir_name = path.dirname(file_name)
if not path.exists(dir_name):
makedirs(dir_name, exist_ok=True)
with open(file_name, 'w') as proto_file:
proto_file.write(content)
def run_compiler(self, files='test.proto'):
if not isinstance(files, list):
ensure_in_syspath('../../../')
import salt.ext.six as six
try:
import zmq
from zmq.eventloop.ioloop import ZMQIOLoop
HAS_ZMQ_IOLOOP = True
except ImportError:
HAS_ZMQ_IOLOOP = False
@skipIf(HAS_ZMQ_IOLOOP is False,
'PyZMQ version must be >= 14.0.1 to run these tests.')
@skipIf(
StrictVersion(zmq.__version__) < StrictVersion('14.0.1'),
'PyZMQ must be >= 14.0.1 to run these tests.')
class TestSaltAPIHandler(SaltnadoTestCase):
def get_app(self):
urls = [('/', saltnado.SaltAPIHandler)]
application = self.build_tornado_app(urls)
application.event_listener = saltnado.EventListener({}, self.opts)
return application
def test_root(self):
'''
Test the root path which returns the list of clients we support
'''
response = self.fetch(
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
zone_type=dict(required=False, choice=['primary', 'secondary']),
email=dict(required=False, default=None),
description=dict(required=False, default=None),
ttl=dict(required=False, default=None, type='int'),
masters=dict(required=False, default=None, type='list'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
if StrictVersion(shade.__version__) < StrictVersion('1.8.0'):
module.fail_json(msg="To utilize this module, the installed version of"
"the shade library MUST be >=1.8.0")
name = module.params.get('name')
state = module.params.get('state')
try:
cloud = shade.openstack_cloud(**module.params)
zone = cloud.get_zone(name)
if state == 'present':
zone_type = module.params.get('zone_type')
email = module.params.get('email')
description = module.params.get('description')
ttl = module.params.get('ttl')
masters = module.params.get('masters')
if module.check_mode:
module.exit_json(changed=_system_state_change(
state, email, description, ttl, masters, zone))
if zone is None:
zone = cloud.create_zone(name=name,
zone_type=zone_type,
email=email,
description=description,
ttl=ttl,
masters=masters)
changed = True
else:
if masters is None:
masters = []
pre_update_zone = zone
changed = _system_state_change(state, email, description, ttl,
masters, pre_update_zone)
if changed:
zone = cloud.update_zone(name,
email=email,
description=description,
ttl=ttl,
masters=masters)
module.exit_json(changed=changed, zone=zone)
elif state == 'absent':
if module.check_mode:
module.exit_json(changed=_system_state_change(
state, None, None, None, None, zone))
if zone is None:
changed = False
else:
cloud.delete_zone(name)
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
import numpy as np
import pandas as pd
import json_tricks
from distutils.version import StrictVersion
import psychopy
from psychopy import logging
from psychopy.tools.filetools import (openOutputFile, genDelimiter,
genFilenameFromDelimiter)
from psychopy.tools.fileerrortools import handleFileCollision
from psychopy.tools.arraytools import extendArr
from .utils import _getExcelCellName
try:
import openpyxl
if StrictVersion(openpyxl.__version__) >= StrictVersion('2.4.0'):
# openpyxl moved get_column_letter to utils.cell
from openpyxl.utils.cell import get_column_letter
else:
from openpyxl.cell import get_column_letter
from openpyxl.reader.excel import load_workbook, Workbook
haveOpenpyxl = True
except ImportError:
haveOpenpyxl = False
_experiments = weakref.WeakValueDictionary()
class _ComparisonMixin(object):
def __eq__(self, other):
# NoneType and booleans, for example, don't have a .__dict__ attribute.
missing_template = '''
*****
***** package {0} not found
***** Please install it (pip install {0} or conda install {0})
***** in order to use {1}
*****
'''
valueerror_template = '''
*****
***** package {0} version not understood
***** Please make sure the installed version ({1})
***** is compatible with the minimum required version ({2})
***** in order to use {3}
*****
'''
# now test the versions of extras
for extra, (module_name, min_version) in extras.items():
try:
module = import_module(module_name)
if StrictVersion(module.__version__) < StrictVersion(min_version):
print(version_template.format(module_name, min_version, extra))
except ImportError:
print(missing_template.format(module_name, extra))
except ValueError:
print(
valueerror_template.format(module_name, module.__version__,
min_version, extra))
import sys
from hpccm.common import cpu_arch
from hpccm.common import container_type
from hpccm.common import linux_distro
# Global variables
g_cpu_arch = cpu_arch.X86_64 # CPU architecture
if platform.machine() == 'aarch64':
g_cpu_arch = cpu_arch.AARCH64
elif platform.machine() == 'ppc64le':
g_cpu_arch = cpu_arch.PPC64LE
g_cpu_target = None # CPU optimization target
g_ctype = container_type.DOCKER # Container type
g_linux_distro = linux_distro.UBUNTU # Linux distribution
g_linux_version = StrictVersion('16.04') # Linux distribution version
g_singularity_version = StrictVersion('2.6') # Singularity version
g_wd = '/var/tmp' # Working directory
def get_cpu_architecture():
"""Return the architecture string for the currently configured CPU
architecture, e.g., `aarch64`, `ppc64le`, or `x86_64`.
"""
this = sys.modules[__name__]
if this.g_cpu_arch == cpu_arch.AARCH64:
return 'aarch64'
elif this.g_cpu_arch == cpu_arch.PPC64LE:
if this.g_linux_distro == linux_distro.UBUNTU:
def set_linux_distro(distro):
"""Set the Linux distribution and version
In most cases, the `baseimage` primitive should be relied upon to
set the Linux distribution. Only use this function if you really
know what you are doing.
# Arguments
distro (string): Valid values are `centos7`, `centos8`, `rhel7`,
`rhel8`, `rockylinux8`, `ubuntu16`, `ubuntu18`, and `ubuntu20`.
`ubuntu` is an alias for `ubuntu16`, `centos` is an alias for
`centos7`, and `rhel` is an alias for `rhel7`.
"""
this = sys.modules[__name__]
if distro == 'centos':
this.g_linux_distro = linux_distro.CENTOS
this.g_linux_version = StrictVersion('7.0')
elif distro == 'centos7':
this.g_linux_distro = linux_distro.CENTOS
this.g_linux_version = StrictVersion('7.0')
elif distro == 'centos8':
this.g_linux_distro = linux_distro.CENTOS
this.g_linux_version = StrictVersion('8.0')
elif distro == 'rhel':
this.g_linux_distro = linux_distro.RHEL
this.g_linux_version = StrictVersion('7.0')
elif distro == 'rhel7':
this.g_linux_distro = linux_distro.RHEL
this.g_linux_version = StrictVersion('7.0')
elif distro == 'rhel8':
this.g_linux_distro = linux_distro.RHEL
this.g_linux_version = StrictVersion('8.0')
elif distro == 'rockylinux8':
this.g_linux_distro = linux_distro.ROCKYLINUX
this.g_linux_version = StrictVersion('8.0')
elif distro == 'ubuntu':
this.g_linux_distro = linux_distro.UBUNTU
this.g_linux_version = StrictVersion('16.04')
elif distro == 'ubuntu16':
this.g_linux_distro = linux_distro.UBUNTU
this.g_linux_version = StrictVersion('16.04')
elif distro == 'ubuntu18':
this.g_linux_distro = linux_distro.UBUNTU
this.g_linux_version = StrictVersion('18.04')
elif distro == 'ubuntu20':
this.g_linux_distro = linux_distro.UBUNTU
this.g_linux_version = StrictVersion('20.04')
else:
logging.warning(
'Unable to determine the Linux distribution, defaulting to Ubuntu')
this.g_linux_distro = linux_distro.UBUNTU
this.g_linux_version = StrictVersion('16.04')
def main(top_block_cls=top_block, options=None):
from distutils.version import StrictVersion
if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"):
style = gr.prefs().get_string('qtgui', 'style', 'raster')
Qt.QApplication.setGraphicsSystem(style)
qapp = Qt.QApplication(sys.argv)
######## ACTUALLY WHERE STUFF HAPPENS #######
tb = top_block_cls()
tb.start()
tb.show()
print('Receiving ...')
global darksky
global darksky_exists
def snapshot(
int_time): #straight snapshot over a certain integration time.
tb.set_integration_time(int_time)
# print 'Integration time set to '+str(int_time)+ ' seconds.'
print 'Snapshot ' + str(int_time) + ' sec'
vec = tb.get_variable_function_probe() #old vector
pointa = vec[0]
pointb = vec[-1]
tb.toggle_copy(True) #start copying
while vec[0] == pointa and vec[-1] == pointb:
pytime.sleep(1)
vec = tb.get_variable_function_probe()
tb.toggle_copy(False) #stop copying
return np.array(vec)
def dark_sky_calib(int_time): #for use when pointing at the dark sky
global darksky
darksky = snapshot(int_time)
global darksky_exists
darksky_exists = True
return
def observe(int_time): #dark sky calbrated snapshot
vec = snapshot(int_time)
wait(int_time)
global darksky_exists
if darksky_exists:
calib = vec - darksky
return calib
else:
print('Warning: No dark sky calibration has been performed.')
return vec
def wait(sec):
pytime.sleep(sec)
return
def graphing(int_time, iter=float('inf')):
plt.ion()
plt.figure()
vec = tb.get_variable_function_probe() #vector
n = len(vec)
x = np.linspace(flo, fhi, n)
i = 0
while (i < iter):
plt.pause(int_time)
y = observe(int_time)
plt.clf()
plt.xlabel('Frequency (MHz)')
plt.ylabel('Scaled power')
plt.axvline(x=1420.406, color='black', ls='--')
plt.ticklabel_format(useOffset=False)
plt.plot(x, y)
plt.draw()
i += 1
return ()
def track(N):
client.track(N)
# License for the specific language governing permissions and limitations
# under the License.
from types import ModuleType
from distutils.version import StrictVersion
from neutron.plugins.ml2.drivers import type_tunnel
from neutron import version
# Some constants and verifier functions have been deprecated but are still
# used by earlier releases of neutron. In order to maintain
# backwards-compatibility with stable/mitaka this will act as a translator
# that passes constants and functions according to version number.
NEUTRON_VERSION = StrictVersion(str(version.version_info))
NEUTRON_NEWTON_VERSION = StrictVersion('9.0.0')
NEUTRON_OCATA_VERSION = StrictVersion('10.0.0')
n_c = __import__('neutron.common.constants', fromlist=['common.constants'])
constants = __import__('neutron_lib.constants', fromlist=['constants'])
if NEUTRON_VERSION >= NEUTRON_NEWTON_VERSION:
from neutron.conf import common as base_config
from neutron_lib.api import validators
is_attr_set = validators.is_attr_set
validators = validators.validators
n_c_attr_names = getattr(n_c, "_mg__my_globals", None)
else:
from neutron.api.v2 import attributes
from neutron.common import config as base_config
files.append('build/util/LASTCHANGE.blink')
print 'copying files to ' + third_party_chromium
for i in xrange(len(files)):
printProgress(i+1, len(files))
f = files[i]
if not isInChromiumBlacklist(f) and not isInGitBlacklist(f):
copyFile(f, os.path.join(third_party_chromium, f))
print("")
commandNotFound = subprocess.call(['which', 'dos2unix'])
if not commandNotFound:
dos2unixVersion , err = subprocess.Popen(['dos2unix', '-V', '| true'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
if not dos2unixVersion:
raise Exception("You need dos2unix version 6.0.6 minimum.")
dos2unixVersion = StrictVersion(dos2unixVersion.splitlines()[0].split()[1])
if commandNotFound or dos2unixVersion < StrictVersion('6.0.6'):
raise Exception("You need dos2unix version 6.0.6 minimum.")
os.chdir(third_party)
ignore_case_setting = subprocess.Popen(['git', 'config', '--get', 'core.ignorecase'], stdout=subprocess.PIPE).communicate()[0]
if 'true' in ignore_case_setting:
raise Exception("Your 3rdparty repository is configured to ignore case. "
"A snapshot created with these settings would cause problems on case sensitive file systems.")
clearDirectory(third_party)
exportNinja()
exportChromium()
RedisError,
ConnectionError,
TimeoutError,
BusyLoadingError,
ResponseError,
InvalidResponse,
AuthenticationError,
NoScriptError,
ExecAbortError,
ReadOnlyError
)
from WebModel.utils.redis.utils import HIREDIS_AVAILABLE
if HIREDIS_AVAILABLE:
import hiredis
hiredis_version = StrictVersion(hiredis.__version__)
HIREDIS_SUPPORTS_CALLABLE_ERRORS = \
hiredis_version >= StrictVersion('0.1.3')
HIREDIS_SUPPORTS_BYTE_BUFFER = \
hiredis_version >= StrictVersion('0.1.4')
if not HIREDIS_SUPPORTS_BYTE_BUFFER:
msg = ("redis-py works best with hiredis >= 0.1.4. You're running "
"hiredis %s. Please consider upgrading." % hiredis.__version__)
warnings.warn(msg)
HIREDIS_USE_BYTE_BUFFER = True
# only use byte buffer if hiredis supports it and the Python version
# is >= 2.7
if not HIREDIS_SUPPORTS_BYTE_BUFFER or (
sys.version_info[0] == 2 and sys.version_info[1] < 7):
