filename
stringlengths
13
19
text
stringlengths
134
1.04M
the-stack_0_3321
from setuptools import find_packages from setuptools import setup package_name = 'ament_cppcheck' setup( name=package_name, version='0.8.0', packages=find_packages(exclude=['test']), data_files=[ ('share/' + package_name, ['package.xml']), ('share/ament_index/resource_index/packages', ['resource/' + package_name]), ], install_requires=['setuptools'], zip_safe=True, author='Dirk Thomas', author_email='[email protected]', maintainer='Dirk Thomas', maintainer_email='[email protected]', url='https://github.com/ament/ament_lint', download_url='https://github.com/ament/ament_lint/releases', keywords=['ROS'], classifiers=[ 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Programming Language :: Python', 'Topic :: Software Development', ], description='Static code analysis on C/C++ code using Cppcheck.', long_description="""\ The ability to perform static code analysis on C/C++ code using Cppcheck and generate xUnit test result files.""", license='Apache License, Version 2.0', tests_require=['pytest'], entry_points={ 'console_scripts': [ 'ament_cppcheck = ament_cppcheck.main:main', ], }, )
the-stack_0_3322
#!/usr/bin/env python3 # Copyright (c) 2010 ArtForz -- public domain half-a-node # Copyright (c) 2012 Jeff Garzik # Copyright (c) 2010-2016 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or https://www.opensource.org/licenses/mit-license.php . # # mininode.py - Bitcoin P2P network half-a-node # # This python code was modified from ArtForz' public domain half-a-node, as # found in the mini-node branch of https://github.com/jgarzik/pynode. # # NodeConn: an object which manages p2p connectivity to a bitcoin node # NodeConnCB: a base class that describes the interface for receiving # callbacks with network messages from a NodeConn # CBlock, CTransaction, CBlockHeader, CTxIn, CTxOut, etc....: # data structures that should map to corresponding structures in # bitcoin/primitives # msg_block, msg_tx, msg_headers, etc.: # data structures that represent network messages # ser_*, deser_*: functions that handle serialization/deserialization import struct import socket import asyncore import time import sys import random from binascii import hexlify from io import BytesIO import hashlib from threading import RLock from threading import Thread import logging import copy from pyblake2 import blake2b try: import yescrypt except ImportError as e: exit("Please run 'sudo pip install https://github.com/wo01/yescrypt_python/archive/master.zip'") BIP0031_VERSION = 60000 SPROUT_PROTO_VERSION = 170002 # past bip-31 for ping/pong OVERWINTER_PROTO_VERSION = 170003 SAPLING_PROTO_VERSION = 170006 BLOSSOM_PROTO_VERSION = 170008 MY_SUBVERSION = b"/python-mininode-tester:0.0.3/" SPROUT_VERSION_GROUP_ID = 0x00000000 OVERWINTER_VERSION_GROUP_ID = 0x02E7D970 SAPLING_VERSION_GROUP_ID = 0x9023E50A # No transaction format change in Blossom. MAX_INV_SZ = 50000 COIN = 100000000 # 1 zec in zatoshis # Keep our own socket map for asyncore, so that we can track disconnects # ourselves (to workaround an issue with closing an asyncore socket when # using select) mininode_socket_map = dict() # One lock for synchronizing all data access between the networking thread (see # NetworkThread below) and the thread running the test logic. For simplicity, # NodeConn acquires this lock whenever delivering a message to to a NodeConnCB, # and whenever adding anything to the send buffer (in send_message()). This # lock should be acquired in the thread running the test logic to synchronize # access to any data shared with the NodeConnCB or NodeConn. mininode_lock = RLock() # Serialization/deserialization tools def bfh(x): if sys.version_info[0] >= 3: return bytes.fromhex(x) else: return x.decode("hex") def rev_hex(s): return bh2u(bfh(s)[::-1]) def bh2u(x): return binascii.hexlify(x).decode('ascii') def sha256(s): return hashlib.new('sha256', s).digest() def hash256(s): return sha256(sha256(s)) def nuparams(branch_id, height): return '-nuparams=%x:%d' % (branch_id, height) def fundingstream(idx, start_height, end_height, addrs): return '-fundingstream=%d:%d:%d:%s' % (idx, start_height, end_height, ",".join(addrs)) def ser_compactsize(n): if n < 253: return struct.pack("B", n) elif n < 0x10000: return struct.pack("<BH", 253, n) elif n < 0x100000000: return struct.pack("<BI", 254, n) return struct.pack("<BQ", 255, n) def deser_string(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] return f.read(nit) def ser_string(s): if len(s) < 253: return struct.pack("B", len(s)) + s elif len(s) < 0x10000: return struct.pack("<BH", 253, len(s)) + s elif len(s) < 0x100000000: return struct.pack("<BI", 254, len(s)) + s return struct.pack("<BQ", 255, len(s)) + s def deser_uint256(f): r = 0 for i in range(8): t = struct.unpack("<I", f.read(4))[0] r += t << (i * 32) return r def ser_uint256(u): rs = b"" for i in range(8): rs += struct.pack("<I", u & 0xFFFFFFFF) u >>= 32 return rs def uint256_from_str(s): r = 0 t = struct.unpack("<IIIIIIII", s[:32]) for i in range(8): r += t[i] << (i * 32) return r def uint256_from_compact(c): nbytes = (c >> 24) & 0xFF v = (c & 0xFFFFFF) << (8 * (nbytes - 3)) return v def block_work_from_compact(c): target = uint256_from_compact(c) return 2**256 // (target + 1) def deser_vector(f, c): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] r = [] for i in range(nit): t = c() t.deserialize(f) r.append(t) return r def ser_vector(l): r = b"" if len(l) < 253: r = struct.pack("B", len(l)) elif len(l) < 0x10000: r = struct.pack("<BH", 253, len(l)) elif len(l) < 0x100000000: r = struct.pack("<BI", 254, len(l)) else: r = struct.pack("<BQ", 255, len(l)) for i in l: r += i.serialize() return r def deser_uint256_vector(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] r = [] for i in range(nit): t = deser_uint256(f) r.append(t) return r def ser_uint256_vector(l): r = b"" if len(l) < 253: r = struct.pack("B", len(l)) elif len(l) < 0x10000: r = struct.pack("<BH", 253, len(l)) elif len(l) < 0x100000000: r = struct.pack("<BI", 254, len(l)) else: r = struct.pack("<BQ", 255, len(l)) for i in l: r += ser_uint256(i) return r def deser_string_vector(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] r = [] for i in range(nit): t = deser_string(f) r.append(t) return r def ser_string_vector(l): r = b"" if len(l) < 253: r = struct.pack("B", len(l)) elif len(l) < 0x10000: r = struct.pack("<BH", 253, len(l)) elif len(l) < 0x100000000: r = struct.pack("<BI", 254, len(l)) else: r = struct.pack("<BQ", 255, len(l)) for sv in l: r += ser_string(sv) return r def deser_int_vector(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] r = [] for i in range(nit): t = struct.unpack("<i", f.read(4))[0] r.append(t) return r def ser_int_vector(l): r = b"" if len(l) < 253: r = struct.pack("B", len(l)) elif len(l) < 0x10000: r = struct.pack("<BH", 253, len(l)) elif len(l) < 0x100000000: r = struct.pack("<BI", 254, len(l)) else: r = struct.pack("<BQ", 255, len(l)) for i in l: r += struct.pack("<i", i) return r def deser_char_vector(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: nit = struct.unpack("<H", f.read(2))[0] elif nit == 254: nit = struct.unpack("<I", f.read(4))[0] elif nit == 255: nit = struct.unpack("<Q", f.read(8))[0] r = [] for i in range(nit): t = struct.unpack("<B", f.read(1))[0] r.append(t) return r def ser_char_vector(l): r = b"" if len(l) < 253: r = struct.pack("B", len(l)) elif len(l) < 0x10000: r = struct.pack("<BH", 253, len(l)) elif len(l) < 0x100000000: r = struct.pack("<BI", 254, len(l)) else: r = struct.pack("<BQ", 255, len(l)) for i in l: r += struct.pack("B", i) return r # Objects that map to bitcoind objects, which can be serialized/deserialized class CAddress(object): def __init__(self): self.nServices = 1 self.pchReserved = b"\x00" * 10 + b"\xff" * 2 self.ip = "0.0.0.0" self.port = 0 def deserialize(self, f): self.nServices = struct.unpack("<Q", f.read(8))[0] self.pchReserved = f.read(12) self.ip = socket.inet_ntoa(f.read(4)) self.port = struct.unpack(">H", f.read(2))[0] def serialize(self): r = b"" r += struct.pack("<Q", self.nServices) r += self.pchReserved r += socket.inet_aton(self.ip) r += struct.pack(">H", self.port) return r def __repr__(self): return "CAddress(nServices=%i ip=%s port=%i)" % (self.nServices, self.ip, self.port) class CInv(object): typemap = { 0: b"Error", 1: b"TX", 2: b"Block"} def __init__(self, t=0, h=0): self.type = t self.hash = h def deserialize(self, f): self.type = struct.unpack("<i", f.read(4))[0] self.hash = deser_uint256(f) def serialize(self): r = b"" r += struct.pack("<i", self.type) r += ser_uint256(self.hash) return r def __repr__(self): return "CInv(type=%s hash=%064x)" \ % (self.typemap[self.type], self.hash) class CBlockLocator(object): def __init__(self): self.nVersion = SPROUT_PROTO_VERSION self.vHave = [] def deserialize(self, f): self.nVersion = struct.unpack("<i", f.read(4))[0] self.vHave = deser_uint256_vector(f) def serialize(self): r = b"" r += struct.pack("<i", self.nVersion) r += ser_uint256_vector(self.vHave) return r def __repr__(self): return "CBlockLocator(nVersion=%i vHave=%r)" \ % (self.nVersion, repr(self.vHave)) class SpendDescription(object): def __init__(self): self.cv = None self.anchor = None self.nullifier = None self.rk = None self.zkproof = None self.spendAuthSig = None def deserialize(self, f): self.cv = deser_uint256(f) self.anchor = deser_uint256(f) self.nullifier = deser_uint256(f) self.rk = deser_uint256(f) self.zkproof = f.read(192) self.spendAuthSig = f.read(64) def serialize(self): r = b"" r += ser_uint256(self.cv) r += ser_uint256(self.anchor) r += ser_uint256(self.nullifier) r += ser_uint256(self.rk) r += self.zkproof r += self.spendAuthSig return r def __repr__(self): return "SpendDescription(cv=%064x, anchor=%064x, nullifier=%064x, rk=%064x, zkproof=%064x, spendAuthSig=%064x)" \ % (self.cv, self.anchor, self.nullifier, self.rk, self.zkproof, self.spendauthsig) class OutputDescription(object): def __init__(self): self.cv = None self.cmu = None self.ephemeralKey = None self.encCiphertext = None self.outCiphertext = None self.zkproof = None def deserialize(self, f): self.cv = deser_uint256(f) self.cmu = deser_uint256(f) self.ephemeralKey = deser_uint256(f) self.encCiphertext = f.read(580) self.outCiphertext = f.read(80) self.zkproof = f.read(192) def serialize(self): r = b"" r += ser_uint256(self.cv) r += ser_uint256(self.cmu) r += ser_uint256(self.ephemeralKey) r += self.encCiphertext r += self.outCiphertext r += self.zkproof return r def __repr__(self): return "OutputDescription(cv=%064x, cmu=%064x, ephemeralKey=%064x, encCiphertext=%064x, outCiphertext=%064x, zkproof=%064x)" \ % (self.cv, self.cmu, self.ephemeralKey, self.encCiphertext, self.outCiphertext, self.zkproof) G1_PREFIX_MASK = 0x02 G2_PREFIX_MASK = 0x0a class ZCProof(object): def __init__(self): self.g_A = None self.g_A_prime = None self.g_B = None self.g_B_prime = None self.g_C = None self.g_C_prime = None self.g_K = None self.g_H = None def deserialize(self, f): def deser_g1(self, f): leadingByte = struct.unpack("<B", f.read(1))[0] return { 'y_lsb': leadingByte & 1, 'x': f.read(32), } def deser_g2(self, f): leadingByte = struct.unpack("<B", f.read(1))[0] return { 'y_gt': leadingByte & 1, 'x': f.read(64), } self.g_A = deser_g1(f) self.g_A_prime = deser_g1(f) self.g_B = deser_g2(f) self.g_B_prime = deser_g1(f) self.g_C = deser_g1(f) self.g_C_prime = deser_g1(f) self.g_K = deser_g1(f) self.g_H = deser_g1(f) def serialize(self): def ser_g1(self, p): return chr(G1_PREFIX_MASK | p['y_lsb']) + p['x'] def ser_g2(self, p): return chr(G2_PREFIX_MASK | p['y_gt']) + p['x'] r = b"" r += ser_g1(self.g_A) r += ser_g1(self.g_A_prime) r += ser_g2(self.g_B) r += ser_g1(self.g_B_prime) r += ser_g1(self.g_C) r += ser_g1(self.g_C_prime) r += ser_g1(self.g_K) r += ser_g1(self.g_H) return r def __repr__(self): return "ZCProof(g_A=%r g_A_prime=%r g_B=%r g_B_prime=%r g_C=%r g_C_prime=%r g_K=%r g_H=%r)" \ % (self.g_A, self.g_A_prime, self.g_B, self.g_B_prime, self.g_C, self.g_C_prime, self.g_K, self.g_H) ZC_NUM_JS_INPUTS = 2 ZC_NUM_JS_OUTPUTS = 2 ZC_NOTEPLAINTEXT_LEADING = 1 ZC_V_SIZE = 8 ZC_RHO_SIZE = 32 ZC_R_SIZE = 32 ZC_MEMO_SIZE = 512 ZC_NOTEPLAINTEXT_SIZE = ( ZC_NOTEPLAINTEXT_LEADING + ZC_V_SIZE + ZC_RHO_SIZE + ZC_R_SIZE + ZC_MEMO_SIZE ) NOTEENCRYPTION_AUTH_BYTES = 16 ZC_NOTECIPHERTEXT_SIZE = ( ZC_NOTEPLAINTEXT_SIZE + NOTEENCRYPTION_AUTH_BYTES ) class JSDescription(object): def __init__(self): self.vpub_old = 0 self.vpub_new = 0 self.anchor = 0 self.nullifiers = [0] * ZC_NUM_JS_INPUTS self.commitments = [0] * ZC_NUM_JS_OUTPUTS self.onetimePubKey = 0 self.randomSeed = 0 self.macs = [0] * ZC_NUM_JS_INPUTS self.proof = None self.ciphertexts = [None] * ZC_NUM_JS_OUTPUTS def deserialize(self, f): self.vpub_old = struct.unpack("<q", f.read(8))[0] self.vpub_new = struct.unpack("<q", f.read(8))[0] self.anchor = deser_uint256(f) self.nullifiers = [] for i in range(ZC_NUM_JS_INPUTS): self.nullifiers.append(deser_uint256(f)) self.commitments = [] for i in range(ZC_NUM_JS_OUTPUTS): self.commitments.append(deser_uint256(f)) self.onetimePubKey = deser_uint256(f) self.randomSeed = deser_uint256(f) self.macs = [] for i in range(ZC_NUM_JS_INPUTS): self.macs.append(deser_uint256(f)) self.proof = ZCProof() self.proof.deserialize(f) self.ciphertexts = [] for i in range(ZC_NUM_JS_OUTPUTS): self.ciphertexts.append(f.read(ZC_NOTECIPHERTEXT_SIZE)) def serialize(self): r = b"" r += struct.pack("<q", self.vpub_old) r += struct.pack("<q", self.vpub_new) r += ser_uint256(self.anchor) for i in range(ZC_NUM_JS_INPUTS): r += ser_uint256(self.nullifiers[i]) for i in range(ZC_NUM_JS_OUTPUTS): r += ser_uint256(self.commitments[i]) r += ser_uint256(self.onetimePubKey) r += ser_uint256(self.randomSeed) for i in range(ZC_NUM_JS_INPUTS): r += ser_uint256(self.macs[i]) r += self.proof.serialize() for i in range(ZC_NUM_JS_OUTPUTS): r += ser_uint256(self.ciphertexts[i]) return r def __repr__(self): return "JSDescription(vpub_old=%i vpub_new=%i anchor=%064x onetimePubKey=%064x randomSeed=%064x proof=%r)" \ % (self.vpub_old, self.vpub_new, self.anchor, self.onetimePubKey, self.randomSeed, self.proof) class COutPoint(object): def __init__(self, hash=0, n=0): self.hash = hash self.n = n def deserialize(self, f): self.hash = deser_uint256(f) self.n = struct.unpack("<I", f.read(4))[0] def serialize(self): r = b"" r += ser_uint256(self.hash) r += struct.pack("<I", self.n) return r def __repr__(self): return "COutPoint(hash=%064x n=%i)" % (self.hash, self.n) class CTxIn(object): def __init__(self, outpoint=None, scriptSig=b"", nSequence=0): if outpoint is None: self.prevout = COutPoint() else: self.prevout = outpoint self.scriptSig = scriptSig self.nSequence = nSequence def deserialize(self, f): self.prevout = COutPoint() self.prevout.deserialize(f) self.scriptSig = deser_string(f) self.nSequence = struct.unpack("<I", f.read(4))[0] def serialize(self): r = b"" r += self.prevout.serialize() r += ser_string(self.scriptSig) r += struct.pack("<I", self.nSequence) return r def __repr__(self): return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \ % (self.prevout, hexlify(self.scriptSig), self.nSequence) class CTxOut(object): def __init__(self, nValue=0, scriptPubKey=b""): self.nValue = nValue self.scriptPubKey = scriptPubKey def deserialize(self, f): self.nValue = struct.unpack("<q", f.read(8))[0] self.scriptPubKey = deser_string(f) def serialize(self): r = b"" r += struct.pack("<q", self.nValue) r += ser_string(self.scriptPubKey) return r def __repr__(self): return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \ % (self.nValue // 100000000, self.nValue % 100000000, hexlify(self.scriptPubKey)) class CTransaction(object): def __init__(self, tx=None): if tx is None: self.fOverwintered = True self.nVersion = 4 self.nVersionGroupId = SAPLING_VERSION_GROUP_ID self.vin = [] self.vout = [] self.nLockTime = 0 self.nExpiryHeight = 0 self.valueBalance = 0 self.shieldedSpends = [] self.shieldedOutputs = [] self.vJoinSplit = [] self.joinSplitPubKey = None self.joinSplitSig = None self.bindingSig = None self.sha256 = None self.hash = None else: self.fOverwintered = tx.fOverwintered self.nVersion = tx.nVersion self.nVersionGroupId = tx.nVersionGroupId self.vin = copy.deepcopy(tx.vin) self.vout = copy.deepcopy(tx.vout) self.nLockTime = tx.nLockTime self.nExpiryHeight = tx.nExpiryHeight self.valueBalance = tx.valueBalance self.shieldedSpends = copy.deepcopy(tx.shieldedSpends) self.shieldedOutputs = copy.deepcopy(tx.shieldedOutputs) self.vJoinSplit = copy.deepcopy(tx.vJoinSplit) self.joinSplitPubKey = tx.joinSplitPubKey self.joinSplitSig = tx.joinSplitSig self.bindingSig = tx.bindingSig self.sha256 = None self.hash = None def deserialize(self, f): header = struct.unpack("<I", f.read(4))[0] self.fOverwintered = bool(header >> 31) self.nVersion = header & 0x7FFFFFFF self.nVersionGroupId = (struct.unpack("<I", f.read(4))[0] if self.fOverwintered else 0) isOverwinterV3 = (self.fOverwintered and self.nVersionGroupId == OVERWINTER_VERSION_GROUP_ID and self.nVersion == 3) isSaplingV4 = (self.fOverwintered and self.nVersionGroupId == SAPLING_VERSION_GROUP_ID and self.nVersion == 4) self.vin = deser_vector(f, CTxIn) self.vout = deser_vector(f, CTxOut) self.nLockTime = struct.unpack("<I", f.read(4))[0] if isOverwinterV3 or isSaplingV4: self.nExpiryHeight = struct.unpack("<I", f.read(4))[0] if isSaplingV4: self.valueBalance = struct.unpack("<q", f.read(8))[0] self.shieldedSpends = deser_vector(f, SpendDescription) self.shieldedOutputs = deser_vector(f, OutputDescription) if self.nVersion >= 2: self.vJoinSplit = deser_vector(f, JSDescription) if len(self.vJoinSplit) > 0: self.joinSplitPubKey = deser_uint256(f) self.joinSplitSig = f.read(64) if isSaplingV4 and not (len(self.shieldedSpends) == 0 and len(self.shieldedOutputs) == 0): self.bindingSig = f.read(64) self.sha256 = None self.hash = None def serialize(self): header = (int(self.fOverwintered)<<31) | self.nVersion isOverwinterV3 = (self.fOverwintered and self.nVersionGroupId == OVERWINTER_VERSION_GROUP_ID and self.nVersion == 3) isSaplingV4 = (self.fOverwintered and self.nVersionGroupId == SAPLING_VERSION_GROUP_ID and self.nVersion == 4) r = b"" r += struct.pack("<I", header) if self.fOverwintered: r += struct.pack("<I", self.nVersionGroupId) r += ser_vector(self.vin) r += ser_vector(self.vout) r += struct.pack("<I", self.nLockTime) if isOverwinterV3 or isSaplingV4: r += struct.pack("<I", self.nExpiryHeight) if isSaplingV4: r += struct.pack("<q", self.valueBalance) r += ser_vector(self.shieldedSpends) r += ser_vector(self.shieldedOutputs) if self.nVersion >= 2: r += ser_vector(self.vJoinSplit) if len(self.vJoinSplit) > 0: r += ser_uint256(self.joinSplitPubKey) r += self.joinSplitSig if isSaplingV4 and not (len(self.shieldedSpends) == 0 and len(self.shieldedOutputs) == 0): r += self.bindingSig return r def rehash(self): self.sha256 = None self.calc_sha256() def calc_sha256(self): if self.sha256 is None: self.sha256 = uint256_from_str(hash256(self.serialize())) self.hash = hash256(self.serialize())[::-1].hex() def is_valid(self): self.calc_sha256() for tout in self.vout: if tout.nValue < 0 or tout.nValue > 214160000 * 100000000: return False return True def __repr__(self): r = ("CTransaction(fOverwintered=%r nVersion=%i nVersionGroupId=0x%08x " "vin=%r vout=%r nLockTime=%i nExpiryHeight=%i " "valueBalance=%i shieldedSpends=%r shieldedOutputs=%r" % (self.fOverwintered, self.nVersion, self.nVersionGroupId, self.vin, self.vout, self.nLockTime, self.nExpiryHeight, self.valueBalance, self.shieldedSpends, self.shieldedOutputs)) if self.nVersion >= 2: r += " vJoinSplit=%r" % (self.vJoinSplit,) if len(self.vJoinSplit) > 0: r += " joinSplitPubKey=%064x joinSplitSig=%064x" \ % (self.joinSplitPubKey, self.joinSplitSig) if len(self.shieldedSpends) > 0 or len(self.shieldedOutputs) > 0: r += " bindingSig=%064x" % (self.bindingSig,) r += ")" return r class CBlockHeader(object): def __init__(self, header=None): if header is None: self.set_null() else: self.nVersion = header.nVersion self.hashPrevBlock = header.hashPrevBlock self.hashMerkleRoot = header.hashMerkleRoot self.hashFinalSaplingRoot = header.hashFinalSaplingRoot self.nTime = header.nTime self.nBits = header.nBits self.nNonce = header.nNonce self.sha256 = header.sha256 self.hash = header.hash self.calc_sha256() def set_null(self): self.nVersion = 4 self.hashPrevBlock = 0 self.hashMerkleRoot = 0 self.hashFinalSaplingRoot = 0 self.nTime = 0 self.nBits = 0 self.nNonce = 0 self.sha256 = None self.hash = None def deserialize(self, f): self.nVersion = struct.unpack("<i", f.read(4))[0] self.hashPrevBlock = deser_uint256(f) self.hashMerkleRoot = deser_uint256(f) self.nTime = struct.unpack("<I", f.read(4))[0] self.nBits = struct.unpack("<I", f.read(4))[0] self.nNonce = struct.unpack("<I", f.read(4))[0] self.hashFinalSaplingRoot = deser_uint256(f) self.sha256 = None self.hash = None def serialize(self): r = b"" r += struct.pack("<i", self.nVersion) r += ser_uint256(self.hashPrevBlock) r += ser_uint256(self.hashMerkleRoot) r += struct.pack("<I", self.nTime) r += struct.pack("<I", self.nBits) r += struct.pack("<I", self.nNonce) r += ser_uint256(self.hashFinalSaplingRoot) return r def calc_sha256(self): if self.sha256 is None: r = b"" r += struct.pack("<i", self.nVersion) r += ser_uint256(self.hashPrevBlock) r += ser_uint256(self.hashMerkleRoot) r += struct.pack("<I", self.nTime) r += struct.pack("<I", self.nBits) r += struct.pack("<I", self.nNonce) r += ser_uint256(self.hashFinalSaplingRoot) self.sha256 = uint256_from_str(hash256(r)) self.hash = hash256(r)[::-1].hex() def rehash(self): self.sha256 = None self.calc_sha256() return self.sha256 def __repr__(self): return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x hashFinalSaplingRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \ % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, self.hashFinalSaplingRoot, time.ctime(self.nTime), self.nBits, self.nNonce) class CBlock(CBlockHeader): def __init__(self, header=None): super(CBlock, self).__init__(header) self.vtx = [] def deserialize(self, f): super(CBlock, self).deserialize(f) self.vtx = deser_vector(f, CTransaction) def serialize(self): r = b"" r += super(CBlock, self).serialize() r += ser_vector(self.vtx) return r def calc_merkle_root(self): hashes = [] for tx in self.vtx: tx.calc_sha256() hashes.append(ser_uint256(tx.sha256)) while len(hashes) > 1: newhashes = [] for i in range(0, len(hashes), 2): i2 = min(i+1, len(hashes)-1) newhashes.append(hash256(hashes[i] + hashes[i2])) hashes = newhashes return uint256_from_str(hashes[0]) def solve(self): target = uint256_from_compact(self.nBits) self.nNonce = 0 while True: _powhash = rev_hex(bh2u(yescrypt.getPoWHash(super(CBlock, self).serialize()))) pow = int('0x' + _powhash, 16) if pow <= target: self.rehash() return self.nNonce += 1 def __repr__(self): return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x hashFinalSaplingRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%r)" \ % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot, self.hashFinalSaplingRoot, time.ctime(self.nTime), self.nBits, self.nNonce, self.vtx) class CUnsignedAlert(object): def __init__(self): self.nVersion = 1 self.nRelayUntil = 0 self.nExpiration = 0 self.nID = 0 self.nCancel = 0 self.setCancel = [] self.nMinVer = 0 self.nMaxVer = 0 self.setSubVer = [] self.nPriority = 0 self.strComment = b"" self.strStatusBar = b"" self.strReserved = b"" def deserialize(self, f): self.nVersion = struct.unpack("<i", f.read(4))[0] self.nRelayUntil = struct.unpack("<q", f.read(8))[0] self.nExpiration = struct.unpack("<q", f.read(8))[0] self.nID = struct.unpack("<i", f.read(4))[0] self.nCancel = struct.unpack("<i", f.read(4))[0] self.setCancel = deser_int_vector(f) self.nMinVer = struct.unpack("<i", f.read(4))[0] self.nMaxVer = struct.unpack("<i", f.read(4))[0] self.setSubVer = deser_string_vector(f) self.nPriority = struct.unpack("<i", f.read(4))[0] self.strComment = deser_string(f) self.strStatusBar = deser_string(f) self.strReserved = deser_string(f) def serialize(self): r = b"" r += struct.pack("<i", self.nVersion) r += struct.pack("<q", self.nRelayUntil) r += struct.pack("<q", self.nExpiration) r += struct.pack("<i", self.nID) r += struct.pack("<i", self.nCancel) r += ser_int_vector(self.setCancel) r += struct.pack("<i", self.nMinVer) r += struct.pack("<i", self.nMaxVer) r += ser_string_vector(self.setSubVer) r += struct.pack("<i", self.nPriority) r += ser_string(self.strComment) r += ser_string(self.strStatusBar) r += ser_string(self.strReserved) return r def __repr__(self): return "CUnsignedAlert(nVersion %d, nRelayUntil %d, nExpiration %d, nID %d, nCancel %d, nMinVer %d, nMaxVer %d, nPriority %d, strComment %s, strStatusBar %s, strReserved %s)" \ % (self.nVersion, self.nRelayUntil, self.nExpiration, self.nID, self.nCancel, self.nMinVer, self.nMaxVer, self.nPriority, self.strComment, self.strStatusBar, self.strReserved) class CAlert(object): def __init__(self): self.vchMsg = b"" self.vchSig = b"" def deserialize(self, f): self.vchMsg = deser_string(f) self.vchSig = deser_string(f) def serialize(self): r = b"" r += ser_string(self.vchMsg) r += ser_string(self.vchSig) return r def __repr__(self): return "CAlert(vchMsg.sz %d, vchSig.sz %d)" \ % (len(self.vchMsg), len(self.vchSig)) # Objects that correspond to messages on the wire class msg_version(object): command = b"version" def __init__(self, protocol_version=SPROUT_PROTO_VERSION): self.nVersion = protocol_version self.nServices = 1 self.nTime = int(time.time()) self.addrTo = CAddress() self.addrFrom = CAddress() self.nNonce = random.getrandbits(64) self.strSubVer = MY_SUBVERSION self.nStartingHeight = -1 def deserialize(self, f): self.nVersion = struct.unpack("<i", f.read(4))[0] if self.nVersion == 10300: self.nVersion = 300 self.nServices = struct.unpack("<Q", f.read(8))[0] self.nTime = struct.unpack("<q", f.read(8))[0] self.addrTo = CAddress() self.addrTo.deserialize(f) if self.nVersion >= 106: self.addrFrom = CAddress() self.addrFrom.deserialize(f) self.nNonce = struct.unpack("<Q", f.read(8))[0] self.strSubVer = deser_string(f) if self.nVersion >= 209: self.nStartingHeight = struct.unpack("<i", f.read(4))[0] else: self.nStartingHeight = None else: self.addrFrom = None self.nNonce = None self.strSubVer = None self.nStartingHeight = None def serialize(self): r = b"" r += struct.pack("<i", self.nVersion) r += struct.pack("<Q", self.nServices) r += struct.pack("<q", self.nTime) r += self.addrTo.serialize() r += self.addrFrom.serialize() r += struct.pack("<Q", self.nNonce) r += ser_string(self.strSubVer) r += struct.pack("<i", self.nStartingHeight) return r def __repr__(self): return 'msg_version(nVersion=%i nServices=%i nTime=%s addrTo=%s addrFrom=%s nNonce=0x%016X strSubVer=%s nStartingHeight=%i)' \ % (self.nVersion, self.nServices, time.ctime(self.nTime), self.addrTo, self.addrFrom, self.nNonce, self.strSubVer, self.nStartingHeight) class msg_verack(object): command = b"verack" def __init__(self): pass def deserialize(self, f): pass def serialize(self): return b"" def __repr__(self): return "msg_verack()" class msg_addr(object): command = b"addr" def __init__(self): self.addrs = [] def deserialize(self, f): self.addrs = deser_vector(f, CAddress) def serialize(self): return ser_vector(self.addrs) def __repr__(self): return "msg_addr(addrs=%r)" % (self.addrs,) class msg_alert(object): command = b"alert" def __init__(self): self.alert = CAlert() def deserialize(self, f): self.alert = CAlert() self.alert.deserialize(f) def serialize(self): r = b"" r += self.alert.serialize() return r def __repr__(self): return "msg_alert(alert=%s)" % (repr(self.alert), ) class msg_inv(object): command = b"inv" def __init__(self, inv=None): if inv is None: self.inv = [] else: self.inv = inv def deserialize(self, f): self.inv = deser_vector(f, CInv) def serialize(self): return ser_vector(self.inv) def __repr__(self): return "msg_inv(inv=%s)" % (repr(self.inv)) class msg_getdata(object): command = b"getdata" def __init__(self, inv=None): self.inv = inv if inv != None else [] def deserialize(self, f): self.inv = deser_vector(f, CInv) def serialize(self): return ser_vector(self.inv) def __repr__(self): return "msg_getdata(inv=%s)" % (repr(self.inv)) class msg_notfound(object): command = b"notfound" def __init__(self): self.inv = [] def deserialize(self, f): self.inv = deser_vector(f, CInv) def serialize(self): return ser_vector(self.inv) def __repr__(self): return "msg_notfound(inv=%r)" % (self.inv,) class msg_getblocks(object): command = b"getblocks" def __init__(self): self.locator = CBlockLocator() self.hashstop = 0 def deserialize(self, f): self.locator = CBlockLocator() self.locator.deserialize(f) self.hashstop = deser_uint256(f) def serialize(self): r = b"" r += self.locator.serialize() r += ser_uint256(self.hashstop) return r def __repr__(self): return "msg_getblocks(locator=%s hashstop=%064x)" \ % (repr(self.locator), self.hashstop) class msg_tx(object): command = b"tx" def __init__(self, tx=CTransaction()): self.tx = tx def deserialize(self, f): self.tx.deserialize(f) def serialize(self): return self.tx.serialize() def __repr__(self): return "msg_tx(tx=%s)" % (repr(self.tx)) class msg_block(object): command = b"block" def __init__(self, block=None): if block is None: self.block = CBlock() else: self.block = block def deserialize(self, f): self.block.deserialize(f) def serialize(self): return self.block.serialize() def __repr__(self): return "msg_block(block=%s)" % (repr(self.block)) class msg_getaddr(object): command = b"getaddr" def __init__(self): pass def deserialize(self, f): pass def serialize(self): return b"" def __repr__(self): return "msg_getaddr()" class msg_ping_prebip31(object): command = b"ping" def __init__(self): pass def deserialize(self, f): pass def serialize(self): return b"" def __repr__(self): return "msg_ping() (pre-bip31)" class msg_ping(object): command = b"ping" def __init__(self, nonce=0): self.nonce = nonce def deserialize(self, f): self.nonce = struct.unpack("<Q", f.read(8))[0] def serialize(self): r = b"" r += struct.pack("<Q", self.nonce) return r def __repr__(self): return "msg_ping(nonce=%08x)" % self.nonce class msg_pong(object): command = b"pong" def __init__(self, nonce=0): self.nonce = nonce def deserialize(self, f): self.nonce = struct.unpack("<Q", f.read(8))[0] def serialize(self): r = b"" r += struct.pack("<Q", self.nonce) return r def __repr__(self): return "msg_pong(nonce=%08x)" % self.nonce class msg_mempool(object): command = b"mempool" def __init__(self): pass def deserialize(self, f): pass def serialize(self): return b"" def __repr__(self): return "msg_mempool()" # getheaders message has # number of entries # vector of hashes # hash_stop (hash of last desired block header, 0 to get as many as possible) class msg_getheaders(object): command = b"getheaders" def __init__(self): self.locator = CBlockLocator() self.hashstop = 0 def deserialize(self, f): self.locator = CBlockLocator() self.locator.deserialize(f) self.hashstop = deser_uint256(f) def serialize(self): r = b"" r += self.locator.serialize() r += ser_uint256(self.hashstop) return r def __repr__(self): return "msg_getheaders(locator=%s, stop=%064x)" \ % (repr(self.locator), self.hashstop) # headers message has # <count> <vector of block headers> class msg_headers(object): command = b"headers" def __init__(self): self.headers = [] def deserialize(self, f): # comment in bitcoind indicates these should be deserialized as blocks blocks = deser_vector(f, CBlock) for x in blocks: self.headers.append(CBlockHeader(x)) def serialize(self): blocks = [CBlock(x) for x in self.headers] return ser_vector(blocks) def __repr__(self): return "msg_headers(headers=%s)" % repr(self.headers) class msg_reject(object): command = b"reject" REJECT_MALFORMED = 1 def __init__(self): self.message = b"" self.code = 0 self.reason = b"" self.data = 0 def deserialize(self, f): self.message = deser_string(f) self.code = struct.unpack("<B", f.read(1))[0] self.reason = deser_string(f) if (self.code != self.REJECT_MALFORMED and (self.message == b"block" or self.message == b"tx")): self.data = deser_uint256(f) def serialize(self): r = ser_string(self.message) r += struct.pack("<B", self.code) r += ser_string(self.reason) if (self.code != self.REJECT_MALFORMED and (self.message == b"block" or self.message == b"tx")): r += ser_uint256(self.data) return r def __repr__(self): return "msg_reject: %s %d %s [%064x]" \ % (self.message, self.code, self.reason, self.data) class msg_filteradd(object): command = b"filteradd" def __init__(self): self.data = b"" def deserialize(self, f): self.data = deser_string(f) def serialize(self): return ser_string(self.data) def __repr__(self): return "msg_filteradd(data=%r)" % (self.data,) class msg_filterclear(object): command = b"filterclear" def __init__(self): pass def deserialize(self, f): pass def serialize(self): return b"" def __repr__(self): return "msg_filterclear()" # This is what a callback should look like for NodeConn # Reimplement the on_* functions to provide handling for events class NodeConnCB(object): def __init__(self): self.verack_received = False # Derived classes should call this function once to set the message map # which associates the derived classes' functions to incoming messages def create_callback_map(self): self.cbmap = { b"version": self.on_version, b"verack": self.on_verack, b"addr": self.on_addr, b"alert": self.on_alert, b"inv": self.on_inv, b"getdata": self.on_getdata, b"notfound": self.on_notfound, b"getblocks": self.on_getblocks, b"tx": self.on_tx, b"block": self.on_block, b"getaddr": self.on_getaddr, b"ping": self.on_ping, b"pong": self.on_pong, b"headers": self.on_headers, b"getheaders": self.on_getheaders, b"reject": self.on_reject, b"mempool": self.on_mempool } def deliver(self, conn, message): with mininode_lock: try: self.cbmap[message.command](conn, message) except: print("ERROR delivering %r (%s)" % (message, sys.exc_info()[0])) def on_version(self, conn, message): if message.nVersion >= 209: conn.send_message(msg_verack()) conn.ver_send = min(SPROUT_PROTO_VERSION, message.nVersion) if message.nVersion < 209: conn.ver_recv = conn.ver_send def on_verack(self, conn, message): conn.ver_recv = conn.ver_send self.verack_received = True def on_inv(self, conn, message): want = msg_getdata() for i in message.inv: if i.type != 0: want.inv.append(i) if len(want.inv): conn.send_message(want) def on_addr(self, conn, message): pass def on_alert(self, conn, message): pass def on_getdata(self, conn, message): pass def on_notfound(self, conn, message): pass def on_getblocks(self, conn, message): pass def on_tx(self, conn, message): pass def on_block(self, conn, message): pass def on_getaddr(self, conn, message): pass def on_headers(self, conn, message): pass def on_getheaders(self, conn, message): pass def on_ping(self, conn, message): if conn.ver_send > BIP0031_VERSION: conn.send_message(msg_pong(message.nonce)) def on_reject(self, conn, message): pass def on_close(self, conn): pass def on_mempool(self, conn): pass def on_pong(self, conn, message): pass # The actual NodeConn class # This class provides an interface for a p2p connection to a specified node class NodeConn(asyncore.dispatcher): messagemap = { b"version": msg_version, b"verack": msg_verack, b"addr": msg_addr, b"alert": msg_alert, b"inv": msg_inv, b"getdata": msg_getdata, b"notfound": msg_notfound, b"getblocks": msg_getblocks, b"tx": msg_tx, b"block": msg_block, b"getaddr": msg_getaddr, b"ping": msg_ping, b"pong": msg_pong, b"headers": msg_headers, b"getheaders": msg_getheaders, b"reject": msg_reject, b"mempool": msg_mempool } MAGIC_BYTES = { "mainnet": b"\x4b\x6f\x74\x6f", # mainnet "testnet3": b"\x54\x6f\x6b\x6f", # testnet3 "regtest": b"\x52\x65\x6b\x6f" # regtest } def __init__(self, dstaddr, dstport, rpc, callback, net="regtest", protocol_version=SAPLING_PROTO_VERSION): asyncore.dispatcher.__init__(self, map=mininode_socket_map) self.log = logging.getLogger("NodeConn(%s:%d)" % (dstaddr, dstport)) self.dstaddr = dstaddr self.dstport = dstport self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.sendbuf = b"" self.recvbuf = b"" self.ver_send = 209 self.ver_recv = 209 self.last_sent = 0 self.state = "connecting" self.network = net self.cb = callback self.disconnect = False # stuff version msg into sendbuf vt = msg_version(protocol_version) vt.addrTo.ip = self.dstaddr vt.addrTo.port = self.dstport vt.addrFrom.ip = "0.0.0.0" vt.addrFrom.port = 0 self.send_message(vt, True) print('MiniNode: Connecting to Bitcoin Node IP # ' + dstaddr + ':' \ + str(dstport) + ' using version ' + str(protocol_version)) try: self.connect((dstaddr, dstport)) except: self.handle_close() self.rpc = rpc def show_debug_msg(self, msg): self.log.debug(msg) def handle_connect(self): self.show_debug_msg("MiniNode: Connected & Listening: \n") self.state = b"connected" def handle_close(self): self.show_debug_msg("MiniNode: Closing Connection to %s:%d... " % (self.dstaddr, self.dstport)) self.state = b"closed" self.recvbuf = b"" self.sendbuf = b"" try: self.close() except: pass self.cb.on_close(self) def handle_read(self): try: t = self.recv(8192) if len(t) > 0: self.recvbuf += t self.got_data() except: pass def readable(self): return True def writable(self): with mininode_lock: length = len(self.sendbuf) return (length > 0) def handle_write(self): with mininode_lock: try: sent = self.send(self.sendbuf) except: self.handle_close() return self.sendbuf = self.sendbuf[sent:] def got_data(self): try: while True: if len(self.recvbuf) < 4: return if self.recvbuf[:4] != self.MAGIC_BYTES[self.network]: raise ValueError("got garbage %r" % (self.recvbuf,)) if self.ver_recv < 209: if len(self.recvbuf) < 4 + 12 + 4: return command = self.recvbuf[4:4+12].split(b"\x00", 1)[0] msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0] checksum = None if len(self.recvbuf) < 4 + 12 + 4 + msglen: return msg = self.recvbuf[4+12+4:4+12+4+msglen] self.recvbuf = self.recvbuf[4+12+4+msglen:] else: if len(self.recvbuf) < 4 + 12 + 4 + 4: return command = self.recvbuf[4:4+12].split(b"\x00", 1)[0] msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0] checksum = self.recvbuf[4+12+4:4+12+4+4] if len(self.recvbuf) < 4 + 12 + 4 + 4 + msglen: return msg = self.recvbuf[4+12+4+4:4+12+4+4+msglen] th = sha256(msg) h = sha256(th) if checksum != h[:4]: raise ValueError("got bad checksum %r" % (self.recvbuf,)) self.recvbuf = self.recvbuf[4+12+4+4+msglen:] if command in self.messagemap: f = BytesIO(msg) t = self.messagemap[command]() t.deserialize(f) self.got_message(t) else: self.show_debug_msg("Unknown command: '" + command + "' " + repr(msg)) except Exception as e: print('got_data:', repr(e)) # import traceback # traceback.print_tb(sys.exc_info()[2]) def send_message(self, message, pushbuf=False): if self.state != b"connected" and not pushbuf: return self.show_debug_msg("Send %s" % repr(message)) command = message.command data = message.serialize() tmsg = self.MAGIC_BYTES[self.network] tmsg += command tmsg += b"\x00" * (12 - len(command)) tmsg += struct.pack("<I", len(data)) if self.ver_send >= 209: th = sha256(data) h = sha256(th) tmsg += h[:4] tmsg += data with mininode_lock: self.sendbuf += tmsg self.last_sent = time.time() def got_message(self, message): if message.command == b"version": if message.nVersion <= BIP0031_VERSION: self.messagemap[b'ping'] = msg_ping_prebip31 if self.last_sent + 30 * 60 < time.time(): self.send_message(self.messagemap[b'ping']()) self.show_debug_msg("Recv %s" % repr(message)) self.cb.deliver(self, message) def disconnect_node(self): self.disconnect = True class NetworkThread(Thread): def run(self): while mininode_socket_map: # We check for whether to disconnect outside of the asyncore # loop to workaround the behavior of asyncore when using # select disconnected = [] for fd, obj in mininode_socket_map.items(): if obj.disconnect: disconnected.append(obj) [ obj.handle_close() for obj in disconnected ] asyncore.loop(0.1, use_poll=True, map=mininode_socket_map, count=1) # An exception we can raise if we detect a potential disconnect # (p2p or rpc) before the test is complete class EarlyDisconnectError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value)
the-stack_0_3325
from __future__ import unicode_literals from django.test import TestCase from .models import Article, Car, Driver, Reporter class ManyToOneNullTests(TestCase): def setUp(self): # Create a Reporter. self.r = Reporter(name='John Smith') self.r.save() # Create an Article. self.a = Article(headline="First", reporter=self.r) self.a.save() # Create an Article via the Reporter object. self.a2 = self.r.article_set.create(headline="Second") # Create an Article with no Reporter by passing "reporter=None". self.a3 = Article(headline="Third", reporter=None) self.a3.save() # Create another article and reporter self.r2 = Reporter(name='Paul Jones') self.r2.save() self.a4 = self.r2.article_set.create(headline='Fourth') def test_get_related(self): self.assertEqual(self.a.reporter.id, self.r.id) # Article objects have access to their related Reporter objects. r = self.a.reporter self.assertEqual(r.id, self.r.id) def test_created_via_related_set(self): self.assertEqual(self.a2.reporter.id, self.r.id) def test_related_set(self): # Reporter objects have access to their related Article objects. self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='Fir'), ['<Article: First>']) self.assertEqual(self.r.article_set.count(), 2) def test_created_without_related(self): self.assertEqual(self.a3.reporter, None) # Need to reget a3 to refresh the cache a3 = Article.objects.get(pk=self.a3.pk) with self.assertRaises(AttributeError): getattr(a3.reporter, 'id') # Accessing an article's 'reporter' attribute returns None # if the reporter is set to None. self.assertEqual(a3.reporter, None) # To retrieve the articles with no reporters set, use "reporter__isnull=True". self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: Third>']) # We can achieve the same thing by filtering for the case where the # reporter is None. self.assertQuerysetEqual(Article.objects.filter(reporter=None), ['<Article: Third>']) # Set the reporter for the Third article self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) self.r.article_set.add(a3) self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>', '<Article: Third>']) # Remove an article from the set, and check that it was removed. self.r.article_set.remove(a3) self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: Third>']) def test_remove_from_wrong_set(self): self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>']) # Try to remove a4 from a set it does not belong to with self.assertRaises(Reporter.DoesNotExist): self.r.article_set.remove(self.a4) self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>']) def test_set(self): # Use manager.set() to allocate ForeignKey. Null is legal, so existing # members of the set that are not in the assignment set are set to null. self.r2.article_set.set([self.a2, self.a3]) self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>']) # Use manager.set(clear=True) self.r2.article_set.set([self.a3, self.a4], clear=True) self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>', '<Article: Third>']) # Clear the rest of the set self.r2.article_set.set([]) self.assertQuerysetEqual(self.r2.article_set.all(), []) self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: Fourth>', '<Article: Second>', '<Article: Third>']) def test_assign_clear_related_set(self): # Use descriptor assignment to allocate ForeignKey. Null is legal, so # existing members of the set that are not in the assignment set are # set to null. self.r2.article_set.set([self.a2, self.a3]) self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>']) # Clear the rest of the set self.r.article_set.clear() self.assertQuerysetEqual(self.r.article_set.all(), []) self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: First>', '<Article: Fourth>']) def test_assign_with_queryset(self): # Ensure that querysets used in reverse FK assignments are pre-evaluated # so their value isn't affected by the clearing operation in # RelatedManager.set() (#19816). self.r2.article_set.set([self.a2, self.a3]) qs = self.r2.article_set.filter(headline="Second") self.r2.article_set.set(qs) self.assertEqual(1, self.r2.article_set.count()) self.assertEqual(1, qs.count()) def test_add_efficiency(self): r = Reporter.objects.create() articles = [] for _ in range(3): articles.append(Article.objects.create()) with self.assertNumQueries(1): r.article_set.add(*articles) self.assertEqual(r.article_set.count(), 3) def test_clear_efficiency(self): r = Reporter.objects.create() for _ in range(3): r.article_set.create() with self.assertNumQueries(1): r.article_set.clear() self.assertEqual(r.article_set.count(), 0) def test_related_null_to_field(self): c1 = Car.objects.create() d1 = Driver.objects.create() self.assertIs(d1.car, None) with self.assertNumQueries(0): self.assertEqual(list(c1.drivers.all()), [])
the-stack_0_3326
# Lint as: python2, python3 # Copyright 2019 Google LLC. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Chicago taxi example using TFX.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import multiprocessing import os from typing import Text import absl import tensorflow_model_analysis as tfma from tfx.components import CsvExampleGen from tfx.components import Evaluator from tfx.components import ExampleValidator from tfx.components import Pusher from tfx.components import ResolverNode from tfx.components import SchemaGen from tfx.components import StatisticsGen from tfx.components import Trainer from tfx.components import Transform from tfx.dsl.experimental import latest_blessed_model_resolver from tfx.orchestration import metadata from tfx.orchestration import pipeline from tfx.orchestration.beam.beam_dag_runner import BeamDagRunner from tfx.proto import pusher_pb2 from tfx.proto import trainer_pb2 from tfx.types import Channel from tfx.types.standard_artifacts import Model from tfx.types.standard_artifacts import ModelBlessing from tfx.utils.dsl_utils import external_input _pipeline_name = 'chicago_taxi_portable_beam' # This example assumes that the taxi data is stored in ~/taxi/data and the # taxi utility function is in ~/taxi. Feel free to customize this as needed. _taxi_root = os.path.join(os.environ['HOME'], 'taxi') _data_root = os.path.join(_taxi_root, 'data', 'simple') # Python module file to inject customized logic into the TFX components. The # Transform and Trainer both require user-defined functions to run successfully. _module_file = os.path.join(_taxi_root, 'taxi_utils.py') # Path which can be listened to by the model server. Pusher will output the # trained model here. _serving_model_dir = os.path.join(_taxi_root, 'serving_model', _pipeline_name) # Directory and data locations. This example assumes all of the chicago taxi # example code and metadata library is relative to $HOME, but you can store # these files anywhere on your local filesystem. _tfx_root = os.path.join(os.environ['HOME'], 'tfx') _pipeline_root = os.path.join(_tfx_root, 'pipelines', _pipeline_name) # Sqlite ML-metadata db path. _metadata_path = os.path.join(_tfx_root, 'metadata', _pipeline_name, 'metadata.db') def _create_pipeline(pipeline_name: Text, pipeline_root: Text, data_root: Text, module_file: Text, serving_model_dir: Text, metadata_path: Text, worker_parallelism: int) -> pipeline.Pipeline: """Implements the chicago taxi pipeline with TFX.""" examples = external_input(data_root) # Brings data into the pipeline or otherwise joins/converts training data. example_gen = CsvExampleGen(input=examples) # Computes statistics over data for visualization and example validation. statistics_gen = StatisticsGen(examples=example_gen.outputs['examples']) # Generates schema based on statistics files. schema_gen = SchemaGen( statistics=statistics_gen.outputs['statistics'], infer_feature_shape=False) # Performs anomaly detection based on statistics and data schema. example_validator = ExampleValidator( statistics=statistics_gen.outputs['statistics'], schema=schema_gen.outputs['schema']) # Performs transformations and feature engineering in training and serving. transform = Transform( examples=example_gen.outputs['examples'], schema=schema_gen.outputs['schema'], module_file=module_file) # Uses user-provided Python function that implements a model using TF-Learn. trainer = Trainer( module_file=module_file, transformed_examples=transform.outputs['transformed_examples'], schema=schema_gen.outputs['schema'], transform_graph=transform.outputs['transform_graph'], train_args=trainer_pb2.TrainArgs(num_steps=10000), eval_args=trainer_pb2.EvalArgs(num_steps=5000)) # Get the latest blessed model for model validation. model_resolver = ResolverNode( instance_name='latest_blessed_model_resolver', resolver_class=latest_blessed_model_resolver.LatestBlessedModelResolver, model=Channel(type=Model), model_blessing=Channel(type=ModelBlessing)) # Uses TFMA to compute a evaluation statistics over features of a model and # perform quality validation of a candidate model (compared to a baseline). eval_config = tfma.EvalConfig( model_specs=[tfma.ModelSpec(signature_name='eval')], slicing_specs=[ tfma.SlicingSpec(), tfma.SlicingSpec(feature_keys=['trip_start_hour']) ], metrics_specs=[ tfma.MetricsSpec( thresholds={ 'binary_accuracy': tfma.config.MetricThreshold( value_threshold=tfma.GenericValueThreshold( lower_bound={'value': 0.6}), change_threshold=tfma.GenericChangeThreshold( direction=tfma.MetricDirection.HIGHER_IS_BETTER, absolute={'value': -1e-10})) }) ]) evaluator = Evaluator( examples=example_gen.outputs['examples'], model=trainer.outputs['model'], baseline_model=model_resolver.outputs['model'], # Change threshold will be ignored if there is no baseline (first run). eval_config=eval_config) # Checks whether the model passed the validation steps and pushes the model # to a file destination if check passed. pusher = Pusher( model=trainer.outputs['model'], model_blessing=evaluator.outputs['blessing'], push_destination=pusher_pb2.PushDestination( filesystem=pusher_pb2.PushDestination.Filesystem( base_directory=serving_model_dir))) return pipeline.Pipeline( pipeline_name=pipeline_name, pipeline_root=pipeline_root, components=[ example_gen, statistics_gen, schema_gen, example_validator, transform, trainer, model_resolver, evaluator, pusher ], enable_cache=True, metadata_connection_config=metadata.sqlite_metadata_connection_config( metadata_path), # LINT.IfChange beam_pipeline_args=[ # -------------------------- Beam Args --------------------------. '--runner=PortableRunner', # Points to the job server started in # setup_beam_on_{flink, spark}.sh '--job_endpoint=localhost:8099', '--environment_type=LOOPBACK', '--sdk_worker_parallelism=%d' % worker_parallelism, '--experiments=use_loopback_process_worker=True', # Setting environment_cache_millis to practically infinity enables # continual reuse of Beam SDK workers, improving performance. '--environment_cache_millis=1000000', # TODO(BEAM-7199): Obviate the need for setting pre_optimize=all. # pylint: disable=g-bad-todo '--experiments=pre_optimize=all', # Note; We use 100 worker threads to mitigate the issue with # scheduling work between the Beam runner and SDK harness. Flink # and Spark can process unlimited work items concurrently while # SdkHarness can only process 1 work item per worker thread. # Having 100 threads will let 100 tasks execute concurrently # avoiding scheduling issue in most cases. In case the threads are # exhausted, beam prints the relevant message in the log. # TODO(BEAM-8151) Remove worker_threads=100 after we start using a # pylint: disable=g-bad-todo # virtually unlimited thread pool by default. '--experiments=worker_threads=100', # ---------------------- End of Beam Args -----------------------. # --------- Flink runner Args (ignored by Spark runner) ---------. '--parallelism=%d' % worker_parallelism, # TODO(FLINK-10672): Obviate setting BATCH_FORCED. # pylint: disable=g-bad-todo '--execution_mode_for_batch=BATCH_FORCED', # ------------------ End of Flink runner Args -------------------. ], # LINT.ThenChange(setup/setup_beam_on_spark.sh) # LINT.ThenChange(setup/setup_beam_on_flink.sh) ) # To run this pipeline from the python CLI: # $python taxi_pipeline_portable_beam.py if __name__ == '__main__': absl.logging.set_verbosity(absl.logging.INFO) # LINT.IfChange try: parallelism = multiprocessing.cpu_count() except NotImplementedError: parallelism = 1 absl.logging.info('Using %d process(es) for Beam pipeline execution.' % parallelism) # LINT.ThenChange(setup/setup_beam_on_flink.sh) BeamDagRunner().run( _create_pipeline( pipeline_name=_pipeline_name, pipeline_root=_pipeline_root, data_root=_data_root, module_file=_module_file, serving_model_dir=_serving_model_dir, metadata_path=_metadata_path, worker_parallelism=parallelism))
the-stack_0_3329
# -*- coding: utf-8 -*-# ''' # Name: dnn_regression-keras # Description: # Author: super # Date: 2020/6/2 ''' from HelperClass2.MnistImageDataReader import * from keras.models import Sequential from keras.layers import Dense import matplotlib.pyplot as plt import os os.environ['KMP_DUPLICATE_LIB_OK']='True' def load_data(): train_file = "../data/ch09.train.npz" test_file = "../data/ch09.test.npz" dataReader = DataReader_2_0(train_file, test_file) dataReader.ReadData() # dr.NormalizeX() # dr.NormalizeY(YNormalizationMethod.Regression) dataReader.Shuffle() dataReader.GenerateValidationSet() x_train, y_train = dataReader.XTrain, dataReader.YTrain x_test, y_test = dataReader.XTest, dataReader.YTest x_val, y_val = dataReader.XDev, dataReader.YDev return x_train, y_train, x_test, y_test, x_val, y_val def build_model(): model = Sequential() model.add(Dense(4, activation='sigmoid', input_shape=(1, ))) model.add(Dense(1, activation='linear')) model.compile(optimizer='Adam', loss='mean_squared_error') return model #画出训练过程中训练和验证的精度与损失 def draw_train_history(history): plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'validation'], loc='upper left') plt.show() if __name__ == '__main__': x_train, y_train, x_test, y_test, x_val, y_val = load_data() # print(x_train.shape) # print(x_test.shape) # print(x_val.shape) model = build_model() history = model.fit(x_train, y_train, epochs=50, batch_size=10, validation_data=(x_val, y_val)) draw_train_history(history) loss = model.evaluate(x_test, y_test) print("test loss: {}".format(loss)) weights = model.get_weights() print("weights: ", weights)
the-stack_0_3332
from theano import function, config, shared, tensor import numpy import time vlen = 10 * 30 * 768 # 10 x #cores x # threads per core iters = 1000 rng = numpy.random.RandomState(22) x = shared(numpy.asarray(rng.rand(vlen), config.floatX)) f = function([], tensor.exp(x)) print(f.maker.fgraph.toposort()) t0 = time.time() for i in range(iters): r = f() t1 = time.time() print("Looping %d times took %f seconds" % (iters, t1 - t0)) print("Result is %s" % (r,)) if numpy.any([isinstance(x.op, tensor.Elemwise) and ('Gpu' not in type(x.op).__name__) for x in f.maker.fgraph.toposort()]): print('Used the cpu') else: print('Used the gpu')
the-stack_0_3334
# flake8: noqa: E402 import time from kube_hunter.conf import Config, set_config set_config(Config()) from kube_hunter.core.events.event_handler import handler from kube_hunter.core.events.types import K8sVersionDisclosure from kube_hunter.modules.hunting.cves import ( K8sClusterCveHunter, ServerApiVersionEndPointAccessPE, ServerApiVersionEndPointAccessDos, CveUtils, ) cve_counter = 0 def test_K8sCveHunter(): global cve_counter # because the hunter unregisters itself, we manually remove this option, so we can test it K8sClusterCveHunter.__new__ = lambda self, cls: object.__new__(self) e = K8sVersionDisclosure(version="1.10.1", from_endpoint="/version") h = K8sClusterCveHunter(e) h.execute() time.sleep(0.01) assert cve_counter == 2 cve_counter = 0 # test patched version e = K8sVersionDisclosure(version="v1.13.6-gke.13", from_endpoint="/version") h = K8sClusterCveHunter(e) h.execute() time.sleep(0.01) assert cve_counter == 0 cve_counter = 0 @handler.subscribe(ServerApiVersionEndPointAccessPE) class test_CVE_2018_1002105: def __init__(self, event): global cve_counter cve_counter += 1 @handler.subscribe(ServerApiVersionEndPointAccessDos) class test_CVE_2019_1002100: def __init__(self, event): global cve_counter cve_counter += 1 class TestCveUtils: def test_is_downstream(self): test_cases = ( ("1", False), ("1.2", False), ("1.2-3", True), ("1.2-r3", True), ("1.2+3", True), ("1.2~3", True), ("1.2+a3f5cb2", True), ("1.2-9287543", True), ("v1", False), ("v1.2", False), ("v1.2-3", True), ("v1.2-r3", True), ("v1.2+3", True), ("v1.2~3", True), ("v1.2+a3f5cb2", True), ("v1.2-9287543", True), ("v1.13.9-gke.3", True), ) for version, expected in test_cases: actual = CveUtils.is_downstream_version(version) assert actual == expected def test_ignore_downstream(self): test_cases = ( ("v2.2-abcd", ["v1.1", "v2.3"], False), ("v2.2-abcd", ["v1.1", "v2.2"], False), ("v1.13.9-gke.3", ["v1.14.8"], False), ) for check_version, fix_versions, expected in test_cases: actual = CveUtils.is_vulnerable(fix_versions, check_version, True) assert actual == expected
the-stack_0_3340
### Simulate a large number of coin flips using Python ### from random import randint def coingame(numflips: int, gamenum: int): flips = [] for _ in range(0, numflips): flips.append(randint(0, 1)) heads = flips.count(0) tails = flips.count(1) # Printing the results and showing the distribution with a pie graph print(f"Game {gamenum + 1} | Heads: {heads:,} | Tails: {tails:,} | Total: {heads + tails:,}") if __name__ == '__main__': # Call the function with the number of games and flips games = 5 flips = 1000000 print("< Python >") for i in range(0, games): coingame(flips, i)
the-stack_0_3341
# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Add master_addresses to bay Revision ID: 6f21dc998bb Revises: 421102d1f2d2 Create Date: 2015-08-20 13:57:14.863292 """ # revision identifiers, used by Alembic. revision = '6f21dc998bb' down_revision = '421102d1f2d2' from alembic import op # noqa: E402 from magnum.db.sqlalchemy import models # noqa: E402 import sqlalchemy as sa # noqa: E402 def upgrade(): op.add_column( 'bay', sa.Column('master_addresses', models.JSONEncodedList(), nullable=True) )
the-stack_0_3344
import mock import csv import furl import pytz import pytest from datetime import datetime, timedelta from nose import tools as nt from django.test import RequestFactory from django.http import Http404 from django.core.files.uploadedfile import SimpleUploadedFile from django.utils import timezone from django.core.urlresolvers import reverse from django.core.exceptions import PermissionDenied from django.contrib.auth.models import Permission from tests.base import AdminTestCase from website import settings from framework.auth import Auth from osf.models.user import OSFUser from osf.models.tag import Tag from osf_tests.factories import ( UserFactory, AuthUserFactory, ProjectFactory, TagFactory, UnconfirmedUserFactory ) from admin_tests.utilities import setup_view, setup_log_view, setup_form_view from admin.users import views from admin.users.forms import WorkshopForm, UserSearchForm from osf.models.admin_log_entry import AdminLogEntry pytestmark = pytest.mark.django_db class TestUserView(AdminTestCase): def test_no_guid(self): request = RequestFactory().get('/fake_path') view = views.UserView() view = setup_view(view, request) with nt.assert_raises(AttributeError): view.get_object() def test_load_data(self): user = UserFactory() guid = user._id request = RequestFactory().get('/fake_path') view = views.UserView() view = setup_view(view, request, guid=guid) res = view.get_object() nt.assert_is_instance(res, dict) def test_name_data(self): user = UserFactory() guid = user._id request = RequestFactory().get('/fake_path') view = views.UserView() view = setup_view(view, request, guid=guid) temp_object = view.get_object() view.object = temp_object res = view.get_context_data() nt.assert_equal(res[views.UserView.context_object_name], temp_object) def test_no_user_permissions_raises_error(self): user = UserFactory() guid = user._id request = RequestFactory().get(reverse('users:user', kwargs={'guid': guid})) request.user = user with self.assertRaises(PermissionDenied): views.UserView.as_view()(request, guid=guid) def test_correct_view_permissions(self): user = UserFactory() guid = user._id view_permission = Permission.objects.get(codename='view_osfuser') user.user_permissions.add(view_permission) user.save() request = RequestFactory().get(reverse('users:user', kwargs={'guid': guid})) request.user = user response = views.UserView.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class TestResetPasswordView(AdminTestCase): def setUp(self): super(TestResetPasswordView, self).setUp() self.user = UserFactory() self.request = RequestFactory().get('/fake_path') self.request.user = self.user self.plain_view = views.ResetPasswordView self.view = setup_view(self.plain_view(), self.request, guid=self.user._id) def test_get_initial(self): self.view.user = self.user self.view.get_initial() res = self.view.initial nt.assert_is_instance(res, dict) nt.assert_equal(res['guid'], self.user._id) nt.assert_equal(res['emails'], [(r, r) for r in self.user.emails.values_list('address', flat=True)]) def test_reset_password_context(self): self.view.user = self.user res = self.view.get_context_data() nt.assert_is_instance(res, dict) nt.assert_in((self.user.emails.first().address, self.user.emails.first().address), self.view.initial['emails']) def test_no_user_permissions_raises_error(self): user = UserFactory() guid = user._id request = RequestFactory().get(reverse('users:reset_password', kwargs={'guid': guid})) request.user = user with self.assertRaises(PermissionDenied): views.ResetPasswordView.as_view()(request, guid=guid) def test_correct_view_permissions(self): user = UserFactory() guid = user._id change_permission = Permission.objects.get(codename='change_osfuser') user.user_permissions.add(change_permission) user.save() request = RequestFactory().get(reverse('users:reset_password', kwargs={'guid': guid})) request.user = user response = views.ResetPasswordView.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class TestDisableUser(AdminTestCase): def setUp(self): self.user = UserFactory() self.request = RequestFactory().post('/fake_path') self.view = views.UserDeleteView self.view = setup_log_view(self.view, self.request, guid=self.user._id) def test_get_object(self): obj = self.view().get_object() nt.assert_is_instance(obj, OSFUser) def test_get_context(self): res = self.view().get_context_data(object=self.user) nt.assert_in('guid', res) nt.assert_equal(res.get('guid'), self.user._id) def test_disable_user(self): settings.ENABLE_EMAIL_SUBSCRIPTIONS = False count = AdminLogEntry.objects.count() self.view().delete(self.request) self.user.reload() nt.assert_true(self.user.is_disabled) nt.assert_equal(AdminLogEntry.objects.count(), count + 1) def test_reactivate_user(self): settings.ENABLE_EMAIL_SUBSCRIPTIONS = False self.view().delete(self.request) count = AdminLogEntry.objects.count() self.view().delete(self.request) self.user.reload() nt.assert_false(self.user.is_disabled) nt.assert_equal(AdminLogEntry.objects.count(), count + 1) def test_no_user(self): view = setup_view(views.UserDeleteView(), self.request, guid='meh') with nt.assert_raises(Http404): view.delete(self.request) def test_no_user_permissions_raises_error(self): user = UserFactory() guid = user._id request = RequestFactory().get(reverse('users:disable', kwargs={'guid': guid})) request.user = user with self.assertRaises(PermissionDenied): self.view.as_view()(request, guid=guid) def test_correct_view_permissions(self): user = UserFactory() guid = user._id change_permission = Permission.objects.get(codename='change_osfuser') user.user_permissions.add(change_permission) user.save() request = RequestFactory().get(reverse('users:disable', kwargs={'guid': guid})) request.user = user response = self.view.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class TestHamUserRestore(AdminTestCase): def setUp(self): self.user = UserFactory() self.request = RequestFactory().post('/fake_path') self.view = views.HamUserRestoreView self.view = setup_log_view(self.view, self.request, guid=self.user._id) self.spam_confirmed, created = Tag.objects.get_or_create(name='spam_confirmed') self.ham_confirmed, created = Tag.objects.get_or_create(name='ham_confirmed') def test_get_object(self): obj = self.view().get_object() nt.assert_is_instance(obj, OSFUser) def test_get_context(self): res = self.view().get_context_data(object=self.user) nt.assert_in('guid', res) nt.assert_equal(res.get('guid'), self.user._id) def test_enable_user(self): self.user.disable_account() self.user.save() nt.assert_true(self.user.is_disabled) self.view().delete(self.request) self.user.reload() nt.assert_false(self.user.is_disabled) nt.assert_false(self.user.all_tags.filter(name=self.spam_confirmed.name).exists()) nt.assert_true(self.user.all_tags.filter(name=self.ham_confirmed.name).exists()) class TestDisableSpamUser(AdminTestCase): def setUp(self): self.user = UserFactory() self.public_node = ProjectFactory(creator=self.user, is_public=True) self.private_node = ProjectFactory(creator=self.user, is_public=False) self.request = RequestFactory().post('/fake_path') self.view = views.SpamUserDeleteView self.view = setup_log_view(self.view, self.request, guid=self.user._id) def test_get_object(self): obj = self.view().get_object() nt.assert_is_instance(obj, OSFUser) def test_get_context(self): res = self.view().get_context_data(object=self.user) nt.assert_in('guid', res) nt.assert_equal(res.get('guid'), self.user._id) def test_disable_spam_user(self): settings.ENABLE_EMAIL_SUBSCRIPTIONS = False count = AdminLogEntry.objects.count() self.view().delete(self.request) self.user.reload() self.public_node.reload() nt.assert_true(self.user.is_disabled) nt.assert_true(self.user.all_tags.filter(name='spam_confirmed').exists()) nt.assert_false(self.public_node.is_public) nt.assert_equal(AdminLogEntry.objects.count(), count + 3) def test_no_user(self): view = setup_view(self.view(), self.request, guid='meh') with nt.assert_raises(Http404): view.delete(self.request) def test_no_user_permissions_raises_error(self): user = UserFactory() guid = user._id request = RequestFactory().get(reverse('users:spam_disable', kwargs={'guid': guid})) request.user = user with self.assertRaises(PermissionDenied): self.view.as_view()(request, guid=guid) def test_correct_view_permissions(self): user = UserFactory() guid = user._id change_permission = Permission.objects.get(codename='change_osfuser') user.user_permissions.add(change_permission) user.save() request = RequestFactory().get(reverse('users:spam_disable', kwargs={'guid': guid})) request.user = user response = self.view.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class SpamUserListMixin(object): def setUp(self): spam_flagged = TagFactory(name='spam_flagged') spam_confirmed = TagFactory(name='spam_confirmed') ham_confirmed = TagFactory(name='ham_confirmed') self.flagged_user = UserFactory() self.flagged_user.tags.add(spam_flagged) self.flagged_user.save() self.spam_user = UserFactory() self.spam_user.tags.add(spam_confirmed) self.spam_user.save() self.ham_user = UserFactory() self.ham_user.tags.add(ham_confirmed) self.ham_user.save() self.request = RequestFactory().post('/fake_path') def test_no_user_permissions_raises_error(self): user = UserFactory() guid = user._id request = RequestFactory().get(self.url) request.user = user with self.assertRaises(PermissionDenied): self.plain_view.as_view()(request, guid=guid) def test_correct_view_permissions(self): user = UserFactory() guid = user._id view_permission = Permission.objects.get(codename='view_osfuser') spam_permission = Permission.objects.get(codename='view_spam') user.user_permissions.add(view_permission) user.user_permissions.add(spam_permission) user.save() request = RequestFactory().get(self.url) request.user = user response = self.plain_view.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class TestFlaggedSpamUserList(SpamUserListMixin, AdminTestCase): def setUp(self): super(TestFlaggedSpamUserList, self).setUp() self.plain_view = views.UserFlaggedSpamList self.view = setup_log_view(self.plain_view(), self.request) self.url = reverse('users:flagged-spam') def test_get_queryset(self): qs = self.view.get_queryset() nt.assert_equal(qs.count(), 1) nt.assert_equal(qs[0]._id, self.flagged_user._id) class TestConfirmedSpamUserList(SpamUserListMixin, AdminTestCase): def setUp(self): super(TestConfirmedSpamUserList, self).setUp() self.plain_view = views.UserKnownSpamList self.view = setup_log_view(self.plain_view(), self.request) self.url = reverse('users:known-spam') def test_get_queryset(self): qs = self.view.get_queryset() nt.assert_equal(qs.count(), 1) nt.assert_equal(qs[0]._id, self.spam_user._id) class TestConfirmedHamUserList(SpamUserListMixin, AdminTestCase): def setUp(self): super(TestConfirmedHamUserList, self).setUp() self.plain_view = views.UserKnownHamList self.view = setup_log_view(self.plain_view(), self.request) self.url = reverse('users:known-ham') def test_get_queryset(self): qs = self.view.get_queryset() nt.assert_equal(qs.count(), 1) nt.assert_equal(qs[0]._id, self.ham_user._id) class TestRemove2Factor(AdminTestCase): def setUp(self): super(TestRemove2Factor, self).setUp() self.user = AuthUserFactory() self.request = RequestFactory().post('/fake_path') self.view = views.User2FactorDeleteView self.setup_view = setup_log_view(self.view(), self.request, guid=self.user._id) self.url = reverse('users:remove2factor', kwargs={'guid': self.user._id}) @mock.patch('osf.models.user.OSFUser.delete_addon') def test_remove_two_factor_get(self, mock_delete_addon): self.setup_view.delete(self.request) mock_delete_addon.assert_called_with('twofactor') def test_integration_delete_two_factor(self): user_addon = self.user.get_or_add_addon('twofactor') nt.assert_not_equal(user_addon, None) user_settings = self.user.get_addon('twofactor') nt.assert_not_equal(user_settings, None) count = AdminLogEntry.objects.count() self.setup_view.delete(self.request) post_addon = self.user.get_addon('twofactor') nt.assert_equal(post_addon, None) nt.assert_equal(AdminLogEntry.objects.count(), count + 1) def test_no_user_permissions_raises_error(self): guid = self.user._id request = RequestFactory().get(self.url) request.user = self.user with self.assertRaises(PermissionDenied): self.view.as_view()(request, guid=guid) def test_correct_view_permissions(self): guid = self.user._id change_permission = Permission.objects.get(codename='change_osfuser') self.user.user_permissions.add(change_permission) self.user.save() request = RequestFactory().get(self.url) request.user = self.user response = self.view.as_view()(request, guid=guid) self.assertEqual(response.status_code, 200) class TestUserWorkshopFormView(AdminTestCase): def setUp(self): self.user_1 = AuthUserFactory() self.auth_1 = Auth(self.user_1) self.view = views.UserWorkshopFormView() self.workshop_date = timezone.now() self.data = [ ['none', 'date', 'none', 'none', 'none', 'email', 'none'], [None, self.workshop_date.strftime('%m/%d/%y'), None, None, None, self.user_1.username, None], ] self.user_exists_by_name_data = [ ['number', 'date', 'location', 'topic', 'name', 'email', 'other'], [None, self.workshop_date.strftime('%m/%d/%y'), None, None, self.user_1.fullname, '[email protected]', None], ] self.user_not_found_data = [ ['none', 'date', 'none', 'none', 'none', 'email', 'none'], [None, self.workshop_date.strftime('%m/%d/%y'), None, None, None, '[email protected]', None], ] self.mock_data = mock.patch.object( csv, 'reader', # parse data into the proper format handling None values as csv reader would side_effect=(lambda values: [[item or '' for item in value] for value in values]) ) self.mock_data.start() def tearDown(self): self.mock_data.stop() def _create_and_parse_test_file(self, data): result_csv = self.view.parse(data) return result_csv def _create_nodes_and_add_logs(self, first_activity_date, second_activity_date=None): node_one = ProjectFactory(creator=self.user_1) node_one.date_created = first_activity_date node_one.add_log( 'log_added', params={'project': node_one._id}, auth=self.auth_1, log_date=first_activity_date, save=True ) if second_activity_date: node_two = ProjectFactory(creator=self.user_1) node_two.date_created = second_activity_date node_two.add_log( 'log_added', params={'project': node_two._id}, auth=self.auth_1, log_date=second_activity_date, save=True ) def test_correct_number_of_columns_added(self): added_columns = ['OSF ID', 'Logs Since Workshop', 'Nodes Created Since Workshop', 'Last Log Data'] result_csv = self._create_and_parse_test_file(self.data) nt.assert_equal(len(self.data[0]) + len(added_columns), len(result_csv[0])) def test_user_activity_day_of_workshop_only(self): self._create_nodes_and_add_logs(first_activity_date=self.workshop_date) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_logs_since_workshop, 0) nt.assert_equal(user_nodes_created_since_workshop, 0) def test_user_activity_before_workshop_only(self): activity_date = timezone.now() - timedelta(days=1) self._create_nodes_and_add_logs(first_activity_date=activity_date) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_logs_since_workshop, 0) nt.assert_equal(user_nodes_created_since_workshop, 0) def test_user_activity_after_workshop_only(self): activity_date = timezone.now() + timedelta(hours=25) self._create_nodes_and_add_logs(first_activity_date=activity_date) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_logs_since_workshop, 1) nt.assert_equal(user_nodes_created_since_workshop, 1) def test_user_activity_day_of_workshop_and_before(self): activity_date = timezone.now() - timedelta(days=1) self._create_nodes_and_add_logs( first_activity_date=self.workshop_date, second_activity_date=activity_date ) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_logs_since_workshop, 0) nt.assert_equal(user_nodes_created_since_workshop, 0) def test_user_activity_day_of_workshop_and_after(self): activity_date = timezone.now() + timedelta(hours=25) self._create_nodes_and_add_logs( first_activity_date=self.workshop_date, second_activity_date=activity_date ) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_logs_since_workshop, 1) nt.assert_equal(user_nodes_created_since_workshop, 1) def test_user_activity_before_workshop_and_after(self): before_activity_date = timezone.now() - timedelta(days=1) after_activity_date = timezone.now() + timedelta(hours=25) self._create_nodes_and_add_logs( first_activity_date=before_activity_date, second_activity_date=after_activity_date ) result_csv = self._create_and_parse_test_file(self.data) user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] # One log before workshop, one after, only should show the one after nt.assert_equal(user_logs_since_workshop, 1) nt.assert_equal(user_nodes_created_since_workshop, 1) def test_user_osf_account_not_found(self): result_csv = self._create_and_parse_test_file(self.user_not_found_data) user_id = result_csv[1][-4] last_log_date = result_csv[1][-1] user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_id, '') nt.assert_equal(last_log_date, '') nt.assert_equal(user_logs_since_workshop, 0) nt.assert_equal(user_nodes_created_since_workshop, 0) def test_user_found_by_name(self): result_csv = self._create_and_parse_test_file(self.user_exists_by_name_data) user_id = result_csv[1][-4] last_log_date = result_csv[1][-1] user_logs_since_workshop = result_csv[1][-3] user_nodes_created_since_workshop = result_csv[1][-2] nt.assert_equal(user_id, self.user_1.id) nt.assert_equal(last_log_date, '') nt.assert_equal(user_logs_since_workshop, 0) nt.assert_equal(user_nodes_created_since_workshop, 0) def test_form_valid(self): request = RequestFactory().post('/fake_path') data = [ ['none', 'date', 'none', 'none', 'none', 'email', 'none'], [None, '9/1/16', None, None, None, self.user_1.username, None], ] uploaded = SimpleUploadedFile('test_name', bytes(csv.reader(data)), content_type='text/csv') form = WorkshopForm(data={'document': uploaded}) form.is_valid() form.cleaned_data['document'] = uploaded setup_form_view(self.view, request, form) class TestUserSearchView(AdminTestCase): def setUp(self): self.user_1 = AuthUserFactory(fullname='Broken Matt Hardy') self.user_2 = AuthUserFactory(fullname='Jeff Hardy') self.user_3 = AuthUserFactory(fullname='Reby Sky') self.user_4 = AuthUserFactory(fullname='King Maxel Hardy') self.user_2_alternate_email = '[email protected]' self.user_2.emails.create(address=self.user_2_alternate_email) self.user_2.save() self.request = RequestFactory().get('/fake_path') self.view = views.UserFormView() self.view = setup_form_view(self.view, self.request, form=UserSearchForm()) def test_search_user_by_guid(self): form_data = { 'guid': self.user_1.guids.first()._id } form = UserSearchForm(data=form_data) nt.assert_true(form.is_valid()) response = self.view.form_valid(form) nt.assert_equal(response.status_code, 302) nt.assert_equal(self.view.success_url, '/users/{}/'.format(self.user_1.guids.first()._id)) def test_search_user_by_name(self): form_data = { 'name': 'Hardy' } form = UserSearchForm(data=form_data) nt.assert_true(form.is_valid()) response = self.view.form_valid(form) nt.assert_equal(response.status_code, 302) nt.assert_equal(self.view.success_url, '/users/search/Hardy/') def test_search_user_by_username(self): form_data = { 'email': self.user_1.username } form = UserSearchForm(data=form_data) nt.assert_true(form.is_valid()) response = self.view.form_valid(form) nt.assert_equal(response.status_code, 302) nt.assert_equal(self.view.success_url, '/users/{}/'.format(self.user_1.guids.first()._id)) def test_search_user_by_alternate_email(self): form_data = { 'email': self.user_2_alternate_email } form = UserSearchForm(data=form_data) nt.assert_true(form.is_valid()) response = self.view.form_valid(form) nt.assert_equal(response.status_code, 302) nt.assert_equal(self.view.success_url, '/users/{}/'.format(self.user_2.guids.first()._id)) def test_search_user_list(self): view = views.UserSearchList() view = setup_view(view, self.request) view.kwargs = {'name': 'Hardy'} results = view.get_queryset() nt.assert_equal(len(results), 3) for user in results: nt.assert_in('Hardy', user.fullname) def test_search_user_list_case_insensitive(self): view = views.UserSearchList() view = setup_view(view, self.request) view.kwargs = {'name': 'hardy'} results = view.get_queryset() nt.assert_equal(len(results), 3) for user in results: nt.assert_in('Hardy', user.fullname) class TestGetLinkView(AdminTestCase): def test_get_user_confirmation_link(self): user = UnconfirmedUserFactory() request = RequestFactory().get('/fake_path') view = views.GetUserConfirmationLink() view = setup_view(view, request, guid=user._id) user_token = user.email_verifications.keys()[0] ideal_link_path = '/confirm/{}/{}/'.format(user._id, user_token) link = view.get_link(user) link_path = str(furl.furl(link).path) nt.assert_equal(link_path, ideal_link_path) def test_get_user_confirmation_link_with_expired_token(self): user = UnconfirmedUserFactory() request = RequestFactory().get('/fake_path') view = views.GetUserConfirmationLink() view = setup_view(view, request, guid=user._id) old_user_token = user.email_verifications.keys()[0] user.email_verifications[old_user_token]['expiration'] = datetime.utcnow().replace(tzinfo=pytz.utc) - timedelta(hours=24) user.save() link = view.get_link(user) new_user_token = user.email_verifications.keys()[0] link_path = str(furl.furl(link).path) ideal_link_path = '/confirm/{}/{}/'.format(user._id, new_user_token) nt.assert_equal(link_path, ideal_link_path) def test_get_password_reset_link(self): user = UnconfirmedUserFactory() request = RequestFactory().get('/fake_path') view = views.GetPasswordResetLink() view = setup_view(view, request, guid=user._id) link = view.get_link(user) user_token = user.verification_key_v2.get('token') nt.assert_is_not_none(user_token) ideal_link_path = '/resetpassword/{}/{}'.format(user._id, user_token) link_path = str(furl.furl(link).path) nt.assert_equal(link_path, ideal_link_path) def test_get_unclaimed_node_links(self): project = ProjectFactory() unregistered_contributor = project.add_unregistered_contributor(fullname='Brother Nero', email='[email protected]', auth=Auth(project.creator)) project.save() request = RequestFactory().get('/fake_path') view = views.GetUserClaimLinks() view = setup_view(view, request, guid=unregistered_contributor._id) links = view.get_claim_links(unregistered_contributor) unclaimed_records = unregistered_contributor.unclaimed_records nt.assert_equal(len(links), 1) nt.assert_equal(len(links), len(unclaimed_records.keys())) link = links[0] nt.assert_in(project._id, link) nt.assert_in(unregistered_contributor.unclaimed_records[project._id]['token'], link) class TestUserReindex(AdminTestCase): def setUp(self): super(TestUserReindex, self).setUp() self.request = RequestFactory().post('/fake_path') self.user = AuthUserFactory() @mock.patch('website.search.search.update_user') def test_reindex_user_elastic(self, mock_reindex_elastic): count = AdminLogEntry.objects.count() view = views.UserReindexElastic() view = setup_log_view(view, self.request, guid=self.user._id) view.delete(self.request) nt.assert_true(mock_reindex_elastic.called) nt.assert_equal(AdminLogEntry.objects.count(), count + 1)
the-stack_0_3345
#!/usr/bin/env python # # Public Domain 2014-2016 MongoDB, Inc. # Public Domain 2008-2014 WiredTiger, Inc. # # This is free and unencumbered software released into the public domain. # # Anyone is free to copy, modify, publish, use, compile, sell, or # distribute this software, either in source code form or as a compiled # binary, for any purpose, commercial or non-commercial, and by any # means. # # In jurisdictions that recognize copyright laws, the author or authors # of this software dedicate any and all copyright interest in the # software to the public domain. We make this dedication for the benefit # of the public at large and to the detriment of our heirs and # successors. We intend this dedication to be an overt act of # relinquishment in perpetuity of all present and future rights to this # software under copyright law. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # # test_cursor08.py # Log cursors with compression # import fnmatch, os, shutil, run, time from suite_subprocess import suite_subprocess from wiredtiger import stat, WiredTigerError from wtscenario import multiply_scenarios, number_scenarios, check_scenarios import wttest class test_cursor08(wttest.WiredTigerTestCase, suite_subprocess): logmax = "100K" tablename = 'test_cursor08' uri = 'table:' + tablename nkeys = 500 reopens = check_scenarios([ ('regular', dict(reopen=False)), ('reopen', dict(reopen=True)) ]) compress = check_scenarios([ ('nop', dict(compress='nop')), ('snappy', dict(compress='snappy')), ('zlib', dict(compress='zlib')), ('none', dict(compress='none')), ]) scenarios = number_scenarios(multiply_scenarios('.', reopens, compress)) # Load the compression extension, and enable it for logging. def conn_config(self, dir): return 'log=(archive=false,enabled,file_max=%s,' % self.logmax + \ 'compressor=%s),' % self.compress + \ 'transaction_sync="(method=dsync,enabled)",' + \ self.extensionArg(self.compress) # Return the wiredtiger_open extension argument for a shared library. def extensionArg(self, name): if name == None or name == 'none': return '' testdir = os.path.dirname(__file__) extdir = os.path.join(run.wt_builddir, 'ext/compressors') extfile = os.path.join( extdir, name, '.libs', 'libwiredtiger_' + name + '.so') if not os.path.exists(extfile): self.skipTest('compression extension "' + extfile + '" not built') return ',extensions=["' + extfile + '"]' def test_log_cursor(self): # print "Creating %s with config '%s'" % (self.uri, self.create_params) create_params = 'key_format=i,value_format=S' self.session.create(self.uri, create_params) c = self.session.open_cursor(self.uri, None) # A binary value. value = u'\u0001\u0002abcd\u0003\u0004' self.session.begin_transaction() for k in range(self.nkeys): c[k] = value self.session.commit_transaction() c.close() if self.reopen: self.reopen_conn() # Check for these values via a log cursor c = self.session.open_cursor("log:", None) count = 0 while c.next() == 0: # lsn.file, lsn.offset, opcount keys = c.get_key() # txnid, rectype, optype, fileid, logrec_key, logrec_value values = c.get_value() try: if value in str(values[5]): # logrec_value count += 1 except: pass c.close() self.assertEqual(count, self.nkeys) if __name__ == '__main__': wttest.run()
the-stack_0_3346
""" pyEngine_problem """ # ============================================================================= # Imports # ============================================================================= from .pyAero_problem import AeroProblem class EngineProblem(AeroProblem): """ The EngineProblem class inherits from the AeroProblem class so that aerodynamic solvers (AeroSolver) and engine models (EngineModelSMT) can reference the same flight condition without needing to define redundant information. The EngineProblem layer simply adds a few possible design variables and handles some stuff with derivatives. Parameters ---------- name : str Name of this Engine problem. evalFuncs : iterable object containing strings The names of the functions the user wants evaluated for this engineProblem. throttle : float Initial value for throttle variable ISA : float Initial value for ISA temperature variable""" def __init__(self, name, throttle=1.0, ISA=0.0, **kwargs): # Initialize AeroProblem super().__init__(name, **kwargs) # Set initial throttle or ISA self.throttle = throttle self.ISA = ISA # Update AeroProblem variable sets with possible engine variables newVars = ["throttle", "ISA"] self.allVarFuncs += newVars self.possibleDVs.update(newVars) self.possibleFunctions.update(newVars)
the-stack_0_3347
import mock import pytest from ocflib.ucb.cas import verify_ticket @pytest.yield_fixture def mock_get(): with mock.patch('requests.get') as mock_get: yield mock_get GOOD_RESPONSE = """ <cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'> <cas:authenticationSuccess> <cas:user>1034192</cas:user> </cas:authenticationSuccess> </cas:serviceResponse>""" BAD_RESPONSE = """ <cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'> <cas:authenticationFailure code='INVALID_TICKET'> ticket &#039;ST-832595-ZOm6NYCTBJO0d41jjL6l-ncas-p3.calnet.berkeley.edu&#039; not recognized </cas:authenticationFailure> </cas:serviceResponse>""" class TestVerifyTicket: def test_good_ticket(self, mock_get): mock_get.return_value.text = GOOD_RESPONSE assert verify_ticket( 'some-ticket', 'https://accounts.ocf.berkeley.edu/', ) == '1034192' called_url = mock_get.call_args[0][0] start = 'https://auth.berkeley.edu/cas/serviceValidate?' assert called_url.startswith(start) params = called_url[len(start):].split('&') assert sorted(params) == [ 'service=https%3A%2F%2Faccounts.ocf.berkeley.edu%2F', 'ticket=some-ticket', ] @pytest.mark.parametrize('response', [ BAD_RESPONSE, '', 'hello world', ]) def test_bad_ticket(self, response, mock_get): mock_get.return_value.text = response assert verify_ticket( 'some-ticket', 'https://accounts.ocf.berkeley.edu/', ) is None
the-stack_0_3350
import logging from Request import * from RandomUtil import * # Extremely basic check to determine if a post is what we are looking for def determineExchangeType(submission): opFlair = submission.link_flair_text opTitle = submission.title.lower() opTitle = opTitle.split("[w]")[0] # Check to ensure the exchange hasn't already been completed if opFlair is not None and opFlair.lower() == "closed": return "" for cardType in searchDict: if len(searchDict[cardType]) > 0: if any(string in opTitle for string in hitWordDict[cardType]): logging.info("Found a valid %s post: %s", cardType, opTitle) return cardType return ""
the-stack_0_3351
from models.network import Net from learning.learning import create_learners, train_model, test_model, Trainer from learning.testing import CorrelationMatrix, ResidualStatistics from data.load_data import load_synth_spectra, split_data import matplotlib.pyplot as plt import numpy as np import torch from torch.autograd import Variable #from utils.errorfuncs import corr_matrix_relresids plt.rcParams["font.family"] = "serif" # first train on the npca=6 set # then test on the npca=15 set # also perform the splitting for better comparison wave_grid, qso_cont_npca6, qso_flux_npca6 = load_synth_spectra(small=False, npca=6) X_train6, X_valid6, X_test6, y_train6, y_valid6, y_test6 = split_data(qso_flux_npca6, qso_cont_npca6) wave_grid15, qso_cont_npca15, qso_flux_npca15 = load_synth_spectra(small=False, npca=15) X_train15, X_valid15, X_test15, y_train15, y_valid15, y_test15 = split_data(qso_flux_npca15, qso_cont_npca15) n_feature = len(X_train6[1]) n_output = len(y_train6[1]) net = Net(n_feature, 100, n_output) optimizer, criterion = create_learners(net.parameters()) trainer = Trainer(net, optimizer, criterion, batch_size=1000, num_epochs=400) trainer.train(wave_grid, X_train6, y_train6, X_valid6, y_valid6) #running_loss, mse_loss_valid, scaler_X, scaler_y = train_model(wave_grid, X_train6, y_train6,\ # X_valid6, y_valid6, net, optimizer,\ # criterion, batch_size=1000, num_epochs=400) #epochs = np.arange(1, len(running_loss)+1) # plot the test statistics as a function of wavelength Stats = ResidualStatistics(X_test15, y_test15, trainer.scaler_X, trainer.scaler_y, net) fig0, ax0 = Stats.plot_means(wave_grid) fig0.show() # test the final model and print the result #mse_test, corr_matrix = test_model(X_test, y_test, scaler_X, scaler_y, net) #print ("MSE on test set:", mse_test) fig, ax = trainer.plot_loss() #ax.plot(epochs, running_loss, label="Training set") #ax.plot(epochs, mse_loss_valid, label="Validation set") #ax.legend() #ax.set_xlabel("Epoch number") #ax.set_ylabel("MSE") #ax.set_yscale("log") #ax.set_title("Mean squared error on the normalised spectra") fig.show() # now plot an example result on the npca = 15 TEST set rand_indx = np.random.randint(len(X_test15)) rescaled_result = net.full_predict(X_test15[rand_indx], trainer.scaler_X, trainer.scaler_y) #test_input_normed = normalise(scaler_X, X_test[rand_indx]) #test_input_normed_var = Variable(torch.FloatTensor(test_input_normed.numpy())) #normed_result = net(test_input_normed_var) #rescaled_result = scaler_y.backward(normed_result) fig2, ax2 = plt.subplots(figsize=(7,5), dpi=320) ax2.plot(wave_grid, X_test15[rand_indx], alpha=0.8, lw=2, label="Input") ax2.plot(wave_grid, y_test15[rand_indx], alpha=0.8, lw=2, label="Target") ax2.plot(wave_grid, rescaled_result, alpha=0.8, lw=2, label="Output") ax2.set_xlabel("Rest-frame wavelength ($\AA$)") ax2.set_ylabel("Flux (a.u.)") ax2.legend() ax2.grid() ax2.set_title("Example of a predicted quasar spectrum") fig2.show() # visualise the correlation matrix for the npca = 15 TEST set CorrMat = CorrelationMatrix(X_test15, y_test15, trainer.scaler_X, trainer.scaler_y, net) CorrMat.show(wave_grid) #fig3, ax3 = plt.subplots() #im = ax3.pcolormesh(wave_grid, wave_grid, corr_matrix) #fig3.show()
the-stack_0_3352
import tkinter as tk import tkinter.messagebox as msg import os import sqlite3 class Todo(tk.Tk): def __init__(self, tasks=None): super().__init__() if not tasks: self.tasks = [] else: self.tasks = tasks self.tasks_canvas = tk.Canvas(self) self.tasks_frame = tk.Frame(self.tasks_canvas) self.text_frame = tk.Frame(self) self.scrollbar = tk.Scrollbar(self.tasks_canvas, orient="vertical", command=self.tasks_canvas.yview) self.tasks_canvas.configure(yscrollcommand=self.scrollbar.set) self.title("To-Do App v3") self.geometry("300x400") self.task_create = tk.Text(self.text_frame, height=3, bg="white", fg="black") self.tasks_canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1) self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y) self.canvas_frame = self.tasks_canvas.create_window((0, 0), window=self.tasks_frame, anchor="n") self.task_create.pack(side=tk.BOTTOM, fill=tk.X) self.text_frame.pack(side=tk.BOTTOM, fill=tk.X) self.task_create.focus_set() self.colour_schemes = [{"bg": "lightgrey", "fg": "black"}, {"bg": "grey", "fg": "white"}] current_tasks = self.load_tasks() for task in current_tasks: task_text = task[0] self.add_task(None, task_text, True) self.bind("<Return>", self.add_task) self.bind("<Configure>", self.on_frame_configure) self.bind_all("<MouseWheel>", self.mouse_scroll) self.bind_all("<Button-4>", self.mouse_scroll) self.bind_all("<Button-5>", self.mouse_scroll) self.tasks_canvas.bind("<Configure>", self.task_width) def add_task(self, event=None, task_text=None, from_db=False): if not task_text: task_text = self.task_create.get(1.0, tk.END).strip() if len(task_text) > 0: new_task = tk.Label(self.tasks_frame, text=task_text, pady=10) self.set_task_colour(len(self.tasks), new_task) new_task.bind("<Button-1>", self.remove_task) new_task.pack(side=tk.TOP, fill=tk.X) self.tasks.append(new_task) if not from_db: self.save_task(task_text) self.task_create.delete(1.0, tk.END) def remove_task(self, event): task = event.widget if msg.askyesno("Really Delete?", "Delete " + task.cget("text") + "?"): self.tasks.remove(event.widget) delete_task_query = "DELETE FROM tasks WHERE task=?" delete_task_data = (task.cget("text"),) self.runQuery(delete_task_query, delete_task_data) event.widget.destroy() self.recolour_tasks() def recolour_tasks(self): for index, task in enumerate(self.tasks): self.set_task_colour(index, task) def set_task_colour(self, position, task): _, task_style_choice = divmod(position, 2) my_scheme_choice = self.colour_schemes[task_style_choice] task.configure(bg=my_scheme_choice["bg"]) task.configure(fg=my_scheme_choice["fg"]) def on_frame_configure(self, event=None): self.tasks_canvas.configure(scrollregion=self.tasks_canvas.bbox("all")) def task_width(self, event): canvas_width = event.width self.tasks_canvas.itemconfig(self.canvas_frame, width = canvas_width) def mouse_scroll(self, event): if event.delta: self.tasks_canvas.yview_scroll(int(-1*(event.delta/120)), "units") else: if event.num == 5: move = 1 else: move = -1 self.tasks_canvas.yview_scroll(move, "units") def save_task(self, task): insert_task_query = "INSERT INTO tasks VALUES (?)" insert_task_data = (task,) self.runQuery(insert_task_query, insert_task_data) def load_tasks(self): load_tasks_query = "SELECT task FROM tasks" my_tasks = self.runQuery(load_tasks_query, receive=True) return my_tasks @staticmethod def runQuery(sql, data=None, receive=False): conn = sqlite3.connect("tasks.db") cursor = conn.cursor() if data: cursor.execute(sql, data) else: cursor.execute(sql) if receive: return cursor.fetchall() else: conn.commit() conn.close() @staticmethod def firstTimeDB(): create_tables = "CREATE TABLE tasks (task TEXT)" Todo.runQuery(create_tables) default_task_query = "INSERT INTO tasks VALUES (?)" default_task_data = ("--- Add Items Here ---",) Todo.runQuery(default_task_query, default_task_data) if __name__ == "__main__": if not os.path.isfile("tasks.db"): Todo.firstTimeDB() todo = Todo() todo.mainloop()
the-stack_0_3353
import io from notifypy.cli import entry import os import sys from setuptools import Command, find_packages, setup # import notifypy with open("README.md", "r") as fh: long_description = fh.read() setup( name="notify_py", version="0.3.2", author="Mustafa Mohamed", author_email="[email protected]", description="Cross-platform desktop notification library for Python", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/ms7m/notify-py", python_requires=">=3.6.0", packages=find_packages( exclude=["testing", "*.testing", "*.testing.*", "testing.*", "tests"] ), classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], entry_points={"console_scripts": ["notifypy = notifypy.cli:entry"]}, include_package_data=True, install_requires=["loguru", "jeepney ; platform_system=='Linux'"], )
the-stack_0_3357
# # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. import json import os import re import unittest from datetime import timedelta from unittest import mock from urllib.parse import quote_plus from airflow import settings from airflow.api.common.experimental.trigger_dag import trigger_dag from airflow.models import DagBag, DagRun, Pool, TaskInstance from airflow.models.serialized_dag import SerializedDagModel from airflow.settings import Session from airflow.utils.timezone import datetime, parse as parse_datetime, utcnow from airflow.version import version from airflow.www import app as application from tests.test_utils.config import conf_vars from tests.test_utils.db import clear_db_pools ROOT_FOLDER = os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir, os.pardir, os.pardir, os.pardir) ) class TestBase(unittest.TestCase): @conf_vars({('api', 'enable_experimental_api'): 'true'}) def setUp(self): self.app = application.create_app(testing=True) self.appbuilder = self.app.appbuilder # pylint: disable=no-member self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' self.app.config['SECRET_KEY'] = 'secret_key' self.app.config['CSRF_ENABLED'] = False self.app.config['WTF_CSRF_ENABLED'] = False self.client = self.app.test_client() settings.configure_orm() self.session = Session def assert_deprecated(self, resp): assert 'true' == resp.headers['Deprecation'] assert re.search( r'\<.+/stable-rest-api/migration.html\>; ' 'rel="deprecation"; type="text/html"', resp.headers['Link'], ) class TestApiExperimental(TestBase): @classmethod def setUpClass(cls): super().setUpClass() session = Session() session.query(DagRun).delete() session.query(TaskInstance).delete() session.commit() session.close() dagbag = DagBag(include_examples=True) for dag in dagbag.dags.values(): dag.sync_to_db() SerializedDagModel.write_dag(dag) def tearDown(self): session = Session() session.query(DagRun).delete() session.query(TaskInstance).delete() session.commit() session.close() super().tearDown() def test_info(self): url = '/api/experimental/info' resp_raw = self.client.get(url) resp = json.loads(resp_raw.data.decode('utf-8')) assert version == resp['version'] self.assert_deprecated(resp_raw) def test_task_info(self): url_template = '/api/experimental/dags/{}/tasks/{}' response = self.client.get(url_template.format('example_bash_operator', 'runme_0')) self.assert_deprecated(response) assert '"email"' in response.data.decode('utf-8') assert 'error' not in response.data.decode('utf-8') assert 200 == response.status_code response = self.client.get(url_template.format('example_bash_operator', 'DNE')) assert 'error' in response.data.decode('utf-8') assert 404 == response.status_code response = self.client.get(url_template.format('DNE', 'DNE')) assert 'error' in response.data.decode('utf-8') assert 404 == response.status_code def test_get_dag_code(self): url_template = '/api/experimental/dags/{}/code' response = self.client.get(url_template.format('example_bash_operator')) self.assert_deprecated(response) assert 'BashOperator(' in response.data.decode('utf-8') assert 200 == response.status_code response = self.client.get(url_template.format('xyz')) assert 404 == response.status_code def test_dag_paused(self): pause_url_template = '/api/experimental/dags/{}/paused/{}' paused_url_template = '/api/experimental/dags/{}/paused' paused_url = paused_url_template.format('example_bash_operator') response = self.client.get(pause_url_template.format('example_bash_operator', 'true')) self.assert_deprecated(response) assert 'ok' in response.data.decode('utf-8') assert 200 == response.status_code paused_response = self.client.get(paused_url) assert 200 == paused_response.status_code assert {"is_paused": True} == paused_response.json response = self.client.get(pause_url_template.format('example_bash_operator', 'false')) assert 'ok' in response.data.decode('utf-8') assert 200 == response.status_code paused_response = self.client.get(paused_url) assert 200 == paused_response.status_code assert {"is_paused": False} == paused_response.json def test_trigger_dag(self): url_template = '/api/experimental/dags/{}/dag_runs' run_id = 'my_run' + utcnow().isoformat() response = self.client.post( url_template.format('example_bash_operator'), data=json.dumps({'run_id': run_id}), content_type="application/json", ) self.assert_deprecated(response) assert 200 == response.status_code response_execution_date = parse_datetime(json.loads(response.data.decode('utf-8'))['execution_date']) assert 0 == response_execution_date.microsecond # Check execution_date is correct response = json.loads(response.data.decode('utf-8')) dagbag = DagBag() dag = dagbag.get_dag('example_bash_operator') dag_run = dag.get_dagrun(response_execution_date) dag_run_id = dag_run.run_id assert run_id == dag_run_id assert dag_run_id == response['run_id'] # Test error for nonexistent dag response = self.client.post( url_template.format('does_not_exist_dag'), data=json.dumps({}), content_type="application/json" ) assert 404 == response.status_code def test_trigger_dag_for_date(self): url_template = '/api/experimental/dags/{}/dag_runs' dag_id = 'example_bash_operator' execution_date = utcnow() + timedelta(hours=1) datetime_string = execution_date.isoformat() # Test correct execution with execution date response = self.client.post( url_template.format(dag_id), data=json.dumps({'execution_date': datetime_string}), content_type="application/json", ) self.assert_deprecated(response) assert 200 == response.status_code assert datetime_string == json.loads(response.data.decode('utf-8'))['execution_date'] dagbag = DagBag() dag = dagbag.get_dag(dag_id) dag_run = dag.get_dagrun(execution_date) assert dag_run, f'Dag Run not found for execution date {execution_date}' # Test correct execution with execution date and microseconds replaced response = self.client.post( url_template.format(dag_id), data=json.dumps({'execution_date': datetime_string, 'replace_microseconds': 'true'}), content_type="application/json", ) assert 200 == response.status_code response_execution_date = parse_datetime(json.loads(response.data.decode('utf-8'))['execution_date']) assert 0 == response_execution_date.microsecond dagbag = DagBag() dag = dagbag.get_dag(dag_id) dag_run = dag.get_dagrun(response_execution_date) assert dag_run, f'Dag Run not found for execution date {execution_date}' # Test error for nonexistent dag response = self.client.post( url_template.format('does_not_exist_dag'), data=json.dumps({'execution_date': datetime_string}), content_type="application/json", ) assert 404 == response.status_code # Test error for bad datetime format response = self.client.post( url_template.format(dag_id), data=json.dumps({'execution_date': 'not_a_datetime'}), content_type="application/json", ) assert 400 == response.status_code def test_task_instance_info(self): url_template = '/api/experimental/dags/{}/dag_runs/{}/tasks/{}' dag_id = 'example_bash_operator' task_id = 'also_run_this' execution_date = utcnow().replace(microsecond=0) datetime_string = quote_plus(execution_date.isoformat()) wrong_datetime_string = quote_plus(datetime(1990, 1, 1, 1, 1, 1).isoformat()) # Create DagRun trigger_dag(dag_id=dag_id, run_id='test_task_instance_info_run', execution_date=execution_date) # Test Correct execution response = self.client.get(url_template.format(dag_id, datetime_string, task_id)) self.assert_deprecated(response) assert 200 == response.status_code assert 'state' in response.data.decode('utf-8') assert 'error' not in response.data.decode('utf-8') # Test error for nonexistent dag response = self.client.get( url_template.format('does_not_exist_dag', datetime_string, task_id), ) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for nonexistent task response = self.client.get(url_template.format(dag_id, datetime_string, 'does_not_exist_task')) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for nonexistent dag run (wrong execution_date) response = self.client.get(url_template.format(dag_id, wrong_datetime_string, task_id)) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for bad datetime format response = self.client.get(url_template.format(dag_id, 'not_a_datetime', task_id)) assert 400 == response.status_code assert 'error' in response.data.decode('utf-8') def test_dagrun_status(self): url_template = '/api/experimental/dags/{}/dag_runs/{}' dag_id = 'example_bash_operator' execution_date = utcnow().replace(microsecond=0) datetime_string = quote_plus(execution_date.isoformat()) wrong_datetime_string = quote_plus(datetime(1990, 1, 1, 1, 1, 1).isoformat()) # Create DagRun trigger_dag(dag_id=dag_id, run_id='test_task_instance_info_run', execution_date=execution_date) # Test Correct execution response = self.client.get(url_template.format(dag_id, datetime_string)) self.assert_deprecated(response) assert 200 == response.status_code assert 'state' in response.data.decode('utf-8') assert 'error' not in response.data.decode('utf-8') # Test error for nonexistent dag response = self.client.get( url_template.format('does_not_exist_dag', datetime_string), ) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for nonexistent dag run (wrong execution_date) response = self.client.get(url_template.format(dag_id, wrong_datetime_string)) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for bad datetime format response = self.client.get(url_template.format(dag_id, 'not_a_datetime')) assert 400 == response.status_code assert 'error' in response.data.decode('utf-8') class TestLineageApiExperimental(TestBase): PAPERMILL_EXAMPLE_DAGS = os.path.join(ROOT_FOLDER, "airflow", "providers", "papermill", "example_dags") @classmethod def setUpClass(cls): super().setUpClass() session = Session() session.query(DagRun).delete() session.query(TaskInstance).delete() session.commit() session.close() dagbag = DagBag(include_examples=False, dag_folder=cls.PAPERMILL_EXAMPLE_DAGS) for dag in dagbag.dags.values(): dag.sync_to_db() SerializedDagModel.write_dag(dag) @mock.patch("airflow.settings.DAGS_FOLDER", PAPERMILL_EXAMPLE_DAGS) def test_lineage_info(self): url_template = '/api/experimental/lineage/{}/{}' dag_id = 'example_papermill_operator' execution_date = utcnow().replace(microsecond=0) datetime_string = quote_plus(execution_date.isoformat()) wrong_datetime_string = quote_plus(datetime(1990, 1, 1, 1, 1, 1).isoformat()) # create DagRun trigger_dag(dag_id=dag_id, run_id='test_lineage_info_run', execution_date=execution_date) # test correct execution response = self.client.get(url_template.format(dag_id, datetime_string)) self.assert_deprecated(response) assert 200 == response.status_code assert 'task_ids' in response.data.decode('utf-8') assert 'error' not in response.data.decode('utf-8') # Test error for nonexistent dag response = self.client.get( url_template.format('does_not_exist_dag', datetime_string), ) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for nonexistent dag run (wrong execution_date) response = self.client.get(url_template.format(dag_id, wrong_datetime_string)) assert 404 == response.status_code assert 'error' in response.data.decode('utf-8') # Test error for bad datetime format response = self.client.get(url_template.format(dag_id, 'not_a_datetime')) assert 400 == response.status_code assert 'error' in response.data.decode('utf-8') class TestPoolApiExperimental(TestBase): USER_POOL_COUNT = 2 TOTAL_POOL_COUNT = USER_POOL_COUNT + 1 # including default_pool @classmethod def setUpClass(cls): super().setUpClass() def setUp(self): super().setUp() clear_db_pools() self.pools = [Pool.get_default_pool()] for i in range(self.USER_POOL_COUNT): name = f'experimental_{i + 1}' pool = Pool( pool=name, slots=i, description=name, ) self.session.add(pool) self.pools.append(pool) self.session.commit() self.pool = self.pools[-1] def _get_pool_count(self): response = self.client.get('/api/experimental/pools') assert response.status_code == 200 return len(json.loads(response.data.decode('utf-8'))) def test_get_pool(self): response = self.client.get( f'/api/experimental/pools/{self.pool.pool}', ) self.assert_deprecated(response) assert response.status_code == 200 assert json.loads(response.data.decode('utf-8')) == self.pool.to_json() def test_get_pool_non_existing(self): response = self.client.get('/api/experimental/pools/foo') assert response.status_code == 404 assert json.loads(response.data.decode('utf-8'))['error'] == "Pool 'foo' doesn't exist" def test_get_pools(self): response = self.client.get('/api/experimental/pools') self.assert_deprecated(response) assert response.status_code == 200 pools = json.loads(response.data.decode('utf-8')) assert len(pools) == self.TOTAL_POOL_COUNT for i, pool in enumerate(sorted(pools, key=lambda p: p['pool'])): assert pool == self.pools[i].to_json() def test_create_pool(self): response = self.client.post( '/api/experimental/pools', data=json.dumps( { 'name': 'foo', 'slots': 1, 'description': '', } ), content_type='application/json', ) self.assert_deprecated(response) assert response.status_code == 200 pool = json.loads(response.data.decode('utf-8')) assert pool['pool'] == 'foo' assert pool['slots'] == 1 assert pool['description'] == '' assert self._get_pool_count() == self.TOTAL_POOL_COUNT + 1 def test_create_pool_with_bad_name(self): for name in ('', ' '): response = self.client.post( '/api/experimental/pools', data=json.dumps( { 'name': name, 'slots': 1, 'description': '', } ), content_type='application/json', ) assert response.status_code == 400 assert json.loads(response.data.decode('utf-8'))['error'] == "Pool name shouldn't be empty" assert self._get_pool_count() == self.TOTAL_POOL_COUNT def test_delete_pool(self): response = self.client.delete( f'/api/experimental/pools/{self.pool.pool}', ) self.assert_deprecated(response) assert response.status_code == 200 assert json.loads(response.data.decode('utf-8')) == self.pool.to_json() assert self._get_pool_count() == self.TOTAL_POOL_COUNT - 1 def test_delete_pool_non_existing(self): response = self.client.delete( '/api/experimental/pools/foo', ) assert response.status_code == 404 assert json.loads(response.data.decode('utf-8'))['error'] == "Pool 'foo' doesn't exist" def test_delete_default_pool(self): clear_db_pools() response = self.client.delete( '/api/experimental/pools/default_pool', ) assert response.status_code == 400 assert json.loads(response.data.decode('utf-8'))['error'] == "default_pool cannot be deleted"
the-stack_0_3358
# Copyright 2003-2008 by Leighton Pritchard. All rights reserved. # This code is part of the Biopython distribution and governed by its # license. Please see the LICENSE file that should have been included # as part of this package. # # Contact: Leighton Pritchard, Scottish Crop Research Institute, # Invergowrie, Dundee, Scotland, DD2 5DA, UK # [email protected] ################################################################################ """ Feature module Provides: o Feature - class to wrap Bio.SeqFeature objects with drawing information For drawing capabilities, this module uses reportlab to define colors: http://www.reportlab.com For dealing with biological information, the package uses BioPython: http://www.biopython.org """ # ReportLab imports from reportlab.lib import colors # GenomeDiagram imports from ._Colors import ColorTranslator class Feature(object): """ Class to wrap Bio.SeqFeature objects for GenomeDiagram Provides: Methods: o __init__(self, parent=None, feature_id=None, feature=None, color=colors.lightgreen) Called when the feature is instantiated o set_feature(self, feature) Wrap the passed feature o get_feature(self) Return the unwrapped Bio.SeqFeature object o set_color(self, color) Set the color in which the feature will be drawn (accepts multiple formats: reportlab color.Color() tuple and color.name, or integer representing Artemis color o get_color(self) Returns color.Color tuple of the feature's color o __getattr__(self, name) Catches attribute requests and passes them to the wrapped Bio.SeqFeature object Attributes: o parent FeatureSet, container for the object o id Unique id o color color.Color, color to draw the feature o hide Boolean for whether the feature will be drawn or not o sigil String denoting the type of sigil to use for the feature. Currently either "BOX" or "ARROW" are supported. o arrowhead_length Float denoting length of the arrow head to be drawn, relative to the bounding box height. The arrow shaft takes up the remainder of the bounding box's length. o arrowshaft_height Float denoting length of the representative arrow shaft to be drawn, relative to the bounding box height. The arrow head takes the full height of the bound box. o name_qualifiers List of Strings, describes the qualifiers that may contain feature names in the wrapped Bio.SeqFeature object o label Boolean, 1 if the label should be shown o label_font String describing the font to use for the feature label o label_size Int describing the feature label font size o label_color color.Color describing the feature label color o label_angle Float describing the angle through which to rotate the feature label in degrees (default = 45, linear only) o label_position String, 'start', 'end' or 'middle' denoting where to place the feature label. Leave as None for the default which is 'start' for linear diagrams, and at the bottom of the feature as drawn on circular diagrams. o label_strand Integer -1 or +1 to explicitly place the label on the forward or reverse strand. Default (None) follows th feature's strand. Use -1 to put labels under (linear) or inside (circular) the track, +1 to put them above (linear) or outside (circular) the track. o locations List of tuples of (start, end) ints describing where the feature and any subfeatures start and end o type String denoting the feature type o name String denoting the feature name o strand Int describing the strand on which the feature is found """ def __init__(self, parent=None, feature_id=None, feature=None, color=colors.lightgreen, label=0, border=None, colour=None): """ __init__(self, parent=None, feature_id=None, feature=None, color=colors.lightgreen, label=0) o parent FeatureSet containing the feature o feature_id Unique id for the feature o feature Bio.SeqFeature object to be wrapped o color color.Color Color to draw the feature (overridden by backwards compatible argument with UK spelling, colour). Either argument is overridden if 'color' is found in feature qualifiers o border color.Color Color to draw the feature border, use None for the same as the fill color, False for no border. o label Boolean, 1 if the label should be shown """ #Let the UK spelling (colour) override the USA spelling (color) if colour is not None: color = colour self._colortranslator = ColorTranslator() # Initialise attributes self.parent = parent self.id = feature_id self.color = color # default color to draw the feature self.border = border self._feature = None # Bio.SeqFeature object to wrap self.hide = 0 # show by default self.sigil = 'BOX' self.arrowhead_length = 0.5 # 50% of the box height self.arrowshaft_height = 0.4 # 40% of the box height self.name_qualifiers = ['gene', 'label', 'name', 'locus_tag', 'product'] self.label = label self.label_font = 'Helvetica' self.label_size = 6 self.label_color = colors.black self.label_angle = 45 self.label_position = None #Expect 'start', 'middle', or 'end' (plus aliases) self.label_strand = None #Expect +1 or -1 if overriding this if feature is not None: self.set_feature(feature) def set_feature(self, feature): """ set_feature(self, feature) o feature Bio.SeqFeature object to be wrapped Defines the Bio.SeqFeature object to be wrapped """ self._feature = feature self.__process_feature() def __process_feature(self): """ __process_feature(self) Examine the feature to be wrapped, and set some of the Feature's properties accordingly """ self.locations = [] bounds = [] #This will be a list of length one for simple FeatureLocation: for location in self._feature.location.parts: start = location.nofuzzy_start end = location.nofuzzy_end #if start > end and self.strand == -1: # start, end = end, start self.locations.append((start, end)) bounds += [start, end] self.type = str(self._feature.type) # Feature type #TODO - Strand can vary with subfeatures (e.g. mixed strand tRNA) if self._feature.strand is None: #This is the SeqFeature default (None), but the drawing code #only expects 0, +1 or -1. self.strand = 0 else: self.strand = int(self._feature.strand) # Feature strand if 'color' in self._feature.qualifiers: # Artemis color (if present) self.color = self._colortranslator.artemis_color( self._feature.qualifiers['color'][0]) self.name = self.type for qualifier in self.name_qualifiers: if qualifier in self._feature.qualifiers: self.name = self._feature.qualifiers[qualifier][0] break #Note will be 0 to N for origin wrapping feature on genome of length N self.start, self.end = min(bounds), max(bounds) def get_feature(self): """ get_feature(self) -> Bio.SeqFeature Returns the unwrapped Bio.SeqFeature object """ return self._feature def set_colour(self, colour): """Backwards compatible variant of set_color(self, color) using UK spelling.""" color = self._colortranslator.translate(colour) self.color = color def set_color(self, color): """ set_color(self, color) o color The color to draw the feature - either a colors.Color object, an RGB tuple of floats, or an integer corresponding to colors in colors.txt Set the color in which the feature will be drawn """ #TODO - Make this into the set method for a color property? color = self._colortranslator.translate(color) self.color = color def __getattr__(self, name): """ __getattr__(self, name) -> various If the Feature class doesn't have the attribute called for, check in self._feature for it """ return getattr(self._feature, name) # try to get the attribute from the feature ################################################################################ # RUN AS SCRIPT ################################################################################ if __name__ == '__main__': # Test code gdf = Feature()
the-stack_0_3360
# -*- coding: utf-8 -*- """ Setup ----- Install troposphere in the current python environment. """ # ---------------------------------------------------------------------------- # Imports # ---------------------------------------------------------------------------- # ---- Future from __future__ import print_function from __future__ import with_statement # ---- System import os from setuptools import setup # ---------------------------------------------------------------------------- # Helper Functions # ---------------------------------------------------------------------------- def file_contents(file_name): """Given a file name to a valid file returns the file object.""" curr_dir = os.path.abspath(os.path.dirname(__file__)) with open(os.path.join(curr_dir, file_name)) as the_file: contents = the_file.read() return contents def get_version(): curr_dir = os.path.abspath(os.path.dirname(__file__)) with open(curr_dir + "/troposphere/__init__.py", "r") as init_version: for line in init_version: if "__version__" in line: return str(line.split("=")[-1].strip(" ")[1:-2]) # ---------------------------------------------------------------------------- # Setup # ---------------------------------------------------------------------------- setup( name='troposphere', version=get_version(), description="AWS CloudFormation creation library", long_description=file_contents("README.rst"), long_description_content_type='text/x-rst', author="Mark Peek", author_email="[email protected]", license="New BSD license", url="https://github.com/cloudtools/troposphere", classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: MacOS :: MacOS X", "Operating System :: Microsoft :: Windows", "Operating System :: POSIX :: BSD", "Operating System :: POSIX :: Linux", "Programming Language :: Python", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 2.7", ], packages=[ 'troposphere', 'troposphere.openstack', 'troposphere.helpers' ], scripts=[ 'scripts/cfn', 'scripts/cfn2py' ], python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", install_requires=file_contents("requirements.txt"), test_suite="tests", tests_require=["awacs>=0.8"], extras_require={'policy': ['awacs>=0.8']}, use_2to3=True, )
the-stack_0_3362
import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable class FocalLoss(nn.Module): def __init__(self, gamma=0, alpha=None, size_average=True): super(FocalLoss, self).__init__() self.gamma = gamma self.alpha = alpha if isinstance(alpha,(float,int)): self.alpha = torch.Tensor([alpha,1-alpha]) if isinstance(alpha,list): self.alpha = torch.Tensor(alpha) self.size_average = size_average def forward(self, input, target): if input.dim()>2: input = input.view(input.size(0),input.size(1),-1) # N,C,H,W => N,C,H*W input = input.transpose(1,2) # N,C,H*W => N,H*W,C input = input.contiguous().view(-1,input.size(2)) # N,H*W,C => N*H*W,C target = target.view(-1,1) logpt = F.log_softmax(input) logpt = logpt.gather(1,target) logpt = logpt.view(-1) pt = Variable(logpt.data.exp()) if self.alpha is not None: if self.alpha.type()!=input.data.type(): self.alpha = self.alpha.type_as(input.data) at = self.alpha.gather(0,target.data.view(-1)) logpt = logpt * Variable(at) loss = -1 * (1-pt)**self.gamma * logpt if self.size_average: return loss.mean() else: return loss.sum()
the-stack_0_3364
# Copyright 2019-2020 Xanadu Quantum Technologies Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Functions for constructing/calculating the means, variances and covariances of Gaussian states. """ from itertools import product from scipy.special import factorial import numpy as np from .._hafnian import hafnian, reduction from .._torontonian import threshold_detection_prob from .conversions import ( reduced_gaussian, Qmat, Xmat, complex_to_real_displacements ) def photon_number_mean(mu, cov, j, hbar=2): r""" Calculate the mean photon number of mode j of a Gaussian state. Args: mu (array): vector of means of the Gaussian state using the ordering :math:`[q_1, q_2, \dots, q_n, p_1, p_2, \dots, p_n]` cov (array): the covariance matrix of the Gaussian state j (int): the j :sup:`th` mode hbar (float): the ``hbar`` convention used in the commutation relation :math:`[q, p]=i\hbar` Returns: float: the mean photon number in mode :math:`j`. """ num_modes = len(mu) // 2 return ( mu[j] ** 2 + mu[j + num_modes] ** 2 + cov[j, j] + cov[j + num_modes, j + num_modes] - hbar ) / (2 * hbar) def photon_number_mean_vector(mu, cov, hbar=2): r""" Calculate the mean photon number of each of the modes in a Gaussian state Args: mu (array): vector of means of the Gaussian state using the ordering :math:`[q_1, q_2, \dots, q_n, p_1, p_2, \dots, p_n]` cov (array): the covariance matrix of the Gaussian state hbar (float): the ``hbar`` convention used in the commutation relation :math:`[q, p]=i\hbar` Returns: array: the vector of means of the photon number distribution """ N = len(mu) // 2 return np.array([photon_number_mean(mu, cov, j, hbar=hbar) for j in range(N)]) def photon_number_covar(mu, cov, j, k, hbar=2): r""" Calculate the variance/covariance of the photon number distribution of a Gaussian state. Implements the covariance matrix of the photon number distribution of a Gaussian state according to the Last two eq. of Part II. in `'Multidimensional Hermite polynomials and photon distribution for polymode mixed light', Dodonov et al. <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.50.813>`_ .. math:: \sigma_{n_j n_j} &= \frac{1}{2}\left(T_j^2 - 2d_j - \frac{1}{2}\right) + \left<\mathbf{Q}_j\right>\mathcal{M}_j\left<\mathbf{Q}_j\right>, \\ \sigma_{n_j n_k} &= \frac{1}{2}\mathrm{Tr}\left(\Lambda_j \mathbf{M} \Lambda_k \mathbf{M}\right) + \left<\mathbf{Q}\right>\Lambda_j \mathbf{M} \Lambda_k\left<\mathbf{Q}\right>, where :math:`T_j` and :math:`d_j` are the trace and the determinant of :math:`2 \times 2` matrix :math:`\mathcal{M}_j` whose elements coincide with the nonzero elements of matrix :math:`\mathbf{M}_j = \Lambda_j \mathbf{M} \Lambda_k` while the two-vector :math:`\mathbf{Q}_j` has the components :math:`(q_j, p_j)`. :math:`2N \times 2N` projector matrix :math:`\Lambda_j` has only two nonzero elements: :math:`\left(\Lambda_j\right)_{jj} = \left(\Lambda_j\right)_{j+N,j+N} = 1`. Note that the convention for ``mu`` used here differs from the one used in Dodonov et al., They both provide the same results in this particular case. Also note that the original reference of Dodonov et al. has an incorrect prefactor of 1/2 in the last terms of the last equation above. Args: mu (array): vector of means of the Gaussian state using the ordering :math:`[q_1, q_2, \dots, q_n, p_1, p_2, \dots, p_n]` cov (array): the covariance matrix of the Gaussian state j (int): the j :sup:`th` mode k (int): the k :sup:`th` mode hbar (float): the ``hbar`` convention used in the commutation relation :math:`[q, p]=i\hbar` Returns: float: the covariance for the photon numbers at modes :math:`j` and :math:`k`. """ if j == k: mu, cov = reduced_gaussian(mu, cov, [j]) term_1 = 0.5 * np.trace(cov) ** 2 - np.linalg.det(cov) term_2 = mu @ cov @ mu return ((term_1 + term_2) / hbar ** 2) - 0.25 mu, cov = reduced_gaussian(mu, cov, [j, k]) term_1 = cov[0, 1] ** 2 + cov[0, 3] ** 2 + cov[2, 1] ** 2 + cov[2, 3] ** 2 term_2 = ( cov[0, 1] * mu[0] * mu[1] + cov[2, 1] * mu[1] * mu[2] + cov[0, 3] * mu[0] * mu[3] + cov[2, 3] * mu[2] * mu[3] ) return (term_1 + 2 * term_2) / (2 * hbar ** 2) def photon_number_covmat(mu, cov, hbar=2): r""" Calculate the covariance matrix of the photon number distribution of a Gaussian state. Args: mu (array): vector of means of the Gaussian state using the ordering :math:`[q_1, q_2, \dots, q_n, p_1, p_2, \dots, p_n]` cov (array): the covariance matrix of the Gaussian state hbar (float): the ``hbar`` convention used in the commutation relation :math:`[q, p]=i\hbar` Returns: array: the covariance matrix of the photon number distribution """ N = len(mu) // 2 pnd_cov = np.zeros((N, N)) for i in range(N): for j in range(i+1): pnd_cov[i][j] = photon_number_covar(mu, cov, i, j, hbar=hbar) pnd_cov[j][i] = pnd_cov[i][j] return pnd_cov def photon_number_expectation(mu, cov, modes, hbar=2): r"""Calculates the expectation value of the product of the number operator of the modes in a Gaussian state. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. modes (list): list of modes hbar (float): value of hbar in the uncertainty relation. Returns: (float): expectation value of the product of the number operators of the modes. """ n, _ = cov.shape n_modes = n // 2 rpt = np.zeros([n], dtype=int) for i in modes: rpt[i] = 1 rpt[i + n_modes] = 1 return normal_ordered_expectation(mu, cov, rpt, hbar=hbar) def photon_number_squared_expectation(mu, cov, modes, hbar=2): r"""Calculates the expectation value of the square of the product of the number operator of the modes in a Gaussian state. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. modes (list): list of modes hbar (float): value of hbar in the uncertainty relation. Returns: (float): expectation value of the square of the product of the number operator of the modes. """ n_modes = len(modes) mu_red, cov_red = reduced_gaussian(mu, cov, modes) result = 0 for item in product([1, 2], repeat=n_modes): rpt = item + item term = normal_ordered_expectation(mu_red, cov_red, rpt, hbar=hbar) result += term return result def normal_ordered_expectation(mu, cov, rpt, hbar=2): r"""Calculates the expectation value of the normal ordered product :math:`\prod_{i=0}^{N-1} a_i^{\dagger n_i} \prod_{j=0}^{N-1} a_j^{m_j}` with respect to an N-mode Gaussian state, where :math:`\text{rpt}=(n_0, n_1, \ldots, n_{N-1}, m_0, m_1, \ldots, m_{N-1})`. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. rpt (list): integers specifying the terms to calculate. hbar (float): value of hbar in the uncertainty relation. Returns: (float): expectation value of the normal ordered product of operators """ return s_ordered_expectation(mu, cov, rpt, hbar, s=1) def s_ordered_expectation(mu, cov, rpt, hbar=2, s=0): r"""Calculates the expectation value of the s-ordered product obtained by taking deirvatives of the characteristic function of a Gaussian states, Here, :math:`\text{rpt}=(n_0, n_1, \ldots, n_{N-1}, m_0, m_1, \ldots, m_{N-1})`. indicates how many derivatives are taken with respect to the complex argument and its conjugate. The values :math:`s=\{1,0,-1\}` correspond respectively to normal, symmetric and antinormal order. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. rpt (list): integers specifying the terms to calculate. hbar (float): value of hbar in the uncertainty relation. s (float): value setting the ordering it must be between -1 and 1. Returns: (float): expectation value of the normal ordered product of operators """ # The following seven lines are written so that we remove from the calculation the # modes k that we don't care about. These modes have rpt[k] = rpt[k+M] = 0 if np.allclose(rpt, 0): return 1.0 M = len(cov) // 2 modes = np.where(np.array(rpt[0:M]) + np.array(rpt[M : 2 * M]) != 0)[0] mu, cov = reduced_gaussian(mu, cov, list(modes)) ind = list(modes) + list(modes + M) rpt = list(np.array(rpt)[np.array(ind)]) alpha = complex_to_real_displacements(mu, hbar=hbar) n = len(cov) V = (Qmat(cov, hbar=hbar) - 0.5 * (s + 1) * np.identity(n)) @ Xmat(n // 2) A = reduction(V, rpt) if np.allclose(mu, 0): return hafnian(A) np.fill_diagonal(A, reduction(np.conj(alpha), rpt)) return hafnian(A, loop=True) def mean_clicks(cov, hbar=2): r""" Calculates the total mean number of clicks when a zero-mean gaussian state is measured using threshold detectors. Args cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering hbar (float): the value of :math:`\hbar` in the commutation relation :math:`[\x,\p]=i\hbar` Returns float: mean number of clicks """ n, _ = cov.shape nmodes = n // 2 Q = Qmat(cov, hbar=hbar) meanc = 1.0 * nmodes for i in range(nmodes): det_val = np.real(Q[i, i] * Q[i + nmodes, i + nmodes] - Q[i + nmodes, i] * Q[i, i + nmodes]) meanc -= 1.0 / np.sqrt(det_val) return meanc def variance_clicks(cov, hbar=2): r""" Calculates the variance of the total number of clicks when a zero-mean gaussian state is measured using threshold detectors. Args cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering hbar (float): the value of :math:`\hbar` in the commutation relation :math:`[\x,\p]=i\hbar` Returns float: variance in the total number of clicks """ n, _ = cov.shape means = np.zeros([n]) nmodes = n // 2 Q = Qmat(cov, hbar=hbar) vac_probs = np.array( [ np.real(Q[i, i] * Q[i + nmodes, i + nmodes] - Q[i + nmodes, i] * Q[i, i + nmodes]) for i in range(nmodes) ] ) vac_probs = np.sqrt(vac_probs) vac_probs = 1 / vac_probs term1 = np.sum(vac_probs * (1 - vac_probs)) term2 = 0 for i in range(nmodes): for j in range(i): _, Qij = reduced_gaussian(means, Q, [i, j]) prob_vac_ij = np.linalg.det(Qij).real prob_vac_ij = 1.0 / np.sqrt(prob_vac_ij) term2 += prob_vac_ij - vac_probs[i] * vac_probs[j] return term1 + 2 * term2 def _coeff_normal_ordered(m, k): r"""Returns the coefficients giving the expansion of a photon number power in terms of normal ordered power of creation and annihilation operators. The coefficient is given by :math:`\sum_{\mu=0}^k \frac{(-1)^{k-\mu} \mu^m}{\mu!(k-\mu)!}`. Args: m (int): power of the photon number operator, :math:`(a^\dagger a)^m `. k (int): power of the normal ordered term, :math:`a^{\dagger i} a^i`. Returns: (float): expansion coefficient """ return sum( [ (1 / (factorial(mu) * factorial(k - mu))) * ((-1) ** (k - mu) * (mu ** m)) for mu in range(0, k + 1) ] ) def photon_number_moment(mu, cov, indices, hbar=2): r"""Calculates the expectation value of product of powers of photon number operators of a Gaussian state. The powers are specified by a dictionary with modes as keys and powers as values. The calculation is performed by first writing any power of the photon number as :math:`(a^\dagger a)^m = \sum_{k=1}^m c_k a^{\dagger k} a^k` where the coefficients :math:`c_i` are provided by the function `_coeff_normal_ordered`. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. indices (dictionary): specification of the different modes and their power of their photon number hbar (float): value of hbar in the uncertainty relation. Returns: float: the expectation value of the photon number powers. """ N = len(cov) // 2 list_indices = [indices[key] for key in indices] modes = list(indices) # Find the expansion coefficients of all the different powers expansion_coeff = [ [_coeff_normal_ordered(indices[key], i) for i in range(1, 1 + indices[key])] for key in indices ] values = [list(range(i)) for i in list_indices] net_sum = 0.0 # Construct the product of each possible term appearing in the normal ordered expansion for item in product(*values): rpt = [0] * N for i, key in enumerate(modes): rpt[key] = item[i] + 1 rpt = rpt + rpt prod_coeff = np.prod([expansion_coeff[i][coeff] for i, coeff in enumerate(item)]) net_sum += prod_coeff * s_ordered_expectation(mu, cov, rpt, s=1, hbar=hbar) return np.real_if_close(net_sum) def partition(collection): """Generate all set partitions of a collection. Taken from: https://stackoverflow.com/a/30134039 Args: collection (sequence): set to find partitions of Yields: list[list]: set partition of collection """ if len(collection) == 1: yield [collection] return first = collection[0] for smaller in partition(collection[1:]): for n, subset in enumerate(smaller): yield smaller[:n] + [[first] + subset] + smaller[n+1:] yield [[first]] + smaller def _list_to_freq_dict(words): """Convert between a list which of "words" and a dictionary which shows how many times each word appears in word Args: words (list): list of words Returns: dict : how many times a word appears. key is word, value is multiplicity """ return {i : words.count(i) for i in set(words)} def photon_number_cumulant(mu, cov, modes, hbar=2): r"""Calculates the photon-number cumulant of the modes in the Gaussian state. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. modes (list or array): list of modes. Note that it can have repetitions. hbar (float): value of hbar in the uncertainty relation. Returns: (float): the cumulant """ modes = list(modes) # turns modes from array to list if passed in as array kappa = 0 for pi in partition(modes): size = len(pi) term = factorial(size - 1) * (-1) ** (size - 1) for B in pi: indices = _list_to_freq_dict(B) term *= photon_number_moment(mu, cov, indices, hbar=hbar) kappa += term return kappa def click_cumulant(mu, cov, modes, hbar=2): r"""Calculates the click cumulant of the modes in the Gaussian state. Args: mu (array): length-:math:`2N` means vector in xp-ordering. cov (array): :math:`2N\times 2N` covariance matrix in xp-ordering. modes (list or array): list of modes. hbar (float): value of hbar in the uncertainty relation. Returns: (float): the cumulant """ modes = list(modes) # turns modes from array to list if passed in as array kappa = 0 for pi in partition(modes): size = len(pi) term = factorial(size - 1) * (-1) ** (size - 1) for B in pi: B = list(set(B)) # remove repetitions pattern = np.ones_like(B) mu_red, cov_red = reduced_gaussian(mu, cov, B) summand = threshold_detection_prob(mu_red, cov_red, pattern, hbar=hbar) term *= summand kappa += term return kappa
the-stack_0_3365
from __future__ import absolute_import try: import holoviews as hv except ImportError: hv = None import pytest from bokeh.plotting import figure from panel.layout import Row from panel.links import Link from panel.pane import Bokeh, HoloViews from panel.widgets import FloatSlider, RangeSlider, ColorPicker, TextInput, DatetimeInput from panel.tests.util import hv_available def test_widget_link_bidirectional(): t1 = TextInput() t2 = TextInput() t1.link(t2, value='value', bidirectional=True) t1.value = 'ABC' assert t1.value == 'ABC' assert t2.value == 'ABC' t2.value = 'DEF' assert t1.value == 'DEF' assert t2.value == 'DEF' def test_widget_jslink_bidirectional(document, comm): t1 = TextInput() t2 = TextInput() t1.jslink(t2, value='value', bidirectional=True) row = Row(t1, t2) model = row.get_root(document, comm) tm1, tm2 = model.children link1_customjs = tm1.js_property_callbacks['change:value'][-1] link2_customjs = tm2.js_property_callbacks['change:value'][-1] assert link1_customjs.args['source'] is tm1 assert link2_customjs.args['source'] is tm2 assert link1_customjs.args['target'] is tm2 assert link2_customjs.args['target'] is tm1 def test_widget_link_source_param_not_found(): t1 = TextInput() t2 = TextInput() with pytest.raises(ValueError) as excinfo: t1.jslink(t2, value1='value') assert "Could not jslink \'value1\' parameter" in str(excinfo) def test_widget_link_target_param_not_found(): t1 = TextInput() t2 = TextInput() with pytest.raises(ValueError) as excinfo: t1.jslink(t2, value='value1') assert "Could not jslink \'value1\' parameter" in str(excinfo) def test_widget_link_no_transform_error(): t1 = DatetimeInput() t2 = TextInput() with pytest.raises(ValueError) as excinfo: t1.jslink(t2, value='value') assert "Cannot jslink \'value\' parameter on DatetimeInput object" in str(excinfo) def test_widget_link_no_target_transform_error(): t1 = DatetimeInput() t2 = TextInput() with pytest.raises(ValueError) as excinfo: t2.jslink(t1, value='value') assert ("Cannot jslink \'value\' parameter on TextInput object " "to \'value\' parameter on DatetimeInput object") in str(excinfo) @hv_available def test_pnwidget_hvplot_links(document, comm): size_widget = FloatSlider(value=5, start=1, end=10) points1 = hv.Points([1, 2, 3]) size_widget.jslink(points1, value='glyph.size') row = Row(points1, size_widget) model = row.get_root(document, comm=comm) hv_views = row.select(HoloViews) widg_views = row.select(FloatSlider) assert len(hv_views) == 1 assert len(widg_views) == 1 slider = widg_views[0]._models[model.ref['id']][0] scatter = hv_views[0]._plots[model.ref['id']][0].handles['glyph'] link_customjs = slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is slider assert link_customjs.args['target'] is scatter code = """ var value = source['value']; value = value; value = value; try { var property = target.properties['size']; if (property !== undefined) { property.validate(value); } } catch(err) { console.log('WARNING: Could not set size on target, raised error: ' + err); return; } try { target['size'] = value; } catch(err) { console.log(err) } """ assert link_customjs.code == code @hv_available def test_bkwidget_hvplot_links(document, comm): from bokeh.models import Slider bokeh_widget = Slider(value=5, start=1, end=10, step=1e-1) points1 = hv.Points([1, 2, 3]) Link(bokeh_widget, points1, properties={'value': 'glyph.size'}) row = Row(points1, bokeh_widget) model = row.get_root(document, comm=comm) hv_views = row.select(HoloViews) assert len(hv_views) == 1 slider = bokeh_widget scatter = hv_views[0]._plots[model.ref['id']][0].handles['glyph'] link_customjs = slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is slider assert link_customjs.args['target'] is scatter code = """ var value = source['value']; value = value; value = value; try { var property = target.properties['size']; if (property !== undefined) { property.validate(value); } } catch(err) { console.log('WARNING: Could not set size on target, raised error: ' + err); return; } try { target['size'] = value; } catch(err) { console.log(err) } """ assert link_customjs.code == code def test_bkwidget_bkplot_links(document, comm): from bokeh.models import Slider bokeh_widget = Slider(value=5, start=1, end=10, step=1e-1) bokeh_fig = figure() scatter = bokeh_fig.scatter([1, 2, 3], [1, 2, 3]) Link(bokeh_widget, scatter, properties={'value': 'glyph.size'}) row = Row(bokeh_fig, bokeh_widget) row.get_root(document, comm=comm) slider = bokeh_widget link_customjs = slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is slider assert link_customjs.args['target'] is scatter.glyph code = """ var value = source['value']; value = value; value = value; try { var property = target.properties['size']; if (property !== undefined) { property.validate(value); } } catch(err) { console.log('WARNING: Could not set size on target, raised error: ' + err); return; } try { target['size'] = value; } catch(err) { console.log(err) } """ assert link_customjs.code == code def test_widget_bkplot_link(document, comm): widget = ColorPicker(value='#ff00ff') bokeh_fig = figure() scatter = bokeh_fig.scatter([1, 2, 3], [1, 2, 3]) widget.jslink(scatter.glyph, value='fill_color') row = Row(bokeh_fig, widget) model = row.get_root(document, comm=comm) link_customjs = model.children[1].js_property_callbacks['change:color'][-1] assert link_customjs.args['source'] is model.children[1] assert link_customjs.args['target'] is scatter.glyph assert scatter.glyph.fill_color == '#ff00ff' code = """ var value = source['color']; value = value; value = value; try { var property = target.properties['fill_color']; if (property !== undefined) { property.validate(value); } } catch(err) { console.log('WARNING: Could not set fill_color on target, raised error: ' + err); return; } try { target['fill_color'] = value; } catch(err) { console.log(err) } """ assert link_customjs.code == code def test_bokeh_figure_jslink(document, comm): fig = figure() pane = Bokeh(fig) t1 = TextInput() pane.jslink(t1, **{'x_range.start': 'value'}) row = Row(pane, t1) model = row.get_root(document, comm) link_customjs = fig.x_range.js_property_callbacks['change:start'][-1] assert link_customjs.args['source'] == fig.x_range assert link_customjs.args['target'] == model.children[1] assert link_customjs.code == """ var value = source['start']; value = value; value = value; try { var property = target.properties['value']; if (property !== undefined) { property.validate(value); } } catch(err) { console.log('WARNING: Could not set value on target, raised error: ' + err); return; } try { target['value'] = value; } catch(err) { console.log(err) } """ def test_widget_jscallback(document, comm): widget = ColorPicker(value='#ff00ff') widget.jscallback(value='some_code') model = widget.get_root(document, comm=comm) customjs = model.js_property_callbacks['change:color'][-1] assert customjs.args['source'] is model assert customjs.code == "try { some_code } catch(err) { console.log(err) }" def test_widget_jscallback_args_scalar(document, comm): widget = ColorPicker(value='#ff00ff') widget.jscallback(value='some_code', args={'scalar': 1}) model = widget.get_root(document, comm=comm) customjs = model.js_property_callbacks['change:color'][-1] assert customjs.args['scalar'] == 1 def test_widget_jscallback_args_model(document, comm): widget = ColorPicker(value='#ff00ff') widget2 = ColorPicker(value='#ff00ff') widget.jscallback(value='some_code', args={'widget': widget2}) model = Row(widget, widget2).get_root(document, comm=comm) customjs = model.children[0].js_property_callbacks['change:color'][-1] assert customjs.args['source'] is model.children[0] assert customjs.args['widget'] is model.children[1] assert customjs.code == "try { some_code } catch(err) { console.log(err) }" @hv_available def test_hvplot_jscallback(document, comm): points1 = hv.Points([1, 2, 3]) hvplot = HoloViews(points1) hvplot.jscallback(**{'x_range.start': "some_code"}) model = hvplot.get_root(document, comm=comm) x_range = hvplot._plots[model.ref['id']][0].handles['x_range'] customjs = x_range.js_property_callbacks['change:start'][-1] assert customjs.args['source'] is x_range assert customjs.code == "try { some_code } catch(err) { console.log(err) }" @hv_available def test_link_with_customcode(document, comm): range_widget = RangeSlider(start=0., end=1.) curve = hv.Curve([]) code = """ x_range.start = source.value[0] x_range.end = source.value[1] """ range_widget.jslink(curve, code={'value': code}) row = Row(curve, range_widget) range_widget.value = (0.5, 0.7) model = row.get_root(document, comm=comm) hv_views = row.select(HoloViews) widg_views = row.select(RangeSlider) assert len(hv_views) == 1 assert len(widg_views) == 1 range_slider = widg_views[0]._models[model.ref['id']][0] x_range = hv_views[0]._plots[model.ref['id']][0].handles['x_range'] link_customjs = range_slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is range_slider assert link_customjs.args['x_range'] is x_range assert link_customjs.code == "try { %s } catch(err) { console.log(err) }" % code
the-stack_0_3366
import uuid from datetime import datetime from flasgger import swag_from from flask import Blueprint, jsonify, request from cloudinary.uploader import upload from src.models import Author, Book, UserProfile, db from src.google import get_user_info from src.constants.http_status_codes import HTTP_201_CREATED, HTTP_400_BAD_REQUEST, HTTP_500_INTERNAL_SERVER_ERROR, HTTP_404_NOT_FOUND book_bp = Blueprint('book', __name__, url_prefix='/api') @book_bp.post('/books') @swag_from('../docs/book/create.yml') def create_book(): file = request.files['image'] # Author author_first_name = request.form['author_first_name'] author_last_name = request.form['author_last_name'] # Book title = request.form['title'] isbn = request.form['isbn'] language = request.form['language'] year_of_publication = request.form['year_of_publication'] category = request.form['category'] owner_id = request.form['owner_id'] if not title: return jsonify({ 'error': "book title is required" }), HTTP_400_BAD_REQUEST if not language: return jsonify({ 'error': "book language is required" }), HTTP_400_BAD_REQUEST if not owner_id: return jsonify({ 'error': "book owner is required" }), HTTP_400_BAD_REQUEST owner = UserProfile.query.filter_by(id=owner_id).first() if not owner: return jsonify({ 'error':f"user with id {owner_id} not found" }), HTTP_404_NOT_FOUND if not year_of_publication: return jsonify({ 'error': "year of publication is required" }), HTTP_400_BAD_REQUEST if not (author_first_name and author_last_name): return jsonify({ 'error': "author's first and last name is required" }), HTTP_400_BAD_REQUEST try: # Upload image to cloudinary server cloudinary_response = upload(file, folder="bookie-books") except Exception as ex: return({'error':"error uploading image to cloudinary"}, HTTP_500_INTERNAL_SERVER_ERROR) if not cloudinary_response: return jsonify({ 'error': "error uploading image" }), HTTP_400_BAD_REQUEST author = Author( id=uuid.uuid4(), first_name=author_first_name, last_name=author_last_name) book = Book( id=uuid.uuid4(), name=title, isbn=isbn, language=language, year_of_publication=year_of_publication, category=category, author_id=author.id, owner_id=uuid.UUID(owner.id), image_url = cloudinary_response['secure_url'], # from cloudinary response after successful upload cld_asset_id=cloudinary_response['asset_id'], cld_public_id=cloudinary_response['public_id'], is_available=True, created_at=datetime.now(), borrowed=False # Not borrowed on creation ) db.session.add(author) db.session.add(book) db.session.commit() return {'message':"book created"}, HTTP_201_CREATED
the-stack_0_3368
import argparse import optparse import sys import turtle from turtle import * import numpy as np parser = optparse.OptionParser(description='paint') parser.add_option('--name', type=str, default='circle', help='file name') parser.add_option('--start_length', type=int, default=0, help='number of forwards') parser.add_option('--end_length', type=int, default=120, help='number of forwards') parser.add_option('--n_edges', type=int, default=6, help='number_of_edges') parser.add_option('--pattern', type=int, default=-2, help='index of pattern, e.g. -2, -1, 0, 1, 2, ...') parser.add_option('--color', type=str, default='monocolor', help='color, e.g. monocolor, red, ...') parser.add_option('--n_circle', type=int, default=10, help='number of circle') (opts, args) = parser.parse_args() argvs = sys.argv if opts.color == 'colorful': colors = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'] else: colors = [opts.color] * 6 speed(0) # bgcolor("Black") def rotation(start_length, end_length, n_edges, pattern, color): n = 0 c = 0 colormode(255) for count in range(start_length, end_length): # decide color if color == 'monocolor': c += int(255 / end_length) # pencolor(np.uint8(-c), np.uint8(-c), np.uint8(-c)) pencolor(np.uint8(c), np.uint8(c), np.uint8(c)) else: # you can change color as you like here start = 255 c += int(start / end_length) # pencolor(np.uint8(start - c), np.uint8(start - c), np.uint8(c)) # pencolor(np.uint8(c), np.uint8(start - c), np.uint8(start - c)) pencolor(np.uint8(c), np.uint8(0), np.uint8(0)) for i in range(n_edges): if color == 'colorful': pencolor(colors[i % 6]) forward(count) left(int(360 / n_edges) + pattern) n += 1 left(3) print(count) window = turtle.Screen() window.setup(width=600, height=600, startx=10, starty=0.5) position_list = np.random.randint(-300, 300, size=(opts.n_circle, 2)) np.random.randint(10) * 10 for ii in range(opts.n_circle): penup() goto(position_list[ii, 0], position_list[ii, 1]) pendown() rotation(np.random.randint(10) * 4, np.random.randint(10, 30) * 4, np.random.randint(4, 5), np.random.choice([-1, 1]) * np.random.randint(0, 3), opts.color) hideturtle() ts = getscreen() bgcolor("Black") ts.getcanvas().postscript(file=f"{opts.name}_{opts.end_length}_{opts.n_edges}_{opts.pattern}_{opts.color}.eps") print('end') exit()
the-stack_0_3369
# Copyright 1996-2021 Cyberbotics Ltd. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ROS2 Tesla driver.""" import os import cv2 import numpy as np import rclpy from sensor_msgs.msg import Image from ackermann_msgs.msg import AckermannDrive from rclpy.qos import qos_profile_sensor_data, QoSReliabilityPolicy from rclpy.node import Node CONTROL_COEFFICIENT = 0.0005 class LaneFollower(Node): def __init__(self): super().__init__('lane_follower') # ROS interface self.__ackermann_publisher = self.create_publisher(AckermannDrive, 'cmd_ackermann', 1) qos_camera_data = qos_profile_sensor_data # In case ROS_DISTRO is Rolling or Galactic the QoSReliabilityPolicy is strict. if ('ROS_DISTRO' in os.environ and (os.environ['ROS_DISTRO'] == 'rolling' or os.environ['ROS_DISTRO'] == 'galactic')): qos_camera_data.reliability = QoSReliabilityPolicy.RELIABLE self.create_subscription(Image, 'vehicle/camera', self.__on_camera_image, qos_camera_data) def __on_camera_image(self, message): img = message.data img = np.frombuffer(img, dtype=np.uint8).reshape((message.height, message.width, 4)) img = img[380:420, :] # Segment the image by color in HSV color space img = cv2.cvtColor(img, cv2.COLOR_RGBA2RGB) img = cv2.cvtColor(img, cv2.COLOR_RGB2HSV) mask = cv2.inRange(img, np.array([50, 110, 150]), np.array([120, 255, 255])) # Find the largest segmented contour contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) command_message = AckermannDrive() command_message.speed = 50.0 command_message.steering_angle = 0.0 if contours: largest_contour = max(contours, key=cv2.contourArea) largest_contour_center = cv2.moments(largest_contour) if largest_contour_center['m00'] != 0: center_x = int(largest_contour_center['m10'] / largest_contour_center['m00']) # Find error (the lane distance from the target distance) error = center_x - 190 command_message.steering_angle = error*CONTROL_COEFFICIENT self.__ackermann_publisher.publish(command_message) def main(args=None): rclpy.init(args=args) follower = LaneFollower() rclpy.spin(follower) rclpy.shutdown() if __name__ == '__main__': main()
the-stack_0_3371
from swsscommon import swsscommon import time import json import random import time from pprint import pprint def create_entry(tbl, key, pairs): fvs = swsscommon.FieldValuePairs(pairs) tbl.set(key, fvs) time.sleep(1) def create_entry_tbl(db, table, separator, key, pairs): tbl = swsscommon.Table(db, table) create_entry(tbl, key, pairs) def create_entry_pst(db, table, separator, key, pairs): tbl = swsscommon.ProducerStateTable(db, table) create_entry(tbl, key, pairs) def how_many_entries_exist(db, table): tbl = swsscommon.Table(db, table) return len(tbl.getKeys()) def entries(db, table): tbl = swsscommon.Table(db, table) return set(tbl.getKeys()) def get_exist_entries(dvs, table): db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) tbl = swsscommon.Table(db, table) return set(tbl.getKeys()) def get_created_entry(db, table, existed_entries): tbl = swsscommon.Table(db, table) entries = set(tbl.getKeys()) new_entries = list(entries - existed_entries) assert len(new_entries) == 1, "Wrong number of created entries." return new_entries[0] def get_created_entries(db, table, existed_entries, count): tbl = swsscommon.Table(db, table) entries = set(tbl.getKeys()) new_entries = list(entries - existed_entries) assert len(new_entries) == count, "Wrong number of created entries." new_entries.sort() return new_entries def get_default_vr_id(dvs): db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) table = 'ASIC_STATE:SAI_OBJECT_TYPE_VIRTUAL_ROUTER' tbl = swsscommon.Table(db, table) keys = tbl.getKeys() assert len(keys) == 1, "Wrong number of virtual routers found" return keys[0] def check_object(db, table, key, expected_attributes): tbl = swsscommon.Table(db, table) keys = tbl.getKeys() assert key in keys, "The desired key is not presented" status, fvs = tbl.get(key) assert status, "Got an error when get a key" assert len(fvs) >= len(expected_attributes), "Incorrect attributes" attr_keys = {entry[0] for entry in fvs} for name, value in fvs: if name in expected_attributes: assert expected_attributes[name] == value, "Wrong value %s for the attribute %s = %s" % \ (value, name, expected_attributes[name]) def create_vnet_local_routes(dvs, prefix, vnet_name, ifname): app_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0) create_entry_pst( app_db, "VNET_ROUTE_TABLE", ':', "%s:%s" % (vnet_name, prefix), [ ("ifname", ifname), ] ) time.sleep(2) def create_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0): app_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0) attrs = [ ("endpoint", endpoint), ] if vni: attrs.append(('vni', vni)) if mac: attrs.append(('mac_address', mac)) create_entry_pst( app_db, "VNET_ROUTE_TUNNEL_TABLE", ':', "%s:%s" % (vnet_name, prefix), attrs, ) time.sleep(2) def create_vlan(dvs, vlan_name, vlan_ids): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0) vlan_id = vlan_name[4:] # create vlan create_entry_tbl( conf_db, "VLAN", '|', vlan_name, [ ("vlanid", vlan_id), ], ) time.sleep(1) vlan_oid = get_created_entry(asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_VLAN", vlan_ids) check_object(asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_VLAN", vlan_oid, { "SAI_VLAN_ATTR_VLAN_ID": vlan_id, } ) return vlan_oid def create_vlan_interface(dvs, vlan_name, ifname, vnet_name, ipaddr): conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0) vlan_ids = get_exist_entries(dvs, "ASIC_STATE:SAI_OBJECT_TYPE_VLAN") vlan_oid = create_vlan (dvs, vlan_name, vlan_ids) # create a vlan member in config db create_entry_tbl( conf_db, "VLAN_MEMBER", '|', "%s|%s" % (vlan_name, ifname), [ ("tagging_mode", "untagged"), ], ) time.sleep(1) # create vlan interface in config db create_entry_tbl( conf_db, "VLAN_INTERFACE", '|', vlan_name, [ ("vnet_name", vnet_name), ], ) #FIXME - This is created by IntfMgr app_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0) create_entry_pst( app_db, "INTF_TABLE", ':', vlan_name, [ ("vnet_name", vnet_name), ], ) time.sleep(2) create_entry_tbl( conf_db, "VLAN_INTERFACE", '|', "%s|%s" % (vlan_name, ipaddr), [ ("family", "IPv4"), ], ) time.sleep(2) return vlan_oid def create_phy_interface(dvs, ifname, vnet_name, ipaddr): conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0) exist_rifs = get_exist_entries(dvs, "ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE") # create vlan interface in config db create_entry_tbl( conf_db, "INTERFACE", '|', ifname, [ ("vnet_name", vnet_name), ], ) #FIXME - This is created by IntfMgr app_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0) create_entry_pst( app_db, "INTF_TABLE", ':', ifname, [ ("vnet_name", vnet_name), ], ) time.sleep(2) create_entry_tbl( conf_db, "INTERFACE", '|', "%s|%s" % (ifname, ipaddr), [ ("family", "IPv4"), ], ) def create_vnet_entry(dvs, name, tunnel, vni, peer_list): conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0) asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) attrs = [ ("vxlan_tunnel", tunnel), ("vni", vni), ("peer_list", peer_list), ] # create the VXLAN tunnel Term entry in Config DB create_entry_tbl( conf_db, "VNET", '|', name, attrs, ) time.sleep(2) def create_vxlan_tunnel(dvs, name, src_ip): conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0) attrs = [ ("src_ip", src_ip), ] # create the VXLAN tunnel Term entry in Config DB create_entry_tbl( conf_db, "VXLAN_TUNNEL", '|', name, attrs, ) def get_lo(dvs): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) vr_id = get_default_vr_id(dvs) tbl = swsscommon.Table(asic_db, 'ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE') entries = tbl.getKeys() lo_id = None for entry in entries: status, fvs = tbl.get(entry) assert status, "Got an error when get a key" for key, value in fvs: if key == 'SAI_ROUTER_INTERFACE_ATTR_TYPE' and value == 'SAI_ROUTER_INTERFACE_TYPE_LOOPBACK': lo_id = entry break else: assert False, 'Don\'t found loopback id' return lo_id def get_switch_mac(dvs): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) tbl = swsscommon.Table(asic_db, 'ASIC_STATE:SAI_OBJECT_TYPE_SWITCH') entries = tbl.getKeys() mac = None for entry in entries: status, fvs = tbl.get(entry) assert status, "Got an error when get a key" for key, value in fvs: if key == 'SAI_SWITCH_ATTR_SRC_MAC_ADDRESS': mac = value break else: assert False, 'Don\'t found switch mac' return mac loopback_id = 0 def_vr_id = 0 switch_mac = None class VnetVxlanVrfTunnel(object): ASIC_TUNNEL_TABLE = "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL" ASIC_TUNNEL_MAP = "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP" ASIC_TUNNEL_MAP_ENTRY = "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY" ASIC_TUNNEL_TERM_ENTRY = "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY" ASIC_RIF_TABLE = "ASIC_STATE:SAI_OBJECT_TYPE_ROUTER_INTERFACE" ASIC_VRF_TABLE = "ASIC_STATE:SAI_OBJECT_TYPE_VIRTUAL_ROUTER" ASIC_ROUTE_ENTRY = "ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY" ASIC_NEXT_HOP = "ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP" tunnel_map_ids = set() tunnel_map_entry_ids = set() tunnel_ids = set() tunnel_term_ids = set() tunnel_map_map = {} tunnel = {} vnet_vr_ids = set() vr_map = {} nh_ids = {} def fetch_exist_entries(self, dvs): self.vnet_vr_ids = get_exist_entries(dvs, self.ASIC_VRF_TABLE) self.tunnel_ids = get_exist_entries(dvs, self.ASIC_TUNNEL_TABLE) self.tunnel_map_ids = get_exist_entries(dvs, self.ASIC_TUNNEL_MAP) self.tunnel_map_entry_ids = get_exist_entries(dvs, self.ASIC_TUNNEL_MAP_ENTRY) self.tunnel_term_ids = get_exist_entries(dvs, self.ASIC_TUNNEL_TERM_ENTRY) self.rifs = get_exist_entries(dvs, self.ASIC_RIF_TABLE) self.routes = get_exist_entries(dvs, self.ASIC_ROUTE_ENTRY) self.nhops = get_exist_entries(dvs, self.ASIC_NEXT_HOP) global loopback_id, def_vr_id, switch_mac if not loopback_id: loopback_id = get_lo(dvs) if not def_vr_id: def_vr_id = get_default_vr_id(dvs) if switch_mac is None: switch_mac = get_switch_mac(dvs) def check_vxlan_tunnel(self, dvs, tunnel_name, src_ip): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) global loopback_id, def_vr_id tunnel_map_id = get_created_entries(asic_db, self.ASIC_TUNNEL_MAP, self.tunnel_map_ids, 2) tunnel_id = get_created_entry(asic_db, self.ASIC_TUNNEL_TABLE, self.tunnel_ids) tunnel_term_id = get_created_entry(asic_db, self.ASIC_TUNNEL_TERM_ENTRY, self.tunnel_term_ids) # check that the vxlan tunnel termination are there assert how_many_entries_exist(asic_db, self.ASIC_TUNNEL_MAP) == (len(self.tunnel_map_ids) + 2), "The TUNNEL_MAP wasn't created" assert how_many_entries_exist(asic_db, self.ASIC_TUNNEL_MAP_ENTRY) == len(self.tunnel_map_entry_ids), "The TUNNEL_MAP_ENTRY is created" assert how_many_entries_exist(asic_db, self.ASIC_TUNNEL_TABLE) == (len(self.tunnel_ids) + 1), "The TUNNEL wasn't created" assert how_many_entries_exist(asic_db, self.ASIC_TUNNEL_TERM_ENTRY) == (len(self.tunnel_term_ids) + 1), "The TUNNEL_TERM_TABLE_ENTRY wasm't created" check_object(asic_db, self.ASIC_TUNNEL_MAP, tunnel_map_id[0], { 'SAI_TUNNEL_MAP_ATTR_TYPE': 'SAI_TUNNEL_MAP_TYPE_VNI_TO_VIRTUAL_ROUTER_ID', } ) check_object(asic_db, self.ASIC_TUNNEL_MAP, tunnel_map_id[1], { 'SAI_TUNNEL_MAP_ATTR_TYPE': 'SAI_TUNNEL_MAP_TYPE_VIRTUAL_ROUTER_ID_TO_VNI', } ) check_object(asic_db, self.ASIC_TUNNEL_TABLE, tunnel_id, { 'SAI_TUNNEL_ATTR_TYPE': 'SAI_TUNNEL_TYPE_VXLAN', 'SAI_TUNNEL_ATTR_UNDERLAY_INTERFACE': loopback_id, 'SAI_TUNNEL_ATTR_DECAP_MAPPERS': '1:%s' % tunnel_map_id[0], 'SAI_TUNNEL_ATTR_ENCAP_MAPPERS': '1:%s' % tunnel_map_id[1], 'SAI_TUNNEL_ATTR_ENCAP_SRC_IP': src_ip, } ) expected_attributes = { 'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TYPE': 'SAI_TUNNEL_TERM_TABLE_ENTRY_TYPE_P2MP', 'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID': def_vr_id, 'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP': src_ip, 'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TUNNEL_TYPE': 'SAI_TUNNEL_TYPE_VXLAN', 'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_ACTION_TUNNEL_ID': tunnel_id, } check_object(asic_db, self.ASIC_TUNNEL_TERM_ENTRY, tunnel_term_id, expected_attributes) self.tunnel_map_ids.update(tunnel_map_id) self.tunnel_ids.add(tunnel_id) self.tunnel_term_ids.add(tunnel_term_id) self.tunnel_map_map[tunnel_name] = tunnel_map_id self.tunnel[tunnel_name] = tunnel_id def check_vxlan_tunnel_entry(self, dvs, tunnel_name, vnet_name, vni_id): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) app_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0) time.sleep(2) if (self.tunnel_map_map.get(tunnel_name) is None): tunnel_map_id = get_created_entries(asic_db, self.ASIC_TUNNEL_MAP, self.tunnel_map_ids, 2) else: tunnel_map_id = self.tunnel_map_map[tunnel_name] tunnel_map_entry_id = get_created_entries(asic_db, self.ASIC_TUNNEL_MAP_ENTRY, self.tunnel_map_entry_ids, 2) # check that the vxlan tunnel termination are there assert how_many_entries_exist(asic_db, self.ASIC_TUNNEL_MAP_ENTRY) == (len(self.tunnel_map_entry_ids) + 2), "The TUNNEL_MAP_ENTRY is created too early" check_object(asic_db, self.ASIC_TUNNEL_MAP_ENTRY, tunnel_map_entry_id[0], { 'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP_TYPE': 'SAI_TUNNEL_MAP_TYPE_VIRTUAL_ROUTER_ID_TO_VNI', 'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP': tunnel_map_id[1], 'SAI_TUNNEL_MAP_ENTRY_ATTR_VIRTUAL_ROUTER_ID_KEY': self.vr_map[vnet_name].get('ing'), 'SAI_TUNNEL_MAP_ENTRY_ATTR_VNI_ID_VALUE': vni_id, } ) check_object(asic_db, self.ASIC_TUNNEL_MAP_ENTRY, tunnel_map_entry_id[1], { 'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP_TYPE': 'SAI_TUNNEL_MAP_TYPE_VNI_TO_VIRTUAL_ROUTER_ID', 'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP': tunnel_map_id[0], 'SAI_TUNNEL_MAP_ENTRY_ATTR_VNI_ID_KEY': vni_id, 'SAI_TUNNEL_MAP_ENTRY_ATTR_VIRTUAL_ROUTER_ID_VALUE': self.vr_map[vnet_name].get('egr'), } ) self.tunnel_map_entry_ids.update(tunnel_map_entry_id) def check_vnet_entry(self, dvs, name, peer_list=[]): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) #Check virtual router objects assert how_many_entries_exist(asic_db, self.ASIC_VRF_TABLE) == (len(self.vnet_vr_ids) + 2),\ "The VR objects are not created" new_vr_ids = get_created_entries(asic_db, self.ASIC_VRF_TABLE, self.vnet_vr_ids, 2) self.vnet_vr_ids.update(new_vr_ids) self.vr_map[name] = { 'ing':new_vr_ids[0], 'egr':new_vr_ids[1], 'peer':peer_list } def vnet_route_ids(self, dvs, name, local=False): vr_set = set() if local: vr_set.add(self.vr_map[name].get('egr')) else: vr_set.add(self.vr_map[name].get('ing')) try: for peer in self.vr_map[name].get('peer'): vr_set.add(self.vr_map[peer].get('ing')) except IndexError: pass return vr_set def check_router_interface(self, dvs, name, vlan_oid=0): # Check RIF in ingress VRF asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) global switch_mac expected_attr = { "SAI_ROUTER_INTERFACE_ATTR_VIRTUAL_ROUTER_ID": self.vr_map[name].get('ing'), "SAI_ROUTER_INTERFACE_ATTR_SRC_MAC_ADDRESS": switch_mac, "SAI_ROUTER_INTERFACE_ATTR_MTU": "9100", } if vlan_oid: expected_attr.update({'SAI_ROUTER_INTERFACE_ATTR_TYPE': 'SAI_ROUTER_INTERFACE_TYPE_VLAN'}) expected_attr.update({'SAI_ROUTER_INTERFACE_ATTR_VLAN_ID': vlan_oid}) else: expected_attr.update({'SAI_ROUTER_INTERFACE_ATTR_TYPE': 'SAI_ROUTER_INTERFACE_TYPE_PORT'}) new_rif = get_created_entry(asic_db, self.ASIC_RIF_TABLE, self.rifs) check_object(asic_db, self.ASIC_RIF_TABLE, new_rif, expected_attr) #IP2ME and subnet routes will be created with every router interface new_route = get_created_entries(asic_db, self.ASIC_ROUTE_ENTRY, self.routes, 2) self.rifs.add(new_rif) self.routes.update(new_route) def check_vnet_local_routes(self, dvs, name): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) vr_ids = self.vnet_route_ids(dvs, name, True) count = len(vr_ids) new_route = get_created_entries(asic_db, self.ASIC_ROUTE_ENTRY, self.routes, count) #Check if the route is duplicated to egress VRF asic_vrs = set() for idx in range(count): rt_key = json.loads(new_route[idx]) asic_vrs.add(rt_key['vr']) assert asic_vrs == vr_ids self.routes.update(new_route) def check_vnet_routes(self, dvs, name, endpoint, tunnel, mac="", vni=0): asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0) vr_ids = self.vnet_route_ids(dvs, name) count = len(vr_ids) # Check routes in ingress VRF expected_attr = { "SAI_NEXT_HOP_ATTR_TYPE": "SAI_NEXT_HOP_TYPE_TUNNEL_ENCAP", "SAI_NEXT_HOP_ATTR_IP": endpoint, "SAI_NEXT_HOP_ATTR_TUNNEL_ID": self.tunnel[tunnel], } if vni: expected_attr.update({'SAI_NEXT_HOP_ATTR_TUNNEL_VNI': vni}) if mac: expected_attr.update({'SAI_NEXT_HOP_ATTR_TUNNEL_MAC': mac}) if endpoint in self.nh_ids: new_nh = self.nh_ids[endpoint] else: new_nh = get_created_entry(asic_db, self.ASIC_NEXT_HOP, self.nhops) self.nh_ids[endpoint] = new_nh self.nhops.add(new_nh) check_object(asic_db, self.ASIC_NEXT_HOP, new_nh, expected_attr) new_route = get_created_entries(asic_db, self.ASIC_ROUTE_ENTRY, self.routes, count) #Check if the route is in expected VRF asic_vrs = set() for idx in range(count): check_object(asic_db, self.ASIC_ROUTE_ENTRY, new_route[idx], { "SAI_ROUTE_ENTRY_ATTR_NEXT_HOP_ID": new_nh, } ) rt_key = json.loads(new_route[idx]) asic_vrs.add(rt_key['vr']) assert asic_vrs == vr_ids self.routes.update(new_route) class TestVnetOrch(object): ''' Test 1 - Create Vlan Interface, Tunnel and Vnet ''' def test_vnet_orch_1(self, dvs, testlog): vnet_obj = VnetVxlanVrfTunnel() tunnel_name = 'tunnel_1' vnet_obj.fetch_exist_entries(dvs) create_vxlan_tunnel(dvs, tunnel_name, '10.10.10.10') create_vnet_entry(dvs, 'Vnet_2000', tunnel_name, '2000', "") vnet_obj.check_vnet_entry(dvs, 'Vnet_2000') vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_2000', '2000') vnet_obj.check_vxlan_tunnel(dvs, tunnel_name, '10.10.10.10') vid = create_vlan_interface(dvs, "Vlan100", "Ethernet24", "Vnet_2000", "100.100.3.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_2000', vid) vid = create_vlan_interface(dvs, "Vlan101", "Ethernet28", "Vnet_2000", "100.100.4.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_2000', vid) create_vnet_routes(dvs, "100.100.1.1/32", 'Vnet_2000', '10.10.10.1') vnet_obj.check_vnet_routes(dvs, 'Vnet_2000', '10.10.10.1', tunnel_name) create_vnet_local_routes(dvs, "100.100.3.0/24", 'Vnet_2000', 'Vlan100') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_2000') create_vnet_local_routes(dvs, "100.100.4.0/24", 'Vnet_2000', 'Vlan101') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_2000') #Create Physical Interface in another Vnet create_vnet_entry(dvs, 'Vnet_2001', tunnel_name, '2001', "") vnet_obj.check_vnet_entry(dvs, 'Vnet_2001') vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_2001', '2001') create_phy_interface(dvs, "Ethernet4", "Vnet_2001", "100.102.1.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_2001') create_vnet_routes(dvs, "100.100.2.1/32", 'Vnet_2001', '10.10.10.2', "00:12:34:56:78:9A") vnet_obj.check_vnet_routes(dvs, 'Vnet_2001', '10.10.10.2', tunnel_name, "00:12:34:56:78:9A") create_vnet_local_routes(dvs, "100.102.1.0/24", 'Vnet_2001', 'Ethernet4') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_2001') ''' Test 2 - Two VNets, One HSMs per VNet ''' def test_vnet_orch_2(self, dvs, testlog): vnet_obj = VnetVxlanVrfTunnel() tunnel_name = 'tunnel_2' vnet_obj.fetch_exist_entries(dvs) create_vxlan_tunnel(dvs, tunnel_name, '6.6.6.6') create_vnet_entry(dvs, 'Vnet_1', tunnel_name, '1111', "") vnet_obj.check_vnet_entry(dvs, 'Vnet_1') vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_1', '1111') tun_id = vnet_obj.check_vxlan_tunnel(dvs, tunnel_name, '6.6.6.6') vid = create_vlan_interface(dvs, "Vlan1001", "Ethernet0", "Vnet_1", "1.1.10.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_1', vid) create_vnet_routes(dvs, "1.1.1.10/32", 'Vnet_1', '100.1.1.10') vnet_obj.check_vnet_routes(dvs, 'Vnet_1', '100.1.1.10', tunnel_name) create_vnet_routes(dvs, "1.1.1.11/32", 'Vnet_1', '100.1.1.10') vnet_obj.check_vnet_routes(dvs, 'Vnet_1', '100.1.1.10', tunnel_name) create_vnet_routes(dvs, "1.1.1.12/32", 'Vnet_1', '200.200.1.200') vnet_obj.check_vnet_routes(dvs, 'Vnet_1', '200.200.1.200', tunnel_name) create_vnet_routes(dvs, "1.1.1.14/32", 'Vnet_1', '200.200.1.201') vnet_obj.check_vnet_routes(dvs, 'Vnet_1', '200.200.1.201', tunnel_name) create_vnet_local_routes(dvs, "1.1.10.0/24", 'Vnet_1', 'Vlan1001') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_1') create_vnet_entry(dvs, 'Vnet_2', tunnel_name, '2222', "") vnet_obj.check_vnet_entry(dvs, 'Vnet_2') vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_2', '2222') vid = create_vlan_interface(dvs, "Vlan1002", "Ethernet4", "Vnet_2", "2.2.10.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_2', vid) create_vnet_routes(dvs, "2.2.2.10/32", 'Vnet_2', '100.1.1.20') vnet_obj.check_vnet_routes(dvs, 'Vnet_2', '100.1.1.20', tunnel_name) create_vnet_routes(dvs, "2.2.2.11/32", 'Vnet_2', '100.1.1.20') vnet_obj.check_vnet_routes(dvs, 'Vnet_2', '100.1.1.20', tunnel_name) create_vnet_local_routes(dvs, "2.2.10.0/24", 'Vnet_2', 'Vlan1002') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_2') ''' Test 3 - Two VNets, One HSMs per VNet, Peering ''' def test_vnet_orch_3(self, dvs, testlog): vnet_obj = VnetVxlanVrfTunnel() tunnel_name = 'tunnel_3' vnet_obj.fetch_exist_entries(dvs) create_vxlan_tunnel(dvs, tunnel_name, '7.7.7.7') create_vnet_entry(dvs, 'Vnet_10', tunnel_name, '1111', "Vnet_20") vnet_obj.check_vnet_entry(dvs, 'Vnet_10', ['Vnet_20']) vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_10', '1111') create_vnet_entry(dvs, 'Vnet_20', tunnel_name, '2222', "Vnet_10") vnet_obj.check_vnet_entry(dvs, 'Vnet_20', ['Vnet_10']) vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, 'Vnet_20', '2222') tun_id = vnet_obj.check_vxlan_tunnel(dvs, tunnel_name, '7.7.7.7') vid = create_vlan_interface(dvs, "Vlan2001", "Ethernet8", "Vnet_10", "5.5.10.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_10', vid) vid = create_vlan_interface(dvs, "Vlan2002", "Ethernet12", "Vnet_20", "8.8.10.1/24") vnet_obj.check_router_interface(dvs, 'Vnet_20', vid) create_vnet_routes(dvs, "5.5.5.10/32", 'Vnet_10', '50.1.1.10') vnet_obj.check_vnet_routes(dvs, 'Vnet_10', '50.1.1.10', tunnel_name) create_vnet_routes(dvs, "8.8.8.10/32", 'Vnet_20', '80.1.1.20') vnet_obj.check_vnet_routes(dvs, 'Vnet_10', '80.1.1.20', tunnel_name) create_vnet_local_routes(dvs, "5.5.10.0/24", 'Vnet_10', 'Vlan2001') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_10') create_vnet_local_routes(dvs, "8.8.10.0/24", 'Vnet_20', 'Vlan2002') vnet_obj.check_vnet_local_routes(dvs, 'Vnet_20')
the-stack_0_3373
def get_parent_index(h, idx): ## calculate the maximum index first ## if the input is too large, return a negative 1 max_idx = 2**h - 1 if max_idx < idx: return -1 # otherwise, carry on else: node_offset = 0 continue_flag = True subtree_size = max_idx result = -1 # default result while continue_flag: if subtree_size == 0: continue_flag = False # right shift is equivalent to dividing by 2 and discarding the remainder. subtree_size = subtree_size >> 1 # predict the left node left_node = node_offset + subtree_size # predict the right node right_node = left_node + subtree_size # calculate my node value my_node = right_node + 1 # if either child is a match, return my node value if (left_node == idx) or (right_node == idx): result = my_node continue_flag = False # Make the current left child the offset if the index is greater than the left. # This effectively searches down the right subtree. if (idx > left_node): node_offset = left_node return result def solution(h, q): return [ get_parent_index(h, x) for x in q ]
the-stack_0_3375
from sklearn.model_selection import train_test_split from sklearn.utils import shuffle import pandas as pd import os import argparse def create_folder(parent_path, folder): if not parent_path.endswith('/'): parent_path += '/' folder_path = parent_path + folder if not os.path.exists(folder_path): os.makedirs(folder_path) return folder_path def shuffle_stays(stays, seed=9): return shuffle(stays, random_state=seed) def process_table(table_name, table, stays, folder_path): table = table.loc[stays].copy() table.to_csv('{}/{}.csv'.format(folder_path, table_name)) return def split_train_test(path, is_test=True, seed=9, cleanup=True, MIMIC=False): labels = pd.read_csv(path + 'preprocessed_labels.csv') labels.set_index('patient', inplace=True) # we split by unique patient identifier to make sure there are no patients # that cross into both the train and the test sets patients = labels.uniquepid.unique() train, test = train_test_split(patients, test_size=0.2, random_state=seed) train, val = train_test_split(train, test_size=0.1/0.8, random_state=seed) print('==> Loading data for splitting...') if is_test: timeseries = pd.read_csv( path + 'preprocessed_timeseries.csv', nrows=999999) else: timeseries = pd.read_csv(path + 'preprocessed_timeseries.csv') timeseries.set_index('patient', inplace=True) if not MIMIC: diagnoses = pd.read_csv(path + 'preprocessed_diagnoses.csv') diagnoses.set_index('patient', inplace=True) flat_features = pd.read_csv(path + 'preprocessed_flat.csv') flat_features.set_index('patient', inplace=True) # delete the source files, as they won't be needed anymore if is_test is False and cleanup: print('==> Removing the unsorted data...') os.remove(path + 'preprocessed_timeseries.csv') if not MIMIC: os.remove(path + 'preprocessed_diagnoses.csv') os.remove(path + 'preprocessed_labels.csv') os.remove(path + 'preprocessed_flat.csv') for partition_name, partition in zip(['train', 'val', 'test'], [train, val, test]): print('==> Preparing {} data...'.format(partition_name)) stays = labels.loc[labels['uniquepid'].isin(partition)].index folder_path = create_folder(path, partition_name) with open(folder_path + '/stays.txt', 'w') as f: for stay in stays: f.write("%s\n" % stay) stays = shuffle_stays(stays, seed=9) if MIMIC: for table_name, table in zip(['labels', 'flat', 'timeseries'], [labels, flat_features, timeseries]): process_table(table_name, table, stays, folder_path) else: for table_name, table in zip(['labels', 'flat', 'diagnoses', 'timeseries'], [labels, flat_features, diagnoses, timeseries]): process_table(table_name, table, stays, folder_path) return if __name__ == '__main__': from eICU_preprocessing.run_all_preprocessing import eICU_path parser = argparse.ArgumentParser() parser.add_argument('--cleanup', action='store_true') args = parser.parse_args() split_train_test(eICU_path, is_test=False, cleanup=args.cleanup)
the-stack_0_3376
""" Support for HomematicIP sensors. For more details about this component, please refer to the documentation at https://home-assistant.io/components/sensor.homematicip_cloud/ """ import logging from homeassistant.core import callback from homeassistant.helpers.entity import Entity from homeassistant.helpers.dispatcher import async_dispatcher_connect from homeassistant.components.homematicip_cloud import ( HomematicipGenericDevice, DOMAIN, EVENT_HOME_CHANGED, ATTR_HOME_LABEL, ATTR_HOME_ID, ATTR_LOW_BATTERY, ATTR_RSSI) from homeassistant.const import TEMP_CELSIUS, STATE_OK _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['homematicip_cloud'] ATTR_VALVE_STATE = 'valve_state' ATTR_VALVE_POSITION = 'valve_position' ATTR_TEMPERATURE_OFFSET = 'temperature_offset' HMIP_UPTODATE = 'up_to_date' HMIP_VALVE_DONE = 'adaption_done' HMIP_SABOTAGE = 'sabotage' STATE_LOW_BATTERY = 'low_battery' STATE_SABOTAGE = 'sabotage' def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the HomematicIP sensors devices.""" # pylint: disable=import-error, no-name-in-module from homematicip.device import ( HeatingThermostat, TemperatureHumiditySensorWithoutDisplay, TemperatureHumiditySensorDisplay) homeid = discovery_info['homeid'] home = hass.data[DOMAIN][homeid] devices = [HomematicipAccesspoint(home)] for device in home.devices: devices.append(HomematicipDeviceStatus(home, device)) if isinstance(device, HeatingThermostat): devices.append(HomematicipHeatingThermostat(home, device)) if isinstance(device, TemperatureHumiditySensorWithoutDisplay): devices.append(HomematicipSensorThermometer(home, device)) devices.append(HomematicipSensorHumidity(home, device)) if isinstance(device, TemperatureHumiditySensorDisplay): devices.append(HomematicipSensorThermometer(home, device)) devices.append(HomematicipSensorHumidity(home, device)) if home.devices: add_devices(devices) class HomematicipAccesspoint(Entity): """Representation of an HomeMaticIP access point.""" def __init__(self, home): """Initialize the access point sensor.""" self._home = home _LOGGER.debug('Setting up access point %s', home.label) async def async_added_to_hass(self): """Register callbacks.""" async_dispatcher_connect( self.hass, EVENT_HOME_CHANGED, self._home_changed) @callback def _home_changed(self, deviceid): """Handle device state changes.""" if deviceid is None or deviceid == self._home.id: _LOGGER.debug('Event home %s', self._home.label) self.async_schedule_update_ha_state() @property def name(self): """Return the name of the access point device.""" if self._home.label == '': return 'Access Point Status' return '{} Access Point Status'.format(self._home.label) @property def icon(self): """Return the icon of the access point device.""" return 'mdi:access-point-network' @property def state(self): """Return the state of the access point.""" return self._home.dutyCycle @property def available(self): """Device available.""" return self._home.connected @property def device_state_attributes(self): """Return the state attributes of the access point.""" return { ATTR_HOME_LABEL: self._home.label, ATTR_HOME_ID: self._home.id, } class HomematicipDeviceStatus(HomematicipGenericDevice): """Representation of an HomematicIP device status.""" def __init__(self, home, device): """Initialize the device.""" super().__init__(home, device) _LOGGER.debug('Setting up sensor device status: %s', device.label) @property def name(self): """Return the name of the device.""" return self._name('Status') @property def icon(self): """Return the icon of the status device.""" if (hasattr(self._device, 'sabotage') and self._device.sabotage == HMIP_SABOTAGE): return 'mdi:alert' elif self._device.lowBat: return 'mdi:battery-outline' elif self._device.updateState.lower() != HMIP_UPTODATE: return 'mdi:refresh' return 'mdi:check' @property def state(self): """Return the state of the generic device.""" if (hasattr(self._device, 'sabotage') and self._device.sabotage == HMIP_SABOTAGE): return STATE_SABOTAGE elif self._device.lowBat: return STATE_LOW_BATTERY elif self._device.updateState.lower() != HMIP_UPTODATE: return self._device.updateState.lower() return STATE_OK class HomematicipHeatingThermostat(HomematicipGenericDevice): """MomematicIP heating thermostat representation.""" def __init__(self, home, device): """"Initialize heating thermostat.""" super().__init__(home, device) _LOGGER.debug('Setting up heating thermostat device: %s', device.label) @property def icon(self): """Return the icon.""" if self._device.valveState.lower() != HMIP_VALVE_DONE: return 'mdi:alert' return 'mdi:radiator' @property def state(self): """Return the state of the radiator valve.""" if self._device.valveState.lower() != HMIP_VALVE_DONE: return self._device.valveState.lower() return round(self._device.valvePosition*100) @property def unit_of_measurement(self): """Return the unit this state is expressed in.""" return '%' @property def device_state_attributes(self): """Return the state attributes.""" return { ATTR_VALVE_STATE: self._device.valveState.lower(), ATTR_TEMPERATURE_OFFSET: self._device.temperatureOffset, ATTR_LOW_BATTERY: self._device.lowBat, ATTR_RSSI: self._device.rssiDeviceValue } class HomematicipSensorHumidity(HomematicipGenericDevice): """MomematicIP thermometer device.""" def __init__(self, home, device): """"Initialize the thermometer device.""" super().__init__(home, device) _LOGGER.debug('Setting up humidity device: %s', device.label) @property def name(self): """Return the name of the device.""" return self._name('Humidity') @property def icon(self): """Return the icon.""" return 'mdi:water' @property def state(self): """Return the state.""" return self._device.humidity @property def unit_of_measurement(self): """Return the unit this state is expressed in.""" return '%' @property def device_state_attributes(self): """Return the state attributes.""" return { ATTR_LOW_BATTERY: self._device.lowBat, ATTR_RSSI: self._device.rssiDeviceValue, } class HomematicipSensorThermometer(HomematicipGenericDevice): """MomematicIP thermometer device.""" def __init__(self, home, device): """"Initialize the thermometer device.""" super().__init__(home, device) _LOGGER.debug('Setting up thermometer device: %s', device.label) @property def name(self): """Return the name of the device.""" return self._name('Temperature') @property def icon(self): """Return the icon.""" return 'mdi:thermometer' @property def state(self): """Return the state.""" return self._device.actualTemperature @property def unit_of_measurement(self): """Return the unit this state is expressed in.""" return TEMP_CELSIUS @property def device_state_attributes(self): """Return the state attributes.""" return { ATTR_TEMPERATURE_OFFSET: self._device.temperatureOffset, ATTR_LOW_BATTERY: self._device.lowBat, ATTR_RSSI: self._device.rssiDeviceValue, }
the-stack_0_3378
from devito.ir.clusters.queue import QueueStateful from devito.ir.support import (SEQUENTIAL, PARALLEL, PARALLEL_INDEP, PARALLEL_IF_ATOMIC, AFFINE, ROUNDABLE, TILABLE, Forward) from devito.tools import as_tuple, flatten, timed_pass __all__ = ['analyze'] @timed_pass() def analyze(clusters): state = QueueStateful.State() # Collect properties clusters = Parallelism(state).process(clusters) clusters = Affiness(state).process(clusters) clusters = Tiling(state).process(clusters) clusters = Rounding(state).process(clusters) # Reconstruct Clusters attaching the discovered properties processed = [c.rebuild(properties=state.properties.get(c)) for c in clusters] return processed class Detector(QueueStateful): def process(self, elements): return self._process_fatd(elements, 1) def callback(self, clusters, prefix): if not prefix: return clusters # The analyzed Dimension d = prefix[-1].dim # Apply the actual callback retval = self._callback(clusters, d, prefix) # Normalize retval retval = set(as_tuple(retval)) # Update `self.state` if retval: for c in clusters: properties = self.state.properties.setdefault(c, {}) properties.setdefault(d, set()).update(retval) return clusters class Parallelism(Detector): """ Detect SEQUENTIAL, PARALLEL, PARALLEL_INDEP and PARALLEL_IF_ATOMIC Dimensions. Consider an IterationSpace over `n` Dimensions. Let `(d_1, ..., d_n)` be the distance vector of a dependence. Let `i` be the `i-th` Dimension of the IterationSpace. Then: * `i` is PARALLEL_INDEP if all dependences have distance vectors: (d_1, ..., d_i) = 0 * `i` is PARALLEL if all dependences have distance vectors: (d_1, ..., d_i) = 0, OR (d_1, ..., d_{i-1}) > 0 * `i` is PARALLEL_IF_ATOMIC if all dependences have distance vectors: (d_1, ..., d_i) = 0, OR (d_1, ..., d_{i-1}) > 0, OR the 'write' is known to be an associative and commutative increment """ def _callback(self, clusters, d, prefix): # Rule out if non-unitary increment Dimension (e.g., `t0=(time+1)%2`) if any(c.sub_iterators.get(d) for c in clusters): return SEQUENTIAL # All Dimensions up to and including `i-1` prev = flatten(i.dim._defines for i in prefix[:-1]) is_parallel_indep = True is_parallel_atomic = False scope = self._fetch_scope(clusters) for dep in scope.d_all_gen(): test00 = dep.is_indep(d) and not dep.is_storage_related(d) test01 = all(dep.is_reduce_atmost(i) for i in prev) if test00 and test01: continue test1 = len(prev) > 0 and any(dep.is_carried(i) for i in prev) if test1: is_parallel_indep &= (dep.distance_mapper.get(d.root) == 0) continue if dep.function in scope.initialized: # False alarm, the dependence is over a locally-defined symbol continue if dep.is_increment: is_parallel_atomic = True continue return SEQUENTIAL if is_parallel_atomic: return PARALLEL_IF_ATOMIC elif is_parallel_indep: return {PARALLEL, PARALLEL_INDEP} else: return PARALLEL class Rounding(Detector): def _callback(self, clusters, d, prefix): itinterval = prefix[-1] # The iteration direction must be Forward -- ROUNDABLE is for rounding *up* if itinterval.direction is not Forward: return properties = self._fetch_properties(clusters, prefix) if PARALLEL not in properties[d]: return scope = self._fetch_scope(clusters) # All accessed Functions must have enough room in the PADDING region # so that `i`'s trip count can safely be rounded up # Note: autopadding guarantees that the padding size along the # Fastest Varying Dimension is a multiple of the SIMD vector length functions = [f for f in scope.functions if f.is_Tensor] if any(not f._honors_autopadding for f in functions): return # Mixed data types (e.g., float and double) is unsupported if len({f.dtype for f in functions}) > 1: return return ROUNDABLE class Affiness(Detector): """ Detect the AFFINE Dimensions. """ def _callback(self, clusters, d, prefix): scope = self._fetch_scope(clusters) accesses = [a for a in scope.accesses if not a.is_scalar] if all(a.is_regular and a.affine_if_present(d._defines) for a in accesses): return AFFINE class Tiling(Detector): """ Detect the TILABLE Dimensions. """ def process(self, elements): return self._process_fdta(elements, 1) def _callback(self, clusters, d, prefix): # A Dimension is TILABLE only if it's PARALLEL and AFFINE properties = self._fetch_properties(clusters, prefix) if not {PARALLEL, AFFINE} <= properties[d]: return # In addition, we use the heuristic that we do not consider # TILABLE a Dimension that is not embedded in at least one # SEQUENTIAL Dimension. This is to rule out tiling when the # computation is not expected to be expensive if not any(SEQUENTIAL in properties[i.dim] for i in prefix[:-1]): return # Likewise, it won't be marked TILABLE if there's at least one # local SubDimension in all Clusters if all(any(i.dim.is_Sub and i.dim.local for i in c.itintervals) for c in clusters): return # If it induces dynamic bounds, then it's ruled out too scope = self._fetch_scope(clusters) if any(i.is_lex_non_stmt for i in scope.d_all_gen()): return return TILABLE
the-stack_0_3380
""" Functions connecting the whole process. 'visual_from_signal' should be run if signal visualization of certain signal is requested. 'visual_from_data' should be run if signal visualization of any point on Earth is requested. Miha Lotric, April 2020 """ import io from signal_visualizer import getters as gt def visual_from_signal(signal_id, show=0, save_as=None, return_bytes=0): """Save/Show static Mapbox map with dome representing reach and position of the signal. Args: signal_id [int]: Unique identifier of a signal. show [bool]: If true final image is shown by default OS image viewer. save_as [None/str]: Path to the location where image is stored. If it is left None image is not stored. return_bytes [bool]: If True image in bytes is returned. Return: BytesIO: Bytes image of Mapbox static map with dome on it. """ signal_info = gt.get_signal_info(signal_id) coordinates = float(signal_info['coordinates'][0]), float(signal_info['coordinates'][1]) radius_meters = signal_info['radius'] map_bytes = visual_from_data(coordinates, radius_meters, save_as=save_as, show=show, return_bytes=return_bytes) return map_bytes if return_bytes else None def visual_from_data(coordinates, radius_meters, show=1, save_as=None, return_bytes=0): """Save/Show static Mapbox map with dome representing specified radius and coordinates. Args: coordinates [tuple]: Coordinates of the signal position - (latitude,longitude). radius_meters [float]: Radius of the dome in meters. show [bool]: If true final image is shown by default OS image viewer. save_as [None/str]: Path to the location where image is stored. If it is left None image is not stored. return_bytes [bool]: If True image in bytes is returned. Return: BytesIO: Bytes image of Mapbox static map with dome on it. """ radius_px = gt.get_radius_px(radius_meters) zoom = gt.get_zoom(coordinates[0], radius_px, radius_meters) map_img = gt.get_map(radius_px, coordinates, zoom) if show: map_img.show() if save_as: map_img.save(save_as) if return_bytes: map_bytes = io.BytesIO() map_img.save(map_bytes, format='PNG') return io.BytesIO(map_bytes.getvalue())
the-stack_0_3383
from srcs.interpretator.interpretator_callback import InterpretatorCallback from srcs.interpretator.context import Context class Interpretator: def __init__(self, runner, meta=None): self.runner = runner self.meta = meta self.callbacks = [] self.context = Context() self.current_string_index = 0 self.strings = [] def __call__(self, filter=None): def decorator(function): self.callbacks.append(InterpretatorCallback(function, filter)) return function return decorator def execute(self, string): result = [] for callback in self.callbacks: single_output = callback(string, self.current_string_index, self.context) if single_output is not None: result.append(single_output) self.current_string_index += 1 self.strings.append(string) return '\n'.join(result) def run(self): self.runner(self)
the-stack_0_3384
from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from structlog import get_logger from covidfaq import config, routers # from covidfaq.evaluating.model.bert_plus_ood import BertPlusOODEn, BertPlusOODFr # from covidfaq.scrape.scrape import ( # load_latest_source_data, # download_OOD_model, # download_cached_embeddings, # ) app = FastAPI() app.include_router(routers.health.router) app.include_router(routers.answers.router) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"] ) @app.on_event("startup") def on_startup(): conf = config.get() log = get_logger() log.info("launching", **conf.dict()) # load_latest_source_data() # download_OOD_model() # download_cached_embeddings() # BertPlusOODEn() # BertPlusOODFr()
the-stack_0_3386
from data_collection.management.commands import BaseXpressDemocracyClubCsvImporter class Command(BaseXpressDemocracyClubCsvImporter): council_id = "E07000086" addresses_name = "parl.2019-12-12/Version 1/Parliamentary Election - Democracy_Club__12December2019east.tsv" stations_name = "parl.2019-12-12/Version 1/Parliamentary Election - Democracy_Club__12December2019east.tsv" elections = ["parl.2019-12-12"] csv_delimiter = "\t" allow_station_point_from_postcode = False def address_record_to_dict(self, record): uprn = record.property_urn.strip().lstrip("0") rec = super().address_record_to_dict(record) # Implausible looking UPRN geocodes. Throw away rather than investigate. if uprn in [ "10091136033", "100060322293", "10091136173", "10009593531", "10012197923", ]: return None if uprn in [ "100060294726", # SO533DA -> SO533HB : 242 Bournemouth Road, Chandler`s Ford, Eastleigh "10009593644", # SO533DA -> SO533AD : Dovecote, Howard Close, Chandler`s Ford, Eastleigh "100060302836", # SO532FG -> SO535BZ : 138 Kingsway, Chandler`s Ford, Eastleigh "10009589400", # SO507DE -> SO507DF : The Chalet, Moon River Pines, Fir Tree Lane, Horton Heath, Eastleigh "10091136799", # SO303FA -> SO532HL : 8a Clanfield Close, Chandler`s Ford, Eastleigh ]: rec["accept_suggestion"] = True return rec def station_record_to_dict(self, record): if record.polling_place_id == "4629": # Abbey Hall, Victoria Road. record = record._replace(polling_place_easting="445232") record = record._replace(polling_place_northing="108734") if ( record.polling_place_uprn == "100062644887" ): # Chandler's Ford Community Centre record = record._replace(polling_place_postcode="SO53 2FT") return super().station_record_to_dict(record)
the-stack_0_3387
# Author: Zheng Hao Tan # Email: [email protected] import sys import SMS if len(sys.argv) != 6: sys.exit('Invalid arguments. Please rerun the script') accountSID = sys.argv[1] authToken = sys.argv[2] from_ = sys.argv[3] to = sys.argv[4] smsBody = sys.argv[5] print('Setting up phone numbers and logging in...') sms = SMS.SMS(accountSID, authToken) print('Sending SMS...') sms.send(from_, to, smsBody) print('SMS sent!')
the-stack_0_3389
from django.conf.urls import url, include from django.contrib import admin from . import views from django.conf import settings from django.conf.urls.static import static from login.views import * app_name='home' urlpatterns = [ #Home url(r'^$', index, name='index'), #semantic url(r'^varta/', video_chat_view, name='varta_chat'), #temp url(r'^temp/', temp_view, name="temp_view"), #get if user exists with username or not url(r'^getifuser/', get_if_user, name="get_if_user"), #general profile settings url(r'^settings/general/', general_info, name="general_info" ), #all auth urls url(r'^accounts/', include('allauth.urls')), #Topic Autocomplete url(r'^topic-autocomplete/$', TopicAutocomplete.as_view(model = Topic, create_field=''), name='topic-autocomplete' ), #login url(r'^login/', login_view, name='login'), #report lost and found url(r'^report/', item_create, name='report'), #lost found view url(r'^lost/(?P<id>\d+)/$', lost_view, name='lost_view'), #follow users url(r'^follow/request/', follow_request, name='follow_request'), #edit profile url(r'^fillup/', person_view, name='fillup'), #markdown drag and drop markdown editor url(r'^markdownx/', include('markdownx.urls')), #post create url(r'^post/create/', post_create, name = 'create_post'), #upvote a post url(r'^post/upvote/', post_upvote, name = 'upvote_post'), #upvote a post url(r'^answer/upvote/', answer_upvote, name = 'upvote_answer'), #update post url(r'^post/update/(?P<id>\d+)/$', post_update, name = 'update_post'), #view individual post url(r'^post/view/(?P<id>\d+)/$', post_view, name='view_post'), #delete post url(r'^post/delete/', post_delete, name = 'delete_post'), #post feed url(r'^post/', post_details, name = 'details_post'), #question create url(r'^question/create/', question_create, name = 'create_question'), #update question url(r'^question/update/(?P<id>\d+)/$', question_update, name = 'update_question'), #view individual question url(r'^question/view/(?P<id>\d+)/$', question_view, name='view_question'), #delete question url(r'^question/delete/', question_delete, name = 'delete_question'), #answer create url(r'^answer/create/(?P<id>\d+)/$', answer_create, name = 'create_answer'), #update answer url(r'^answer/update/(?P<id>\d+)/$', answer_update, name = 'update_answer'), #view individual answer url(r'^answer/view/(?P<id>\d+)/$', answer_view, name='view_answer'), #delete answer url(r'^answer/delete/', answer_delete, name = 'delete_answer'), #create a comment url(r'^comment/create/$', CommentCreateView.as_view(), name='comment-create'), #update a comment url(r'comment/update/(?P<pk>[0-9]+)/$',CommentUpdateView.as_view(), name='comment-update'), #delete a comment url(r'^comment/delete/(?P<pk>[-\w]+)$', CommentDeleteView.as_view(), name='comment-delete'), #like a comment url(r'^comments/like/$', LikeComment.as_view(), name='comment-like'), #unlike a comment url(r'^comments/unlike/$', UnlikeComment.as_view(), name='comment-unlike'), #simply logout or GTFO url(r'^logout/', logout_view, name='logout'), #draceditor urls url(r'^draceditor/', include('draceditor.urls')), #Searching Users url(r'^search/user/profiles/', profile_search, name='profile_search'), #view individuals profile url(r'^view/profile/(?P<id>\d+)/$', profile_view, name='profile_view'), #admin/ url(r'^admin/', admin.site.urls), ] if settings.DEBUG: urlpatterns += static(settings.STATIC_URL, document_root = settings.STATIC_ROOT) urlpatterns += static(settings.MEDIA_URL, document_root = settings.MEDIA_ROOT)
the-stack_0_3390
# coding=utf-8 # Copyright 2021 The TensorFlow Datasets Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Source-based register.""" import collections import datetime import hashlib import json import tempfile from typing import Any, List, Optional, Type from absl import logging import dataclasses from tensorflow_datasets.core import dataset_builder from tensorflow_datasets.core import registered from tensorflow_datasets.core import utils from tensorflow_datasets.core.community import cache from tensorflow_datasets.core.community import dataset_sources as dataset_sources_lib from tensorflow_datasets.core.community import load from tensorflow_datasets.core.community import register_base from tensorflow_datasets.core.download import checksums from tensorflow_datasets.core.utils import gcs_utils # Datasets are installed as `import tfds_community.<ns>.<ds>.<hash>` _IMPORT_MODULE_NAME = 'tfds_community' _METADATA_FILENAME = 'installation.json' @dataclasses.dataclass(frozen=True, eq=True) class _DatasetPackage: """Dataset metadata (before installation), of a single dataset package. Contains the information required to fetch the dataset package. Attributes: name: Dataset name source: Source to locate of the source code (e.g. `github://...`) """ name: utils.DatasetName source: dataset_sources_lib.DatasetSource # Ideally, we should also save the version so `tfds.load('ns:ds/1.0.0')` # fetch a specific version (e.g. at an older commit). @classmethod def from_json(cls, data: utils.Json) -> '_DatasetPackage': """Factory which creates the cls from json.""" return cls( name=utils.DatasetName(data['name']), source=dataset_sources_lib.DatasetSource.from_json(data['source']), ) def to_json(self) -> utils.Json: """Exports the cls as json.""" return { 'name': str(self.name), 'source': self.source.to_json(), } @dataclasses.dataclass(frozen=True, eq=True) class _InstalledPackage: """Dataset metadata (after installation), of a single dataset package. Contains the local informations of the installed dataset package. This is specific to the user. Attributes: package: Source of the dataset package. instalation_date: Date of installation of the package hash: base64 checksum of the installed files """ package: _DatasetPackage instalation_date: datetime.datetime hash: str @property def module_name(self) -> str: """Module name to import this dataset.""" name = self.package.name return f'{_IMPORT_MODULE_NAME}.{name.namespace}.{name.name}.{self.hash}.{name.name}' @property def installation_path(self) -> utils.ReadWritePath: """Local path of the package.""" name = self.package.name sub_dir = f'{_IMPORT_MODULE_NAME}/{name.namespace}/{name.name}/{self.hash}' return cache.module_path() / sub_dir @classmethod def from_json(cls, data: utils.Json) -> '_InstalledPackage': """Factory which creates the cls from json.""" return cls( package=_DatasetPackage.from_json(data['package']), # TODO(py3.7): Should use `datetime.fromisoformat` instalation_date=datetime.datetime.strptime( data['instalation_date'], '%Y-%m-%dT%H:%M:%S.%f' ), hash=data['hash'], ) def to_json(self) -> utils.Json: """Exports the cls as json.""" return { 'package': self.package.to_json(), 'instalation_date': self.instalation_date.isoformat(), 'hash': self.hash, } # TODO(py3.9): Should be `UserDict[utils.DatasetName, _DatasetPackage]` class _PackageIndex(collections.UserDict): """Package index. Package index is a `Dict[DatasetName, _DatasetPackage]` loaded from cache. It has an additional `.refresh()` method to update the local cache by querying the remote index (stored in `gs://tfds-data`). On disk, the package index is a simple list of datasets with their associated source: ```jsonl {"name": "kaggle:ds0", "source": "github://..."} {"name": "kaggle:ds1", "source": "github://..."} {"name": "tensorflow_graphics:shapenet", "source": "github://..."} [...] ``` """ def __init__(self, path: utils.PathLike): """Contructor. Args: path: Remote location of the package index (file containing the list of dataset packages) """ super().__init__() self._remote_path: utils.ReadOnlyPath = utils.as_path(path) self._cached_path: utils.ReadOnlyPath = ( cache.cache_path() / 'community-datasets-list.jsonl' ) # Pre-load the index from the cache if self._cached_path.exists(): self._refresh_from_content(self._cached_path.read_text()) def _refresh_from_content(self, content: str) -> None: """Update the index from the given `jsonl` content.""" dataset_packages = [ _DatasetPackage.from_json(json.loads(line)) for line in content.splitlines() if line.strip() ] self.clear() self.update({src.name: src for src in dataset_packages}) def refresh(self) -> None: """Update the cache.""" # Should have a timer to avoid refreshing the cache immediatelly # (and a force=True option to ignore this) # e.g. with os.path.getmtime(cached_path) - time.gmtime() try: content = self._remote_path.read_text() except gcs_utils.GCS_UNAVAILABLE_EXCEPTIONS as e: # Do not crash if GCS access not available, but instead silently reuse # the cache. logging.info( 'Could not refresh the package index (GCS unavailable): %s', e ) return # If read was sucessful, update the cache with the new dataset list self._cached_path.write_text(content) self._refresh_from_content(content) class PackageRegister(register_base.BaseRegister): """Dataset register based on a list of remotely stored datasets definitions. Package register is similar to a dataset package manager. It contains a package index containing the list of all registered datasets with their associated location. When a specific dataset is requested, `PackageRegister` will download and cache the original source code locally. Usage: ```python register = PackageRegister(path='/path/to/datasets-source-list.jsonl') # List all registered datasets: ['kaggle:ds0', 'kaggle:ds1',...] register.list_builders() # Load a specific dataset builder = register.builder('tensorflow_graphics:shapenet') ``` """ def __init__(self, path: utils.PathLike): """Contructor. Args: path: Path to the register files containing the list of dataset sources, forwarded to `_PackageIndex` """ self._path = utils.as_path(path) @utils.memoized_property def _package_index(self) -> _PackageIndex: """`Dict[DatasetName, _DatasetPackage]` containg the community datasets.""" # Use property to lazy-initialize the cache (and create the tmp dir) only # if it is used. return _PackageIndex(self._path) def list_builders(self) -> List[str]: """Returns the list of registered builders.""" if not self._package_index: # Package index not loaded nor cached self._package_index.refresh() # Try updating the index return sorted(str(name) for name in self._package_index) # pylint: disable=not-an-iterable def builder_cls( self, name: utils.DatasetName, ) -> Type[dataset_builder.DatasetBuilder]: """Returns the builder class.""" # Download the dataset generation code, or reuse the cache # TODO(tfds): Should add the option to request a specific code version installed_dataset = _download_or_reuse_cache( name=name, package_index=self._package_index, ) # Load the dataset from the module return load.builder_cls_from_module(installed_dataset.module_name) def builder( self, name: utils.DatasetName, **builder_kwargs: Any, ) -> dataset_builder.DatasetBuilder: """Returns the dataset builder.""" return self.builder_cls(name)(**builder_kwargs) # pytype: disable=not-instantiable def _download_or_reuse_cache( name: utils.DatasetName, package_index: _PackageIndex, ) -> _InstalledPackage: """Downloads the dataset generation source code. Search the dataset in the cache, or download it from the package index otherwise. Args: name: Dataset name to load. package_index: Index of all community datasets. Might be updated. Returns: The installed dataset information. Raises: DatasetNotFoundError: If the dataset can't be loaded. """ # Dataset can be: # * Installed locally (in the cache) -> reuse # * Not installed but present in the package index -> install # * Not present in the package index -> raise error # Check if the file is already downloaded/cached # TODO(tfds): To force a download even if file already present, we # should add a `ignore_cache=True` option in `tfds.load`. Or should always # try to download the file ? last_installed_version = _get_last_installed_version(name) if last_installed_version: return last_installed_version # If file isn't cached yet, we need to download it. # First need to find it's location. if name not in package_index: # If not, we need to update the package index cache package_index.refresh() # If the dataset is present in the package index cache, use this package = package_index.get(name) if not package: # If still not found, raise an DatasetNotFoundError raise registered.DatasetNotFoundError( f'Could not find dataset {name}: Dataset not found among the ' f'{len(package_index)} datasets of the community index.' ) # If package was found, download it. installed_package = _download_and_cache(package) return installed_package def _get_last_installed_version( name: utils.DatasetName, ) -> Optional[_InstalledPackage]: """Checks whether the datasets is installed locally and returns it.""" root_dir = ( cache.module_path() / _IMPORT_MODULE_NAME / name.namespace / name.name ) if not root_dir.exists(): # Dataset not found return None all_installed_package_metadatas = [ package / _METADATA_FILENAME for package in root_dir.iterdir() ] all_installed_packages = [ _InstalledPackage.from_json(json.loads(metadata.read_text())) for metadata in all_installed_package_metadatas if metadata.exists() ] all_installed_packages = sorted( all_installed_packages, key=lambda p: p.instalation_date ) if not all_installed_packages: # No valid package found return None else: return all_installed_packages[-1] # Most recently installed package def _download_and_cache(package: _DatasetPackage) -> _InstalledPackage: """Downloads and installs locally the dataset source. This function install the dataset package in: `<module_path>/<namespace>/<ds_name>/<hash>/...`. Args: package: Package to install. Returns: installed_dataset: The installed dataset package. """ tmp_dir = utils.as_path(tempfile.mkdtemp()) try: # Download the package in a tmp directory dataset_sources_lib.download_from_source( package.source, tmp_dir, ) # Compute the package hash (to install the dataset in a unique dir) package_hash = _compute_dir_hash(tmp_dir) # Add package metadata installed_package = _InstalledPackage( package=package, instalation_date=datetime.datetime.now(), hash=package_hash, ) package_metadata = json.dumps(installed_package.to_json()) (tmp_dir / _METADATA_FILENAME).write_text(package_metadata) # Rename the package to it's final destination installation_path = installed_package.installation_path if installation_path.exists(): # Package already exists (with same hash) # In the future, we should be smarter to allow overwrite. raise ValueError( f'Package {package} already installed in {installation_path}.' ) installation_path.parent.mkdir(parents=True, exist_ok=True) tmp_dir.rename(installation_path) finally: # Cleanup the tmp directory if it still exists. if tmp_dir.exists(): tmp_dir.rmtree() return installed_package def _compute_dir_hash(path: utils.ReadOnlyPath) -> str: """Computes the checksums of the given directory deterministically.""" all_files = sorted(path.iterdir()) if any(f.is_dir() for f in all_files): raise ValueError('Installed package should only contains files.') # Concatenate the filenames and files content to create the directory hash all_checksums = [f.name for f in all_files] all_checksums += [checksums.compute_url_info(f).checksum for f in all_files] return hashlib.sha256(''.join(all_checksums).encode()).hexdigest() # Register pointing to the GCS community list. community_register = PackageRegister(path=gcs_utils.GCS_COMMUNITY_INDEX_PATH)
the-stack_0_3392
## \file Projectile.py # \author Samuel J. Crawford, Brooks MacLachlan, and W. Spencer Smith # \brief Contains the entire Projectile program import math import sys ## \brief Calculates flight duration: the time when the projectile lands (s) # \param v_launch launch speed: the initial speed of the projectile when launched (m/s) # \param theta launch angle: the angle between the launcher and a straight line from the launcher to the target (rad) # \param g_vect gravitational acceleration (m/s^2) # \return flight duration: the time when the projectile lands (s) def func_t_flight(v_launch, theta, g_vect): return 2 * v_launch * math.sin(theta) / g_vect ## \brief Calculates landing position: the distance from the launcher to the final position of the projectile (m) # \param v_launch launch speed: the initial speed of the projectile when launched (m/s) # \param theta launch angle: the angle between the launcher and a straight line from the launcher to the target (rad) # \param g_vect gravitational acceleration (m/s^2) # \return landing position: the distance from the launcher to the final position of the projectile (m) def func_p_land(v_launch, theta, g_vect): return 2 * v_launch ** 2 * math.sin(theta) * math.cos(theta) / g_vect ## \brief Calculates distance between the target position and the landing position: the offset between the target position and the landing position (m) # \param p_target target position: the distance from the launcher to the target (m) # \param p_land landing position: the distance from the launcher to the final position of the projectile (m) # \return distance between the target position and the landing position: the offset between the target position and the landing position (m) def func_d_offset(p_target, p_land): return p_land - p_target ## \brief Calculates output message as a string # \param p_target target position: the distance from the launcher to the target (m) # \param epsilon hit tolerance # \param d_offset distance between the target position and the landing position: the offset between the target position and the landing position (m) # \return output message as a string def func_s(p_target, epsilon, d_offset): if (math.fabs(d_offset / p_target) < epsilon) : return "The target was hit." elif (d_offset < 0) : return "The projectile fell short." else : return "The projectile went long." ## \brief Reads input from a file with the given file name # \param filename name of the input file # \return launch speed: the initial speed of the projectile when launched (m/s) # \return launch angle: the angle between the launcher and a straight line from the launcher to the target (rad) # \return target position: the distance from the launcher to the target (m) def get_input(filename): infile = open(filename, "r") infile.readline() v_launch = float(infile.readline()) infile.readline() theta = float(infile.readline()) infile.readline() p_target = float(infile.readline()) infile.close() return v_launch, theta, p_target ## \brief Verifies that input values satisfy the physical constraints # \param v_launch launch speed: the initial speed of the projectile when launched (m/s) # \param theta launch angle: the angle between the launcher and a straight line from the launcher to the target (rad) # \param p_target target position: the distance from the launcher to the target (m) def input_constraints(v_launch, theta, p_target): if (not(v_launch > 0)) : print("Warning: ", end="") print("v_launch has value ", end="") print(v_launch, end="") print(", but is suggested to be ", end="") print("above ", end="") print(0, end="") print(".") if (not(0 < theta and theta < math.pi / 2)) : print("Warning: ", end="") print("theta has value ", end="") print(theta, end="") print(", but is suggested to be ", end="") print("between ", end="") print(0, end="") print(" and ", end="") print(math.pi / 2, end="") print(" ((pi)/(2))", end="") print(".") if (not(p_target > 0)) : print("Warning: ", end="") print("p_target has value ", end="") print(p_target, end="") print(", but is suggested to be ", end="") print("above ", end="") print(0, end="") print(".") ## \brief Writes the output values to output.txt # \param s output message as a string # \param d_offset distance between the target position and the landing position: the offset between the target position and the landing position (m) def write_output(s, d_offset): outputfile = open("output.txt", "w") print("s = ", end="", file=outputfile) print(s, file=outputfile) print("d_offset = ", end="", file=outputfile) print(d_offset, file=outputfile) outputfile.close() filename = sys.argv[1] g_vect = 9.8 epsilon = 2.0e-2 v_launch, theta, p_target = get_input(filename) input_constraints(v_launch, theta, p_target) t_flight = func_t_flight(v_launch, theta, g_vect) p_land = func_p_land(v_launch, theta, g_vect) d_offset = func_d_offset(p_target, p_land) s = func_s(p_target, epsilon, d_offset) write_output(s, d_offset)
the-stack_0_3393
#!/usr/bin/env python3 # Copyright (c) 2014-2018 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test longpolling with getblocktemplate.""" from decimal import Decimal from test_framework.test_framework import DollarTestFramework from test_framework.util import get_rpc_proxy, random_transaction import threading class LongpollThread(threading.Thread): def __init__(self, node): threading.Thread.__init__(self) # query current longpollid templat = node.getblocktemplate() self.longpollid = templat['longpollid'] # create a new connection to the node, we can't use the same # connection from two threads self.node = get_rpc_proxy(node.url, 1, timeout=600, coveragedir=node.coverage_dir) def run(self): self.node.getblocktemplate({'longpollid':self.longpollid}) class GetBlockTemplateLPTest(DollarTestFramework): def set_test_params(self): self.num_nodes = 2 def skip_test_if_missing_module(self): self.skip_if_no_wallet() def run_test(self): self.log.info("Warning: this test will take about 70 seconds in the best case. Be patient.") self.nodes[0].generate(10) templat = self.nodes[0].getblocktemplate() longpollid = templat['longpollid'] # longpollid should not change between successive invocations if nothing else happens templat2 = self.nodes[0].getblocktemplate() assert(templat2['longpollid'] == longpollid) # Test 1: test that the longpolling wait if we do nothing thr = LongpollThread(self.nodes[0]) thr.start() # check that thread still lives thr.join(5) # wait 5 seconds or until thread exits assert(thr.is_alive()) # Test 2: test that longpoll will terminate if another node generates a block self.nodes[1].generate(1) # generate a block on another node # check that thread will exit now that new transaction entered mempool thr.join(5) # wait 5 seconds or until thread exits assert(not thr.is_alive()) # Test 3: test that longpoll will terminate if we generate a block ourselves thr = LongpollThread(self.nodes[0]) thr.start() self.nodes[0].generate(1) # generate a block on another node thr.join(5) # wait 5 seconds or until thread exits assert(not thr.is_alive()) # Test 4: test that introducing a new transaction into the mempool will terminate the longpoll thr = LongpollThread(self.nodes[0]) thr.start() # generate a random transaction and submit it min_relay_fee = self.nodes[0].getnetworkinfo()["relayfee"] # min_relay_fee is fee per 1000 bytes, which should be more than enough. (txid, txhex, fee) = random_transaction(self.nodes, Decimal("1.1"), min_relay_fee, Decimal("0.001"), 20) # after one minute, every 10 seconds the mempool is probed, so in 80 seconds it should have returned thr.join(60 + 20) assert(not thr.is_alive()) if __name__ == '__main__': GetBlockTemplateLPTest().main()
the-stack_0_3394
''' 实验名称:大气压强传感器BMP280 版本:v1.0 日期:2020.5 作者:01Studio(www.01studio.org) ''' #导入相关模块 import time,board,busio from analogio import AnalogIn import adafruit_ssd1306,adafruit_hcsr04 #构建I2C对象 i2c = busio.I2C(board.SCK, board.MOSI) #构建oled对象,01Studio配套的OLED地址为0x3C display = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C) #清屏 display.fill(0) display.show() #构建超声波传感器对象 sonar = adafruit_hcsr04.HCSR04(trigger_pin=board.TX, echo_pin=board.RX) while True: #获取距离值 distance=sonar.distance #基础信息显示 display.fill(0) #清屏 display.text('01Studio', 0,0, 1,font_name='font5x8.bin') display.text('Distance Test', 0,15, 1,font_name='font5x8.bin') #距离信息显示 display.text(str(round(distance,1))+' CM', 0,40, 1,font_name='font5x8.bin') display.show() print(str(round(distance,1))+' CM') time.sleep(0.2) #检测周期0.2秒
the-stack_0_3398
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon May 7 10:13:43 2018 @author: Stamatis Lefkimmiatis @email : [email protected] """ import argparse import os.path import torch as th from pydl.networks.ResDNet.net import ResDNet_denoise from pydl.utils import psnr from pydl.datasets.BSDS import BSDS68 from torch.utils.data import DataLoader def tupleOfData(s,dtype): if s.find('(',0,1) > -1: # If the first character of the string is '(' then # this is a tuple and we keep only the substring with the values # separated by commas, i.e., s[1:-1]. Then we create a list that holds # the characters which corresponds to the entries of the tuple by using # s[1:-1].split(',') s = tuple(dtype(i) for i in s[1:-1].replace(" ","").split(',') if i!="") else: s = dtype(s) return s tupleOfInts = lambda s: tupleOfData(s,int) tupleOfFloats = lambda s: tupleOfData(s,float) parser = argparse.ArgumentParser(description='Validation of ResDNet in BSDS68') parser.add_argument('--stdn', type = tupleOfFloats, default='(5,10,15,20,25,30,35,40,45,50,55)', help=" Number of noise levels (standard deviation) for which the network will be validated.") parser.add_argument('--color', action='store_true', help="Type of images used to validate the network.") parser.add_argument('--seed', type = int, default = 20151909, help='random seed to use for generating the noisy images.') parser.add_argument('--batchSize', type = int, default = 64, help='validation batch size.') parser.add_argument('--threads', type = int, default = 4, help='number of threads for data loader to use.') parser.add_argument('--cuda', action='store_true', help='use cuda?') parser.add_argument('--gpu_device', type = int, default = 0, help='which gpu to use?') opt = parser.parse_args() print('========= Selected validation parameters =============') print(opt) print('======================================================') print('\n') if opt.cuda: if opt.gpu_device != th.cuda.current_device()\ and (opt.gpu_device >= 0 and opt.gpu_device < th.cuda.device_count()): print("===> Setting GPU device {}".format(opt.gpu_device)) th.cuda.set_device(opt.gpu_device) val_tall_set = BSDS68(opt.stdn,random_seed=opt.seed,tall=True,color=opt.color) val_wide_set = BSDS68(opt.stdn,random_seed=opt.seed,tall=False,color=opt.color) Nstdn = len(opt.stdn) Ntall = len(val_tall_set.img_gt) Nwide = len(val_wide_set.img_gt) dataLoader_tall = DataLoader(dataset=val_tall_set, num_workers=opt.threads, batch_size=opt.batchSize, shuffle=False) dataLoader_wide = DataLoader(dataset=val_wide_set, num_workers=opt.threads, batch_size=opt.batchSize, shuffle=False) ptable_tall = th.ones(Ntall*Nstdn,2) ptable_wide = th.ones(Nwide*Nstdn,2) for i, batch in enumerate(dataLoader_tall, 0): input, target, sigma = batch[0], batch[1], batch[2] start = i*opt.batchSize end = min((i+1)*opt.batchSize,Ntall*Nstdn) if opt.cuda: input = input.cuda() target = target.cuda() sigma = sigma.cuda() out = ResDNet_denoise(input,sigma) ptable_tall[start:end:1,0]= psnr(input,target) ptable_tall[start:end:1,1]= psnr(out,target) del out,input,target,sigma ptable_tall = ptable_tall.t().contiguous().view(2,Nstdn,Ntall).permute(2,1,0) for i, batch in enumerate(dataLoader_wide, 0): input, target, sigma = batch[0], batch[1], batch[2] start = i*opt.batchSize end = min((i+1)*opt.batchSize,Nwide*Nstdn) if opt.cuda: input = input.cuda() target = target.cuda() sigma = sigma.cuda() out = ResDNet_denoise(input,sigma) ptable_wide[start:end:1,0]= psnr(input,target) ptable_wide[start:end:1,1]= psnr(out,target) del out,input,target,sigma ptable_wide = ptable_wide.t().contiguous().view(2,Nstdn,Nwide).permute(2,1,0) ptable = th.cat((ptable_tall,ptable_wide),dim=0) del ptable_tall,ptable_wide results = dict.fromkeys(opt.stdn) for i,stdn in enumerate(opt.stdn,0): results[stdn] = {"noisy":ptable[:,i,0],"denoised":ptable[:,i,1]} del ptable cstr = "color_BSDS68_std:" if opt.color else "gray_BSDS68_std:" cstr += str(opt.stdn) + ".pth" currentPath = os.path.dirname(os.path.realpath(__file__)) dirPath = os.path.join(currentPath,'Results') os.makedirs(dirPath,exist_ok = True) th.save(results,os.path.join(dirPath,cstr))
the-stack_0_3399
# -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- import argparse from azure.cli.core.commands import ExtensionCommandSource from knack.help import (HelpFile as KnackHelpFile, CommandHelpFile as KnackCommandHelpFile, GroupHelpFile as KnackGroupHelpFile, ArgumentGroupRegistry as KnackArgumentGroupRegistry, HelpExample as KnackHelpExample, HelpParameter as KnackHelpParameter, _print_indent, CLIHelp, HelpAuthoringException) from knack.log import get_logger from knack.util import CLIError logger = get_logger(__name__) PRIVACY_STATEMENT = """ Welcome to Azure CLI! --------------------- Use `az -h` to see available commands or go to https://aka.ms/cli. Telemetry --------- The Azure CLI collects usage data in order to improve your experience. The data is anonymous and does not include commandline argument values. The data is collected by Microsoft. You can change your telemetry settings with `az configure`. """ WELCOME_MESSAGE = r""" /\ / \ _____ _ _ ___ _ / /\ \ |_ / | | | \'__/ _\ / ____ \ / /| |_| | | | __/ /_/ \_\/___|\__,_|_| \___| Welcome to the cool new Azure CLI! Use `az --version` to display the current version. Here are the base commands: """ # PrintMixin class to decouple printing functionality from AZCLIHelp class. # Most of these methods override print methods in CLIHelp class CLIPrintMixin(CLIHelp): def _print_header(self, cli_name, help_file): super(CLIPrintMixin, self)._print_header(cli_name, help_file) links = help_file.links if links: link_text = "{} and {}".format(", ".join([link["url"] for link in links[0:-1]]), links[-1]["url"]) if len(links) > 1 else links[0]["url"] link_text = "For more information, see: {}\n".format(link_text) _print_indent(link_text, 2, width=self.textwrap_width) def _print_detailed_help(self, cli_name, help_file): CLIPrintMixin._print_extensions_msg(help_file) super(CLIPrintMixin, self)._print_detailed_help(cli_name, help_file) self._print_az_find_message(help_file.command, self.cli_ctx.enable_color) @staticmethod def _get_choices_defaults_sources_str(p): choice_str = ' Allowed values: {}.'.format(', '.join(sorted([str(x) for x in p.choices]))) \ if p.choices else '' default_value_source = p.default_value_source if p.default_value_source else 'Default' default_str = ' {}: {}.'.format(default_value_source, p.default) \ if p.default and p.default != argparse.SUPPRESS else '' value_sources_str = CLIPrintMixin._process_value_sources(p) if p.value_sources else '' return '{}{}{}'.format(choice_str, default_str, value_sources_str) @staticmethod def _print_examples(help_file): indent = 0 _print_indent('Examples', indent) for e in help_file.examples: indent = 1 _print_indent('{0}'.format(e.short_summary), indent) indent = 2 if e.long_summary: _print_indent('{0}'.format(e.long_summary), indent) _print_indent('{0}'.format(e.command), indent) print('') @staticmethod def _print_az_find_message(command, enable_color): from colorama import Style indent = 0 message = 'To search AI knowledge base for examples, use: az find "az {}"'.format(command) if enable_color: message = Style.BRIGHT + message + Style.RESET_ALL _print_indent(message + '\n', indent) @staticmethod def _process_value_sources(p): commands, strings, urls = [], [], [] for item in p.value_sources: if "string" in item: strings.append(item["string"]) elif "link" in item and "command" in item["link"]: commands.append(item["link"]["command"]) elif "link" in item and "url" in item["link"]: urls.append(item["link"]["url"]) command_str = ' Values from: {}.'.format(", ".join(commands)) if commands else '' string_str = ' {}'.format(", ".join(strings)) if strings else '' string_str = string_str + "." if string_str and not string_str.endswith(".") else string_str urls_str = ' For more info, go to: {}.'.format(", ".join(urls)) if urls else '' return '{}{}{}'.format(command_str, string_str, urls_str) @staticmethod def _print_extensions_msg(help_file): if help_file.type != 'command': return if isinstance(help_file.command_source, ExtensionCommandSource): logger.warning(help_file.command_source.get_command_warn_msg()) # Extension preview/experimental warning is disabled because it can be confusing when displayed together # with command or command group preview/experimental warning. See #12556 # # If experimental is true, it overrides preview # if help_file.command_source.experimental: # logger.warning(help_file.command_source.get_experimental_warn_msg()) # elif help_file.command_source.preview: # logger.warning(help_file.command_source.get_preview_warn_msg()) class AzCliHelp(CLIPrintMixin, CLIHelp): def __init__(self, cli_ctx): super(AzCliHelp, self).__init__(cli_ctx, privacy_statement=PRIVACY_STATEMENT, welcome_message=WELCOME_MESSAGE, command_help_cls=CliCommandHelpFile, group_help_cls=CliGroupHelpFile, help_cls=CliHelpFile) from knack.help import HelpObject # TODO: This workaround is used to avoid a bizarre bug in Python 2.7. It # essentially reassigns Knack's HelpObject._normalize_text implementation # with an identical implemenation in Az. For whatever reason, this fixes # the bug in Python 2.7. @staticmethod def new_normalize_text(s): if not s or len(s) < 2: return s or '' s = s.strip() initial_upper = s[0].upper() + s[1:] trailing_period = '' if s[-1] in '.!?' else '.' return initial_upper + trailing_period HelpObject._normalize_text = new_normalize_text # pylint: disable=protected-access self._register_help_loaders() self._name_to_content = {} def show_help(self, cli_name, nouns, parser, is_group): self.update_loaders_with_help_file_contents(nouns) delimiters = ' '.join(nouns) help_file = self.command_help_cls(self, delimiters, parser) if not is_group \ else self.group_help_cls(self, delimiters, parser) help_file.load(parser) if not nouns: help_file.command = '' else: AzCliHelp.update_examples(help_file) self._print_detailed_help(cli_name, help_file) from azure.cli.core.util import show_updates_available show_updates_available(new_line_after=True) show_link = self.cli_ctx.config.getboolean('output', 'show_survey_link', True) from azure.cli.core.commands.constants import (SURVEY_PROMPT_STYLED, UX_SURVEY_PROMPT_STYLED) from azure.cli.core.style import print_styled_text if show_link: print_styled_text(SURVEY_PROMPT_STYLED) if not nouns: print_styled_text(UX_SURVEY_PROMPT_STYLED) def get_examples(self, command, parser, is_group): """Get examples of a certain command from the help file. Get the text of the example, strip the newline character and return a list of commands which start with the given command name. """ nouns = command.split(' ')[1:] self.update_loaders_with_help_file_contents(nouns) delimiters = ' '.join(nouns) help_file = self.command_help_cls(self, delimiters, parser) if not is_group \ else self.group_help_cls(self, delimiters, parser) help_file.load(parser) def strip_command(command): command = command.replace('\\\n', '') contents = [item for item in command.split(' ') if item] return ' '.join(contents).strip() examples = [] for example in help_file.examples: if example.command and example.name: examples.append({ 'command': strip_command(example.command), 'description': example.name }) return examples def _register_help_loaders(self): import azure.cli.core._help_loaders as help_loaders import inspect def is_loader_cls(cls): return inspect.isclass(cls) and cls.__name__ != 'BaseHelpLoader' and issubclass(cls, help_loaders.BaseHelpLoader) # pylint: disable=line-too-long versioned_loaders = {} for cls_name, loader_cls in inspect.getmembers(help_loaders, is_loader_cls): loader = loader_cls(self) versioned_loaders[cls_name] = loader if len(versioned_loaders) != len({ldr.version for ldr in versioned_loaders.values()}): ldrs_str = " ".join("{}-version:{}".format(cls_name, ldr.version) for cls_name, ldr in versioned_loaders.items()) # pylint: disable=line-too-long raise CLIError("Two loaders have the same version. Loaders:\n\t{}".format(ldrs_str)) self.versioned_loaders = versioned_loaders def update_loaders_with_help_file_contents(self, nouns): loader_file_names_dict = {} file_name_set = set() for ldr_cls_name, loader in self.versioned_loaders.items(): new_file_names = loader.get_noun_help_file_names(nouns) or [] loader_file_names_dict[ldr_cls_name] = new_file_names file_name_set.update(new_file_names) for file_name in file_name_set: if file_name not in self._name_to_content: with open(file_name, 'r') as f: self._name_to_content[file_name] = f.read() for ldr_cls_name, file_names in loader_file_names_dict.items(): file_contents = {} for name in file_names: file_contents[name] = self._name_to_content[name] self.versioned_loaders[ldr_cls_name].update_file_contents(file_contents) # This method is meant to be a hook that can be overridden by an extension or module. @staticmethod def update_examples(help_file): pass class CliHelpFile(KnackHelpFile): def __init__(self, help_ctx, delimiters): # Each help file (for a command or group) has a version denoting the source of its data. super(CliHelpFile, self).__init__(help_ctx, delimiters) self.links = [] def _should_include_example(self, ex): supported_profiles = ex.get('supported-profiles') unsupported_profiles = ex.get('unsupported-profiles') if all((supported_profiles, unsupported_profiles)): raise HelpAuthoringException("An example cannot have both supported-profiles and unsupported-profiles.") if supported_profiles: supported_profiles = [profile.strip() for profile in supported_profiles.split(',')] return self.help_ctx.cli_ctx.cloud.profile in supported_profiles if unsupported_profiles: unsupported_profiles = [profile.strip() for profile in unsupported_profiles.split(',')] return self.help_ctx.cli_ctx.cloud.profile not in unsupported_profiles return True # Needs to override base implementation to exclude unsupported examples. def _load_from_data(self, data): if not data: return if isinstance(data, str): self.long_summary = data return if 'type' in data: self.type = data['type'] if 'short-summary' in data: self.short_summary = data['short-summary'] self.long_summary = data.get('long-summary') if 'examples' in data: self.examples = [] for d in data['examples']: if self._should_include_example(d): self.examples.append(HelpExample(**d)) def load(self, options): ordered_loaders = sorted(self.help_ctx.versioned_loaders.values(), key=lambda ldr: ldr.version) for loader in ordered_loaders: loader.versioned_load(self, options) class CliGroupHelpFile(KnackGroupHelpFile, CliHelpFile): def load(self, options): # forces class to use this load method even if KnackGroupHelpFile overrides CliHelpFile's method. CliHelpFile.load(self, options) class CliCommandHelpFile(KnackCommandHelpFile, CliHelpFile): def __init__(self, help_ctx, delimiters, parser): super(CliCommandHelpFile, self).__init__(help_ctx, delimiters, parser) self.type = 'command' self.command_source = getattr(parser, 'command_source', None) self.parameters = [] for action in [a for a in parser._actions if a.help != argparse.SUPPRESS]: # pylint: disable=protected-access if action.option_strings: self._add_parameter_help(action) else: # use metavar for positional parameters param_kwargs = { 'name_source': [action.metavar or action.dest], 'deprecate_info': getattr(action, 'deprecate_info', None), 'preview_info': getattr(action, 'preview_info', None), 'experimental_info': getattr(action, 'experimental_info', None), 'default_value_source': getattr(action, 'default_value_source', None), 'description': action.help, 'choices': action.choices, 'required': False, 'default': None, 'group_name': 'Positional' } self.parameters.append(HelpParameter(**param_kwargs)) help_param = next(p for p in self.parameters if p.name == '--help -h') help_param.group_name = 'Global Arguments' # update parameter type so we can use overriden update_from_data method to update value sources. for param in self.parameters: param.__class__ = HelpParameter def _load_from_data(self, data): super(CliCommandHelpFile, self)._load_from_data(data) if isinstance(data, str) or not self.parameters or not data.get('parameters'): return loaded_params = [] loaded_param = {} for param in self.parameters: loaded_param = next((n for n in data['parameters'] if n['name'] == param.name), None) if loaded_param: param.update_from_data(loaded_param) loaded_params.append(param) self.parameters = loaded_params def load(self, options): # forces class to use this load method even if KnackCommandHelpFile overrides CliHelpFile's method. CliHelpFile.load(self, options) class ArgumentGroupRegistry(KnackArgumentGroupRegistry): # pylint: disable=too-few-public-methods def __init__(self, group_list): super(ArgumentGroupRegistry, self).__init__(group_list) self.priorities = { None: 0, 'Resource Id Arguments': 1, 'Generic Update Arguments': 998, 'Global Arguments': 1000, } priority = 2 # any groups not already in the static dictionary should be prioritized alphabetically other_groups = [g for g in sorted(list(set(group_list))) if g not in self.priorities] for group in other_groups: self.priorities[group] = priority priority += 1 class HelpExample(KnackHelpExample): # pylint: disable=too-few-public-methods def __init__(self, **_data): # Old attributes _data['name'] = _data.get('name', '') _data['text'] = _data.get('text', '') super(HelpExample, self).__init__(_data) self.name = _data.get('summary', '') if _data.get('summary', '') else self.name self.text = _data.get('command', '') if _data.get('command', '') else self.text self.long_summary = _data.get('description', '') self.supported_profiles = _data.get('supported-profiles', None) self.unsupported_profiles = _data.get('unsupported-profiles', None) # alias old params with new @property def short_summary(self): return self.name @short_summary.setter def short_summary(self, value): self.name = value @property def command(self): return self.text @command.setter def command(self, value): self.text = value class HelpParameter(KnackHelpParameter): # pylint: disable=too-many-instance-attributes def __init__(self, **kwargs): super(HelpParameter, self).__init__(**kwargs) def update_from_data(self, data): super(HelpParameter, self).update_from_data(data) # original help.py value_sources are strings, update command strings to value-source dict if self.value_sources: self.value_sources = [str_or_dict if isinstance(str_or_dict, dict) else {"link": {"command": str_or_dict}} for str_or_dict in self.value_sources]
the-stack_0_3400
# -*- coding: UTF-8 -*- import os from setuptools import setup from typing import List def _get_relative_path(file_path: str) -> str: return os.path.join(os.path.dirname(__file__), file_path) def load_requirements() -> List[str]: # Load requirements requirements = [] # type: List[str] with open(_get_relative_path("requirements.txt"), "r") as req_file: lines = [line.rstrip("\n") for line in req_file] lines = list(filter(lambda line: line != "" and line[0] != "#", lines)) for line in lines: hash_pos = line.find("#") if hash_pos != -1: requirements.append(line[:hash_pos].strip()) else: requirements.append(line) return requirements def main(): drive_ns = {} with open(_get_relative_path("drive/__version__.py")) as f: exec(f.read(), drive_ns) setup( name='drive', version=drive_ns["__version__"], author='Baptiste Fontaine', author_email='[email protected]', packages=['drive', 'drive.cli'], url='https://github.com/NoName115/drive', license='MIT License', description='Google Drive client', long_description=open('README.md', encoding='utf-8').read(), long_description_content_type='text/markdown', install_requires=load_requirements(), classifiers=[ 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', ], entry_points={ "console_scripts": [ "gd-upload=drive.cli.upload:main", "gd-download=drive.cli.download:main", ] } ) if __name__ == "__main__": main()
the-stack_0_3403
""" /*********************************************************************************/ * The MIT License (MIT) * * * * Copyright (c) 2014 EOX IT Services GmbH * * * * Permission is hereby granted, free of charge, to any person obtaining a copy * * of this software and associated documentation files (the "Software"), to deal * * in the Software without restriction, including without limitation the rights * * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * * copies of the Software, and to permit persons to whom the Software is * * furnished to do so, subject to the following conditions: * * * * The above copyright notice and this permission notice shall be included in * * all copies or substantial portions of the Software. * * * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * * SOFTWARE. * * * *********************************************************************************/ """ import os import logging import pprint from datetime import datetime, timedelta from airflow import DAG from airflow.models import XCOM_RETURN_KEY from airflow.operators import PythonOperator from airflow.operators import RSYNCOperator from airflow.operators import DHUSSearchOperator from airflow.operators import DHUSDownloadOperator from airflow.operators import ZipInspector from airflow.operators import S1MetadataOperator from airflow.operators import GDALWarpOperator from airflow.operators import GDALAddoOperator from airflow.utils.trigger_rule import TriggerRule from geoserver_plugin import publish_product import config as CFG import config.s1_grd_1sdv as S1GRD1SDV log = logging.getLogger(__name__) # Settings default_args = { ################################################## # General configuration # 'start_date': datetime.now() - timedelta(hours=1), 'owner': 'airflow', 'depends_on_past': False, 'provide_context': True, 'email': ['[email protected]'], 'email_on_failure': False, 'email_on_retry': False, 'retries': 1, 'max_threads': 1, 'max_active_runs': 1, # 'queue': 'bash_queue', # 'pool': 'backfill', # 'priority_weight': 10, # 'end_date': datetime(2016, 1, 1), # } print("#######################") print("Interval: ".format(S1GRD1SDV.dag_schedule_interval)) print("ID: {}".format(S1GRD1SDV.id)) print("DHUS: {} @ {}, Region: {}".format(CFG.dhus_username, CFG.dhus_url, S1GRD1SDV.dhus_search_bbox) ) print("GeoServer: {} @ {}".format(CFG.geoserver_username, CFG.geoserver_rest_url) ) print("RSYNC: {} @ {} using {}".format(CFG.rsync_username, CFG.rsync_hostname, CFG.rsync_ssh_key)) print("Date: {} / {}".format(S1GRD1SDV.dhus_search_startdate, S1GRD1SDV.dhus_search_enddate)) print("Search: max={}, order_by={}, keywords={}".format(S1GRD1SDV.dhus_filter_max, S1GRD1SDV.dhus_search_orderby,S1GRD1SDV.dhus_search_keywords)) print("Paths:\n collection_dir={}\n download_dir={}\n process_dir={}\n original_package_upload_dir={}\n repository_dir={}".format(S1GRD1SDV.collection_dir, S1GRD1SDV.download_dir, S1GRD1SDV.process_dir, S1GRD1SDV.original_package_upload_dir, S1GRD1SDV.repository_dir)) print("Collection:\n workspace={}\n layer={}".format(S1GRD1SDV.geoserver_workspace, S1GRD1SDV.geoserver_layer)) print("#######################") TARGET_SRS = 'EPSG:4326' TILE_SIZE = 512 OVERWRITE = True RESAMPLING_METHOD = 'average' MAX_OVERVIEW_LEVEL = 512 def prepare_band_paths(get_inputs_from, *args, **kwargs): """Get Product / Band files path Dictionary from ZipInspector and extract the list of band files """ task_instance = kwargs['ti'] # band number from task name task_id = task_instance.task_id band_number = int(task_id.split('_')[-1]) log.info("Getting inputs from: " + get_inputs_from) product_bands_dict = task_instance.xcom_pull(task_ids=get_inputs_from, key=XCOM_RETURN_KEY) if product_bands_dict is None: log.info("No input from ZipInspector. Nothing to do") return None log.info("Product Band Dictionary: {}".format(pprint.pformat(product_bands_dict))) files_path=[] for k in product_bands_dict: files_path += product_bands_dict[k] # Push one of the band paths to XCom file_path = files_path[band_number - 1] return [file_path] # DAG definition dag = DAG(S1GRD1SDV.id, description='DAG for searching, filtering and downloading Sentinel 1 data from DHUS server', schedule_interval=S1GRD1SDV.dag_schedule_interval, catchup=False, default_args=default_args ) # DHUS Search Task Operator search_task = DHUSSearchOperator(task_id='search_product_task', dhus_url=CFG.dhus_url, dhus_user=CFG.dhus_username, dhus_pass=CFG.dhus_password, geojson_bbox=S1GRD1SDV.dhus_search_bbox, startdate=S1GRD1SDV.dhus_search_startdate, enddate=S1GRD1SDV.dhus_search_enddate, filter_max=S1GRD1SDV.dhus_filter_max, order_by=S1GRD1SDV.dhus_search_orderby, keywords=S1GRD1SDV.dhus_search_keywords, dag=dag) # DHUS Download Task Operator download_task = DHUSDownloadOperator(task_id='download_product_task', dhus_url=CFG.dhus_url, dhus_user=CFG.dhus_username, dhus_pass=CFG.dhus_password, download_max=S1GRD1SDV.dhus_download_max, download_dir=S1GRD1SDV.download_dir, get_inputs_from=search_task.task_id, download_timeout=timedelta(hours=12), dag=dag) # Rsync Archive Task for Products archive_task = RSYNCOperator(task_id="upload_original_package", host = CFG.rsync_hostname, remote_usr = CFG.rsync_username, ssh_key_file = CFG.rsync_ssh_key, remote_dir = S1GRD1SDV.original_package_upload_dir, get_inputs_from=download_task.task_id, dag=dag) # Zip Inspector and Extractor Task zip_task = ZipInspector(task_id='zip_inspector', extension_to_search='tiff', get_inputs_from=download_task.task_id, dag=dag) warp_tasks = [] addo_tasks = [] upload_tasks = [] band_paths_tasks = [] for i in range(1, 3): band_paths = PythonOperator(task_id="get_band_paths_" + str(i), python_callable=prepare_band_paths, op_kwargs={ 'get_inputs_from': zip_task.task_id }, dag=dag) band_paths_tasks.append(band_paths) warp = GDALWarpOperator( task_id='gdalwarp_' + str(i), target_srs=TARGET_SRS, tile_size=TILE_SIZE, overwrite=OVERWRITE, dstdir=S1GRD1SDV.process_dir, get_inputs_from=band_paths.task_id, dag=dag ) warp_tasks.append(warp) addo = GDALAddoOperator( trigger_rule=TriggerRule.ALL_SUCCESS, resampling_method=RESAMPLING_METHOD, max_overview_level=MAX_OVERVIEW_LEVEL, task_id='gdal_addo_' + str(i), get_inputs_from=warp.task_id, dag=dag ) addo_tasks.append(addo) upload = RSYNCOperator(task_id="upload_granule_{}_task".format(str(i)), host=CFG.rsync_hostname, remote_usr=CFG.rsync_username, ssh_key_file=CFG.rsync_ssh_key, remote_dir=S1GRD1SDV.repository_dir, get_inputs_from=addo.task_id, dag=dag) upload_tasks.append(upload) band_paths.set_upstream(zip_task) warp.set_upstream(band_paths) addo.set_upstream(warp) upload.set_upstream(addo) # Metadata Extraction task addo_task_ids = ( task.task_id for task in addo_tasks ) upload_task_ids = ( task.task_id for task in upload_tasks ) metadata_task = S1MetadataOperator(task_id="extract_metadata_task", product_safe_path=None, granules_paths=None, granules_upload_dir=S1GRD1SDV.repository_dir, processing_dir=S1GRD1SDV.process_dir, original_package_download_base_url=S1GRD1SDV.original_package_download_base_url, gs_workspace=S1GRD1SDV.geoserver_workspace, bands_dict = S1GRD1SDV.bands_dict, gs_wms_layer=S1GRD1SDV.geoserver_layer, gs_wfs_featuretype=S1GRD1SDV.geoserver_featuretype, gs_wfs_format=S1GRD1SDV.geoserver_oseo_wfs_format, gs_wfs_version=S1GRD1SDV.geoserver_oseo_wfs_version, gs_wms_width=S1GRD1SDV.geoserver_oseo_wms_width, gs_wms_height=S1GRD1SDV.geoserver_oseo_wms_height, gs_wms_format=S1GRD1SDV.geoserver_oseo_wms_format, gs_wms_version=S1GRD1SDV.geoserver_oseo_wms_version, gs_wcs_coverage_id=S1GRD1SDV.geoserver_coverage, gs_wcs_scale_i=S1GRD1SDV.geoserver_oseo_wcs_scale_i, gs_wcs_scale_j=S1GRD1SDV.geoserver_oseo_wcs_scale_j, gs_wcs_format=S1GRD1SDV.geoserver_oseo_wcs_format, gs_wcs_version=S1GRD1SDV.geoserver_oseo_wcs_version, get_inputs_from = { 'download_task_id': download_task.task_id, 'addo_task_ids': addo_task_ids, 'upload_task_ids': upload_task_ids, 'archive_product_task_id' : archive_task.task_id, }, dag=dag) # Publish product.zip to GeoServer publish_task = PythonOperator(task_id="publish_product_task", python_callable=publish_product, op_kwargs={ 'geoserver_username': CFG.geoserver_username, 'geoserver_password': CFG.geoserver_password, 'geoserver_rest_endpoint': '{}/oseo/collections/{}/products'.format(CFG.geoserver_rest_url, S1GRD1SDV.geoserver_oseo_collection), 'get_inputs_from': metadata_task.task_id, }, dag = dag) if CFG.eoxserver_rest_url: publish_eox_task = PythonOperator(task_id="publish_product_eox_task", python_callable=publish_product, op_kwargs={ 'geoserver_username': CFG.eoxserver_username, 'geoserver_password': CFG.eoxserver_password, 'geoserver_rest_endpoint': CFG.eoxserver_rest_url, 'get_inputs_from': metadata_task.task_id, }, dag = dag) download_task.set_upstream(search_task) archive_task.set_upstream(download_task) zip_task.set_upstream(download_task) metadata_task.set_upstream(download_task) metadata_task.set_upstream(archive_task) for task in upload_tasks: metadata_task.set_upstream(task) publish_task.set_upstream(metadata_task) if CFG.eoxserver_rest_url: publish_eox_task.set_upstream(metadata_task)
the-stack_0_3404
# -*- coding: utf-8 -*- import random import gym import numpy as np from collections import deque from keras.models import Sequential from keras.layers import Dense from keras.optimizers import adam_v2 EPISODES = 1000 class DQNAgent: def __init__(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.memory = deque(maxlen=2000) self.gamma = 0.95 # discount rate self.epsilon = 1.0 # exploration rate self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.model = self._build_model() def _build_model(self): # Neural Net for Deep-Q learning Model model = Sequential() model.add(Dense(24, input_dim=self.state_size, activation='relu')) model.add(Dense(24, activation='relu')) model.add(Dense(self.action_size, activation='linear')) model.compile(loss='mse', optimizer=adam_v2.Adam(lr=self.learning_rate)) return model def memorize(self, state, action, reward, next_state, done): self.memory.append((state, action, reward, next_state, done)) def act(self, state): if np.random.rand() <= self.epsilon: return random.randrange(self.action_size) act_values = self.model.predict(state) return np.argmax(act_values[0]) # returns action def replay(self, batch_size): minibatch = random.sample(self.memory, batch_size) for state, action, reward, next_state, done in minibatch: target = reward if not done: target = (reward + self.gamma * np.amax(self.model.predict(next_state)[0])) target_f = self.model.predict(state) target_f[0][action] = target self.model.fit(state, target_f, epochs=1, verbose=0) if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay def load(self, name): self.model.load_weights(name) def save(self, name): self.model.save_weights(name) if __name__ == "__main__": env = gym.make('CartPole-v1') state_size = env.observation_space.shape[0] action_size = env.action_space.n agent = DQNAgent(state_size, action_size) # agent.load("./save/cartpole-dqn.h5") done = False batch_size = 4 for e in range(EPISODES): state = env.reset() state = np.reshape(state, [1, state_size]) for time in range(500): # env.render() action = agent.act(state) next_state, reward, done, _ = env.step(action) reward = reward if not done else -10 next_state = np.reshape(next_state, [1, state_size]) agent.memorize(state, action, reward, next_state, done) state = next_state if done: print("episode: {}/{}, score: {}, e: {:.2}" .format(e, EPISODES, time, agent.epsilon)) break if len(agent.memory) > batch_size: agent.replay(batch_size) if e % 10 == 0: agent.save("./save/cartpole-dqn.h5")
the-stack_0_3407
import logging import time import traceback from pathlib import Path from secrets import token_bytes from typing import Any, Dict, List, Optional, Tuple from blspy import AugSchemeMPL from dogechia.types.blockchain_format.coin import Coin from dogechia.types.blockchain_format.program import Program from dogechia.types.blockchain_format.sized_bytes import bytes32 from dogechia.types.spend_bundle import SpendBundle from dogechia.types.coin_solution import CoinSolution from dogechia.util.byte_types import hexstr_to_bytes from dogechia.util.db_wrapper import DBWrapper from dogechia.util.hash import std_hash from dogechia.util.ints import uint32, uint64 from dogechia.wallet.cc_wallet import cc_utils from dogechia.wallet.cc_wallet.cc_utils import CC_MOD, SpendableCC, spend_bundle_for_spendable_ccs, uncurry_cc from dogechia.wallet.cc_wallet.cc_wallet import CCWallet from dogechia.wallet.puzzles.genesis_by_coin_id_with_0 import genesis_coin_id_for_genesis_coin_checker from dogechia.wallet.trade_record import TradeRecord from dogechia.wallet.trading.trade_status import TradeStatus from dogechia.wallet.trading.trade_store import TradeStore from dogechia.wallet.transaction_record import TransactionRecord from dogechia.wallet.util.trade_utils import ( get_discrepancies_for_spend_bundle, get_output_amount_for_puzzle_and_solution, get_output_discrepancy_for_puzzle_and_solution, ) from dogechia.wallet.util.transaction_type import TransactionType from dogechia.wallet.util.wallet_types import WalletType from dogechia.wallet.wallet import Wallet from dogechia.wallet.wallet_coin_record import WalletCoinRecord class TradeManager: wallet_state_manager: Any log: logging.Logger trade_store: TradeStore @staticmethod async def create( wallet_state_manager: Any, db_wrapper: DBWrapper, name: str = None, ): self = TradeManager() if name: self.log = logging.getLogger(name) else: self.log = logging.getLogger(__name__) self.wallet_state_manager = wallet_state_manager self.trade_store = await TradeStore.create(db_wrapper) return self async def get_offers_with_status(self, status: TradeStatus) -> List[TradeRecord]: records = await self.trade_store.get_trade_record_with_status(status) return records async def get_coins_of_interest( self, ) -> Tuple[Dict[bytes32, Coin], Dict[bytes32, Coin]]: """ Returns list of coins we want to check if they are included in filter, These will include coins that belong to us and coins that that on other side of treade """ all_pending = [] pending_accept = await self.get_offers_with_status(TradeStatus.PENDING_ACCEPT) pending_confirm = await self.get_offers_with_status(TradeStatus.PENDING_CONFIRM) pending_cancel = await self.get_offers_with_status(TradeStatus.PENDING_CANCEL) all_pending.extend(pending_accept) all_pending.extend(pending_confirm) all_pending.extend(pending_cancel) removals = {} additions = {} for trade in all_pending: for coin in trade.removals: removals[coin.name()] = coin for coin in trade.additions: additions[coin.name()] = coin return removals, additions async def get_trade_by_coin(self, coin: Coin) -> Optional[TradeRecord]: all_trades = await self.get_all_trades() for trade in all_trades: if trade.status == TradeStatus.CANCELED.value: continue if coin in trade.removals: return trade if coin in trade.additions: return trade return None async def coins_of_interest_farmed(self, removals: List[Coin], additions: List[Coin], height: uint32): """ If both our coins and other coins in trade got removed that means that trade was successfully executed If coins from other side of trade got farmed without ours, that means that trade failed because either someone else completed trade or other side of trade canceled the trade by doing a spend. If our coins got farmed but coins from other side didn't, we successfully canceled trade by spending inputs. """ removal_dict = {} addition_dict = {} checked: Dict[bytes32, Coin] = {} for coin in removals: removal_dict[coin.name()] = coin for coin in additions: addition_dict[coin.name()] = coin all_coins = [] all_coins.extend(removals) all_coins.extend(additions) for coin in all_coins: if coin.name() in checked: continue trade = await self.get_trade_by_coin(coin) if trade is None: self.log.error(f"Coin: {Coin}, not in any trade") continue # Check if all coins that are part of the trade got farmed # If coin is missing, trade failed failed = False for removed_coin in trade.removals: if removed_coin.name() not in removal_dict: self.log.error(f"{removed_coin} from trade not removed") failed = True checked[removed_coin.name()] = removed_coin for added_coin in trade.additions: if added_coin.name() not in addition_dict: self.log.error(f"{added_coin} from trade not added") failed = True checked[coin.name()] = coin if failed is False: # Mark this trade as successful await self.trade_store.set_status(trade.trade_id, TradeStatus.CONFIRMED, True, height) self.log.info(f"Trade with id: {trade.trade_id} confirmed at height: {height}") else: # Either we canceled this trade or this trade failed if trade.status == TradeStatus.PENDING_CANCEL.value: await self.trade_store.set_status(trade.trade_id, TradeStatus.CANCELED, True) self.log.info(f"Trade with id: {trade.trade_id} canceled at height: {height}") elif trade.status == TradeStatus.PENDING_CONFIRM.value: await self.trade_store.set_status(trade.trade_id, TradeStatus.FAILED, True) self.log.warning(f"Trade with id: {trade.trade_id} failed at height: {height}") async def get_locked_coins(self, wallet_id: int = None) -> Dict[bytes32, WalletCoinRecord]: """Returns a dictionary of confirmed coins that are locked by a trade.""" all_pending = [] pending_accept = await self.get_offers_with_status(TradeStatus.PENDING_ACCEPT) pending_confirm = await self.get_offers_with_status(TradeStatus.PENDING_CONFIRM) pending_cancel = await self.get_offers_with_status(TradeStatus.PENDING_CANCEL) all_pending.extend(pending_accept) all_pending.extend(pending_confirm) all_pending.extend(pending_cancel) if len(all_pending) == 0: return {} result = {} for trade_offer in all_pending: if trade_offer.tx_spend_bundle is None: locked = await self.get_locked_coins_in_spend_bundle(trade_offer.spend_bundle) else: locked = await self.get_locked_coins_in_spend_bundle(trade_offer.tx_spend_bundle) for name, record in locked.items(): if wallet_id is None or record.wallet_id == wallet_id: result[name] = record return result async def get_all_trades(self): all: List[TradeRecord] = await self.trade_store.get_all_trades() return all async def get_trade_by_id(self, trade_id: bytes) -> Optional[TradeRecord]: record = await self.trade_store.get_trade_record(trade_id) return record async def get_locked_coins_in_spend_bundle(self, bundle: SpendBundle) -> Dict[bytes32, WalletCoinRecord]: """Returns a list of coin records that are used in this SpendBundle""" result = {} removals = bundle.removals() for coin in removals: coin_record = await self.wallet_state_manager.coin_store.get_coin_record(coin.name()) if coin_record is None: continue result[coin_record.name()] = coin_record return result async def cancel_pending_offer(self, trade_id: bytes32): await self.trade_store.set_status(trade_id, TradeStatus.CANCELED, False) async def cancel_pending_offer_safely(self, trade_id: bytes32): """This will create a transaction that includes coins that were offered""" self.log.info(f"Secure-Cancel pending offer with id trade_id {trade_id.hex()}") trade = await self.trade_store.get_trade_record(trade_id) if trade is None: return None all_coins = trade.removals for coin in all_coins: wallet = await self.wallet_state_manager.get_wallet_for_coin(coin.name()) if wallet is None: continue new_ph = await wallet.get_new_puzzlehash() if wallet.type() == WalletType.COLOURED_COIN.value: tx = await wallet.generate_signed_transaction( [coin.amount], [new_ph], 0, coins={coin}, ignore_max_send_amount=True ) else: tx = await wallet.generate_signed_transaction( coin.amount, new_ph, 0, coins={coin}, ignore_max_send_amount=True ) await self.wallet_state_manager.add_pending_transaction(tx_record=tx) await self.trade_store.set_status(trade_id, TradeStatus.PENDING_CANCEL, False) return None async def save_trade(self, trade: TradeRecord): await self.trade_store.add_trade_record(trade, False) async def create_offer_for_ids( self, offer: Dict[int, int], file_name: str ) -> Tuple[bool, Optional[TradeRecord], Optional[str]]: success, trade_offer, error = await self._create_offer_for_ids(offer) if success is True and trade_offer is not None: self.write_offer_to_disk(Path(file_name), trade_offer) await self.save_trade(trade_offer) return success, trade_offer, error async def _create_offer_for_ids(self, offer: Dict[int, int]) -> Tuple[bool, Optional[TradeRecord], Optional[str]]: """ Offer is dictionary of wallet ids and amount """ spend_bundle = None try: for id in offer.keys(): amount = offer[id] wallet_id = uint32(int(id)) wallet = self.wallet_state_manager.wallets[wallet_id] if isinstance(wallet, CCWallet): balance = await wallet.get_confirmed_balance() if balance < abs(amount) and amount < 0: raise Exception(f"insufficient funds in wallet {wallet_id}") if amount > 0: if spend_bundle is None: to_exclude: List[Coin] = [] else: to_exclude = spend_bundle.removals() zero_spend_bundle: SpendBundle = await wallet.generate_zero_val_coin(False, to_exclude) if spend_bundle is None: spend_bundle = zero_spend_bundle else: spend_bundle = SpendBundle.aggregate([spend_bundle, zero_spend_bundle]) additions = zero_spend_bundle.additions() removals = zero_spend_bundle.removals() zero_val_coin: Optional[Coin] = None for add in additions: if add not in removals and add.amount == 0: zero_val_coin = add new_spend_bundle = await wallet.create_spend_bundle_relative_amount(amount, zero_val_coin) else: new_spend_bundle = await wallet.create_spend_bundle_relative_amount(amount) elif isinstance(wallet, Wallet): if spend_bundle is None: to_exclude = [] else: to_exclude = spend_bundle.removals() new_spend_bundle = await wallet.create_spend_bundle_relative_dogechia(amount, to_exclude) else: return False, None, "unsupported wallet type" if new_spend_bundle is None or new_spend_bundle.removals() == []: raise Exception(f"Wallet {id} was unable to create offer.") if spend_bundle is None: spend_bundle = new_spend_bundle else: spend_bundle = SpendBundle.aggregate([spend_bundle, new_spend_bundle]) if spend_bundle is None: return False, None, None now = uint64(int(time.time())) trade_offer: TradeRecord = TradeRecord( confirmed_at_index=uint32(0), accepted_at_time=None, created_at_time=now, my_offer=True, sent=uint32(0), spend_bundle=spend_bundle, tx_spend_bundle=None, additions=spend_bundle.additions(), removals=spend_bundle.removals(), trade_id=std_hash(spend_bundle.name() + bytes(now)), status=uint32(TradeStatus.PENDING_ACCEPT.value), sent_to=[], ) return True, trade_offer, None except Exception as e: tb = traceback.format_exc() self.log.error(f"Error with creating trade offer: {type(e)}{tb}") return False, None, str(e) def write_offer_to_disk(self, file_path: Path, offer: TradeRecord): if offer is not None: file_path.write_text(bytes(offer).hex()) async def get_discrepancies_for_offer(self, file_path: Path) -> Tuple[bool, Optional[Dict], Optional[Exception]]: self.log.info(f"trade offer: {file_path}") trade_offer_hex = file_path.read_text() trade_offer = TradeRecord.from_bytes(bytes.fromhex(trade_offer_hex)) return get_discrepancies_for_spend_bundle(trade_offer.spend_bundle) async def get_inner_puzzle_for_puzzle_hash(self, puzzle_hash) -> Program: info = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(puzzle_hash.hex()) assert info is not None puzzle = self.wallet_state_manager.main_wallet.puzzle_for_pk(bytes(info.pubkey)) return puzzle async def maybe_create_wallets_for_offer(self, file_path: Path) -> bool: success, result, error = await self.get_discrepancies_for_offer(file_path) if not success or result is None: return False for key, value in result.items(): wsm = self.wallet_state_manager wallet: Wallet = wsm.main_wallet if key == "dogechia": continue self.log.info(f"value is {key}") exists = await wsm.get_wallet_for_colour(key) if exists is not None: continue await CCWallet.create_wallet_for_cc(wsm, wallet, key) return True async def respond_to_offer(self, file_path: Path) -> Tuple[bool, Optional[TradeRecord], Optional[str]]: has_wallets = await self.maybe_create_wallets_for_offer(file_path) if not has_wallets: return False, None, "Unknown Error" trade_offer = None try: trade_offer_hex = file_path.read_text() trade_offer = TradeRecord.from_bytes(hexstr_to_bytes(trade_offer_hex)) except Exception as e: return False, None, f"Error: {e}" if trade_offer is not None: offer_spend_bundle: SpendBundle = trade_offer.spend_bundle coinsols: List[CoinSolution] = [] # [] of CoinSolutions cc_coinsol_outamounts: Dict[bytes32, List[Tuple[CoinSolution, int]]] = dict() aggsig = offer_spend_bundle.aggregated_signature cc_discrepancies: Dict[bytes32, int] = dict() dogechia_discrepancy = None wallets: Dict[bytes32, Any] = dict() # colour to wallet dict for coinsol in offer_spend_bundle.coin_solutions: puzzle: Program = Program.from_bytes(bytes(coinsol.puzzle_reveal)) solution: Program = Program.from_bytes(bytes(coinsol.solution)) # work out the deficits between coin amount and expected output for each r = cc_utils.uncurry_cc(puzzle) if r: # Calculate output amounts mod_hash, genesis_checker, inner_puzzle = r colour = bytes(genesis_checker).hex() if colour not in wallets: wallets[colour] = await self.wallet_state_manager.get_wallet_for_colour(colour) unspent = await self.wallet_state_manager.get_spendable_coins_for_wallet(wallets[colour].id()) if coinsol.coin in [record.coin for record in unspent]: return False, None, "can't respond to own offer" innersol = solution.first() total = get_output_amount_for_puzzle_and_solution(inner_puzzle, innersol) if colour in cc_discrepancies: cc_discrepancies[colour] += coinsol.coin.amount - total else: cc_discrepancies[colour] = coinsol.coin.amount - total # Store coinsol and output amount for later if colour in cc_coinsol_outamounts: cc_coinsol_outamounts[colour].append((coinsol, total)) else: cc_coinsol_outamounts[colour] = [(coinsol, total)] else: # standard dogechia coin unspent = await self.wallet_state_manager.get_spendable_coins_for_wallet(1) if coinsol.coin in [record.coin for record in unspent]: return False, None, "can't respond to own offer" if dogechia_discrepancy is None: dogechia_discrepancy = get_output_discrepancy_for_puzzle_and_solution(coinsol.coin, puzzle, solution) else: dogechia_discrepancy += get_output_discrepancy_for_puzzle_and_solution(coinsol.coin, puzzle, solution) coinsols.append(coinsol) dogechia_spend_bundle: Optional[SpendBundle] = None if dogechia_discrepancy is not None: dogechia_spend_bundle = await self.wallet_state_manager.main_wallet.create_spend_bundle_relative_dogechia( dogechia_discrepancy, [] ) if dogechia_spend_bundle is not None: for coinsol in coinsols: dogechia_spend_bundle.coin_solutions.append(coinsol) zero_spend_list: List[SpendBundle] = [] spend_bundle = None # create coloured coin self.log.info(cc_discrepancies) for colour in cc_discrepancies.keys(): if cc_discrepancies[colour] < 0: my_cc_spends = await wallets[colour].select_coins(abs(cc_discrepancies[colour])) else: if dogechia_spend_bundle is None: to_exclude: List = [] else: to_exclude = dogechia_spend_bundle.removals() my_cc_spends = await wallets[colour].select_coins(0) if my_cc_spends is None or my_cc_spends == set(): zero_spend_bundle: SpendBundle = await wallets[colour].generate_zero_val_coin(False, to_exclude) if zero_spend_bundle is None: return ( False, None, "Unable to generate zero value coin. Confirm that you have dogechia available", ) zero_spend_list.append(zero_spend_bundle) additions = zero_spend_bundle.additions() removals = zero_spend_bundle.removals() my_cc_spends = set() for add in additions: if add not in removals and add.amount == 0: my_cc_spends.add(add) if my_cc_spends == set() or my_cc_spends is None: return False, None, "insufficient funds" # Create SpendableCC list and innersol_list with both my coins and the offered coins # Firstly get the output coin my_output_coin = my_cc_spends.pop() spendable_cc_list = [] innersol_list = [] genesis_id = genesis_coin_id_for_genesis_coin_checker(Program.from_bytes(bytes.fromhex(colour))) # Make the rest of the coins assert the output coin is consumed for coloured_coin in my_cc_spends: inner_solution = self.wallet_state_manager.main_wallet.make_solution(consumed=[my_output_coin.name()]) inner_puzzle = await self.get_inner_puzzle_for_puzzle_hash(coloured_coin.puzzle_hash) assert inner_puzzle is not None sigs = await wallets[colour].get_sigs(inner_puzzle, inner_solution, coloured_coin.name()) sigs.append(aggsig) aggsig = AugSchemeMPL.aggregate(sigs) lineage_proof = await wallets[colour].get_lineage_proof_for_coin(coloured_coin) spendable_cc_list.append(SpendableCC(coloured_coin, genesis_id, inner_puzzle, lineage_proof)) innersol_list.append(inner_solution) # Create SpendableCC for each of the coloured coins received for cc_coinsol_out in cc_coinsol_outamounts[colour]: cc_coinsol = cc_coinsol_out[0] puzzle = Program.from_bytes(bytes(cc_coinsol.puzzle_reveal)) solution = Program.from_bytes(bytes(cc_coinsol.solution)) r = uncurry_cc(puzzle) if r: mod_hash, genesis_coin_checker, inner_puzzle = r inner_solution = solution.first() lineage_proof = solution.rest().rest().first() spendable_cc_list.append(SpendableCC(cc_coinsol.coin, genesis_id, inner_puzzle, lineage_proof)) innersol_list.append(inner_solution) # Finish the output coin SpendableCC with new information newinnerpuzhash = await wallets[colour].get_new_inner_hash() outputamount = sum([c.amount for c in my_cc_spends]) + cc_discrepancies[colour] + my_output_coin.amount inner_solution = self.wallet_state_manager.main_wallet.make_solution( primaries=[{"puzzlehash": newinnerpuzhash, "amount": outputamount}] ) inner_puzzle = await self.get_inner_puzzle_for_puzzle_hash(my_output_coin.puzzle_hash) assert inner_puzzle is not None lineage_proof = await wallets[colour].get_lineage_proof_for_coin(my_output_coin) spendable_cc_list.append(SpendableCC(my_output_coin, genesis_id, inner_puzzle, lineage_proof)) innersol_list.append(inner_solution) sigs = await wallets[colour].get_sigs(inner_puzzle, inner_solution, my_output_coin.name()) sigs.append(aggsig) aggsig = AugSchemeMPL.aggregate(sigs) if spend_bundle is None: spend_bundle = spend_bundle_for_spendable_ccs( CC_MOD, Program.from_bytes(bytes.fromhex(colour)), spendable_cc_list, innersol_list, [aggsig], ) else: new_spend_bundle = spend_bundle_for_spendable_ccs( CC_MOD, Program.from_bytes(bytes.fromhex(colour)), spendable_cc_list, innersol_list, [aggsig], ) spend_bundle = SpendBundle.aggregate([spend_bundle, new_spend_bundle]) # reset sigs and aggsig so that they aren't included next time around sigs = [] aggsig = AugSchemeMPL.aggregate(sigs) my_tx_records = [] if zero_spend_list is not None and spend_bundle is not None: zero_spend_list.append(spend_bundle) spend_bundle = SpendBundle.aggregate(zero_spend_list) if spend_bundle is None: return False, None, "spend_bundle missing" # Add transaction history for this trade now = uint64(int(time.time())) if dogechia_spend_bundle is not None: spend_bundle = SpendBundle.aggregate([spend_bundle, dogechia_spend_bundle]) if dogechia_discrepancy < 0: tx_record = TransactionRecord( confirmed_at_height=uint32(0), created_at_time=now, to_puzzle_hash=token_bytes(), amount=uint64(abs(dogechia_discrepancy)), fee_amount=uint64(0), confirmed=False, sent=uint32(10), spend_bundle=dogechia_spend_bundle, additions=dogechia_spend_bundle.additions(), removals=dogechia_spend_bundle.removals(), wallet_id=uint32(1), sent_to=[], trade_id=std_hash(spend_bundle.name() + bytes(now)), type=uint32(TransactionType.OUTGOING_TRADE.value), name=dogechia_spend_bundle.name(), ) else: tx_record = TransactionRecord( confirmed_at_height=uint32(0), created_at_time=uint64(int(time.time())), to_puzzle_hash=token_bytes(), amount=uint64(abs(dogechia_discrepancy)), fee_amount=uint64(0), confirmed=False, sent=uint32(10), spend_bundle=dogechia_spend_bundle, additions=dogechia_spend_bundle.additions(), removals=dogechia_spend_bundle.removals(), wallet_id=uint32(1), sent_to=[], trade_id=std_hash(spend_bundle.name() + bytes(now)), type=uint32(TransactionType.INCOMING_TRADE.value), name=dogechia_spend_bundle.name(), ) my_tx_records.append(tx_record) for colour, amount in cc_discrepancies.items(): wallet = wallets[colour] if dogechia_discrepancy > 0: tx_record = TransactionRecord( confirmed_at_height=uint32(0), created_at_time=uint64(int(time.time())), to_puzzle_hash=token_bytes(), amount=uint64(abs(amount)), fee_amount=uint64(0), confirmed=False, sent=uint32(10), spend_bundle=spend_bundle, additions=spend_bundle.additions(), removals=spend_bundle.removals(), wallet_id=wallet.id(), sent_to=[], trade_id=std_hash(spend_bundle.name() + bytes(now)), type=uint32(TransactionType.OUTGOING_TRADE.value), name=spend_bundle.name(), ) else: tx_record = TransactionRecord( confirmed_at_height=uint32(0), created_at_time=uint64(int(time.time())), to_puzzle_hash=token_bytes(), amount=uint64(abs(amount)), fee_amount=uint64(0), confirmed=False, sent=uint32(10), spend_bundle=spend_bundle, additions=spend_bundle.additions(), removals=spend_bundle.removals(), wallet_id=wallet.id(), sent_to=[], trade_id=std_hash(spend_bundle.name() + bytes(now)), type=uint32(TransactionType.INCOMING_TRADE.value), name=token_bytes(), ) my_tx_records.append(tx_record) tx_record = TransactionRecord( confirmed_at_height=uint32(0), created_at_time=uint64(int(time.time())), to_puzzle_hash=token_bytes(), amount=uint64(0), fee_amount=uint64(0), confirmed=False, sent=uint32(0), spend_bundle=spend_bundle, additions=spend_bundle.additions(), removals=spend_bundle.removals(), wallet_id=uint32(0), sent_to=[], trade_id=std_hash(spend_bundle.name() + bytes(now)), type=uint32(TransactionType.OUTGOING_TRADE.value), name=spend_bundle.name(), ) now = uint64(int(time.time())) trade_record: TradeRecord = TradeRecord( confirmed_at_index=uint32(0), accepted_at_time=now, created_at_time=now, my_offer=False, sent=uint32(0), spend_bundle=offer_spend_bundle, tx_spend_bundle=spend_bundle, additions=spend_bundle.additions(), removals=spend_bundle.removals(), trade_id=std_hash(spend_bundle.name() + bytes(now)), status=uint32(TradeStatus.PENDING_CONFIRM.value), sent_to=[], ) await self.save_trade(trade_record) await self.wallet_state_manager.add_pending_transaction(tx_record) for tx in my_tx_records: await self.wallet_state_manager.add_transaction(tx) return True, trade_record, None
the-stack_0_3408
def buddy(start, limit): for i in range(start, limit): res=prime(i) if res>i: res2=prime(res-1) if (res2-i)==1: return [i,res-1] return "Nothing" def prime(n): total=1 for i in range(2, int(n**0.5)+1): if n%i==0: total+=(i) if i==n//i: continue total+=(n//i) return total
the-stack_0_3409
from typing import Any import torch from torch import fx class NodeProfiler(fx.Interpreter): """ This is basically a variant of shape prop in https://github.com/pytorch/pytorch/blob/74849d9188de30d93f7c523d4eeceeef044147a9/torch/fx/passes/shape_prop.py#L65. Instead of propagating just the shape, we record all the intermediate node Tensor values. This is useful to debug some of lowering pass issue where we want to check a specific tensor value. Note that output value can be tuple(Tensor) as well as Tensor. """ def __init__(self, module: fx.GraphModule): super().__init__(module) self.execution_time = {} self.node_map = {} self.iter = 100 def run_node(self, n: fx.Node) -> Any: result = super().run_node(n) if n.op not in {"call_function", "call_method", "call_module"}: return result torch.cuda.synchronize() start_event = torch.cuda.Event(enable_timing=True) end_event = torch.cuda.Event(enable_timing=True) start_event.record() for _ in range(self.iter): result = super().run_node(n) end_event.record() torch.cuda.synchronize() self.execution_time[f"{n.name}"] = ( start_event.elapsed_time(end_event) / self.iter ) self.node_map[n.name] = n return result def propagate(self, *args): """ Run `module` via interpretation and return the result and record the shape and type of each node. Args: *args (Tensor): the sample input. Returns: Any: The value returned from executing the Module """ return super().run(*args)
the-stack_0_3412
import unicodedata from .add_whitespace_around_character import AddWhitespaceAroundCharacter class AddWhitespaceAroundPunctuation(AddWhitespaceAroundCharacter): """ Recognize punctuation characters and add whitespace around each punctuation character E.g. >>> from uttut.pipeline.ops.add_whitespace_around_punctuation import ( AddWhitespaceAroundPunctuation) >>> op = AddWhitespaceAroundPunctuation() >>> output_seq, label_aligner = op.transform("GB,薄餡亂入") >>> output_labels = label_aligner.transform([1, 1, 2, 3, 3, 4, 5]) >>> output_seq "GB , 薄餡亂入" >>> output_labels [1, 1, 0, 2, 0, 3, 3, 4, 5] >>> label_aligner.inverse_transform(output_labels) [1, 1, 2, 3, 3, 4, 5] """ def _is_valid_char(self, char: str) -> bool: return is_punctuation(char) def is_punctuation(char: str) -> bool: """Check whether char is a punctuation character. This code is copied from Bert `tokenization.py`. We treat all non-letter/number ASCII as punctuation. Characters such as "^", "$", and "`" are not in the Unicode Punctuation class but we treat them as punctuation anyways, for consistency. """ code_point = ord(char) if (( code_point >= 33 and code_point <= 47) or ( code_point >= 58 and code_point <= 64) or ( code_point >= 91 and code_point <= 96) or ( code_point >= 123 and code_point <= 126) ): return True cat = unicodedata.category(char) # For more details, please take a look at # https://www.fileformat.info/info/unicode/category/index.htm if cat.startswith("P"): return True return False
the-stack_0_3413
""" Unit tests for Unified/Monitor.py module Author: Valentin Kuznetsov <vkuznet [AT] gmail [DOT] com> """ from __future__ import division, print_function import time # system modules import unittest from copy import deepcopy # WMCore modules from WMCore.MicroService.Unified.MSMonitor import MSMonitor from WMQuality.Emulators.EmulatedUnitTestCase import EmulatedUnitTestCase from WMQuality.Emulators.ReqMgrAux.MockReqMgrAux import MockReqMgrAux class MSMonitorTest(EmulatedUnitTestCase): "Unit test for Monitor module" def setUp(self): "init test class" self.msConfig = {'verbose': False, 'group': 'DataOps', 'interval': 1 * 60, 'updateInterval': 0, 'enableStatusTransition': True, 'reqmgr2Url': 'https://cmsweb-testbed.cern.ch/reqmgr2', 'reqmgrCacheUrl': 'https://cmsweb-testbed.cern.ch/couchdb/reqmgr_workload_cache', 'phedexUrl': 'https://cmsweb-testbed.cern.ch/phedex/datasvc/json/prod', 'dbsUrl': 'https://cmsweb-testbed.cern.ch/dbs/int/global/DBSReader'} self.ms = MSMonitor(self.msConfig) self.ms.reqmgrAux = MockReqMgrAux() super(MSMonitorTest, self).setUp() def testUpdateCaches(self): """ Test the getCampaignConfig method """ campaigns, transfersDocs = self.ms.updateCaches() self.assertNotEqual(transfersDocs, []) self.assertEqual(len(transfersDocs[0]['transfers']), 1) self.assertTrue(time.time() > transfersDocs[0]['lastUpdate'], 1) self.assertNotEqual(campaigns, []) for cname, cdict in campaigns.items(): self.assertEqual(cname, cdict['CampaignName']) self.assertEqual(isinstance(cdict, dict), True) self.assertNotEqual(cdict.get('CampaignName', {}), {}) def testGetTransferInfo(self): """ Test the getTransferInfo method """ _, transfersDocs = self.ms.updateCaches() transfersDocs[0]['transfers'] = [] originalTransfers = deepcopy(transfersDocs) self.ms.getTransferInfo(transfersDocs) self.assertNotEqual(transfersDocs, []) self.assertEqual(len(transfersDocs), len(originalTransfers)) for rec in transfersDocs: self.assertEqual(isinstance(rec, dict), True) keys = sorted(['workflowName', 'lastUpdate', 'transfers']) self.assertEqual(keys, sorted(rec.keys())) self.assertTrue(time.time() >= rec['lastUpdate']) def testCompletion(self): """ Test the completion method """ campaigns, transfersDocs = self.ms.updateCaches() transfersDocs.append(deepcopy(transfersDocs[0])) transfersDocs.append(deepcopy(transfersDocs[0])) transfersDocs[0]['transfers'] = [] transfersDocs[0]['workflowName'] = 'workflow_0' transfersDocs[1]['transfers'][0]['completion'].append(100) transfersDocs[1]['workflowName'] = 'workflow_1' transfersDocs[2]['workflowName'] = 'workflow_2' self.assertEqual(len(transfersDocs), 3) completedWfs = self.ms.getCompletedWorkflows(transfersDocs, campaigns) self.assertEqual(len(completedWfs), 2) def testUpdateTransferInfo(self): """ Test the updateTransferInfo method """ _, transferRecords = self.ms.updateCaches() failed = self.ms.updateTransferDocs(transferRecords) self.assertEqual(len(failed), len(transferRecords)) if __name__ == '__main__': unittest.main()
the-stack_0_3415
# Copyright 2012-2017 The Meson development team # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os.path, subprocess from ..mesonlib import ( EnvironmentException, MachineChoice, version_compare, is_windows, is_osx ) from .compilers import ( CompilerType, d_dmd_buildtype_args, d_gdc_buildtype_args, d_ldc_buildtype_args, clike_debug_args, Compiler, CompilerArgs, ) from .mixins.gnu import get_gcc_soname_args, gnu_color_args, gnu_optimization_args d_feature_args = {'gcc': {'unittest': '-funittest', 'debug': '-fdebug', 'version': '-fversion', 'import_dir': '-J' }, 'llvm': {'unittest': '-unittest', 'debug': '-d-debug', 'version': '-d-version', 'import_dir': '-J' }, 'dmd': {'unittest': '-unittest', 'debug': '-debug', 'version': '-version', 'import_dir': '-J' } } ldc_optimization_args = {'0': [], 'g': [], '1': ['-O1'], '2': ['-O2'], '3': ['-O3'], 's': ['-Os'], } dmd_optimization_args = {'0': [], 'g': [], '1': ['-O'], '2': ['-O'], '3': ['-O'], 's': ['-O'], } class DCompiler(Compiler): mscrt_args = { 'none': ['-mscrtlib='], 'md': ['-mscrtlib=msvcrt'], 'mdd': ['-mscrtlib=msvcrtd'], 'mt': ['-mscrtlib=libcmt'], 'mtd': ['-mscrtlib=libcmtd'], } def __init__(self, exelist, version, for_machine: MachineChoice, arch, **kwargs): self.language = 'd' super().__init__(exelist, version, for_machine, **kwargs) self.id = 'unknown' self.arch = arch def sanity_check(self, work_dir, environment): source_name = os.path.join(work_dir, 'sanity.d') output_name = os.path.join(work_dir, 'dtest') with open(source_name, 'w') as ofile: ofile.write('''void main() { }''') pc = subprocess.Popen(self.exelist + self.get_output_args(output_name) + self.get_target_arch_args() + [source_name], cwd=work_dir) pc.wait() if pc.returncode != 0: raise EnvironmentException('D compiler %s can not compile programs.' % self.name_string()) if subprocess.call(output_name) != 0: raise EnvironmentException('Executables created by D compiler %s are not runnable.' % self.name_string()) def needs_static_linker(self): return True def name_string(self): return ' '.join(self.exelist) def get_exelist(self): return self.exelist def get_linker_exelist(self): return self.exelist[:] def get_output_args(self, target): return ['-of=' + target] def get_linker_output_args(self, target): return ['-of=' + target] def get_include_args(self, path, is_system): return ['-I=' + path] def compute_parameters_with_absolute_paths(self, parameter_list, build_dir): for idx, i in enumerate(parameter_list): if i[:3] == '-I=': parameter_list[idx] = i[:3] + os.path.normpath(os.path.join(build_dir, i[3:])) if i[:4] == '-L-L': parameter_list[idx] = i[:4] + os.path.normpath(os.path.join(build_dir, i[4:])) if i[:5] == '-L=-L': parameter_list[idx] = i[:5] + os.path.normpath(os.path.join(build_dir, i[5:])) if i[:6] == '-Wl,-L': parameter_list[idx] = i[:6] + os.path.normpath(os.path.join(build_dir, i[6:])) return parameter_list def get_warn_args(self, level): return ['-wi'] def get_werror_args(self): return ['-w'] def get_dependency_gen_args(self, outtarget, outfile): # DMD and LDC does not currently return Makefile-compatible dependency info. return [] def get_linker_search_args(self, dirname): # -L is recognized as "add this to the search path" by the linker, # while the compiler recognizes it as "pass to linker". return ['-Wl,-L' + dirname] def get_coverage_args(self): return ['-cov'] def get_preprocess_only_args(self): return ['-E'] def get_compile_only_args(self): return ['-c'] def depfile_for_object(self, objfile): return objfile + '.' + self.get_depfile_suffix() def get_depfile_suffix(self): return 'deps' def get_pic_args(self): if is_windows(): return [] return ['-fPIC'] def get_std_shared_lib_link_args(self): return ['-shared'] def get_soname_args(self, *args): # FIXME: Make this work for cross-compiling if is_windows(): return [] elif is_osx(): soname_args = get_gcc_soname_args(CompilerType.GCC_OSX, *args) if soname_args: return ['-Wl,' + ','.join(soname_args)] return [] return get_gcc_soname_args(CompilerType.GCC_STANDARD, *args) def get_feature_args(self, kwargs, build_to_src): res = [] if 'unittest' in kwargs: unittest = kwargs.pop('unittest') unittest_arg = d_feature_args[self.id]['unittest'] if not unittest_arg: raise EnvironmentException('D compiler %s does not support the "unittest" feature.' % self.name_string()) if unittest: res.append(unittest_arg) if 'debug' in kwargs: debug_level = -1 debugs = kwargs.pop('debug') if not isinstance(debugs, list): debugs = [debugs] debug_arg = d_feature_args[self.id]['debug'] if not debug_arg: raise EnvironmentException('D compiler %s does not support conditional debug identifiers.' % self.name_string()) # Parse all debug identifiers and the largest debug level identifier for d in debugs: if isinstance(d, int): if d > debug_level: debug_level = d elif isinstance(d, str) and d.isdigit(): if int(d) > debug_level: debug_level = int(d) else: res.append('{0}={1}'.format(debug_arg, d)) if debug_level >= 0: res.append('{0}={1}'.format(debug_arg, debug_level)) if 'versions' in kwargs: version_level = -1 versions = kwargs.pop('versions') if not isinstance(versions, list): versions = [versions] version_arg = d_feature_args[self.id]['version'] if not version_arg: raise EnvironmentException('D compiler %s does not support conditional version identifiers.' % self.name_string()) # Parse all version identifiers and the largest version level identifier for v in versions: if isinstance(v, int): if v > version_level: version_level = v elif isinstance(v, str) and v.isdigit(): if int(v) > version_level: version_level = int(v) else: res.append('{0}={1}'.format(version_arg, v)) if version_level >= 0: res.append('{0}={1}'.format(version_arg, version_level)) if 'import_dirs' in kwargs: import_dirs = kwargs.pop('import_dirs') if not isinstance(import_dirs, list): import_dirs = [import_dirs] import_dir_arg = d_feature_args[self.id]['import_dir'] if not import_dir_arg: raise EnvironmentException('D compiler %s does not support the "string import directories" feature.' % self.name_string()) for idir_obj in import_dirs: basedir = idir_obj.get_curdir() for idir in idir_obj.get_incdirs(): # Avoid superfluous '/.' at the end of paths when d is '.' if idir not in ('', '.'): expdir = os.path.join(basedir, idir) else: expdir = basedir srctreedir = os.path.join(build_to_src, expdir) res.append('{0}{1}'.format(import_dir_arg, srctreedir)) if kwargs: raise EnvironmentException('Unknown D compiler feature(s) selected: %s' % ', '.join(kwargs.keys())) return res def get_buildtype_linker_args(self, buildtype): if buildtype != 'plain': return self.get_target_arch_args() return [] def get_std_exe_link_args(self): return [] def gen_import_library_args(self, implibname): return ['-Wl,--out-implib=' + implibname] def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath): if is_windows(): return [] # This method is to be used by LDC and DMD. # GDC can deal with the verbatim flags. if not rpath_paths and not install_rpath: return [] paths = ':'.join([os.path.join(build_dir, p) for p in rpath_paths]) if build_rpath != '': paths += ':' + build_rpath if len(paths) < len(install_rpath): padding = 'X' * (len(install_rpath) - len(paths)) if not paths: paths = padding else: paths = paths + ':' + padding return ['-Wl,-rpath,{}'.format(paths)] def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile'): if callable(extra_args): extra_args = extra_args(mode) if extra_args is None: extra_args = [] elif isinstance(extra_args, str): extra_args = [extra_args] if dependencies is None: dependencies = [] elif not isinstance(dependencies, list): dependencies = [dependencies] # Collect compiler arguments args = CompilerArgs(self) for d in dependencies: # Add compile flags needed by dependencies args += d.get_compile_args() if mode == 'link': # Add link flags needed to find dependencies args += d.get_link_args() if mode == 'compile': # Add DFLAGS from the env args += env.coredata.get_external_args(self.for_machine, self.language) elif mode == 'link': # Add LDFLAGS from the env args += env.coredata.get_external_link_args(self.for_machine, self.language) # extra_args must override all other arguments, so we add them last args += extra_args return args def compiles(self, code, env, *, extra_args=None, dependencies=None, mode='compile'): args = self._get_compiler_check_args(env, extra_args, dependencies, mode) with self.cached_compile(code, env.coredata, extra_args=args, mode=mode) as p: return p.returncode == 0, p.cached def has_multi_arguments(self, args, env): return self.compiles('int i;\n', env, extra_args=args) def get_target_arch_args(self): # LDC2 on Windows targets to current OS architecture, but # it should follow the target specified by the MSVC toolchain. if is_windows(): if self.arch == 'x86_64': return ['-m64'] return ['-m32'] return [] @classmethod def translate_args_to_nongnu(cls, args): dcargs = [] # Translate common arguments to flags the LDC/DMD compilers # can understand. # The flags might have been added by pkg-config files, # and are therefore out of the user's control. for arg in args: # Translate OS specific arguments first. osargs = [] if is_windows(): osargs = cls.translate_arg_to_windows(arg) elif is_osx(): osargs = cls.translate_arg_to_osx(arg) if osargs: dcargs.extend(osargs) continue # Translate common D arguments here. if arg == '-pthread': continue if arg.startswith('-fstack-protector'): continue if arg.startswith('-D'): continue if arg.startswith('-Wl,'): # Translate linker arguments here. linkargs = arg[arg.index(',') + 1:].split(',') for la in linkargs: dcargs.append('-L=' + la.strip()) continue elif arg.startswith(('-link-defaultlib', '-linker', '-link-internally', '-linkonce-templates', '-lib')): # these are special arguments to the LDC linker call, # arguments like "-link-defaultlib-shared" do *not* # denote a library to be linked, but change the default # Phobos/DRuntime linking behavior, while "-linker" sets the # default linker. dcargs.append(arg) continue elif arg.startswith('-l'): # translate library link flag dcargs.append('-L=' + arg) continue elif arg.startswith('-isystem'): # translate -isystem system include path # this flag might sometimes be added by C library Cflags via # pkg-config. # NOTE: -isystem and -I are not 100% equivalent, so this is just # a workaround for the most common cases. if arg.startswith('-isystem='): dcargs.append('-I=' + arg[9:]) else: dcargs.append('-I') continue elif arg.startswith('-L/') or arg.startswith('-L./'): # we need to handle cases where -L is set by e.g. a pkg-config # setting to select a linker search path. We can however not # unconditionally prefix '-L' with '-L' because the user might # have set this flag too to do what it is intended to for this # compiler (pass flag through to the linker) # Hence, we guess here whether the flag was intended to pass # a linker search path. # Make sure static library files are passed properly to the linker. if arg.endswith('.a') or arg.endswith('.lib'): if arg.startswith('-L='): farg = arg[3:] else: farg = arg[2:] if len(farg) > 0 and not farg.startswith('-'): dcargs.append('-L=' + farg) continue dcargs.append('-L=' + arg) continue elif not arg.startswith('-') and arg.endswith(('.a', '.lib')): # ensure static libraries are passed through to the linker dcargs.append('-L=' + arg) continue else: dcargs.append(arg) return dcargs @classmethod def translate_arg_to_windows(cls, arg): args = [] if arg.startswith('-Wl,'): # Translate linker arguments here. linkargs = arg[arg.index(',') + 1:].split(',') for la in linkargs: if la.startswith('--out-implib='): # Import library name args.append('-L=/IMPLIB:' + la[13:].strip()) elif arg.startswith('-mscrtlib='): args.append(arg) mscrtlib = arg[10:].lower() if cls is LLVMDCompiler: # Default crt libraries for LDC2 must be excluded for other # selected crt options. if mscrtlib != 'libcmt': args.append('-L=/NODEFAULTLIB:libcmt') args.append('-L=/NODEFAULTLIB:libvcruntime') # Fixes missing definitions for printf-functions in VS2017 if mscrtlib.startswith('msvcrt'): args.append('-L=/DEFAULTLIB:legacy_stdio_definitions.lib') return args @classmethod def translate_arg_to_osx(cls, arg): args = [] if arg.startswith('-install_name'): args.append('-L=' + arg) return args def get_debug_args(self, is_debug): ddebug_args = [] if is_debug: ddebug_args = [d_feature_args[self.id]['debug']] return clike_debug_args[is_debug] + ddebug_args def get_crt_args(self, crt_val, buildtype): if not is_windows(): return [] if crt_val in self.mscrt_args: return self.mscrt_args[crt_val] assert(crt_val == 'from_buildtype') # Match what build type flags used to do. if buildtype == 'plain': return [] elif buildtype == 'debug': return self.mscrt_args['mdd'] elif buildtype == 'debugoptimized': return self.mscrt_args['md'] elif buildtype == 'release': return self.mscrt_args['md'] elif buildtype == 'minsize': return self.mscrt_args['md'] else: assert(buildtype == 'custom') raise EnvironmentException('Requested C runtime based on buildtype, but buildtype is "custom".') def get_crt_compile_args(self, crt_val, buildtype): return [] def get_crt_link_args(self, crt_val, buildtype): return [] def thread_link_flags(self, env): return ['-pthread'] class GnuDCompiler(DCompiler): def __init__(self, exelist, version, for_machine: MachineChoice, arch, **kwargs): DCompiler.__init__(self, exelist, version, for_machine, arch, **kwargs) self.id = 'gcc' default_warn_args = ['-Wall', '-Wdeprecated'] self.warn_args = {'0': [], '1': default_warn_args, '2': default_warn_args + ['-Wextra'], '3': default_warn_args + ['-Wextra', '-Wpedantic']} self.base_options = ['b_colorout', 'b_sanitize', 'b_staticpic', 'b_vscrt'] self._has_color_support = version_compare(self.version, '>=4.9') # dependencies were implemented before, but broken - support was fixed in GCC 7.1+ # (and some backported versions) self._has_deps_support = version_compare(self.version, '>=7.1') def get_colorout_args(self, colortype): if self._has_color_support: return gnu_color_args[colortype][:] return [] def get_dependency_gen_args(self, outtarget, outfile): if not self._has_deps_support: return [] return ['-MD', '-MQ', outtarget, '-MF', outfile] def get_output_args(self, target): return ['-o', target] def get_linker_output_args(self, target): return ['-o', target] def get_include_args(self, path, is_system): return ['-I' + path] def get_warn_args(self, level): return self.warn_args[level] def get_werror_args(self): return ['-Werror'] def get_linker_search_args(self, dirname): return ['-L' + dirname] def get_coverage_args(self): return [] def get_buildtype_args(self, buildtype): return d_gdc_buildtype_args[buildtype] def compute_parameters_with_absolute_paths(self, parameter_list, build_dir): for idx, i in enumerate(parameter_list): if i[:2] == '-I' or i[:2] == '-L': parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:])) return parameter_list def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath): return self.build_unix_rpath_args(build_dir, from_dir, rpath_paths, build_rpath, install_rpath) def get_optimization_args(self, optimization_level): return gnu_optimization_args[optimization_level] class LLVMDCompiler(DCompiler): def __init__(self, exelist, version, for_machine: MachineChoice, arch, **kwargs): DCompiler.__init__(self, exelist, version, for_machine, arch, **kwargs) self.id = 'llvm' self.base_options = ['b_coverage', 'b_colorout', 'b_vscrt'] def get_colorout_args(self, colortype): if colortype == 'always': return ['-enable-color'] return [] def get_warn_args(self, level): if level == '2' or level == '3': return ['-wi', '-dw'] elif level == '1': return ['-wi'] else: return [] def get_buildtype_args(self, buildtype): if buildtype != 'plain': return self.get_target_arch_args() + d_ldc_buildtype_args[buildtype] return d_ldc_buildtype_args[buildtype] def get_pic_args(self): return ['-relocation-model=pic'] def get_crt_link_args(self, crt_val, buildtype): return self.get_crt_args(crt_val, buildtype) @classmethod def unix_args_to_native(cls, args): return cls.translate_args_to_nongnu(args) def get_optimization_args(self, optimization_level): return ldc_optimization_args[optimization_level] class DmdDCompiler(DCompiler): def __init__(self, exelist, version, for_machine: MachineChoice, arch, **kwargs): DCompiler.__init__(self, exelist, version, for_machine, arch, **kwargs) self.id = 'dmd' self.base_options = ['b_coverage', 'b_colorout', 'b_vscrt'] def get_colorout_args(self, colortype): if colortype == 'always': return ['-color=on'] return [] def get_buildtype_args(self, buildtype): if buildtype != 'plain': return self.get_target_arch_args() + d_dmd_buildtype_args[buildtype] return d_dmd_buildtype_args[buildtype] def get_std_exe_link_args(self): if is_windows(): # DMD links against D runtime only when main symbol is found, # so these needs to be inserted when linking static D libraries. if self.arch == 'x86_64': return ['phobos64.lib'] elif self.arch == 'x86_mscoff': return ['phobos32mscoff.lib'] return ['phobos.lib'] return [] def get_std_shared_lib_link_args(self): libname = 'libphobos2.so' if is_windows(): if self.arch == 'x86_64': libname = 'phobos64.lib' elif self.arch == 'x86_mscoff': libname = 'phobos32mscoff.lib' else: libname = 'phobos.lib' return ['-shared', '-defaultlib=' + libname] def get_target_arch_args(self): # DMD32 and DMD64 on 64-bit Windows defaults to 32-bit (OMF). # Force the target to 64-bit in order to stay consistent # across the different platforms. if is_windows(): if self.arch == 'x86_64': return ['-m64'] elif self.arch == 'x86_mscoff': return ['-m32mscoff'] return ['-m32'] return [] def get_crt_compile_args(self, crt_val, buildtype): return self.get_crt_args(crt_val, buildtype) @classmethod def unix_args_to_native(cls, args): return cls.translate_args_to_nongnu(args) def get_optimization_args(self, optimization_level): return dmd_optimization_args[optimization_level]
the-stack_0_3416
from django.apps.registry import Apps from django.db import DatabaseError, models from django.utils.functional import classproperty from django.utils.timezone import now from .exceptions import MigrationSchemaMissing class MigrationRecorder: """ Deal with storing migration records in the database. Because this table is actually itself used for dealing with model creation, it's the one thing we can't do normally via migrations. We manually handle table creation/schema updating (using schema backend) and then have a floating model to do queries with. If a migration is unapplied its row is removed from the table. Having a row in the table always means a migration is applied. """ _migration_class = None @classproperty def Migration(cls): """ Lazy load to avoid AppRegistryNotReady if installed apps import MigrationRecorder. """ if cls._migration_class is None: class Migration(models.Model): app = models.CharField(max_length=255) name = models.CharField(max_length=255) applied = models.DateTimeField(default=now) class Meta: apps = Apps() app_label = 'migrations' db_table = 'django_migrations' def __str__(self): return 'Migration %s for %s' % (self.name, self.app) cls._migration_class = Migration return cls._migration_class def __init__(self, connection): self.connection = connection @property def migration_qs(self): return self.Migration.objects.using(self.connection.alias) def has_table(self): """Return True if the django_migrations table exists.""" with self.connection.cursor() as cursor: tables = self.connection.introspection.table_names(cursor) return self.Migration._meta.db_table in tables def ensure_schema(self): """Ensure the table exists and has the correct schema.""" # If the table's there, that's fine - we've never changed its schema # in the codebase. if self.has_table(): return # Make the table try: with self.connection.schema_editor() as editor: editor.create_model(self.Migration) except DatabaseError as exc: raise MigrationSchemaMissing("Unable to create the django_migrations table (%s)" % exc) def applied_migrations(self): """ Return a dict mapping (app_name, migration_name) to Migration instances for all applied migrations. """ if self.has_table(): return {(migration.app, migration.name): migration for migration in self.migration_qs} else: # If the django_migrations table doesn't exist, then no migrations # are applied. return {} def record_applied(self, app, name): """Record that a migration was applied.""" self.ensure_schema() self.migration_qs.create(app=app, name=name) def record_unapplied(self, app, name): """Record that a migration was unapplied.""" self.ensure_schema() self.migration_qs.filter(app=app, name=name).delete() def flush(self): """Delete all migration records. Useful for testing migrations.""" self.migration_qs.all().delete()
the-stack_0_3417
from __future__ import absolute_import, division, print_function from cfn_model.model.ModelElement import ModelElement class EC2NetworkInterface(ModelElement): """ Ec2 network interface model lement """ def __init__(self, cfn_model): """ Initialize :param cfn_model: """ ModelElement.__init__(self, cfn_model) self.groupSet= [] self.ipv6Addresses= [] self.privateIpAddresses= [] self.tags= [] self.security_groups= [] self.resource_type = 'AWS::EC2::NetworkInterface'
the-stack_0_3420
# Copyright 2018 The TensorFlow Probability Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ """Tests for the LKJ distribution.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function # Dependency imports from absl.testing import parameterized import numpy as np import tensorflow as tf import tensorflow_probability as tfp from tensorflow_probability.python.distributions.internal import statistical_testing as st tfd = tfp.distributions from tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import,g-import-not-at-top def _det_ok_mask(x, det_bounds, input_output_cholesky=False): if input_output_cholesky: logdet = 2.0 * tf.reduce_sum( input_tensor=tf.math.log(tf.linalg.diag_part(x)), axis=[-1]) else: _, logdet = tf.linalg.slogdet(x) return tf.cast(tf.exp(logdet) > det_bounds, dtype=x.dtype) # Each leaf entry here is a confidence interval for the volume of some # set of correlation matrices. To wit, k-by-k correlation matrices # whose determinant is at least d appear as volume_bounds[k][d]. # These particular confidence intervals were estimated by the # Clopper-Pearson method applied to 10^7 rejection samples, with an # error probability of 5e-7. This computation may be performed by # executing the correlation_matrix_volumes program with argument # --num_samples 1e7. Doing so took about 45 minutes on a standard # workstation. volume_bounds = { 3: {0.01: (04.8334339757361420, 4.845866340472709), 0.25: (02.9993127232473036, 3.011629093880439), 0.30: (02.6791373340121916, 2.691146382760893), 0.35: (02.3763254004846030, 2.3879545568875358), 0.40: (02.0898224112869355, 2.1010041316917913), 0.45: (01.8202389505755674, 1.8309117190894892)}, 4: {0.01: (10.983339932556953, 11.060156130783517), 0.25: (03.4305021152837020, 3.4764695469900464), 0.30: (02.6624323207206930, 2.703204389589173), 0.35: (02.0431263321809440, 2.0790437132708752), 0.40: (01.5447440594930320, 1.5761221057556805), 0.45: (01.1459065289947180, 1.1730410135527702)}, 5: {0.01: (19.081135276668707, 19.523821224876603), 0.20: (02.8632254471072285, 3.0376848112309776), 0.25: (01.8225680180604158, 1.9623522646052605), 0.30: (01.1299612119639912, 1.2406126830051296), 0.35: (00.6871928383147943, 0.7740705901566753), 0.40: (00.4145900446719042, 0.482655106057178)}} @test_util.run_all_in_graph_and_eager_modes @parameterized.parameters(np.float32, np.float64) class LKJTest(parameterized.TestCase, tf.test.TestCase): def testNormConst2D(self, dtype): expected = 2. # 2x2 correlation matrices are determined by one number between -1 # and 1, so the volume of density 1 over all of them is 2. answer = self.evaluate(tfd.LKJ(2, dtype([1.]))._log_normalization()) self.assertAllClose(answer, np.log([expected])) def testNormConst3D(self, dtype): expected = np.pi**2 / 2. # 3x3 correlation matrices are determined by the three # lower-triangular entries. In addition to being between -1 and # 1, they must also obey the constraint that the determinant of # the resulting symmetric matrix is non-negative. The post # https://psychometroscar.com/the-volume-of-a-3-x-3-correlation-matrix/ # derives (with elementary calculus) that the volume of this set # (with respect to Lebesgue^3 measure) is pi^2/2. The same result # is also obtained by Rousseeuw, P. J., & Molenberghs, # G. (1994). "The shape of correlation matrices." The American # Statistician, 48(4), 276-279. answer = self.evaluate(tfd.LKJ(3, dtype([1.]))._log_normalization()) self.assertAllClose(answer, np.log([expected])) def _testSampleLogProbExact(self, concentrations, det_bounds, dim, means, num_samples=int(1e5), dtype=np.float32, target_discrepancy=0.1, input_output_cholesky=False, seed=42): # For test methodology see the comment in # _testSampleConsistentLogProbInterval, except that this test # checks those parameter settings where the true volume is known # analytically. concentration = np.array(concentrations, dtype=dtype) det_bounds = np.array(det_bounds, dtype=dtype) means = np.array(means, dtype=dtype) # Add a tolerance to guard against some of the importance_weights exceeding # the theoretical maximum (importance_maxima) due to numerical inaccuracies # while lower bounding the determinant. See corresponding comment in # _testSampleConsistentLogProbInterval. high_tolerance = 1e-6 testee_lkj = tfd.LKJ( dimension=dim, concentration=concentration, input_output_cholesky=input_output_cholesky, validate_args=True) x = testee_lkj.sample(num_samples, seed=seed) importance_weights = ( tf.exp(-testee_lkj.log_prob(x)) * _det_ok_mask(x, det_bounds, input_output_cholesky)) importance_maxima = (1. / det_bounds) ** (concentration - 1) * tf.exp( testee_lkj._log_normalization()) chk1 = st.assert_true_mean_equal_by_dkwm( importance_weights, low=0., high=importance_maxima + high_tolerance, expected=means, false_fail_rate=1e-6) chk2 = tf.compat.v1.assert_less( st.min_discrepancy_of_true_means_detectable_by_dkwm( num_samples, low=0., high=importance_maxima + high_tolerance, false_fail_rate=1e-6, false_pass_rate=1e-6), dtype(target_discrepancy)) self.evaluate([chk1, chk2]) def testSampleConsistentLogProb2(self, dtype): concentrations = np.array([ 1.00, 1.30, 1.50, 1.70, 1.90, 2.00, 2.10, 2.50, 3.00]) det_bounds = np.array([ 0.01, 0.25, 0.30, 0.40, 0.50, 0.50, 0.50, 0.70, 0.70]) exact_volumes = 2 * np.sqrt(1. - det_bounds) for input_output_cholesky in [True, False]: self._testSampleLogProbExact( concentrations, det_bounds, 2, exact_volumes, num_samples=int(1.1e5), dtype=dtype, input_output_cholesky=input_output_cholesky, target_discrepancy=0.05, seed=41) def _testSampleConsistentLogProbInterval(self, concentrations, det_bounds, dim, num_samples=int(1e5), dtype=np.float32, input_output_cholesky=False, false_fail_rate=1e-6, target_discrepancy=0.1, seed=42): # Consider the set M of dim x dim correlation matrices whose # determinant exceeds some bound (rationale for bound forthwith). # - This is a (convex!) shape in dim * (dim - 1) / 2 dimensions # (because a correlation matrix is determined by its lower # triangle, and the main diagonal is all 1s). # - Further, M is contained entirely in the [-1,1] cube, # because no correlation can fall outside that interval. # # We have two different ways to estimate the volume of M: # - Importance sampling from the LKJ distribution # - Importance sampling from the uniform distribution on the cube # # This test checks that these two methods agree. However, because # the uniform proposal leads to many rejections (thus slowness), # those volumes are computed offline and the confidence intervals # are presented to this test procedure in the "volume_bounds" # table. # # Why place a lower bound on the determinant? Because for eta > 1, # the density of LKJ approaches 0 as the determinant approaches 0. # However, the test methodology requires an upper bound on the # improtance weights produced. Rejecting matrices with too-small # determinant (from both methods) allows me to supply that bound. # # I considered several alternative regions whose volume I might # know analytically (without having to do rejection). # - Option a: Some hypersphere guaranteed to be contained inside M. # - Con: I don't know a priori how to find a radius for it. # - Con: I still need a lower bound on the determinants that appear # in this sphere, and I don't know how to compute it. # - Option b: Some trapezoid given as the convex hull of the # nearly-extreme correlation matrices (i.e., those that partition # the variables into two strongly anti-correclated groups). # - Con: Would have to dig up n-d convex hull code to implement this. # - Con: Need to compute the volume of that convex hull. # - Con: Need a bound on the determinants of the matrices in that hull. # - Option c: Same thing, but with the matrices that make a single pair # of variables strongly correlated (or anti-correlated), and leaves # the others uncorrelated. # - Same cons, except that there is a determinant bound (which # felt pretty loose). lows = [dtype(volume_bounds[dim][db][0]) for db in det_bounds] highs = [dtype(volume_bounds[dim][db][1]) for db in det_bounds] concentration = np.array(concentrations, dtype=dtype) det_bounds = np.array(det_bounds, dtype=dtype) # Due to possible numerical inaccuracies while lower bounding the # determinant, the maximum of the importance weights may exceed the # theoretical maximum (importance_maxima). We add a tolerance to guard # against this. An alternative would have been to add a threshold while # filtering in _det_ok_mask, but that would affect the mean as well. high_tolerance = 1e-6 testee_lkj = tfd.LKJ( dimension=dim, concentration=concentration, input_output_cholesky=input_output_cholesky, validate_args=True) x = testee_lkj.sample(num_samples, seed=seed) importance_weights = ( tf.exp(-testee_lkj.log_prob(x)) * _det_ok_mask(x, det_bounds, input_output_cholesky)) importance_maxima = (1. / det_bounds) ** (concentration - 1) * tf.exp( testee_lkj._log_normalization()) check1 = st.assert_true_mean_in_interval_by_dkwm( samples=importance_weights, low=0., high=importance_maxima + high_tolerance, expected_low=lows, expected_high=highs, false_fail_rate=false_fail_rate) check2 = tf.compat.v1.assert_less( st.min_discrepancy_of_true_means_detectable_by_dkwm( num_samples, low=0., high=importance_maxima + high_tolerance, false_fail_rate=false_fail_rate, false_pass_rate=false_fail_rate), dtype(target_discrepancy)) self.evaluate([check1, check2]) def testSampleConsistentLogProbInterval3(self, dtype): # The hardcoded volume boundaries are (5e-7)-confidence intervals # of a rejection sampling run. Ergo, I only have 5e-7 probability # mass left for the false fail rate of the test so the aggregate # false fail probability is 1e-6. concentrations = [ 1.00, 1.30, 1.50, 1.70, 1.90, 2.00, 2.10, 2.50, 3.00] det_bounds = [ 0.01, 0.25, 0.25, 0.30, 0.35, 0.35, 0.35, 0.40, 0.45] for input_output_cholesky in [True, False]: self._testSampleConsistentLogProbInterval( concentrations, det_bounds, 3, dtype=dtype, input_output_cholesky=input_output_cholesky, false_fail_rate=5e-7, target_discrepancy=0.11, seed=40) def testSampleConsistentLogProbInterval4(self, dtype): # The hardcoded volume boundaries are (5e-7)-confidence intervals # of a rejection sampling run. Ergo, I only have 5e-7 probability # mass left for the false fail rate of the test so the aggregate # false fail probability is 1e-6. concentrations = [ 1.00, 1.30, 1.50, 1.70, 1.90, 2.00, 2.10, 2.50, 3.00] det_bounds = [ 0.01, 0.25, 0.25, 0.30, 0.35, 0.35, 0.35, 0.40, 0.45] for input_output_cholesky in [True, False]: self._testSampleConsistentLogProbInterval( concentrations, det_bounds, 4, dtype=dtype, input_output_cholesky=input_output_cholesky, false_fail_rate=5e-7, target_discrepancy=0.22, seed=39) def testSampleConsistentLogProbInterval5(self, dtype): # The hardcoded volume boundaries are (5e-7)-confidence intervals # of a rejection sampling run. Ergo, I only have 5e-7 probability # mass left for the false fail rate of the test so the aggregate # false fail probability is 1e-6. concentrations = [ 1.00, 1.30, 1.50, 1.70, 1.90, 2.00, 2.10, 2.50, 3.00] det_bounds = [ 0.01, 0.20, 0.20, 0.25, 0.30, 0.30, 0.30, 0.35, 0.40] for input_output_cholesky in [True, False]: self._testSampleConsistentLogProbInterval( concentrations, det_bounds, 5, dtype=dtype, input_output_cholesky=input_output_cholesky, false_fail_rate=5e-7, target_discrepancy=0.41, seed=37) def testDimensionGuard(self, dtype): testee_lkj = tfd.LKJ( dimension=3, concentration=dtype([1., 4.]), validate_args=True) with self.assertRaisesRegexp(ValueError, 'dimension mismatch'): testee_lkj.log_prob(tf.eye(4)) def testZeroDimension(self, dtype): testee_lkj = tfd.LKJ( dimension=0, concentration=dtype([1., 4.]), validate_args=True) results = testee_lkj.sample(sample_shape=[4, 3]) self.assertEqual(results.shape, [4, 3, 2, 0, 0]) def testOneDimension(self, dtype): testee_lkj = tfd.LKJ( dimension=1, concentration=dtype([1., 4.]), validate_args=True) results = testee_lkj.sample(sample_shape=[4, 3]) self.assertEqual(results.shape, [4, 3, 2, 1, 1]) def testMean(self, dtype): testee_lkj = tfd.LKJ(dimension=3, concentration=dtype([1., 3., 5.])) num_samples = 20000 results = testee_lkj.sample(sample_shape=[num_samples]) mean = testee_lkj.mean() self.assertEqual(mean.shape, [3, 3, 3]) check1 = st.assert_true_mean_equal_by_dkwm( samples=results, low=-1., high=1., expected=mean, false_fail_rate=1e-6) check2 = tf.compat.v1.assert_less( st.min_discrepancy_of_true_means_detectable_by_dkwm( num_samples, low=-1., high=1., # Smaller false fail rate because of different batch sizes between # these two checks. false_fail_rate=1e-7, false_pass_rate=1e-6), # 4% relative error 0.08) self.evaluate([check1, check2]) class LKJTestGraphOnly(tf.test.TestCase): def testDimensionGuardDynamicShape(self): if tf.executing_eagerly(): return testee_lkj = tfd.LKJ( dimension=3, concentration=[1., 4.], validate_args=True) with self.assertRaisesOpError('dimension mismatch'): self.evaluate( testee_lkj.log_prob( tf.compat.v1.placeholder_with_default(tf.eye(4), shape=None))) if __name__ == '__main__': tf.test.main()
the-stack_0_3422
import cv2 import mediapipe as mp import numpy as np import pyautogui from google.protobuf.json_format import MessageToDict from datetime import datetime import os from os import path import time from tkinter import * from tkinter import filedialog from PIL import Image from PIL import ImageTk import imutils import sys def hands_detection(frame): global bclick global xp, yp global xclick_menique, yclick_menique mp_drawing = mp.solutions.drawing_utils mp_drawing_styles = mp.solutions.drawing_styles mp_hands = mp.solutions.hands color_pointer = (255,255,255) ANCHO_P=1920 ALTO_P=1080 RATIO=ANCHO_P/ALTO_P X=100 Y=200 xmano_ant=0 ymano_ant=0 b=3 pyautogui.FAILSAFE=False with mp_hands.Hands( static_image_mode=False, max_num_hands=1, min_detection_confidence=0.5) as hands: height, width, _ = frame.shape frame = cv2.flip(frame, 1) area_width = width - X*2 area_height = int(area_width/RATIO) aux = np.zeros(frame.shape, np.uint8) aux = cv2.rectangle(aux,(X,Y),(X + area_width, Y + area_height), (255, 0, 0),-1) output=cv2.addWeighted(frame,1,aux,0.7,0) frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) results = hands.process(frame_rgb) if results.multi_hand_landmarks is not None: for hand_landmarks in results.multi_hand_landmarks: # Get hand data handesness_dict = MessageToDict(results.multi_handedness[0]) # Type of hand (left or right) type_hand = handesness_dict['classification'][0]['label'] # level of certainty certainty_score = handesness_dict['classification'][0]['score'] # If the prediction is not if(certainty_score<0.9): continue #MEDICION DE LOS PUNTOS DE LAS MANOS xmano = int(hand_landmarks.landmark[0].x * width) ymano = int(hand_landmarks.landmark[0].y * height) xbase = int(hand_landmarks.landmark[4].x * width) ybase = int(hand_landmarks.landmark[4].y * height) xindice = int(hand_landmarks.landmark[8].x * width) yindice = int(hand_landmarks.landmark[8].y * height) xmedio = int(hand_landmarks.landmark[12].x * width) ymedio = int(hand_landmarks.landmark[12].y * height) xanular = int(hand_landmarks.landmark[16].x * width) yanular = int(hand_landmarks.landmark[16].y * height) xmenique = int(hand_landmarks.landmark[20].x * width) ymenique = int(hand_landmarks.landmark[20].y * height) #MEDICIONES ENTRE BASE Y DEDO xclick_indice = xbase-xindice yclick_indice = ybase-yindice xclick_medio = xbase - xmedio yclick_medio = ybase - ymedio xclick_menique = xbase - xmenique yclick_menique = ybase - ymenique xclick_anular = xbase - xanular yclick_anular = ybase - yanular distancia_indice = int((xclick_indice**2 + yclick_indice**2)**(1/2)) distancia_medio = int((xclick_medio ** 2 + yclick_medio ** 2) ** (1 / 2)) distancia_anular = int((xclick_anular ** 2 + yclick_anular ** 2) ** (1 / 2)) distancia_menique = int((xclick_menique ** 2 + yclick_menique ** 2)** (1 / 2)) # Move mouse pointer with both hands if((xmano<= xmano_ant-b) | (xmano>=xmano_ant+b)): xmano_ant = xmano if ((ymano <= ymano_ant - b) | (ymano >= ymano_ant + b)): ymano_ant = ymano xp = np.interp(xmano_ant, (X,X+ area_width), (0,ANCHO_P)) yp = np.interp(ymano_ant, (Y, Y + area_height), (0, ALTO_P)) pyautogui.moveTo(int(xp),int(yp)) # The right hand will have the mouse options if(type_hand == 'Right'): # Left click if(distancia_indice<=50): if(bclick[0]==False): print("Click") pyautogui.leftClick() bclick[0]=True if(distancia_indice>=60): if(bclick[0]==True): bclick[0]=False # Middle click if (distancia_medio<=50): if (bclick[1] == False): print("Click") pyautogui.middleClick() bclick[1] = True if (distancia_medio>=60): if (bclick[1] == True): bclick[1] = False # Right click if (distancia_anular<=50): if (bclick[2] == False): print("Click") pyautogui.rightClick() bclick[2] = True if (distancia_anular>=60): if (bclick[2] == True): bclick[2] = False # Drag if (distancia_menique<=50): if (bclick[3] == False): print("Arrastrar") pyautogui.mouseDown() bclick[3] = True else: pyautogui.moveTo(xp, yp) if (distancia_menique>=60): if (bclick[3] == True): pyautogui.mouseUp() bclick[3] = False # The left hand will be able to set audio, brightness, etc else: # Volume up if(distancia_indice<=30): if(bclick[0]==False): print("Volume up") pyautogui.press("volumeup") bclick[0]=True if(distancia_indice>=40): if(bclick[0]==True): bclick[0]=False # Screenshot # image will be save in Images folder, under the present # hour time name if (distancia_medio<=50): if (bclick[1] == False): print("Screenshot") now = datetime.now() print(now.strftime("%d-%m-%Y_%H-%M-%S")) image_name = folder+"/"+now.strftime("%d-%m-%Y_%H-%M-%S")+".png" pyautogui.screenshot(image_name) bclick[1] = True if (distancia_medio>=60): if (bclick[1] == True): bclick[1] = False # Volume down if (distancia_anular<=30): if (bclick[2] == False): print("Volume down") pyautogui.press("volumedown") bclick[2] = True if (distancia_anular>=40): if (bclick[2] == True): bclick[2] = False #Texto rápido if (distancia_menique<=50): if (bclick[3] == False): print("Texto") pyautogui.typewrite("No puedo contestar por el momento, te marco cuanto me desocupe") bclick[3] = True if (distancia_menique>=60): if (bclick[3] == True): bclick[3] = False def visualizar(lblVideo): global cap global xp, yp if cap is not None: ret, frame = cap.read() if ret == True: frame = imutils.resize(frame,width=640) hands_detection(frame) frame = cv2.cvtColor(frame,cv2.COLOR_BGR2RGB) im = Image.fromarray(frame) img = ImageTk.PhotoImage(image=im) lblVideo.configure(image=img) lblVideo.image = img lblVideo.after(1,lambda : visualizar(lblVideo)) else: lblVideo.image = "" cap.release() def iniciar(): global cap global counter global bclick global xp, yp bclick = np.full((4,1), False) xp = 0 yp = 0 if counter < 1: counter+=1 cap = cv2.VideoCapture(0,cv2.CAP_DSHOW) # Video video = Toplevel() lblVideo = Label(video) lblVideo.grid(column=0,row=0,columnspan=2) visualizar(lblVideo) def finalizar(): global cap if cap is not None: cap.release() sys.exit(0) def main(): global cap cap = None global counter counter = 0 global folder # Set folder name for screenshots folder = "./images" # Check if the folder containing the images exits. If not, create it if(not path.isdir(folder)): os.mkdir(folder) # Start main frame root = Tk() root.title('Hands-Free Mouse') root.iconphoto(False, PhotoImage(file='./icons/icon.png')) root.geometry('400x300+700+200') root.configure(bg='black') # Image m_im = Image.open("./icons/hand.jpg") m_im = m_im.resize((300,250), Image.ANTIALIAS) m_image = ImageTk.PhotoImage(m_im) main_image = Label(root, image=m_image) main_image.grid(column=0, row=0, columnspan=2) main_image.image = m_image # Create a botton to start the application btn = Button(root, text="Iniciar", width=25, command=iniciar, bg='white') btn.grid(column=0,row=1,padx=5,pady=5) # Create a button to finish the application btnFinalizar = Button(root, text="Finalizar", width=25, command=finalizar, bg='white') btnFinalizar.grid(column=1,row=1,padx=5,pady=5) # Create an event loop root.mainloop() # Destroy all cap.release() cv2.destroyAllWindows() if __name__=="__main__": main()
the-stack_0_3424
import numpy as np from bpn import new, trf from bpn.utils import get from numpy.linalg.linalg import inv def demo(): """camera, object = demo()""" d = Dancer() d.translate((2, 1, 0)) d.turn(30) d.turn_head(45) return d class Dancer: def __init__(self): # create dancer body = new.cone(name='body',r1=0.2, r2=0.2, h=1.5) body.translate(z=0.75) body.scale((0.5, 1, 1)) body.apply_matrix() head = new.cone(name='head', r1=0.2, r2=0, h=0.3) head.rotate((0.,90.,0.)) head.translate(x=0.1) head.apply_matrix() head.translate(z=1.6) self.gp = [] self.gp.append(body.show_frame()) self.gp.append(head.show_frame()) # create markers m1 = new.sphere(name='m1', r=0.05) self.m1_pos = trf.PointCloud((-0.1, 0, 1)) # both body frame and world frame self.body = body self.head = head self.m1 = m1 self.screen = new.empty() self.screen.frame = self.head.frame self.screen.translate((1, 0, -0.3)) self.m1viz = new.sphere(name='m1viz', r=0.08) self._update_m1() def translate(self, delta=(0., 0., 0.)): self.body.translate(delta) self.head.translate(delta) self.screen.translate(delta) self._update_m1() self.body.show_frame() self.head.show_frame() self.screen.show_frame() def turn(self, angle_deg): self.body.rotate((0., 0., angle_deg)) self.screen.frame = self.screen.frame.transform(trf.m4(trf.twisttf(angle_deg*np.pi/180)), tf_frame=self.head.frame) self.head.rotate((0., 0., angle_deg)) self._update_m1() self.body.show_frame() self.head.show_frame() self.screen.show_frame() def turn_head(self, angle_deg): self.head.rotate((0., 0., angle_deg)) self.screen.frame = self.screen.frame.transform(trf.m4(trf.twisttf(angle_deg*np.pi/180)), tf_frame=self.head.frame) self.head.show_frame() self.screen.show_frame() self._update_m1() def _update_m1(self): self.m1.loc = self.m1_pos.transform(self.body.frame.m).co[0] self.m1viz.loc = (self.screen.frame.m@inv(self.body.frame.m)@np.hstack((self.m1.loc, 1)))[:-1] # self.m1viz.loc = trf.PointCloud(trf.PointCloud(self.m1.loc).in_frame(self.body.frame.m).co[0], self.screen.frame).in_world().co[0] def __neg__(self): -self.body -self.head -self.m1 for g in self.gp: -g
the-stack_0_3425
""" Bayesian Network class """ import pandas as pd from .conditional_probability_table import ConditionalProbabilityTable as CPT from .directed_acyclic_graph import DirectedAcyclicGraph from .markov_network import MarkovNetwork from .factor import Factor from .null_graphviz_dag import NullGraphvizDag class BayesianNetwork(DirectedAcyclicGraph): """ Bayesian Network that stores ConditionalProbabilityTables. Parameters: cpts: list[ConditionalProbabilityTable]. Optional. Meant for specifying conditional probability tables of variables that are endogenous.. priors: list[ConditionalProbabilityTable]. Optional. Meant for probability tables of Variables that are exogenous. graphviz_dag: DiGraph Could be used to display the graph. """ def __init__(self, cpts=None, priors=None, graphviz_dag=None): super().__init__() if graphviz_dag is None: self.graphviz_dag = NullGraphvizDag() else: self.graphviz_dag = graphviz_dag if cpts is None: self.cpts = {} else: self.cpts = {} for cpt in cpts: self.add_edge(cpt) if priors: for prior_cpt in priors: self.add_node(prior_cpt) def __repr__(self): return f"BayesianNetwork(\n\t{self.cpts})" def add_prior(self, cpt): """ Add a conditional probability table. This adds a node. Parameters cpt: ConditionalProbabilityTable """ self.add_node(cpt) def set_priors(self, dictionary, data_class, data_storage_folder=None): """ Parameters: dictionary: dict Ex: { 'prior_var_a': { 'value_it_can_take_1': 0.2, 'value_it_can_take_2': 0.3, ... } 'prior_var_b': { 'value_it_can_take_1': 0.4, 'value_it_can_take_2': 0.2, ... } } """ for prior_var, mapping in dictionary.items(): collection = [] for value_prior_var_can_take, proba in mapping.items(): collection.append( { prior_var: value_prior_var_can_take, 'value': proba } ) df = pd.DataFrame(collection) givens = list(set(df.columns) - {'value', prior_var}) cpt = CPT( data_class( df, data_storage_folder ), givens=givens, outcomes=[prior_var] ) self.add_prior(cpt) def add_cpt(self, cpt): """ Add a conditional probability table. This in turn adds an edge. Parameters cpt: ConditionalProbabilityTable """ self.add_edge(cpt) def add_node(self, cpt): """ Add a conditional probability table. This adds a node. Parameters: cpt: ConditionalProbabilityTable """ outcomes = cpt.get_outcomes() if cpt.get_givens(): raise ValueError( "There should not be any givens for the CPT when adding a" + " node." ) if len(outcomes) != 1: raise ValueError( "There should only be one outcome for a CPT of a " + "Bayesian Network." ) for outcome in outcomes: self.cpts[outcome] = cpt self.graphviz_dag.node(outcome) super().add_node(outcome) def add_edge(self, cpt): """ Add a conditional probability table. This in turn adds an edge. Parameters: cpt: ConditionalProbabilityTable """ outcomes = cpt.get_outcomes() givens = cpt.get_givens() if len(outcomes) != 1: raise ValueError( "There should only be one outcome for a CPT of a " + "Bayesian Network." ) for outcome in outcomes: self.cpts[outcome] = cpt for given in givens: self.graphviz_dag.edge(given, outcome) super().add_edge(start=given, end=outcome) def find_cpt_for_node(self, node): """ Find conditional probability table for node. Parameters: node: str Returns: ConditionalProbabilityTable """ return self.cpts[node] def to_markov_network(self): """ Returns: MarkovNetwork """ markov_network = MarkovNetwork() for _, cpt in self.cpts.items(): factor = Factor(cpt=cpt) markov_network.add_factor(factor) return markov_network
the-stack_0_3428
import operator import uuid from functools import reduce import arrow import django_filters from arrow.parser import ParserError from django.conf import settings from guardian.core import ObjectPermissionChecker from django.contrib.auth import get_user_model from django.utils.translation import ugettext_lazy as _ from django.core.exceptions import ( PermissionDenied, ValidationError as DjangoValidationError ) from django.db.models import Q from django.utils import timezone from django_filters.rest_framework import DjangoFilterBackend from rest_framework import viewsets, serializers, filters, exceptions, permissions from rest_framework.authentication import TokenAuthentication, SessionAuthentication from rest_framework.fields import BooleanField, IntegerField from rest_framework import renderers from rest_framework.exceptions import NotAcceptable, ValidationError from rest_framework.settings import api_settings as drf_settings from munigeo import api as munigeo_api from resources.models import ( Reservation, Resource, ReservationMetadataSet, ReservationCancelReasonCategory, ReservationCancelReason) from resources.models.reservation import RESERVATION_EXTRA_FIELDS from resources.pagination import ReservationPagination from resources.models.utils import generate_reservation_xlsx, get_object_or_none from ..auth import is_general_admin from .base import ( NullableDateTimeField, TranslatedModelSerializer, register_view, DRFFilterBooleanWidget, ExtraDataMixin ) from respa.renderers import ResourcesBrowsableAPIRenderer User = get_user_model() # FIXME: Make this configurable? USER_ID_ATTRIBUTE = 'id' try: User._meta.get_field('uuid') USER_ID_ATTRIBUTE = 'uuid' except Exception: pass class UserSerializer(TranslatedModelSerializer): display_name = serializers.ReadOnlyField(source='get_display_name') email = serializers.ReadOnlyField() def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if USER_ID_ATTRIBUTE == 'id': # id field is read_only by default, that needs to be changed # so that the field will be validated self.fields['id'] = IntegerField(label='ID') else: # if the user id attribute isn't id, modify the id field to point to the right attribute. # the field needs to be of the right type so that validation works correctly model_field_type = type(get_user_model()._meta.get_field(USER_ID_ATTRIBUTE)) serializer_field = self.serializer_field_mapping[model_field_type] self.fields['id'] = serializer_field(source=USER_ID_ATTRIBUTE, label='ID') class Meta: model = get_user_model() fields = ('id', 'display_name', 'email') class ReservationCancelReasonCategorySerializer(TranslatedModelSerializer): class Meta: model = ReservationCancelReasonCategory fields = [ 'id', 'reservation_type', 'name', 'description' ] class ReservationCancelReasonSerializer(serializers.ModelSerializer): category = ReservationCancelReasonCategorySerializer(read_only=True) category_id = serializers.PrimaryKeyRelatedField(write_only=True, source='category', queryset=ReservationCancelReasonCategory.objects.all()) class Meta: model = ReservationCancelReason fields = [ 'category', 'description', 'reservation', 'category_id' ] class ReservationSerializer(ExtraDataMixin, TranslatedModelSerializer, munigeo_api.GeoModelSerializer): begin = NullableDateTimeField() end = NullableDateTimeField() user = UserSerializer(required=False) is_own = serializers.SerializerMethodField() state = serializers.ChoiceField(choices=Reservation.STATE_CHOICES, required=False) need_manual_confirmation = serializers.ReadOnlyField() user_permissions = serializers.SerializerMethodField() cancel_reason = ReservationCancelReasonSerializer(required=False) patchable_fields = ['state', 'cancel_reason'] class Meta: model = Reservation fields = [ 'url', 'id', 'resource', 'user', 'begin', 'end', 'comments', 'is_own', 'state', 'need_manual_confirmation', 'staff_event', 'access_code', 'user_permissions', 'type', 'cancel_reason' ] + list(RESERVATION_EXTRA_FIELDS) read_only_fields = list(RESERVATION_EXTRA_FIELDS) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) data = self.get_initial() resource = None # try to find out the related resource using initial data if that is given resource_id = data.get('resource') if data else None if resource_id: resource = get_object_or_none(Resource, id=resource_id) # if that didn't work out use the reservation's old resource if such exists if not resource: if isinstance(self.instance, Reservation) and isinstance(self.instance.resource, Resource): resource = self.instance.resource # set supported and required extra fields if resource: cache = self.context.get('reservation_metadata_set_cache') supported = resource.get_supported_reservation_extra_field_names(cache=cache) required = resource.get_required_reservation_extra_field_names(cache=cache) # staff events have less requirements request_user = self.context['request'].user is_staff_event = data.get('staff_event', False) if is_staff_event and resource.can_create_staff_event(request_user): required = {'reserver_name', 'event_description'} # we don't need to remove a field here if it isn't supported, as it will be read-only and will be more # easily removed in to_representation() for field_name in supported: self.fields[field_name].read_only = False for field_name in required: self.fields[field_name].required = True self.context.update({'resource': resource}) def get_extra_fields(self, includes, context): from .resource import ResourceInlineSerializer """ Define extra fields that can be included via query parameters. Method from ExtraDataMixin.""" extra_fields = {} if 'resource_detail' in includes: extra_fields['resource'] = ResourceInlineSerializer(read_only=True, context=context) return extra_fields def validate_state(self, value): instance = self.instance request_user = self.context['request'].user # new reservations will get their value regardless of this value if not instance: return value # state not changed if instance.state == value: return value if instance.resource.can_approve_reservations(request_user): allowed_states = (Reservation.REQUESTED, Reservation.CONFIRMED, Reservation.DENIED) if instance.state in allowed_states and value in allowed_states: return value if instance.can_modify(request_user) and value == Reservation.CANCELLED: return value raise ValidationError(_('Illegal state change')) def validate(self, data): reservation = self.instance request_user = self.context['request'].user # this check is probably only needed for PATCH try: resource = data['resource'] except KeyError: resource = reservation.resource if not resource.can_make_reservations(request_user): raise PermissionDenied(_('You are not allowed to make reservations in this resource.')) if 'end' in data and data['end'] < timezone.now(): raise ValidationError(_('You cannot make a reservation in the past')) if not resource.can_ignore_opening_hours(request_user): reservable_before = resource.get_reservable_before() if reservable_before and data['begin'] >= reservable_before: raise ValidationError(_('The resource is reservable only before %(datetime)s' % {'datetime': reservable_before})) reservable_after = resource.get_reservable_after() if reservable_after and data['begin'] < reservable_after: raise ValidationError(_('The resource is reservable only after %(datetime)s' % {'datetime': reservable_after})) # normal users cannot make reservations for other people if not resource.can_create_reservations_for_other_users(request_user): data.pop('user', None) # Check user specific reservation restrictions relating to given period. resource.validate_reservation_period(reservation, request_user, data=data) if data.get('staff_event', False): if not resource.can_create_staff_event(request_user): raise ValidationError(dict(staff_event=_('Only allowed to be set by resource managers'))) if 'type' in data: if (data['type'] != Reservation.TYPE_NORMAL and not resource.can_create_special_type_reservation(request_user)): raise ValidationError({'type': _('You are not allowed to make a reservation of this type')}) if 'comments' in data: if not resource.can_comment_reservations(request_user): raise ValidationError(dict(comments=_('Only allowed to be set by staff members'))) if 'access_code' in data: if data['access_code'] is None: data['access_code'] = '' access_code_enabled = resource.is_access_code_enabled() if not access_code_enabled and data['access_code']: raise ValidationError(dict(access_code=_('This field cannot have a value with this resource'))) if access_code_enabled and reservation and data['access_code'] != reservation.access_code: raise ValidationError(dict(access_code=_('This field cannot be changed'))) # Mark begin of a critical section. Subsequent calls with this same resource will block here until the first # request is finished. This is needed so that the validations and possible reservation saving are # executed in one block and concurrent requests cannot be validated incorrectly. Resource.objects.select_for_update().get(pk=resource.pk) # Check maximum number of active reservations per user per resource. # Only new reservations are taken into account ie. a normal user can modify an existing reservation # even if it exceeds the limit. (one that was created via admin ui for example). if reservation is None: resource.validate_max_reservations_per_user(request_user) if self.context['request'] and self.context['request'].method == 'PATCH': for key, val in data.items(): if key not in self.patchable_fields: raise ValidationError(_('Patching of field %(field)s is not allowed' % {'field': key})) else: # Run model clean instance = Reservation(**data) try: instance.clean(original_reservation=reservation, user=request_user) except DjangoValidationError as exc: # Convert Django ValidationError to DRF ValidationError so that in the response # field specific error messages are added in the field instead of in non_field_messages. if not hasattr(exc, 'error_dict'): raise ValidationError(exc) error_dict = {} for key, value in exc.error_dict.items(): error_dict[key] = [error.message for error in value] raise ValidationError(error_dict) return data def to_internal_value(self, data): user_data = data.copy().pop('user', None) # handle user manually deserialized_data = super().to_internal_value(data) # validate user and convert it to User object if user_data: UserSerializer(data=user_data).is_valid(raise_exception=True) try: deserialized_data['user'] = User.objects.get(**{USER_ID_ATTRIBUTE: user_data['id']}) except User.DoesNotExist: raise ValidationError({ 'user': { 'id': [_('Invalid pk "{pk_value}" - object does not exist.').format(pk_value=user_data['id'])] } }) return deserialized_data def to_representation(self, instance): data = super(ReservationSerializer, self).to_representation(instance) resource = instance.resource prefetched_user = self.context.get('prefetched_user', None) user = prefetched_user or self.context['request'].user if self.context['request'].accepted_renderer.format == 'xlsx': # Return somewhat different data in case we are dealing with xlsx. # The excel renderer needs datetime objects, so begin and end are passed as objects # to avoid needing to convert them back and forth. data.update(**{ 'unit': resource.unit.name, # additional 'resource': resource.name, # resource name instead of id 'begin': instance.begin, # datetime object 'end': instance.end, # datetime object 'user': instance.user.email if instance.user else '', # just email 'created_at': instance.created_at }) if not resource.can_access_reservation_comments(user): del data['comments'] if not resource.can_view_reservation_user(user): del data['user'] if instance.are_extra_fields_visible(user): cache = self.context.get('reservation_metadata_set_cache') supported_fields = set(resource.get_supported_reservation_extra_field_names(cache=cache)) else: del data['cancel_reason'] supported_fields = set() for field_name in RESERVATION_EXTRA_FIELDS: if field_name not in supported_fields: data.pop(field_name, None) if not (resource.is_access_code_enabled() and instance.can_view_access_code(user)): data.pop('access_code') if 'access_code' in data and data['access_code'] == '': data['access_code'] = None if instance.can_view_catering_orders(user): data['has_catering_order'] = instance.catering_orders.exists() return data def update(self, instance, validated_data): request = self.context['request'] cancel_reason = validated_data.pop('cancel_reason', None) new_state = validated_data.pop('state', instance.state) validated_data['modified_by'] = request.user reservation = super().update(instance, validated_data) if new_state in [Reservation.DENIED, Reservation.CANCELLED] and cancel_reason: if hasattr(instance, 'cancel_reason'): instance.cancel_reason.delete() cancel_reason['reservation'] = reservation reservation.cancel_reason = ReservationCancelReason(**cancel_reason) reservation.cancel_reason.save() reservation.set_state(new_state, request.user) return reservation def get_is_own(self, obj): return obj.user == self.context['request'].user def get_user_permissions(self, obj): request = self.context.get('request') prefetched_user = self.context.get('prefetched_user', None) user = prefetched_user or request.user can_modify_and_delete = obj.can_modify(user) if request else False return { 'can_modify': can_modify_and_delete, 'can_delete': can_modify_and_delete, } class UserFilterBackend(filters.BaseFilterBackend): """ Filter by user uuid and by is_own. """ def filter_queryset(self, request, queryset, view): user = request.query_params.get('user', None) if user: try: user_uuid = uuid.UUID(user) except ValueError: raise exceptions.ParseError(_('Invalid value in filter %(filter)s') % {'filter': 'user'}) queryset = queryset.filter(user__uuid=user_uuid) if not request.user.is_authenticated: return queryset is_own = request.query_params.get('is_own', None) if is_own is not None: is_own = is_own.lower() if is_own in ('true', 't', 'yes', 'y', '1'): queryset = queryset.filter(user=request.user) elif is_own in ('false', 'f', 'no', 'n', '0'): queryset = queryset.exclude(user=request.user) else: raise exceptions.ParseError(_('Invalid value in filter %(filter)s') % {'filter': 'is_own'}) return queryset class ExcludePastFilterBackend(filters.BaseFilterBackend): """ Exclude reservations in the past. """ def filter_queryset(self, request, queryset, view): past = request.query_params.get('all', 'false') past = BooleanField().to_internal_value(past) if not past: now = timezone.now() return queryset.filter(end__gte=now) return queryset class ReservationFilterBackend(filters.BaseFilterBackend): """ Filter reservations by time. """ def filter_queryset(self, request, queryset, view): params = request.query_params times = {} past = False for name in ('start', 'end'): if name not in params: continue # whenever date filtering is in use, include past reservations past = True try: times[name] = arrow.get(params[name]).to('utc').datetime except ParserError: raise exceptions.ParseError("'%s' must be a timestamp in ISO 8601 format" % name) is_detail_request = 'pk' in request.parser_context['kwargs'] if not past and not is_detail_request: past = params.get('all', 'false') past = BooleanField().to_internal_value(past) if not past: now = timezone.now() queryset = queryset.filter(end__gte=now) if times.get('start', None): queryset = queryset.filter(end__gte=times['start']) if times.get('end', None): queryset = queryset.filter(begin__lte=times['end']) return queryset class NeedManualConfirmationFilterBackend(filters.BaseFilterBackend): def filter_queryset(self, request, queryset, view): filter_value = request.query_params.get('need_manual_confirmation', None) if filter_value is not None: need_manual_confirmation = BooleanField().to_internal_value(filter_value) return queryset.filter(resource__need_manual_confirmation=need_manual_confirmation) return queryset class StateFilterBackend(filters.BaseFilterBackend): def filter_queryset(self, request, queryset, view): state = request.query_params.get('state', None) if state: queryset = queryset.filter(state__in=state.replace(' ', '').split(',')) return queryset class CanApproveFilterBackend(filters.BaseFilterBackend): def filter_queryset(self, request, queryset, view): filter_value = request.query_params.get('can_approve', None) if filter_value: queryset = queryset.filter(resource__need_manual_confirmation=True) allowed_resources = Resource.objects.with_perm('can_approve_reservation', request.user) can_approve = BooleanField().to_internal_value(filter_value) if can_approve: queryset = queryset.filter(resource__in=allowed_resources) else: queryset = queryset.exclude(resource__in=allowed_resources) return queryset class ReservationFilterSet(django_filters.rest_framework.FilterSet): class Meta: model = Reservation fields = ('event_subject', 'host_name', 'reserver_name', 'resource_name', 'is_favorite_resource', 'unit') @property def qs(self): qs = super().qs user = self.request.user query_params = set(self.request.query_params) # if any of the extra field related filters are used, restrict results to reservations # the user has right to see if bool(query_params & set(RESERVATION_EXTRA_FIELDS)): qs = qs.extra_fields_visible(user) if 'has_catering_order' in query_params: qs = qs.catering_orders_visible(user) return qs event_subject = django_filters.CharFilter(lookup_expr='icontains') host_name = django_filters.CharFilter(lookup_expr='icontains') reserver_name = django_filters.CharFilter(lookup_expr='icontains') resource_name = django_filters.CharFilter(field_name='resource', lookup_expr='name__icontains') is_favorite_resource = django_filters.BooleanFilter(method='filter_is_favorite_resource', widget=DRFFilterBooleanWidget) resource_group = django_filters.Filter(field_name='resource__groups__identifier', lookup_expr='in', widget=django_filters.widgets.CSVWidget, distinct=True) unit = django_filters.CharFilter(field_name='resource__unit_id') has_catering_order = django_filters.BooleanFilter(method='filter_has_catering_order', widget=DRFFilterBooleanWidget) resource = django_filters.Filter(lookup_expr='in', widget=django_filters.widgets.CSVWidget) reserver_info_search = django_filters.CharFilter(method="filter_reserver_info_search") def filter_is_favorite_resource(self, queryset, name, value): user = self.request.user if not user.is_authenticated: return queryset.none() if value else queryset filtering = {'resource__favorited_by': user} return queryset.filter(**filtering) if value else queryset.exclude(**filtering) def filter_has_catering_order(self, queryset, name, value): return queryset.exclude(catering_orders__isnull=value) def filter_reserver_info_search(self, queryset, name, value): """ A partial copy of rest_framework.filters.SearchFilter.filter_queryset. Needed due to custom filters applied to queryset within this ReservationFilterSet. Does not support comma separation of values, i.e. '?reserver_info_search=foo,bar' will be considered as one string - 'foo,bar'. """ if not value: return queryset fields = ('user__first_name', 'user__last_name', 'user__email') conditions = [] for field in fields: conditions.append(Q(**{field + '__icontains': value})) # assume that first_name and last_name were provided if empty space was found if ' ' in value and value.count(' ') == 1: name1, name2 = value.split() filters = Q( user__first_name__icontains=name1, user__last_name__icontains=name2, ) | Q( user__first_name__icontains=name2, user__last_name__icontains=name1, ) conditions.append(filters) return queryset.filter(reduce(operator.or_, conditions)) class ReservationPermission(permissions.BasePermission): def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: return True return obj.can_modify(request.user) class ReservationExcelRenderer(renderers.BaseRenderer): media_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' format = 'xlsx' charset = None render_style = 'binary' def render(self, data, media_type=None, renderer_context=None): if not renderer_context or renderer_context['response'].status_code == 404: return bytes() if renderer_context['view'].action == 'retrieve': return generate_reservation_xlsx([data]) elif renderer_context['view'].action == 'list': return generate_reservation_xlsx(data['results']) else: return NotAcceptable() class ReservationCacheMixin: def _preload_permissions(self): units = set() resource_groups = set() resources = set() checker = ObjectPermissionChecker(self.request.user) for rv in self._page: resources.add(rv.resource) rv.resource._permission_checker = checker for res in resources: units.add(res.unit) for g in res.groups.all(): resource_groups.add(g) if units: checker.prefetch_perms(units) if resource_groups: checker.prefetch_perms(resource_groups) def _get_cache_context(self): context = {} set_list = ReservationMetadataSet.objects.all().prefetch_related('supported_fields', 'required_fields') context['reservation_metadata_set_cache'] = {x.id: x for x in set_list} self._preload_permissions() return context class ReservationViewSet(munigeo_api.GeoModelAPIView, viewsets.ModelViewSet, ReservationCacheMixin): queryset = Reservation.objects.select_related('user', 'resource', 'resource__unit')\ .prefetch_related('catering_orders').prefetch_related('resource__groups').order_by('begin', 'resource__unit__name', 'resource__name') if settings.RESPA_PAYMENTS_ENABLED: queryset = queryset.prefetch_related('order', 'order__order_lines', 'order__order_lines__product') filter_backends = (DjangoFilterBackend, filters.OrderingFilter, UserFilterBackend, ReservationFilterBackend, NeedManualConfirmationFilterBackend, StateFilterBackend, CanApproveFilterBackend) filterset_class = ReservationFilterSet permission_classes = (permissions.IsAuthenticatedOrReadOnly, ReservationPermission) renderer_classes = (renderers.JSONRenderer, ResourcesBrowsableAPIRenderer, ReservationExcelRenderer) pagination_class = ReservationPagination authentication_classes = ( list(drf_settings.DEFAULT_AUTHENTICATION_CLASSES) + [TokenAuthentication, SessionAuthentication]) ordering_fields = ('begin',) def get_serializer_class(self): if settings.RESPA_PAYMENTS_ENABLED: from payments.api.reservation import PaymentsReservationSerializer # noqa return PaymentsReservationSerializer else: return ReservationSerializer def get_serializer(self, *args, **kwargs): if 'data' not in kwargs and len(args) == 1: # It's a read operation instance_or_page = args[0] if isinstance(instance_or_page, Reservation): self._page = [instance_or_page] else: self._page = instance_or_page return super().get_serializer(*args, **kwargs) def get_serializer_context(self, *args, **kwargs): context = super().get_serializer_context(*args, **kwargs) if hasattr(self, '_page'): context.update(self._get_cache_context()) request_user = self.request.user if request_user.is_authenticated: prefetched_user = get_user_model().objects.prefetch_related('unit_authorizations', 'unit_group_authorizations__subject__members').\ get(pk=request_user.pk) context['prefetched_user'] = prefetched_user return context def get_queryset(self): queryset = super().get_queryset() user = self.request.user # General Administrators can see all reservations if is_general_admin(user): return queryset # normal users can see only their own reservations and reservations that are confirmed, requested or # waiting for payment filters = Q(state__in=(Reservation.CONFIRMED, Reservation.REQUESTED, Reservation.WAITING_FOR_PAYMENT)) if user.is_authenticated: filters |= Q(user=user) queryset = queryset.filter(filters) queryset = queryset.filter(resource__in=Resource.objects.visible_for(user)) return queryset def perform_create(self, serializer): override_data = {'created_by': self.request.user, 'modified_by': self.request.user} if 'user' not in serializer.validated_data: override_data['user'] = self.request.user override_data['state'] = Reservation.CREATED instance = serializer.save(**override_data) resource = serializer.validated_data['resource'] if resource.need_manual_confirmation and not resource.can_bypass_manual_confirmation(self.request.user): new_state = Reservation.REQUESTED else: if instance.get_order(): new_state = Reservation.WAITING_FOR_PAYMENT else: new_state = Reservation.CONFIRMED instance.set_state(new_state, self.request.user) def perform_destroy(self, instance): instance.set_state(Reservation.CANCELLED, self.request.user) def list(self, request, *args, **kwargs): response = super().list(request, *args, **kwargs) if request.accepted_renderer.format == 'xlsx': response['Content-Disposition'] = 'attachment; filename={}.xlsx'.format(_('reservations')) return response def retrieve(self, request, *args, **kwargs): response = super().retrieve(request, *args, **kwargs) if request.accepted_renderer.format == 'xlsx': response['Content-Disposition'] = 'attachment; filename={}-{}.xlsx'.format(_('reservation'), kwargs['pk']) return response class ReservationCancelReasonCategoryViewSet(viewsets.ReadOnlyModelViewSet): queryset = ReservationCancelReasonCategory.objects.all() filter_backends = (DjangoFilterBackend,) serializer_class = ReservationCancelReasonCategorySerializer filterset_fields = ['reservation_type'] pagination_class = None register_view(ReservationViewSet, 'reservation') register_view(ReservationCancelReasonCategoryViewSet, 'cancel_reason_category')
the-stack_0_3429
#!/usr/bin/env python from pyscf import gto, scf, dft from pyscf.prop import hfc mol = gto.M(atom=''' C 0 0 0 N 0 0 1.1747 ''', basis='ccpvdz', spin=1, charge=0, verbose=3) mf = scf.UHF(mol).run() gobj = hfc.uhf.HFC(mf).set(verbose=4) gobj.sso = True gobj.soo = True gobj.so_eff_charge = False gobj.kernel()
the-stack_0_3431
from orbit_fits import * def ref_frame(): """Print properties of the reference frame""" print(gc_frame) def potentials(): """Print properties of the gravitational potentials used""" pot = [ham, ham_bovy, ham_heavy] name = ['fiducial', 'bovy', 'heavy'] #pos = np.array([[0, 0, 25], [0,0,200]]).T * u.kpc pos = np.array([[25, 0, 0], [200,0,0]]).T * u.kpc mass = np.zeros((3,2)) * u.Msun for e, p in enumerate(pot): print(name[e]) # potential parameters keys = p.potential.parameters.keys() for k in keys: print(k, p.potential.parameters[k]) # enclosed mass mass[e] = p.potential.mass_enclosed(pos) print(mass[e]) print(mass[0]) print(mass[1]/mass[0]) print(mass[2]/mass[0]) def plot_enclosed_mass(): """Plot the ratio of enclosed mass for the adopted potentials""" pot = [ham, ham_bovy, ham_heavy] name = ['Fiducial', 'MWPotential2014', 'Price-Whelan & Bonaca (2018)'] colors = ['k', 'tab:blue', 'tab:red'] pos = np.zeros((3,100)) * u.kpc pos[0] = np.logspace(np.log10(20./100.), np.log10(20*10.), pos.shape[1]) * u.kpc mass = np.zeros((3,100)) for e, p in enumerate(pot): mass[e] = p.potential.mass_enclosed(pos) plt.close() plt.figure(figsize=(8,6)) for i in range(3): plt.plot(pos[0], mass[i]/mass[0], '-', color=colors[i], label=name[i]) plt.axvline(25, color='k', ls=':') plt.legend(fontsize='small', loc=0) plt.ylim(0.7, 1.3) plt.xlim(0,200) plt.xlabel('r [kpc]') plt.ylabel('M(<r) / M$_{fid}$(<r)') plt.tight_layout() plt.savefig('../plots/response/enclosed_mass_potentials.png')
the-stack_0_3433
# -*- coding: utf-8 -*- # Copyright (c) St. Anne's University Hospital in Brno. International Clinical # Research Center, Biomedical Engineering. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # Std imports # Third pary imports import numpy as np # Local imports from ..utils.method import Method def compute_lincorr(sig, lag=0, lag_step=0): """ Linear correlation (Pearson's coefficient) between two time series When lag and lag_step is not 0, shifts the sig[1] from negative to positive lag and takes the max correlation (best fit) Parameters ---------- sig: np.array 2D numpy array of shape (signals, samples), time series (int, float) lag: int negative and positive shift of time series in samples lag_step: int step of shift Returns ------- lincorr: list maximum linear correlation in shift tau: float shift of maximum correlation in samples, value in range <-lag,+lag> (float) tau<0: sig[1] -> sig[0] tau>0: sig[0] -> sig[1] Example ------- lincorr,tau = compute_lincorr(sig, 200, 20) """ if type(sig) != np.ndarray: raise TypeError(f"Signals have to be in numpy arrays!") if lag == 0: lag_step = 1 nstep_lag = int(lag * 2 / lag_step) sig1_w = sig[0] sig2_w = sig[1] sig1_wl = sig1_w[lag:len(sig1_w) - lag] lincorr = [] for i in range(0, nstep_lag + 1): ind1 = i * lag_step ind2 = ind1 + len(sig1_wl) sig2_wl = sig2_w[ind1:ind2] corr_val = np.corrcoef(sig1_wl, sig2_wl) lincorr.append(corr_val[0][1]) return np.max(lincorr), lincorr.index(max(lincorr)) class LinearCorrelation(Method): algorithm = 'LINEAR_CORRELATION' algorithm_type = 'bivariate' version = '1.0.0' dtype = [('max_corr', 'float32'), ('tau', 'float32')] def __init__(self, **kwargs): """ Linear correlation (Pearson's coefficient) between two time series When win and win_step is not 0, calculates evolution of correlation When win>len(sig) or win<=0, calculates only one corr coef When lag and lag_step is not 0, shifts the sig[1] from negative to positive lag and takes the max correlation (best fit) Parameters ---------- lag: int negative and positive shift of time series in samples lag_step: int step of shift """ super().__init__(compute_lincorr, **kwargs)
the-stack_0_3434
#!/usr/bin/env python3 """ Tests of ktrain text classification flows """ import testenv import numpy as np from unittest import TestCase, main, skip import ktrain from ktrain.imports import ACC_NAME, VAL_ACC_NAME from ktrain import utils as U Sequential = ktrain.imports.keras.models.Sequential Dense = ktrain.imports.keras.layers.Dense Embedding = ktrain.imports.keras.layers.Embedding GlobalAveragePooling1D = ktrain.imports.keras.layers.GlobalAveragePooling1D def synthetic_multilabel(): # data X = [[1,0,0,0,0,0,0], [1,2,0,0,0,0,0], [3,0,0,0,0,0,0], [3,4,0,0,0,0,0], [2,0,0,0,0,0,0], [3,0,0,0,0,0,0], [4,0,0,0,0,0,0], [2,3,0,0,0,0,0], [1,2,3,0,0,0,0], [1,2,3,4,0,0,0], [0,0,0,0,0,0,0], [1,1,2,3,0,0,0], [2,3,3,4,0,0,0], [4,4,1,1,2,0,0], [1,2,3,3,3,3,3], [2,4,2,4,2,0,0], [1,3,3,3,0,0,0], [4,4,0,0,0,0,0], [3,3,0,0,0,0,0], [1,1,4,0,0,0,0]] Y = [[1,0,0,0], [1,1,0,0], [0,0,1,0], [0,0,1,1], [0,1,0,0], [0,0,1,0], [0,0,0,1], [0,1,1,0], [1,1,1,0], [1,1,1,1], [0,0,0,0], [1,1,1,0], [0,1,1,1], [1,1,0,1], [1,1,1,0], [0,1,0,0], [1,0,1,0], [0,0,0,1], [0,0,1,0], [1,0,0,1]] X = np.array(X) Y = np.array(Y) return (X, Y) class TestMultilabel(TestCase): def test_multilabel(self): X, Y = synthetic_multilabel() self.assertTrue(U.is_multilabel( (X,Y))) MAXLEN = 7 MAXFEATURES = 4 NUM_CLASSES = 4 model = Sequential() model.add(Embedding(MAXFEATURES+1, 50, input_length=MAXLEN)) model.add(GlobalAveragePooling1D()) model.add(Dense(NUM_CLASSES, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) learner = ktrain.get_learner(model, train_data=(X, Y), val_data=(X, Y), batch_size=1) learner.lr_find(max_epochs=5) # use max_epochs until TF 2.4 # use loss instead of accuracy due to: https://github.com/tensorflow/tensorflow/issues/41114 hist = learner.fit(0.001, 200) learner.view_top_losses(n=5) learner.validate() #final_acc = hist.history[VAL_ACC_NAME][-1] #print('final_accuracy:%s' % (final_acc)) #self.assertGreater(final_acc, 0.97) final_loss = hist.history['val_loss'][-1] print('final_loss:%s' % (final_loss)) self.assertLess(final_loss, 0.05) if __name__ == "__main__": main()
the-stack_0_3435
#!/usr/bin/env python3 import pytest import sys import fileinput from os.path import splitext, abspath F_NAME = splitext(abspath(__file__))[0][:-1] def answer(lines): tot = 0 for line in map(str.strip, lines): print(line) l, w, h = map(int, line.split('x')) sides = [] sides.append(l*w) sides.append(w*h) sides.append(h*l) print(sides) tot += 2*sum(sides) + min(sides) #add smallest side as slack return tot @pytest.mark.parametrize( "inp,outp", [ (['2x3x4'], 58), (['1x1x10'], 43), ]) def test_answer(inp, outp): assert answer(inp) == outp if __name__ == '__main__': print(answer(fileinput.input(F_NAME + '.input')))
the-stack_0_3437
#!/usr/bin/env python import rospy import math from geometry_msgs.msg import Twist from sensor_msgs.msg import LaserScan from std_msgs.msg import Float32 from kobuki_msgs.msg import BumperEvent from kobuki_msgs.msg import CliffEvent import sys, select, termios, tty range_center = Float32() range_left = Float32() range_right = Float32() range_left_last = Float32() range_right_last = Float32() turnAngle = 17 backUpDistance = 6 speed = 0.5 def callback(data): #rospy.loginfo("Center: %f", data.ranges[359]) #rospy.loginfo("Left: %f", data.ranges[180]) #rospy.loginfo("Right: %f", data.ranges[540]) range_center.data = data.ranges[359] range_left.data = data.ranges[180] range_right.data = data.ranges[540] def processBump(data): print ("Bump!") global bp global which_bp if (data.state == BumperEvent.PRESSED): bp = True else: bp = False rospy.loginfo("Bumper Event") rospy.loginfo(data.bumper) which_bp = data.bumper def processCliff(data): print ("Cliff!") global cf global which_cf global dis if (data.state == CliffEvent.CLIFF): cf = True else: cf = False rospy.loginfo("Cliff Event") rospy.loginfo(data.sensor) which_cf = data.sensor dis = data.bottom def set_normal_speed(): twist.linear.x = speed twist.linear.y, twist.linear.z = 0, 0 twist.angular.x, twist.angular.y = 0, 0 twist.angular.z = 0 def turn_left(): twist.linear.x = 0 twist.linear.y, twist.linear.z = 0, 0 twist.angular.x, twist.angular.y = 0, 0 twist.angular.z = 1 * speed def turn_right(): twist.linear.x = 0 twist.linear.y, twist.linear.z = 0, 0 twist.angular.x, twist.angular.y = 0, 0 twist.angular.z = -1 * speed def set_backup_speed(): twist.linear.x = -1 * speed twist.linear.y, twist.linear.z = 0, 0 twist.angular.x, twist.angular.y = 0, 0 twist.angular.z = 0 # mode = {'forward', 'backup', 'turnLeft', 'turnRight'} def move(): pub = rospy.Publisher('mobile_base/commands/velocity', Twist, queue_size = 20) sub1 = rospy.Subscriber("scan", LaserScan, callback) sub2 = rospy.Subscriber('mobile_base/events/bumper', BumperEvent, processBump) sub3 = rospy.Subscriber('mobile_base/events/cliff', CliffEvent, processCliff) rospy.init_node('test', anonymous = True) rate = rospy.Rate(10) # 10HZ global twist, mode, cf, which_cf, which_bp, dis, bp cf = False which_cf = 0 which_bp = 0 twist = Twist() left, right, bp = False, False, False mode = 'Forward' BackupCounter = 0 TurnRightCounter, TurnLeftCounter = 0, 0 ignoreCliff = False while not rospy.is_shutdown(): if (mode == 'Forward'): set_normal_speed() elif (mode == 'Backup'): ignoreCliff = True set_backup_speed() BackupCounter += 1 elif (mode == 'TurnLeft'): ignoreCliff = False left = False turn_left() TurnLeftCounter += 1 elif (mode == 'TurnRight'): ignoreCliff = False right = False turn_right() TurnRightCounter += 1 pub.publish(twist) if (left and BackupCounter > backUpDistance): BackupCounter = 0 mode = 'TurnLeft' if (right and BackupCounter > backUpDistance): BackupCounter = 0 mode = 'TurnRight' if (TurnRightCounter > turnAngle): TurnRightCounter = 0 mode = 'Forward' if (TurnLeftCounter > turnAngle): TurnLeftCounter = 0 mode = 'Forward' # if (range_center.data > 1 and not mode == 'Backup' and not mode == 'TurnLeft' and not mode == 'TurnRight'): # if (range_left.data < 0.2): # mode = 'Backup' # if (not right and not left): # BackupCounter = 0 # right, left = True, False # elif (range_right.data < 0.2): # mode = 'Backup' # if (not right and not left): # BackupCounter = 0 # right, left = False, True # elif (range_center.data < 1 and range_center.data > 0.001): # mode = 'Backup' # if (not right and not left): # BackupCounter = 0 # right, left = False, True if (not ignoreCliff and cf and which_cf == 0): if (dis < 50000): which_cf = 0 mode = 'Backup' print("left cliff") if (not right and not left): BackupCounter = 0 right, left = True, False elif (not ignoreCliff and cf and (which_cf == 2 or which_cf == 1)): if (dis < 50000): which_cf = 0 print("right cliff") mode = 'Backup' if (not right and not left): BackupCounter = 0 right, left = False, True if (bp and which_bp == 0): which_bp = 0 mode = 'Backup' print("left bump") if (not right and not left): BackupCounter = 0 right, left = True, False elif (bp and (which_bp == 2 or which_bp == 1)): which_bp = 0 print("right bump") mode = 'Backup' if (not right and not left): BackupCounter = 0 right, left = False, True print(mode) rate.sleep() if __name__ == '__main__': try: move() except rospy.ROSInterruptException: pass
the-stack_0_3438
import numpy as np import pandas as pd import os import sqlalchemy from time import sleep import pickle from numbers import Number def serialize(x): if not isinstance(x, (str, Number)): return pickle.dumps(x) else: return x def unserialize(x): if not isinstance(x, (str, Number)): return pickle.loads(x) else: return x class ScanStoreSQL(object): """Generic SQLite parameter scan store.""" def __init__(self, scanname, scanid=1, datadir=None): self.scanname = scanname self.scanid = scanname if datadir is None: datadir = os.getcwd() self.datadir = datadir _filename = '{}_{}.sqlite'.format(scanname, scanid) self.filename = os.path.join(self.datadir, _filename) @property def engine(self): return sqlalchemy.create_engine('sqlite:///' + self.filename) def store_df(self, key, df, append=True, **kwargs): """Store a Pandas DataFrame in a table.""" if_exists = 'append' if append else 'replace' while True: try: df.applymap(serialize).to_sql(key, self.engine, if_exists=if_exists) break except sqlalchemy.exc.OperationalError: sleep(0.001) def store_row(self, key, array, index=0, columns=None, append=True, **kwargs): """Store a numpy array or a list in a table.""" df = pd.DataFrame([array], columns=columns, index=(index,)) self.store_df(key, df, append=append) def store_dict(self, key, dict, index=0, append=True, **kwargs): """Store a dictionary in a table.""" self.store_row(key, array=list(dict.values()), index=index, columns=list(dict.keys()), **kwargs) def store_array(self, key, array, index=None, columns=None, append=True, **kwargs): """Store a numpy array in a table.""" df = pd.DataFrame(array, columns=columns, index=index, dtype=complex) self.store_df(key, df, append=append) def get(self, key): """Return a DataFrame for a given key (table name).""" while True: try: with self.engine.connect() as conn, conn.begin(): data = pd.read_sql_table(key, conn) break except sqlalchemy.exc.OperationalError: sleep(0.001) data = data.set_index('index') return data.applymap(unserialize) def drop_table(self, key): """Delete (drop) a table""" pd.io.sql.execute('DROP TABLE {};'.format(key), self.engine) def read_sql(self, sql): """Read SQL query into a data frame.""" return pd.io.sql.read_sql(sql, self.engine)
the-stack_0_3440
import socket host = '127.0.0.1' port = 80 client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client.sendto(b'AAABBBCCC', (host, port)) data, addr = client.recvfrom(4096) print(data)
the-stack_0_3441
#!/usr/bin/env python3 import operator from collections import Counter def read_pt_br_words(filename='/usr/share/dict/brazilian'): with open(filename) as f: lines = list(f) words = [line[:-1] for line in lines] print(f"Leu {len(words)} palavras em pt-BR") return words def make_sbk_table(words): c = Counter() for word in words: c.update(word) chars = sorted(c.keys()) print(f"Tabela SBK ({len(chars)} caracteres): {''.join(chars)}") return {ch: i for i, ch in enumerate(chars)} def _sbk(text, char_to_int=ord): s = 0 for ch in text: s += char_to_int(ch) return {'text': text, 'sum': s, 'sbk': s % 1000} def _show_sbk(text, char_to_int=ord): info = _sbk(text, char_to_int) print(f'Texto: {info["text"]!r}') print(f'Soma: {info["sum"]}') print(f'SBK: {info["sbk"]:03d}') print() tweet = """Uma função hash bem simples para um trecho de texto é "Atribua um valor pra cada caractere, some todos, e pegue os últimos 3 dígitos" Vamos chamar essa função de SBK (Soma do Bruno Kim). Ela produz, pra qualquer texto, um número entre 000 e 999.""" def main(): words = read_pt_br_words() table = make_sbk_table(words) def char_to_int(ch): if ch in table: return table[ch] + 1 return ord(ch) + len(table) + 1 def sbk(text): return _sbk(text, char_to_int) def show_sbk(text): return _show_sbk(text, char_to_int) print() show_sbk(tweet) show_sbk("patos") show_sbk("nadam") show_sbk("debaixo") show_sbk("d'água") from collections import Counter sbk_infos = [sbk(word) for word in words] sums = Counter(info['sum'] for info in sbk_infos) hashes = Counter(info['sbk'] for info in sbk_infos) import csv with open('sbk-sum-freq.csv', 'w') as f: w = csv.writer(f) w.writerow(['sum', 'freq']) for i in range(max(sums)+1): w.writerow([i, sums[i]]) with open('sbk-freq.csv', 'w') as f: w = csv.writer(f) w.writerow(['hash', 'freq']) for i in range(1000): w.writerow([i, hashes[i]]) cum = 0 by_freq = sorted(hashes.items(), reverse=True, key=lambda entry: entry[1]) for i, (h, freq) in enumerate(by_freq): #print(f"{h:03d}: {freq} (cum={cum:06d})") cum += freq if cum > len(words)/2: print(f"{i} hashes ocupam >50% de todas as palavras") break print() print("SBK:") print(f" patos: {sbk('patos')['sbk']:03d}") print(f" patas: {sbk('patas')['sbk']:03d}") print(f" pat: {sbk('pat')['sbk']:03d}") print(f" patoso: {sbk('patoso')['sbk']:03d}") words_201 = [word for word, info in zip(words, sbk_infos) if info['sbk'] == 201] smallest_201 = sorted(words_201, key = lambda s: len(s))[:200] print(smallest_201) import hashlib def sha256(text): m = hashlib.sha256() m.update(text.encode("utf-8")) x = 0 for b in m.digest(): x = 256*x + b return x print() print("SHA-256:") print(f" patos: {sha256('patos'):076d}") print(f" patas: {sha256('patas'):076d}") print(f" pat: {sha256('pat'):076d}") print(f" patoso: {sha256('patoso'):076d}") if __name__ == '__main__': main()
the-stack_0_3442
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from setuptools import setup name_ = 'lindh-jsonobject' github_name = 'jsonobject' version_ = '1.4.0' packages_ = [ 'lindh.jsonobject', ] with open("README.rst", "r") as fh: long_description = fh.read() classifiers = [ "Programming Language :: Python :: 3", "Operating System :: OS Independent", "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", ] setup( name=name_, version=version_, author='Johan Egneblad', author_email='[email protected]', description='JSON serializable objects', long_description=long_description, long_description_content_type="text/x-rst", license="MIT", url='https://github.com/eblade/'+github_name, download_url=('https://github.com/eblade/%s/archive/v%s.tar.gz' % (github_name, version_)), packages=packages_, install_requires=[], classifiers=classifiers, )
the-stack_0_3443
import pandas as pd def get_density(s, T): try: s = s.replace('%20', '+') except: pass density_url = 'http://ddbonline.ddbst.de/DIPPR105DensityCalculation/DIPPR105CalculationCGI.exe?component=' + s if s == 'Hexane': rho = float(655) else: density = pd.read_html(density_url)[6] density = density.drop(density.index[0:3]).drop('No.', axis=1) A = float(density['A']) B = float(density['B']) C = float(density['C']) D = float(density['D']) Tmin, Tmax = float(density['Tmin']), float(density['Tmax']) # in K def rho(T): return A / B ** (1 + (1 - T / C) ** D) return rho(T) if s != 'Hexane' else rho
the-stack_0_3444
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved import logging from typing import Optional, Sequence from hydra.core.utils import JobReturn from hydra.plugins.launcher import Launcher from hydra.types import HydraContext, TaskFunction from omegaconf import DictConfig from hydra_plugins.hydra_ray_launcher._config import ( # type: ignore RayAWSConf, RsyncConf, ) log = logging.getLogger(__name__) class RayAWSLauncher(Launcher): def __init__( self, env_setup: DictConfig, ray: RayAWSConf, stop_cluster: bool, sync_up: RsyncConf, sync_down: RsyncConf, ) -> None: self.ray_cfg = ray self.stop_cluster = stop_cluster self.sync_up = sync_up self.sync_down = sync_down self.config: Optional[DictConfig] = None self.hydra_context: Optional[HydraContext] = None self.task_function: Optional[TaskFunction] = None self.ray_yaml_path: Optional[str] = None self.env_setup = env_setup def setup( self, *, hydra_context: HydraContext, task_function: TaskFunction, config: DictConfig, ) -> None: self.config = config self.hydra_context = hydra_context self.task_function = task_function def launch( self, job_overrides: Sequence[Sequence[str]], initial_job_idx: int ) -> Sequence[JobReturn]: from . import _core_aws return _core_aws.launch( launcher=self, job_overrides=job_overrides, initial_job_idx=initial_job_idx )
the-stack_0_3447
# -*- coding: utf-8 -*- import logging import operator from pymongo.errors import DuplicateKeyError, BulkWriteError import pymongo from anytree import RenderTree, Node, search, resolver from anytree.exporter import DictExporter from scout.exceptions import IntegrityError LOG = logging.getLogger(__name__) class HpoHandler(object): def load_hpo_term(self, hpo_obj): """Add a hpo object Arguments: hpo_obj(dict) """ LOG.debug("Loading hpo term %s into database", hpo_obj["_id"]) try: self.hpo_term_collection.insert_one(hpo_obj) except DuplicateKeyError as err: raise IntegrityError("Hpo term %s already exists in database".format(hpo_obj["_id"])) LOG.debug("Hpo term saved") def load_hpo_bulk(self, hpo_bulk): """Add a hpo object Arguments: hpo_bulk(list(scout.models.HpoTerm)) Returns: result: pymongo bulkwrite result """ LOG.debug("Loading hpo bulk") try: result = self.hpo_term_collection.insert_many(hpo_bulk) except (DuplicateKeyError, BulkWriteError) as err: raise IntegrityError(err) return result def hpo_term(self, hpo_id): """Fetch a hpo term Args: hpo_id(str) Returns: hpo_obj(dict) """ LOG.debug("Fetching hpo term %s", hpo_id) return self.hpo_term_collection.find_one({"_id": hpo_id}) def hpo_terms(self, query=None, hpo_term=None, text=None, limit=None): """Return all HPO terms If a query is sent hpo_terms will try to match with regex on term or description. Args: query(str): Part of a hpoterm or description hpo_term(str): Search for a specific hpo term limit(int): the number of desired results Returns: result(pymongo.Cursor): A cursor with hpo terms """ query_dict = {} search_term = None if query: query_dict = { "$or": [ {"hpo_id": {"$regex": query, "$options": "i"}}, {"description": {"$regex": query, "$options": "i"}}, ] } search_term = query elif text: new_string = "" for i, word in enumerate(text.split(" ")): if i == 0: new_string += word else: new_string += ' "{0}"'.format(word) LOG.info("Search HPO terms with %s", new_string) query_dict["$text"] = {"$search": new_string} search_term = text elif hpo_term: query_dict["hpo_id"] = hpo_term search_term = hpo_term limit = limit or 0 res = ( self.hpo_term_collection.find(query_dict) .limit(limit) .sort("hpo_number", pymongo.ASCENDING) ) return res def generate_hpo_gene_list(self, *hpo_terms): """Generate a sorted list with namedtuples of hpogenes Each namedtuple of the list looks like (hgnc_id, count) Args: hpo_terms(iterable(str)) Returns: hpo_genes(list(HpoGene)) """ genes = {} for term in hpo_terms: hpo_obj = self.hpo_term(term) if hpo_obj: for hgnc_id in hpo_obj["genes"]: if hgnc_id in genes: genes[hgnc_id] += 1 else: genes[hgnc_id] = 1 else: LOG.warning("Term %s could not be found", term) sorted_genes = sorted(genes.items(), key=operator.itemgetter(1), reverse=True) return sorted_genes def organize_tree(self, all_terms, root): """Organizes a set of Tree node objects into a tree, according to their ancestors and children Args: all_terms(dict): a dictionary with "term_name" as keys and term_dict as values root(anytree.Node) Returns root(anytree.Node): the updated root node of the tree """ # Move tree nodes in the right position according to the ontology for key, term in all_terms.items(): ancestors = term["ancestors"] if len(ancestors) == 0: continue for ancestor in ancestors: ancestor_node = search.find_by_attr(root, ancestor) if ancestor_node is None: # It's probably the term on the top continue node = search.find_by_attr(root, key) node.parent = ancestor_node return root def build_phenotype_tree(self, hpo_id): """Creates an HPO Tree based on one or more given ancestors Args: hpo_id(str): an HPO term Returns: tree_dict(dict): a tree of all HPO children of the given term, as a dictionary """ root = Node(id="root", name="root", parent=None) all_terms = {} unique_terms = set() def _hpo_terms_list(hpo_ids): for term_id in hpo_ids: term_obj = self.hpo_term(term_id) if term_obj is None: continue # sort term children by ascending HPO number children = sorted( term_obj["children"], key=lambda x: int("".join([i for i in x if i.isdigit()])) ) term_obj["children"] = children all_terms[term_id] = term_obj if term_id not in unique_terms: node = Node(term_id, parent=root, description=term_obj["description"]) unique_terms.add(term_id) # recursive loop to collect children, children of children and so on _hpo_terms_list(term_obj["children"]) # compile a list of all HPO term objects to include in the submodel _hpo_terms_list([hpo_id]) # trigger the recursive loop to collect nested HPO terms # rearrange tree according to the HPO ontology root = self.organize_tree(all_terms, root) node_resolver = resolver.Resolver("name") # Extract a tree structure having the chosen HPO term (hpo_id) as ancestor of all the children terms term_node = node_resolver.get(root, hpo_id) LOG.info(f"Built ontology for HPO term:{hpo_id}:\n{RenderTree(term_node)}") exporter = DictExporter() # Export this tree structure as dictionary, so that can be saved in database tree_dict = exporter.export(term_node) return tree_dict
the-stack_0_3448
from __future__ import unicode_literals, absolute_import import io import os import re import abc import csv import sys import zipp import operator import functools import itertools import collections from ._compat import ( install, NullFinder, ConfigParser, suppress, map, FileNotFoundError, IsADirectoryError, NotADirectoryError, PermissionError, pathlib, PYPY_OPEN_BUG, ModuleNotFoundError, MetaPathFinder, email_message_from_string, ensure_is_path, ) from importlib import import_module from itertools import starmap __metaclass__ = type __all__ = [ 'Distribution', 'DistributionFinder', 'PackageNotFoundError', 'distribution', 'distributions', 'entry_points', 'files', 'metadata', 'requires', 'version', ] class PackageNotFoundError(ModuleNotFoundError): """The package was not found.""" class EntryPoint(collections.namedtuple('EntryPointBase', 'name value group')): """An entry point as defined by Python packaging conventions. See `the packaging docs on entry points <https://packaging.python.org/specifications/entry-points/>`_ for more information. """ pattern = re.compile( r'(?P<module>[\w.]+)\s*' r'(:\s*(?P<attr>[\w.]+))?\s*' r'(?P<extras>\[.*\])?\s*$' ) """ A regular expression describing the syntax for an entry point, which might look like: - module - package.module - package.module:attribute - package.module:object.attribute - package.module:attr [extra1, extra2] Other combinations are possible as well. The expression is lenient about whitespace around the ':', following the attr, and following any extras. """ def load(self): """Load the entry point from its definition. If only a module is indicated by the value, return that module. Otherwise, return the named object. """ match = self.pattern.match(self.value) module = import_module(match.group('module')) attrs = filter(None, (match.group('attr') or '').split('.')) return functools.reduce(getattr, attrs, module) @property def extras(self): match = self.pattern.match(self.value) return list(re.finditer(r'\w+', match.group('extras') or '')) @classmethod def _from_config(cls, config): return [ cls(name, value, group) for group in config.sections() for name, value in config.items(group) ] @classmethod def _from_text(cls, text): config = ConfigParser(delimiters='=') # case sensitive: https://stackoverflow.com/q/1611799/812183 config.optionxform = str try: config.read_string(text) except AttributeError: # pragma: nocover # Python 2 has no read_string config.readfp(io.StringIO(text)) return EntryPoint._from_config(config) def __iter__(self): """ Supply iter so one may construct dicts of EntryPoints easily. """ return iter((self.name, self)) class PackagePath(pathlib.PurePosixPath): """A reference to a path in a package""" def read_text(self, encoding='utf-8'): with self.locate().open(encoding=encoding) as stream: return stream.read() def read_binary(self): with self.locate().open('rb') as stream: return stream.read() def locate(self): """Return a path-like object for this path""" return self.dist.locate_file(self) class FileHash: def __init__(self, spec): self.mode, _, self.value = spec.partition('=') def __repr__(self): return '<FileHash mode: {} value: {}>'.format(self.mode, self.value) class Distribution: """A Python distribution package.""" @abc.abstractmethod def read_text(self, filename): """Attempt to load metadata file given by the name. :param filename: The name of the file in the distribution info. :return: The text if found, otherwise None. """ @abc.abstractmethod def locate_file(self, path): """ Given a path to a file in this distribution, return a path to it. """ @classmethod def from_name(cls, name): """Return the Distribution for the given package name. :param name: The name of the distribution package to search for. :return: The Distribution instance (or subclass thereof) for the named package, if found. :raises PackageNotFoundError: When the named package's distribution metadata cannot be found. """ for resolver in cls._discover_resolvers(): dists = resolver(DistributionFinder.Context(name=name)) dist = next(dists, None) if dist is not None: return dist else: raise PackageNotFoundError(name) @classmethod def discover(cls, **kwargs): """Return an iterable of Distribution objects for all packages. Pass a ``context`` or pass keyword arguments for constructing a context. :context: A ``DistributionFinder.Context`` object. :return: Iterable of Distribution objects for all packages. """ context = kwargs.pop('context', None) if context and kwargs: raise ValueError("cannot accept context and kwargs") context = context or DistributionFinder.Context(**kwargs) return itertools.chain.from_iterable( resolver(context) for resolver in cls._discover_resolvers() ) @staticmethod def at(path): """Return a Distribution for the indicated metadata path :param path: a string or path-like object :return: a concrete Distribution instance for the path """ return PathDistribution(ensure_is_path(path)) @staticmethod def _discover_resolvers(): """Search the meta_path for resolvers.""" declared = ( getattr(finder, 'find_distributions', None) for finder in sys.meta_path ) return filter(None, declared) @property def metadata(self): """Return the parsed metadata for this Distribution. The returned object will have keys that name the various bits of metadata. See PEP 566 for details. """ text = ( self.read_text('METADATA') or self.read_text('PKG-INFO') # This last clause is here to support old egg-info files. Its # effect is to just end up using the PathDistribution's self._path # (which points to the egg-info file) attribute unchanged. or self.read_text('') ) return email_message_from_string(text) @property def version(self): """Return the 'Version' metadata for the distribution package.""" return self.metadata['Version'] @property def entry_points(self): return EntryPoint._from_text(self.read_text('entry_points.txt')) @property def files(self): """Files in this distribution. :return: List of PackagePath for this distribution or None Result is `None` if the metadata file that enumerates files (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is missing. Result may be empty if the metadata exists but is empty. """ file_lines = self._read_files_distinfo() or self._read_files_egginfo() def make_file(name, hash=None, size_str=None): result = PackagePath(name) result.hash = FileHash(hash) if hash else None result.size = int(size_str) if size_str else None result.dist = self return result return file_lines and list(starmap(make_file, csv.reader(file_lines))) def _read_files_distinfo(self): """ Read the lines of RECORD """ text = self.read_text('RECORD') return text and text.splitlines() def _read_files_egginfo(self): """ SOURCES.txt might contain literal commas, so wrap each line in quotes. """ text = self.read_text('SOURCES.txt') return text and map('"{}"'.format, text.splitlines()) @property def requires(self): """Generated requirements specified for this Distribution""" reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs() return reqs and list(reqs) def _read_dist_info_reqs(self): return self.metadata.get_all('Requires-Dist') def _read_egg_info_reqs(self): source = self.read_text('requires.txt') return source and self._deps_from_requires_text(source) @classmethod def _deps_from_requires_text(cls, source): section_pairs = cls._read_sections(source.splitlines()) sections = { section: list(map(operator.itemgetter('line'), results)) for section, results in itertools.groupby(section_pairs, operator.itemgetter('section')) } return cls._convert_egg_info_reqs_to_simple_reqs(sections) @staticmethod def _read_sections(lines): section = None for line in filter(None, lines): section_match = re.match(r'\[(.*)\]$', line) if section_match: section = section_match.group(1) continue yield locals() @staticmethod def _convert_egg_info_reqs_to_simple_reqs(sections): """ Historically, setuptools would solicit and store 'extra' requirements, including those with environment markers, in separate sections. More modern tools expect each dependency to be defined separately, with any relevant extras and environment markers attached directly to that requirement. This method converts the former to the latter. See _test_deps_from_requires_text for an example. """ def make_condition(name): return name and 'extra == "{name}"'.format(name=name) def parse_condition(section): section = section or '' extra, sep, markers = section.partition(':') if extra and markers: markers = '({markers})'.format(markers=markers) conditions = list(filter(None, [markers, make_condition(extra)])) return '; ' + ' and '.join(conditions) if conditions else '' for section, deps in sections.items(): for dep in deps: yield dep + parse_condition(section) class DistributionFinder(MetaPathFinder): """ A MetaPathFinder capable of discovering installed distributions. """ class Context: name = None """ Specific name for which a distribution finder should match. """ def __init__(self, **kwargs): vars(self).update(kwargs) @property def path(self): """ The path that a distribution finder should search. """ return vars(self).get('path', sys.path) @property def pattern(self): return '.*' if self.name is None else re.escape(self.name) @abc.abstractmethod def find_distributions(self, context=Context()): """ Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching the ``context``, a DistributionFinder.Context instance. """ @install class MetadataPathFinder(NullFinder, DistributionFinder): """A degenerate finder for distribution packages on the file system. This finder supplies only a find_distributions() method for versions of Python that do not have a PathFinder find_distributions(). """ def find_distributions(self, context=DistributionFinder.Context()): """ Find distributions. Return an iterable of all Distribution instances capable of loading the metadata for packages matching ``context.name`` (or all names if ``None`` indicated) along the paths in the list of directories ``context.path``. """ found = self._search_paths(context.pattern, context.path) return map(PathDistribution, found) @classmethod def _search_paths(cls, pattern, paths): """Find metadata directories in paths heuristically.""" return itertools.chain.from_iterable( cls._search_path(path, pattern) for path in map(cls._switch_path, paths) ) @staticmethod def _switch_path(path): if not PYPY_OPEN_BUG or os.path.isfile(path): # pragma: no branch with suppress(Exception): return zipp.Path(path) return pathlib.Path(path) @classmethod def _matches_info(cls, normalized, item): template = r'{pattern}(-.*)?\.(dist|egg)-info' manifest = template.format(pattern=normalized) return re.match(manifest, item.name, flags=re.IGNORECASE) @classmethod def _matches_legacy(cls, normalized, item): template = r'{pattern}-.*\.egg[\\/]EGG-INFO' manifest = template.format(pattern=normalized) return re.search(manifest, str(item), flags=re.IGNORECASE) @classmethod def _search_path(cls, root, pattern): if not root.is_dir(): return () normalized = pattern.replace('-', '_') return (item for item in root.iterdir() if cls._matches_info(normalized, item) or cls._matches_legacy(normalized, item)) class PathDistribution(Distribution): def __init__(self, path): """Construct a distribution from a path to the metadata directory. :param path: A pathlib.Path or similar object supporting .joinpath(), __div__, .parent, and .read_text(). """ self._path = path def read_text(self, filename): with suppress(FileNotFoundError, IsADirectoryError, KeyError, NotADirectoryError, PermissionError): return self._path.joinpath(filename).read_text(encoding='utf-8') read_text.__doc__ = Distribution.read_text.__doc__ def locate_file(self, path): return self._path.parent / path def distribution(distribution_name): """Get the ``Distribution`` instance for the named package. :param distribution_name: The name of the distribution package as a string. :return: A ``Distribution`` instance (or subclass thereof). """ return Distribution.from_name(distribution_name) def distributions(**kwargs): """Get all ``Distribution`` instances in the current environment. :return: An iterable of ``Distribution`` instances. """ return Distribution.discover(**kwargs) def metadata(distribution_name): """Get the metadata for the named package. :param distribution_name: The name of the distribution package to query. :return: An email.Message containing the parsed metadata. """ return Distribution.from_name(distribution_name).metadata def version(distribution_name): """Get the version string for the named package. :param distribution_name: The name of the distribution package to query. :return: The version string for the package as defined in the package's "Version" metadata key. """ return distribution(distribution_name).version def entry_points(): """Return EntryPoint objects for all installed packages. :return: EntryPoint objects for all installed packages. """ eps = itertools.chain.from_iterable( dist.entry_points for dist in distributions()) by_group = operator.attrgetter('group') ordered = sorted(eps, key=by_group) grouped = itertools.groupby(ordered, by_group) return { group: tuple(eps) for group, eps in grouped } def files(distribution_name): """Return a list of files for the named package. :param distribution_name: The name of the distribution package to query. :return: List of files composing the distribution. """ return distribution(distribution_name).files def requires(distribution_name): """ Return a list of requirements for the named package. :return: An iterator of requirements, suitable for packaging.requirement.Requirement. """ return distribution(distribution_name).requires try: __version__ = version(__name__) except: __version__ = '0.22'
the-stack_0_3450
import os import torch import torch.nn as nn import torchvision.models import collections import math def weights_init(modules, type='xavier'): m = modules if isinstance(m, nn.Conv2d): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.ConvTranspose2d): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1.0) m.bias.data.zero_() elif isinstance(m, nn.Linear): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: m.weight.data.fill_(1.0) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.Module): for m in modules: if isinstance(m, nn.Conv2d): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.ConvTranspose2d): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1.0) m.bias.data.zero_() elif isinstance(m, nn.Linear): if type == 'xavier': torch.nn.init.xavier_normal_(m.weight) elif type == 'kaiming': # msra torch.nn.init.kaiming_normal_(m.weight) else: m.weight.data.fill_(1.0) if m.bias is not None: m.bias.data.zero_() class FullImageEncoder(nn.Module): def __init__(self, dataset='kitti'): super(FullImageEncoder, self).__init__() self.global_pooling = nn.AvgPool2d(8, stride=8, padding=(1, 0)) # KITTI 16 16 self.dropout = nn.Dropout2d(p=0.5) self.global_fc = nn.Linear(2048 * 4 * 5, 512) self.relu = nn.ReLU(inplace=True) self.conv1 = nn.Conv2d(512, 512, 1) # 1x1 卷积 self.upsample = nn.UpsamplingBilinear2d(size=(30, 40)) # KITTI 49X65 NYU 33X45 self.dataset = dataset weights_init(self.modules(), 'xavier') def forward(self, x): x1 = self.global_pooling(x) # print('# x1 size:', x1.size()) x2 = self.dropout(x1) x3 = x2.view(-1, 2048 * 4 * 5) x4 = self.relu(self.global_fc(x3)) # print('# x4 size:', x4.size()) x4 = x4.view(-1, 512, 1, 1) # print('# x4 size:', x4.size()) x5 = self.conv1(x4) out = self.upsample(x5) return out class SceneUnderstandingModule(nn.Module): def __init__(self, output_channel=136, dataset='kitti'): super(SceneUnderstandingModule, self).__init__() self.encoder = FullImageEncoder(dataset=dataset) self.aspp1 = nn.Sequential( nn.Conv2d(2048, 512, 1), nn.ReLU(inplace=True), nn.Conv2d(512, 512, 1), nn.ReLU(inplace=True) ) self.aspp2 = nn.Sequential( nn.Conv2d(2048, 512, 3, padding=6, dilation=6), nn.ReLU(inplace=True), nn.Conv2d(512, 512, 1), nn.ReLU(inplace=True) ) self.aspp3 = nn.Sequential( nn.Conv2d(2048, 512, 3, padding=12, dilation=12), nn.ReLU(inplace=True), nn.Conv2d(512, 512, 1), nn.ReLU(inplace=True) ) self.aspp4 = nn.Sequential( nn.Conv2d(2048, 512, 3, padding=18, dilation=18), nn.ReLU(inplace=True), nn.Conv2d(512, 512, 1), nn.ReLU(inplace=True) ) self.concat_process = nn.Sequential( nn.Dropout2d(p=0.5), nn.Conv2d(512 * 5, 2048, 1), nn.ReLU(inplace=True), nn.Dropout2d(p=0.5), nn.Conv2d(2048, output_channel, 1), # KITTI 142 NYU 136 In paper, K = 80 is best, so use 160 is good! # nn.UpsamplingBilinear2d(scale_factor=8) nn.UpsamplingBilinear2d(size=(240, 320)) ) weights_init(self.modules(), type='xavier') def forward(self, x): x1 = self.encoder(x) x2 = self.aspp1(x) x3 = self.aspp2(x) x4 = self.aspp3(x) x5 = self.aspp4(x) x6 = torch.cat((x1, x2, x3, x4, x5), dim=1) # print('cat x6 size:', x6.size()) out = self.concat_process(x6) return out class OrdinalRegressionLayer(nn.Module): def __init__(self): super(OrdinalRegressionLayer, self).__init__() #self.logsoftmax = nn.Logsoftmax(dim=1) def forward(self, x): N, C, H, W = x.size() ord_num = C // 2 A = x[:, ::2, :, :].clone() B = x[:, 1::2, :, :].clone() A = A.view(N, 1, ord_num * H * W) B = B.view(N, 1, ord_num * H * W) C = torch.cat((A, B), dim=1) #C = torch.clamp(C, min=1e-7, max=1e7) # prevent nans ord_c = nn.functional.softmax(C, dim=1) ord_c1 = ord_c[:, 1, :].clone() ord_c2 = nn.LogSoftmax(dim=1)(C) ord_c1 = ord_c1.view(-1, ord_num, H, W) ord_c2 = ord_c2.view(-1, ord_num * 2, H, W) decode_c = torch.sum((ord_c1 >= 0.5), dim=1).view(-1, 1, H, W).float() return decode_c, ord_c2 class ResNet(nn.Module): def __init__(self, in_channels=3, pretrained=True, freeze=True): super(ResNet, self).__init__() pretrained_model = torchvision.models.__dict__['resnet{}'.format(101)](pretrained=pretrained) self.channel = in_channels self.conv1 = nn.Sequential(collections.OrderedDict([ ('conv1_1', nn.Conv2d(self.channel, 64, kernel_size=3, stride=2, padding=1, bias=False)), ('bn1_1', nn.BatchNorm2d(64)), ('relu1_1', nn.ReLU(inplace=True)), ('conv1_2', nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False)), ('bn_2', nn.BatchNorm2d(64)), ('relu1_2', nn.ReLU(inplace=True)), ('conv1_3', nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1, bias=False)), ('bn1_3', nn.BatchNorm2d(128)), ('relu1_3', nn.ReLU(inplace=True)) ])) self.bn1 = nn.BatchNorm2d(128) # print(pretrained_model._modules['layer1'][0].conv1) self.relu = pretrained_model._modules['relu'] self.maxpool = pretrained_model._modules['maxpool'] self.layer1 = pretrained_model._modules['layer1'] self.layer1[0].conv1 = nn.Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) self.layer1[0].downsample[0] = nn.Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False) self.layer2 = pretrained_model._modules['layer2'] self.layer3 = pretrained_model._modules['layer3'] self.layer3[0].conv2 = nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) self.layer3[0].downsample[0] = nn.Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False) self.layer4 = pretrained_model._modules['layer4'] self.layer4[0].conv2 = nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) self.layer4[0].downsample[0] = nn.Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False) # clear memory del pretrained_model if pretrained: weights_init(self.conv1, type='kaiming') weights_init(self.layer1[0].conv1, type='kaiming') weights_init(self.layer1[0].downsample[0], type='kaiming') weights_init(self.layer3[0].conv2, type='kaiming') weights_init(self.layer3[0].downsample[0], type='kaiming') weights_init(self.layer4[0].conv2, 'kaiming') weights_init(self.layer4[0].downsample[0], 'kaiming') else: weights_init(self.modules(), type='kaiming') if freeze: self.freeze() def forward(self, x): # print(pretrained_model._modules) x = self.conv1(x) x = self.bn1(x) x = self.relu(x) # print('conv1:', x.size()) x = self.maxpool(x) # print('pool:', x.size()) x1 = self.layer1(x) # print('layer1 size:', x1.size()) x2 = self.layer2(x1) # print('layer2 size:', x2.size()) x3 = self.layer3(x2) # print('layer3 size:', x3.size()) x4 = self.layer4(x3) # print('layer4 size:', x4.size()) return x4 def freeze(self): for m in self.modules(): if isinstance(m, nn.BatchNorm2d): m.eval() class DORN(nn.Module): def __init__(self, output_size=(240, 320), losstype=1, channel=3, pretrained=True, freeze=True, output_channel=3, dataset='kitti'): super(DORN, self).__init__() self.output_size = output_size self.channel = channel self.feature_extractor = ResNet(in_channels=channel, pretrained=pretrained, freeze=freeze) self.aspp_module = SceneUnderstandingModule(output_channel=output_channel, dataset=dataset) self.orl = OrdinalRegressionLayer() self.losstype = losstype def forward(self, x): x1 = self.feature_extractor(x) x2 = self.aspp_module(x1) return x2 def get_1x_lr_params(self): b = [self.feature_extractor] for i in range(len(b)): for k in b[i].parameters(): if k.requires_grad: yield k def get_10x_lr_params(self): b = [self.aspp_module, self.orl] for j in range(len(b)): for k in b[j].parameters(): if k.requires_grad: yield k # os.environ["CUDA_VISIBLE_DEVICES"] = "1" # 默认使用GPU 0 if __name__ == "__main__": model = DORN() model = model.cuda() model.eval() image = torch.randn(1, 3, 257, 353) image = image.cuda() with torch.no_grad(): out0, out1 = model(image) print('out0 size:', out0.size()) print('out1 size:', out1.size()) print(out0)
the-stack_0_3451
#!/usr/bin/env python from os import listdir from os.path import isfile, join import pickle import os from loguru import logger def diff(l1, l2): return list(set(l2) - set(l1)) logger.info("Running") WORK_DIR = os.environ['WORK_DIR'] cur_files = [f for f in listdir(WORK_DIR) if isfile(join(WORK_DIR, f))] try: last_files_pickle = open('/tmp/workdir_files.pickle','rb') last_files = pickle.load(last_files_pickle) last_files_pickle.close() logger.info("Compare Work Dir") if len(diff(cur_files, last_files)) > 0 or len(diff(last_files, cur_files)) > 0: logger.warning("Changes found, restarting Frontail") os.system("pkill -f frontail") os.system("/root/run_trail.sh") except: pass # Write status logger.info("Writing current dir status") cur_files_pickle = open('/tmp/workdir_files.pickle','wb') pickle.dump(cur_files, cur_files_pickle) cur_files_pickle.close()
the-stack_0_3452
""" Copyright (c) 2013, SMART Technologies ULC All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Copyright holder (SMART Technologies ULC) nor the names of its contributors (Joshua Henn) may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER (SMART Technologies ULC) "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ from org.sikuli.script import Location, Pattern import types from sikuli import Env, Region from org.sikuli.script import Region as JRegion from org.sikuli.script import Env as JEnv #from config import Config #from logger import Logger from sikuli.Sikuli import capture # =============================================== # # Overwritten sikuli methods # # =============================================== # # function for calling native sikuli methods def sikuli_method(name, *args, **kwargs): return sys.modules['sikuli.Sikuli'].__dict__[name](*args, **kwargs) # overwritten Screen.exists method def exists(target, timeout=None): addFoundImage(getFilename(target)) return sikuli_method('exists', target, timeout) # =============================================== # # Overwritten sikuli classes # # =============================================== # @staticmethod def EnvGetOSVersion(fullName=None): if not fullName: return Env.oldGetOSVersion(); elif Env.oldGetOSVersion() == '5.1': return 'XP' elif Env.oldGetOSVersion() == '6.0': return 'Vista' elif Env.oldGetOSVersion() == '6.1': return 'Win7' Env.oldGetOSVersion = Env.getOSVersion Env.getOSVersion = EnvGetOSVersion ## Java Region patching def add(self, operand): # If we're trying to add None, just return the original region if not operand: return self regions = [self, operand] # more than one region, get min/max region minX, minY = 9999, 9999 maxX, maxY = -9999, -9999 for region in regions: if region.getX() < minX: minX = int(region.getX()) if region.getY() < minY: minY = int(region.getY()) # If this is a region type if hasattr(region, "getW") and hasattr(region, "getH"): if (region.getX() + region.getW()) > maxX: maxX = region.getX() + region.getW() if (region.getY() + region.getH()) > maxY: maxY = region.getY() + region.getH() else: if region.getX() > maxX: maxX = int(region.getX()) if region.getY() > maxY: maxY = int(region.getY()) return Region(minX, minY, maxX-minX, maxY-minY) JRegion.add = add # Java Region patching def limit(self, operand): # If we're trying to limit None, return original if not operand: return self x1 = self.getX() if self.getX() > operand.getX() else operand.getX() y1 = self.getY() if self.getY() > operand.getY() else operand.getY() x2 = (self.getX() + self.getW()) if (self.getX() + self.getW()) < (operand.getX() + operand.getW()) else (operand.getX() + operand.getW()) y2 = (self.getY() + self.getH()) if (self.getY() + self.getH()) < (operand.getY() + operand.getH()) else (operand.getY() + operand.getH()) # Check region is valid positive if x2-x1 < 0 or y2-y1 < 0: raise Exception("Region %s is outside the bounds of the ParentRegion %s" % (self, operand)) return Region(x1, y1, x2-x1, y2-y1) JRegion.limit = limit def offset(self, operand): self.setX(self.getX() + operand.getX()) self.setY(self.getY() + operand.getY()) return self ## def regionInit(self, operand, *args, **kargs): # Handle a list of regions if isinstance(operand, list): region = None for item in operand: if region: region = region.add(item) else: region = item self.oldInit(region, *args, **kargs) else: self.oldInit(operand, *args, **kargs) JRegion.oldInit = JRegion.__init__ JRegion.__init__ = regionInit ## Region patching #JRegion.timeout = Config.regionTimeout JRegion.clickOffset = Location(0,0) # Define setClickOffset def setClickOffset(self, offset): assert isinstance(offset, Location) self.clickOffset = offset JRegion.setClickOffset = setClickOffset # Define getClickLocation def getClickLocation(self): x = self.x + (self.w/2) + self.clickOffset.getX() y = self.y + (self.h/2) + self.clickOffset.getY() return Location(x, y) JRegion.getClickLocation = getClickLocation # Define getClickLocation def getClickOffset(self): return self.clickOffset JRegion.getClickOffset = getClickOffset
the-stack_0_3454
""" Robust Principal Component Analysis """ import numpy as np from numpy.linalg import norm from numpy.linalg import svd def rpca_alm(M, mu=None, l=None, mu_tol=1E7, tol=1E-7, max_iter=1000): """Matrix recovery/decomposition using Robust Principal Component Analysis Decompose a rectengular matrix M into a low-rank component, and a sparse component, by solving a convex minimization problem via Augmented Lagrangian Method. minimize ||A||_* + λ ||E||_1 subject to A + E = M where ||A||_* is the nuclear norm of A (sum of singular values) - surrogate of matrix rank ||E||_1 is the l1 norm of E (absolute values of elements) - surrogate of matrix sparseness Relaxed to L(A,E,Y,λ) .= ||A||_* + λ||E||_1 + <Y, M-A-E> + µ/2 ||M-A-E||_F^2 Parameters ---------- M : array-like, shape (n_samples, n_features) Matrix to decompose, where n_samples in the number of samples and n_features is the number of features. l : float (default 1/sqrt(max(m,n)), for m x n of M) Parameter λ (lambda) of the convex problem ||A||_* + λ ||E||_1. [2]_ mu : float (default 1.25 * ||M||_2) Parameter µ (mu) of the Augmented Lagrange Multiplier form of Principal Component Pursuit (PCP). [2]_ mu_tol : float >= 0 (default 1E-7) Weight parameter. tol : float >= 0 (default 1E-7) Tolerance for accuracy of matrix reconstruction of low rank and sparse components. max_iter : int >= 0 (default 1000) Maximum number of iterations to perform. Returns ------- A : array, shape (n_samples, n_features) Low-rank component of the matrix decomposition. E : array, shape (n_samples, n_features) Sparse component of the matrix decomposition. err : float Error of matrix reconstruction ||M-A-E||_F / ||M||_F References ---------- .. [1] Z. Lin, M. Chen, Y. Ma. The Augmented Lagrange Multiplier Method for Exact Recovery of Corrupted Low-Rank Matrices, arXiv:1009.5055 .. [2] E. J. Candés, X. Li, Y. Ma, J. Wright. Robust principal component analysis? Journal of the ACM v.58 n.11 May 2011 """ rho = 1.5 if not mu: mu = 1.25 * norm(M, ord=2) if not l: l = np.max(M.shape)**-.5 M_sign = np.sign(M) norm_spectral = norm(M_sign, ord=2) norm_inf = norm(M_sign, ord=np.inf) norm_dual = np.max([norm_spectral, norm_inf * l**-1]) Y = M_sign * norm_dual**-1 A = np.zeros(M.shape) E = np.zeros(M.shape) err = np.inf i = 0 while err > tol and i < max_iter: U, S, V = svd(M - E + Y * mu**-1, full_matrices=False) A = np.dot(U, np.dot(np.diag(_shrink(S, mu**-1)), V)) E = _shrink(M - A + Y * mu**-1, l * mu**-1) Y = Y + mu * (M - A - E) err = _fro_error(M, A, E) mu *= rho mu = np.min([mu, mu_tol]) i += 1 return A, E, err def _fro_error(M, A, E): """Error of matrix reconstruction""" return norm(M - A - E, ord='fro') * norm(M, ord='fro')**-1 def _shrink(M, t): """Shrinkage operator""" return np.sign(M) * np.maximum((np.abs(M) - t), np.zeros(M.shape))
the-stack_0_3455
#PART 1 - CORPUS import random import time import csv from collections import Counter t1=time.time() print("Warning: This program is long, and takes some time to execute, because of the big file sizes.") print("It took around 30s on an i7 7700HQ laptop with 16 GB of RAM. Performance might vary.") def combine_lists(l1, l2): return list(map(lambda x, y:"{} {}".format(x,y), l1, l2)) def givetaggivenword(some_dict): temp_dict={} temp=list(some_dict.values()) for a_dict in temp: for tag in a_dict: if tag in temp_dict: temp_dict[tag]=temp_dict[tag]+a_dict[tag] else: temp_dict[tag]=a_dict[tag] best_tag=keywithmaxval(temp_dict) return(best_tag) #Function to return the key having maximum value in a dictionary def keywithmaxval(dic): val=list(dic.values()) key=list(dic.keys()) return key[val.index(max(val))] def givesingletons(arr): freq = Counter(arr) return [elem for elem in arr if freq[elem] == 1] #MODEL SCRAPPED AS NOT ENOUGH TIME #Function to give a tag which is calculated randomly by using the test tag set frequency as weights # def weighted_random_tag(tag_list): # import numpy as np # unique_elements, counts_elements = np.unique(tag_list, return_counts=True) # counts_elements=counts_elements/np.sum(counts_elements) # weighted_tag=np.random.choice(unique_elements,p=counts_elements) # return(weighted_tag) #Open File and read brown.txt file=open("brown.txt","r") all_text=file.read() file.close() clean_text=all_text.strip() #Get all words along with their tags trainfile=open("brown-train.txt","w") testfile=open("brown-test.txt","w") all_words=clean_text.split() all_sent=[] sent="" #Join words to form sentences using the following loop i=0 #Number of sentences for word in all_words: if word[-2:]=="/.": sent=sent+word+" " all_sent.append(sent.strip()) if len(all_sent[-1])==3: #This is to remove all duplicates # print("All sent of -2 is{}".format(all_sent[-2])) # print("All sent of -1 is{}".format(all_sent[-1])) # print("Current sent is{}".format(sent)) # print(all_sent[-1]) del all_sent[-1] i=i-1 sent="" i=i+1 continue sent=sent+word+" " #The first 2000 sentences of all sentences will form training set, while remaining will form test dataset train_sent=all_sent[:2000] test_sent=all_sent[2000:] trainfile.write('\n'.join(train_sent)) testfile.write('\n'.join(test_sent)) #Write these training and test datasets to files trainfile.close() testfile.close() print("brown-train.txt saved succesfully.") print("brown-test.txt saved succesfully.") #PART 2 - TAGGER IMPLEMENTATION #Subpart 1 - Unigram print("------------UNIGRAM------------") #Create a nested dictionary of form {WORD1:{Tag1:Freqeuncy,Tag2:Freqeuncy,Tag3:Freqeuncy...},WORD2:{Tag1:Freqeuncy,Tag2:Freqeuncy,Tag3:Freqeuncy...},WORD3:{Tag1:Freqeuncy,Tag2:Freqeuncy,Tag3:Freqeuncy...}...} unigram_tagger_dict={} #Nested Dictionary unigram_list=[] #List of all unigrams tag_list=[] #List of all tags for sent in train_sent: for word in sent.split(): unigram=word.rsplit("/",1)[0] tag=word.rsplit("/",1)[1] unigram_list.append(unigram) tag_list.append(tag) #A Tag Dictionary for the current word i.e for current word {Tag1,Tag2,Tag3...} if unigram in unigram_tagger_dict: tag_dict=unigram_tagger_dict[unigram] else: tag_dict={} if tag not in tag_dict: tag_dict[tag]=0 tag_dict[tag]=tag_dict[tag]+1 unigram_tagger_dict[unigram]=tag_dict #Get the list of all unique unigrams and tags unigram_set=list(set(unigram_list)) tag_set=list(set(tag_list)) max_tag_unigram_dict={} unigramfile=open("unigram-tag.txt","w") #Find out the most frequent tag for each word in training set and store as a dictionary for unigram in unigram_set: current_unigram_dict=unigram_tagger_dict[unigram] unigram_values=list(current_unigram_dict.values()) unigram_keys=list(current_unigram_dict.keys()) max_tag=unigram_keys[unigram_values.index(max(unigram_values))] max_tag_unigram_dict[unigram]=max_tag #Write the dictionary to a file outside the loop to save time unigramfile.write(str(max_tag_unigram_dict)) unigramfile.close() print("unigram-tag.txt saved succesfully.") #Assign the most frequent tag calculated above to all words in training set unigramresultfile=open("unigram-results.txt","w") unigramresult="" #String that holds all sentences after they've been tagged using unigram model true_unigam_tag_counts=0 #To count how many assigned tags match the original correct tags false_unigam_tag_counts=0 #To count how many assigned tags were assigned wrongly unknown_correct=0 all_unknown={} #Dictionary of all unknown unigrams unigram_confusion={} # { (tag1(true), tag2(model)) : freq } hapax=givesingletons(unigram_list) hapax_tags=[] for elem in hapax: hapax_tags.append(max_tag_unigram_dict[elem]) #We have multiple models to assign tags to unknown words print("Enter model number you would like to use : 0,1 or 2 based on:") print("Approach 0: Mark all unknowns as UNK tags") print("Approach 1: For unknown unigrams, give them a random tag with equal prob (1/n)") print("Approach 2: For unknown unigrams, give them a random tag where the random prob is based ONLY ON THE UNIGRAMS WHICH APPEARED ONCE in the training data set.") inp=int(input("Enter your choice:\n")) for sent in test_sent: for word in sent.split(): #Extract unigram and true_tag from "unigram/true_tag" unigram=word.rsplit("/",1)[0] true_tag=word.rsplit("/",1)[1] #Find out tag based on our model: #If the current unigram is a known unigram, then assign it the tag calculated earlier if unigram in max_tag_unigram_dict: model_tag=max_tag_unigram_dict[unigram] #If it's unknown, we have various strategies for that else: if inp==0: model_tag="UNK" if inp==1: model_tag=random.choice(tag_set) # if inp==2: #MODEL SCRAPPED AS NOT ENOUGH TIME # model_tag=weighted_random_tag(tag_list) if inp==2: model_tag=random.choice(hapax_tags) if model_tag==true_tag: unknown_correct+=1 all_unknown.setdefault(unigram,0) all_unknown[unigram]=all_unknown[unigram]+1 unigramresult=unigramresult+"{}/{} ".format(unigram,model_tag) #Update true and false tag counters if true_tag==model_tag: true_unigam_tag_counts+=1 else: false_unigam_tag_counts+=1 #CONFUSION unigram_confusion.setdefault((true_tag,model_tag),0) unigram_confusion[(true_tag,model_tag)]+=1 unigramresult=unigramresult+"\n" unigramresultfile.write(unigramresult) unigramresultfile.close() print("unigram-results.txt saved succesfully.") unigram_accuracy=100*true_unigam_tag_counts/(false_unigam_tag_counts+true_unigam_tag_counts) unknown_accuracy=unknown_correct/len(all_unknown) print("Unigram Tagger Accuracy is {}%".format(unigram_accuracy)) print("Total unknowns is {}".format(len(all_unknown))) print("Unknown Accuracy is {}%".format(unknown_accuracy)) #all_unknown_list=list(all_unknown.keys()) #Subpart 2 - Bigram print("------------BIGRAM------------") next_word_list=all_words[1:] bigram_word_list=combine_lists(all_words,next_word_list) bigram_tagger_dict={} # Word1:{Tag1:{Possible Next Tags: Count},Tag2:{Possible Next Tags: Count}},Word2:... bigramfile=open("bigram-tag.txt","w") bigramtagtext="The format is:\nCurrent Word:\n\tPrevious Tag:\n\t\tNext Tag :\tFrequency\n-------------------\n" #Order is Count(previous,next) for i in range(len(bigram_word_list)): bigram_4_parts=bigram_word_list[i].replace(" ","/").rsplit("/") prev_tag=bigram_4_parts[1] next_tag=bigram_4_parts[3] next_word=bigram_4_parts[2] if next_word in bigram_tagger_dict: next_word_dict=bigram_tagger_dict[next_word] else: next_word_dict={} both_tags=bigram_4_parts[1]+bigram_4_parts[3] if prev_tag in next_word_dict: tag_dict=next_word_dict[prev_tag] else: tag_dict={} if next_tag not in tag_dict: tag_dict[next_tag]=0 tag_dict[next_tag]=tag_dict[next_tag]+1 next_word_dict[prev_tag]=tag_dict bigram_tagger_dict[next_word]=next_word_dict bigramfile.write(str(bigram_tagger_dict)) bigramfile.close() print("bigram-tag.txt saved succesfully.") #Calculate the most probable next tag given previous tag for current word: bigramresultfile=open("bigram-results.txt","w") bigramresult="" #String that holds all sentences after they've been tagged using unigram model true_bigam_tag_counts=0 #To count how many assigned tags match the original correct tags false_bigam_tag_counts=0 #To count how many assigned tags were assigned wrongly unknown_correct_bigram=0 all_unknown_bigram={} bigram_confusion={} # { (tag1(true), tag2(model)) : freq } i=0 j=0 print("Enter model number you would like to use : 1 or 2 based on:") print("Approach 1: For unknown words, give them a random tag with equal prob (1/n)") print("Approach 2: For unknown words, give them a random tag where the random prob is based ONLY ON THE UNIGRAMS WHICH APPEARED ONCE in the training data set.") inp2=int(input("Enter your choice:\n")) starting_tag="." #Because this is a new sentence. for sent in test_sent: for word in sent.split(): if i==0 and j==0: prev_tag=starting_tag #Extract unigram and true_tag from "unigram/true_tag" unigram=word.rsplit("/",1)[0] true_tag=word.rsplit("/",1)[1] if unigram in bigram_tagger_dict: try: bigram_model_tag=keywithmaxval(bigram_tagger_dict[unigram][prev_tag]) except Exception as e: #WORD FOUND, BUT NO TAG FOR PREV_TAG FOR THIS WORD Unknown Model if inp2==1: bigram_model_tag=random.choice(tag_set) if inp2==2: bigram_model_tag=random.choice(hapax_tags) #bigram_model_tag=givetaggivenword(bigram_tagger_dict[unigram]) else: #WORD NOT FOUND: Unkown Model if inp2==1: bigram_model_tag=random.choice(tag_set) if inp2==2: bigram_model_tag=random.choice(hapax_tags) all_unknown_bigram.setdefault(prev_tag,0) all_unknown_bigram[prev_tag]=all_unknown_bigram[prev_tag]+1 bigramresult=bigramresult+"{}/{} ".format(unigram,bigram_model_tag) if true_tag==bigram_model_tag: true_bigam_tag_counts+=1 else: false_bigam_tag_counts+=1 #CONFUSION bigram_confusion.setdefault((true_tag,model_tag),0) bigram_confusion[(true_tag,model_tag)]+=1 prev_tag=bigram_model_tag j+=1 bigramresult=bigramresult+"\n" i+=1 bigramresultfile.write(bigramresult) bigramresultfile.close() print("bigram-results.txt saved succesfully.") bigram_accuracy=100*true_bigam_tag_counts/(false_bigam_tag_counts+true_bigam_tag_counts) unknown_accuracy_bigram=unknown_correct_bigram/len(all_unknown_bigram) print("Bigram Tagger Accuracy is {}%".format(bigram_accuracy)) print("Total unknowns is {}".format(len(all_unknown_bigram))) print("Unknown Accuracy is {}%".format(unknown_accuracy_bigram)) print("------------CONFUSION MATRICES------------") #A part of the below code has been re-used from my earlier assignment https://github.com/AKnightWing/bigram/blob/master/comp_ling.py #Unigram Tagger Confusion Matrix #Normalise both confusion dictionarues for key in unigram_confusion: unigram_confusion[key]=100*unigram_confusion[key]/false_unigam_tag_counts for key in bigram_confusion: bigram_confusion[key]=100*bigram_confusion[key]/false_bigam_tag_counts firstrow=[' '] #The first row in the 2D list for key in tag_set: firstrow.append(key) unigram_matrix=[] #A n*n 2D list which stores only the skeleton of the matrix for i in range(len(tag_set)+1): if i==0: unigram_matrix.append(firstrow) else: row=[] for j in range(len(tag_set)+1): if j==0: row.append(firstrow[i]) else: try: row.append(unigram_confusion[(tag_set[i]),(tag_set[j])]) except Exception as e: row.append("0") unigram_matrix.append(row) bigram_matrix=[] for i in range(len(tag_set)+1): if i==0: bigram_matrix.append(firstrow) else: row=[] for j in range(len(tag_set)+1): if j==0: row.append(firstrow[i]) else: try: row.append(bigram_confusion[(tag_set[i]),(tag_set[j])]) except Exception as e: row.append("0") bigram_matrix.append(row) with open('unigram_confusion.csv', 'w') as writeFile: writer = csv.writer(writeFile) writer.writerows(unigram_matrix) writeFile.close() print("unigram_confusion.csv saved succesfully.") with open('bigram_confusion.csv', 'w') as writeFile2: writer = csv.writer(writeFile2) writer.writerows(bigram_matrix) writeFile2.close() print("bigram_confusion.csv saved succesfully.") t2=time.time() print("Total time taken by program = {} seconds".format(t2-t1))
the-stack_0_3457
""" Agent namespaced tasks """ from __future__ import print_function import glob import os import shutil import sys import platform from distutils.dir_util import copy_tree import invoke from invoke import task from invoke.exceptions import Exit from .utils import bin_name, get_build_flags, get_version_numeric_only, load_release_versions from .utils import REPO_PATH from .build_tags import get_build_tags, get_default_build_tags, LINUX_ONLY_TAGS, DEBIAN_ONLY_TAGS from .go import deps # constants BIN_PATH = os.path.join(".", "bin", "agent") AGENT_TAG = "datadog/agent:master" DEFAULT_BUILD_TAGS = [ "apm", "consul", "cpython", "docker", "ec2", "etcd", "gce", "jmx", "kubeapiserver", "kubelet", "log", "systemd", "process", "snmp", "zk", "zlib", ] @task def build(ctx, rebuild=False, race=False, build_include=None, build_exclude=None, puppy=False, use_embedded_libs=False, development=True, precompile_only=False, skip_assets=False): """ Build the agent. If the bits to include in the build are not specified, the values from `invoke.yaml` will be used. Example invokation: inv agent.build --build-exclude=snmp,systemd """ build_include = DEFAULT_BUILD_TAGS if build_include is None else build_include.split(",") build_exclude = [] if build_exclude is None else build_exclude.split(",") ldflags, gcflags, env = get_build_flags(ctx, use_embedded_libs=use_embedded_libs) if not sys.platform.startswith('linux'): for ex in LINUX_ONLY_TAGS: if ex not in build_exclude: build_exclude.append(ex) # remove all tags that are only available on debian distributions distname = platform.linux_distribution()[0].lower() if distname not in ['debian', 'ubuntu']: for ex in DEBIAN_ONLY_TAGS: if ex not in build_exclude: build_exclude.append(ex) if sys.platform == 'win32': # This generates the manifest resource. The manifest resource is necessary for # being able to load the ancient C-runtime that comes along with Python 2.7 # command = "rsrc -arch amd64 -manifest cmd/agent/agent.exe.manifest -o cmd/agent/rsrc.syso" ver = get_version_numeric_only(ctx) build_maj, build_min, build_patch = ver.split(".") command = "windmc --target pe-x86-64 -r cmd/agent cmd/agent/agentmsg.mc " ctx.run(command, env=env) command = "windres --define MAJ_VER={build_maj} --define MIN_VER={build_min} --define PATCH_VER={build_patch} ".format( build_maj=build_maj, build_min=build_min, build_patch=build_patch ) command += "-i cmd/agent/agent.rc --target=pe-x86-64 -O coff -o cmd/agent/rsrc.syso" ctx.run(command, env=env) if puppy: # Puppy mode overrides whatever passed through `--build-exclude` and `--build-include` build_tags = get_default_build_tags(puppy=True) else: build_tags = get_build_tags(build_include, build_exclude) cmd = "go build {race_opt} {build_type} -tags \"{go_build_tags}\" " cmd += "-o {agent_bin} -gcflags=\"{gcflags}\" -ldflags=\"{ldflags}\" {REPO_PATH}/cmd/agent" args = { "race_opt": "-race" if race else "", "build_type": "-a" if rebuild else ("-i" if precompile_only else ""), "go_build_tags": " ".join(build_tags), "agent_bin": os.path.join(BIN_PATH, bin_name("agent", android=False)), "gcflags": gcflags, "ldflags": ldflags, "REPO_PATH": REPO_PATH, } ctx.run(cmd.format(**args), env=env) # Render the configuration file template # # We need to remove cross compiling bits if any because go generate must # build and execute in the native platform env.update({ "GOOS": "", "GOARCH": "", }) cmd = "go generate {}/cmd/agent" ctx.run(cmd.format(REPO_PATH), env=env) if not skip_assets: refresh_assets(ctx, development=development) @task def refresh_assets(ctx, development=True): """ Clean up and refresh Collector's assets and config files """ # ensure BIN_PATH exists if not os.path.exists(BIN_PATH): os.mkdir(BIN_PATH) dist_folder = os.path.join(BIN_PATH, "dist") if os.path.exists(dist_folder): shutil.rmtree(dist_folder) copy_tree("./cmd/agent/dist/", dist_folder) copy_tree("./pkg/status/dist/", dist_folder) copy_tree("./cmd/agent/gui/views", os.path.join(dist_folder, "views")) if development: copy_tree("./dev/dist/", dist_folder) # copy the dd-agent placeholder to the bin folder bin_ddagent = os.path.join(BIN_PATH, "dd-agent") shutil.move(os.path.join(dist_folder, "dd-agent"), bin_ddagent) @task def run(ctx, rebuild=False, race=False, build_include=None, build_exclude=None, puppy=False, skip_build=False): """ Execute the agent binary. By default it builds the agent before executing it, unless --skip-build was passed. It accepts the same set of options as agent.build. """ if not skip_build: build(ctx, rebuild, race, build_include, build_exclude, puppy) ctx.run(os.path.join(BIN_PATH, bin_name("agent"))) @task def system_tests(ctx): """ Run the system testsuite. """ pass @task def image_build(ctx, base_dir="omnibus"): """ Build the docker image """ base_dir = base_dir or os.environ.get("OMNIBUS_BASE_DIR") pkg_dir = os.path.join(base_dir, 'pkg') list_of_files = glob.glob(os.path.join(pkg_dir, 'datadog-agent*_amd64.deb')) # get the last debian package built if not list_of_files: print("No debian package build found in {}".format(pkg_dir)) print("See agent.omnibus-build") raise Exit(code=1) latest_file = max(list_of_files, key=os.path.getctime) shutil.copy2(latest_file, "Dockerfiles/agent/") ctx.run("docker build -t {} Dockerfiles/agent".format(AGENT_TAG)) ctx.run("rm Dockerfiles/agent/datadog-agent*_amd64.deb") @task def integration_tests(ctx, install_deps=False, race=False, remote_docker=False): """ Run integration tests for the Agent """ if install_deps: deps(ctx) test_args = { "go_build_tags": " ".join(get_default_build_tags()), "race_opt": "-race" if race else "", "exec_opts": "", } if remote_docker: test_args["exec_opts"] = "-exec \"inv docker.dockerize-test\"" go_cmd = 'go test {race_opt} -tags "{go_build_tags}" {exec_opts}'.format(**test_args) prefixes = [ "./test/integration/config_providers/...", "./test/integration/corechecks/...", "./test/integration/listeners/...", "./test/integration/util/kubelet/...", ] for prefix in prefixes: ctx.run("{} {}".format(go_cmd, prefix)) @task(help={'skip-sign': "On macOS, use this option to build an unsigned package if you don't have Datadog's developer keys."}) def omnibus_build(ctx, puppy=False, log_level="info", base_dir=None, gem_path=None, skip_deps=False, skip_sign=False, release_version="nightly", omnibus_s3_cache=False): """ Build the Agent packages with Omnibus Installer. """ if not skip_deps: deps(ctx, no_checks=True) # no_checks since the omnibus build installs checks with a dedicated software def # omnibus config overrides overrides = [] # base dir (can be overridden through env vars, command line takes precedence) base_dir = base_dir or os.environ.get("OMNIBUS_BASE_DIR") if base_dir: overrides.append("base_dir:{}".format(base_dir)) overrides_cmd = "" if overrides: overrides_cmd = "--override=" + " ".join(overrides) with ctx.cd("omnibus"): env = load_release_versions(ctx, release_version) cmd = "bundle install" if gem_path: cmd += " --path {}".format(gem_path) ctx.run(cmd, env=env) omnibus = "bundle exec omnibus.bat" if sys.platform == 'win32' else "bundle exec omnibus" cmd = "{omnibus} build {project_name} --log-level={log_level} {populate_s3_cache} {overrides}" args = { "omnibus": omnibus, "project_name": "puppy" if puppy else "agent", "log_level": log_level, "overrides": overrides_cmd, "populate_s3_cache": "" } if omnibus_s3_cache: args['populate_s3_cache'] = " --populate-s3-cache " if skip_sign: env['SKIP_SIGN_MAC'] = 'true' ctx.run(cmd.format(**args), env=env) @task def clean(ctx): """ Remove temporary objects and binary artifacts """ # go clean print("Executing go clean") ctx.run("go clean") # remove the bin/agent folder print("Remove agent binary folder") ctx.run("rm -rf ./bin/agent")
the-stack_0_3458
import pymysql from .function import create_insert_sql_values, create_update_sql, create_insert_sql_column from . import SQLConfig class MySqldb(object): def __init__(self): self.SQLConfig = SQLConfig # self.db = pymysql.connect(SQLConfig.SQL_ADDRESS,SQLConfig.SQL_USERNAME,\ # SQLConfig.SQL_PASSWORD,SQLConfig.SQL_DATABASE) def connect(self): self.db = pymysql.connect(self.SQLConfig.SQL_ADDRESS,self.SQLConfig.SQL_USERNAME,\ self.SQLConfig.SQL_PASSWORD,self.SQLConfig.SQL_DATABASE) # 一共就四个方法,增删改查。 # 增,也就是insert # 增加一共有两个变量,一个是需要增加到哪个表里面去,另一个是数据。 # 数据必须是一个dict def insert(self, table, values): if not isinstance(values,dict): raise TypeError('values must be dict') if not isinstance(table,str): raise TypeError('table must be str') cursor = self.db.cursor() # 创建sql sql = "INSERT INTO %s%s VALUES %s"%(table,\ create_insert_sql_column(values),create_insert_sql_values(values)) try: cursor.execute(sql) self.db.commit() return True except: print('insert fail') return False # 删除,变量只有两个 # 表名, 条件 def delete(self, table, condition): if not isinstance(condition,dict): raise TypeError('condition must be dict') if not isinstance(table,str): raise TypeError('table must be str') cursor = self.db.cursor() sql = "DELETE FROM %s WHERE %s = '%s'" % \ (table,list(condition.keys())[0],condition[list(condition.keys())[0]]) try: cursor.execute(sql) self.db.commit() return True except: print('delete fail') return False # 改 # 传入参数依次为,表名,需要修改的值, 寻找条件 def update(self, table, values, condition): if not isinstance(condition,dict): raise TypeError('condition must be dict') if not isinstance(values,dict): raise TypeError('values must be dict') if not isinstance(table,str): raise TypeError('table must be str') cursor = self.db.cursor() sql = "UPDATE %s SET %s WHERE %s = '%s'"%\ (table,create_update_sql(values),list(condition.keys())[0],condition[list(condition.keys())[0]]) try: print(sql) cursor.execute(sql) self.db.commit() return True except: print("update fail") return False # 全查 # 传入参数依次:表名 def list_all(self, table): if not isinstance(table,str): raise TypeError('table must be str') cursor = self.db.cursor() # 获取当前表头 sql = "select COLUMN_NAME from information_schema.COLUMNS where table_name = '%s'"%(table) cursor.execute(sql) table_name = cursor.fetchall() table_column = [] for i in table_name: table_column.append(i[0]) sql = "SELECT * FROM %s" % (table) try: cursor.execute(sql) table_data = [] data = cursor.fetchall() for i in data: table_data.append(dict(zip(table_column,list(i)))) return table_data except: print('get fail') return False def list_one(self, table, condition): if not isinstance(condition,dict): raise TypeError('condition must be dict') if not isinstance(table,str): raise TypeError('table must be str') cursor = self.db.cursor() # 获取当前表头 sql = "select COLUMN_NAME from information_schema.COLUMNS where table_name = '%s'"%(table) cursor.execute(sql) table_name = cursor.fetchall() table_column = [] for i in table_name: table_column.append(i[0]) sql = "SELECT * FROM %s WHERE %s = '%s'" % (table,\ list(condition.keys())[0], condition[list(condition.keys())[0]]) try: cursor.execute(sql) table_data = [] data = cursor.fetchall() for i in data: table_data.append(dict(zip(table_column,list(i)))) return table_data except: print("list one fail") return False def list_column(self, table, columns): if not isinstance(table,str): raise TypeError('table must be str') if not isinstance(columns,list): raise TypeError('columns must be list') cursor = self.db.cursor() sql = "SELECT %s FROM %s" % (",".join(columns),table) try: cursor.execute(sql) data = cursor.fetchall() columnData = [] for i in data: columnData.append(i[0]) return columnData except: print("list one fail") return False def close(self): self.db.close()
the-stack_0_3459
from oracles.abstract_oracle import * from json import loads import requests class WebStatusBinaryOracle(AbstractOracle): name = 'web_status_boolean_oracle' description = 'Creates a binary oracle based on HTTP status code' arguments = [OracleArgumentDescription('url','Base URL', True), OracleArgumentDescription('verb', 'HTTP Method for the request', False, defaultValue='GET'), OracleArgumentDescription('cipherparam', 'Parameter that contains the ciphertext', True), OracleArgumentDescription('params', 'Other parameters to add to the request', False, defaultValue='{}'), OracleArgumentDescription('goodstatuses', 'Comma separated list of good status codes', True), ] def makeoracle(self): url = self.get_argument_value('url') verb = self.get_argument_value('verb') cipherparam = self.get_argument_value('cipherparam') paramstring = self.get_argument_value('params') params = loads(paramstring) goodstatuses = set(map(int,self.get_argument_value('goodstatuses').split(','))) def oracle(ctext): params[cipherparam] = ctext if verb == 'GET': resp = requests.get(url,params=params) else: resp = requests.post(url,params=params) return resp.status_code in goodstatuses return oracle
the-stack_0_3460
# Copyright 2021 Karan Sharma - [email protected] # # Redistribution and use in source and binary forms, with or without modification, are permitted provided that the # following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, # INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import chess import tensorflow as tf from tensorflow import keras import numpy as np piece_cp_values = { chess.PAWN: 100, chess.KNIGHT: 300, chess.BISHOP: 300, chess.ROOK: 500, chess.QUEEN: 900, chess.KING: 0 } def boardToOneHotNNInput(board: chess.Board): array = np.zeros(320, dtype=int) piecesDict = board.piece_map() white_map = { chess.PAWN: [100, 0, 0, 0, 0], chess.KNIGHT: [0, 100, 0, 0, 0], chess.BISHOP: [0, 0, 100, 0, 0], chess.ROOK: [0, 0, 0, 100, 0], chess.QUEEN: [0, 0, 133, 100, 0], chess.KING: [0, 0, 0, 0, 100] } black_map = { chess.PAWN: [-100, 0, 0, 0, 0], chess.KNIGHT: [0, -100, 0, 0, 0], chess.BISHOP: [0, 0, -100, 0, 0], chess.ROOK: [0, 0, 0, -100, 0], chess.QUEEN: [0, 0, -133, -100, 0], chess.KING: [0, 0, 0, 0, -100] } data_map = { chess.WHITE: white_map, chess.BLACK: black_map } for square in piecesDict: piece = piecesDict.get(square) array[square*5:(square+1)*5] = data_map[piece.color][piece.piece_type] return np.array([array]) class Evaluator: def __init__(self, num_inputs: int, hidden_layer_sizes=[32, 32]): input = keras.Input(shape=(num_inputs,)) x = input for i in range(len(hidden_layer_sizes)): x = keras.layers.Dense(hidden_layer_sizes[i], activation="relu")(x) output = keras.layers.Dense(1)(x) self.model = keras.Model(inputs=input, outputs=output) def __init__(self, model: keras.Model): self.model = model def func(self, board: chess.Board) -> float: return 0.0 @classmethod def randomModelFromModel(cls, model: keras.Model, deviation=1): new_model = keras.models.clone_model(model) for layer in new_model.layers: layer.set_weights(np.random.uniform(layer.get_weights() - deviation, layer.get_weights() + deviation)) return Evaluator(new_model) class Evaluator_Type3(Evaluator): def func(self, board: chess.Board) -> float: return self.model.predict(boardToOneHotNNInput(board)) class ColorError(Exception): """Raised if the wrong chess color was detected""" pass class Engine: def __init__(self, evaluator: Evaluator, color: chess.Color): self.evaluator = evaluator self.color = color def best_move(self, board: chess.Board) -> chess.Move: if board.turn != self.color: raise ColorError def is_better(x, y): if self.color == chess.WHITE: return x > y else: return y > x high = None best_move = None for move in board.legal_moves: board.push(move) rating = self.evaluator.func(board) print("Considering " + move.uci() + ": " + str(rating)) #DEBUG if high is None or is_better(rating, high): high = rating best_move = move board.pop() return best_move # -------------------------------------------------- DEPRECATED CODE ------------------------------------------------- def boardToNNInput_deprecated(board: chess.Board): array = np.zeros(64, dtype=int) piecesDict = board.piece_map() for square in piecesDict: if piecesDict.get(square).color == chess.WHITE: array[square] = piece_cp_values[piecesDict.get(square).piece_type] else: array[square] = -piece_cp_values[piecesDict.get(square).piece_type] return np.array([array]) class Evaluator_Type1_deprecated(Evaluator): def func(self, board: chess.Board) -> float: input = boardToNNInput_deprecated(board) print("SHAPE:" + str(input.shape)) return self.model.predict(input)
the-stack_0_3462
""" Create the numpy.core.multiarray namespace for backward compatibility. In v1.16 the multiarray and umath c-extension modules were merged into a single _multiarray_umath extension module. So we replicate the old namespace by importing from the extension module. """ import functools from . import overrides from . import _multiarray_umath from ._multiarray_umath import * # noqa: F403 # These imports are needed for backward compatibility, # do not change them. issue gh-15518 # _get_ndarray_c_version is semi-public, on purpose not added to __all__ from ._multiarray_umath import ( _fastCopyAndTranspose, _flagdict, from_dlpack, _insert, _reconstruct, _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version, _set_madvise_hugepage, ) __all__ = [ '_ARRAY_API', 'ALLOW_THREADS', 'BUFSIZE', 'CLIP', 'DATETIMEUNITS', 'ITEM_HASOBJECT', 'ITEM_IS_POINTER', 'LIST_PICKLE', 'MAXDIMS', 'MAY_SHARE_BOUNDS', 'MAY_SHARE_EXACT', 'NEEDS_INIT', 'NEEDS_PYAPI', 'RAISE', 'USE_GETITEM', 'USE_SETITEM', 'WRAP', '_fastCopyAndTranspose', '_flagdict', 'from_dlpack', '_insert', '_reconstruct', '_vec_string', '_monotonicity', 'add_docstring', 'arange', 'array', 'asarray', 'asanyarray', 'ascontiguousarray', 'asfortranarray', 'bincount', 'broadcast', 'busday_count', 'busday_offset', 'busdaycalendar', 'can_cast', 'compare_chararrays', 'concatenate', 'copyto', 'correlate', 'correlate2', 'count_nonzero', 'c_einsum', 'datetime_as_string', 'datetime_data', 'dot', 'dragon4_positional', 'dragon4_scientific', 'dtype', 'empty', 'empty_like', 'error', 'flagsobj', 'flatiter', 'format_longfloat', 'frombuffer', 'fromfile', 'fromiter', 'fromstring', 'get_handler_name', 'get_handler_version', 'inner', 'interp', 'interp_complex', 'is_busday', 'lexsort', 'matmul', 'may_share_memory', 'min_scalar_type', 'ndarray', 'nditer', 'nested_iters', 'normalize_axis_index', 'packbits', 'promote_types', 'putmask', 'ravel_multi_index', 'result_type', 'scalar', 'set_datetimeparse_function', 'set_legacy_print_mode', 'set_numeric_ops', 'set_string_function', 'set_typeDict', 'shares_memory', 'tracemalloc_domain', 'typeinfo', 'unpackbits', 'unravel_index', 'vdot', 'where', 'zeros'] # For backward compatibility, make sure pickle imports these functions from here _reconstruct.__module__ = 'numpy.core.multiarray' scalar.__module__ = 'numpy.core.multiarray' from_dlpack.__module__ = 'numpy' arange.__module__ = 'numpy' array.__module__ = 'numpy' asarray.__module__ = 'numpy' asanyarray.__module__ = 'numpy' ascontiguousarray.__module__ = 'numpy' asfortranarray.__module__ = 'numpy' datetime_data.__module__ = 'numpy' empty.__module__ = 'numpy' frombuffer.__module__ = 'numpy' fromfile.__module__ = 'numpy' fromiter.__module__ = 'numpy' frompyfunc.__module__ = 'numpy' fromstring.__module__ = 'numpy' geterrobj.__module__ = 'numpy' may_share_memory.__module__ = 'numpy' nested_iters.__module__ = 'numpy' promote_types.__module__ = 'numpy' set_numeric_ops.__module__ = 'numpy' seterrobj.__module__ = 'numpy' zeros.__module__ = 'numpy' # We can't verify dispatcher signatures because NumPy's C functions don't # support introspection. array_function_from_c_func_and_dispatcher = functools.partial( overrides.array_function_from_dispatcher, module='numpy', docs_from_dispatcher=True, verify=False) @array_function_from_c_func_and_dispatcher(_multiarray_umath.empty_like) def empty_like(prototype, dtype=None, order=None, subok=None, shape=None): """ empty_like(prototype, dtype=None, order='K', subok=True, shape=None) Return a new array with the same shape and type as a given array. Parameters ---------- prototype : array_like The shape and data-type of `prototype` define these same attributes of the returned array. dtype : data-type, optional Overrides the data type of the result. .. versionadded:: 1.6.0 order : {'C', 'F', 'A', or 'K'}, optional Overrides the memory layout of the result. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `prototype` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `prototype` as closely as possible. .. versionadded:: 1.6.0 subok : bool, optional. If True, then the newly created array will use the sub-class type of `prototype`, otherwise it will be a base-class array. Defaults to True. shape : int or sequence of ints, optional. Overrides the shape of the result. If order='K' and the number of dimensions is unchanged, will try to keep order, otherwise, order='C' is implied. .. versionadded:: 1.17.0 Returns ------- out : ndarray Array of uninitialized (arbitrary) data with the same shape and type as `prototype`. See Also -------- ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. Notes ----- This function does *not* initialize the returned array; to do that use `zeros_like` or `ones_like` instead. It may be marginally faster than the functions that do set the array values. Examples -------- >>> a = ([1,2,3], [4,5,6]) # a is array-like >>> np.empty_like(a) array([[-1073741821, -1073741821, 3], # uninitialized [ 0, 0, -1073741821]]) >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) >>> np.empty_like(a) array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) """ return (prototype,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.concatenate) def concatenate(arrays, axis=None, out=None, *, dtype=None, casting=None): """ concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind") Join a sequence of arrays along an existing axis. Parameters ---------- a1, a2, ... : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to `axis` (the first, by default). axis : int, optional The axis along which the arrays will be joined. If axis is None, arrays are flattened before use. Default is 0. out : ndarray, optional If provided, the destination to place the result. The shape must be correct, matching that of what concatenate would have returned if no out argument were specified. dtype : str or dtype If provided, the destination array will have this dtype. Cannot be provided together with `out`. .. versionadded:: 1.20.0 casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur. Defaults to 'same_kind'. .. versionadded:: 1.20.0 Returns ------- res : ndarray The concatenated array. See Also -------- ma.concatenate : Concatenate function that preserves input masks. array_split : Split an array into multiple sub-arrays of equal or near-equal size. split : Split array into a list of multiple sub-arrays of equal size. hsplit : Split array into multiple sub-arrays horizontally (column wise). vsplit : Split array into multiple sub-arrays vertically (row wise). dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). stack : Stack a sequence of arrays along a new axis. block : Assemble arrays from blocks. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). column_stack : Stack 1-D arrays as columns into a 2-D array. Notes ----- When one or more of the arrays to be concatenated is a MaskedArray, this function will return a MaskedArray object instead of an ndarray, but the input masks are *not* preserved. In cases where a MaskedArray is expected as input, use the ma.concatenate function from the masked array module instead. Examples -------- >>> a = np.array([[1, 2], [3, 4]]) >>> b = np.array([[5, 6]]) >>> np.concatenate((a, b), axis=0) array([[1, 2], [3, 4], [5, 6]]) >>> np.concatenate((a, b.T), axis=1) array([[1, 2, 5], [3, 4, 6]]) >>> np.concatenate((a, b), axis=None) array([1, 2, 3, 4, 5, 6]) This function will not preserve masking of MaskedArray inputs. >>> a = np.ma.arange(3) >>> a[1] = np.ma.masked >>> b = np.arange(2, 5) >>> a masked_array(data=[0, --, 2], mask=[False, True, False], fill_value=999999) >>> b array([2, 3, 4]) >>> np.concatenate([a, b]) masked_array(data=[0, 1, 2, 2, 3, 4], mask=False, fill_value=999999) >>> np.ma.concatenate([a, b]) masked_array(data=[0, --, 2, 2, 3, 4], mask=[False, True, False, False, False, False], fill_value=999999) """ if out is not None: # optimize for the typical case where only arrays is provided arrays = list(arrays) arrays.append(out) return arrays @array_function_from_c_func_and_dispatcher(_multiarray_umath.inner) def inner(a, b): """ inner(a, b, /) Inner product of two arrays. Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes. Parameters ---------- a, b : array_like If `a` and `b` are nonscalar, their last dimensions must match. Returns ------- out : ndarray If `a` and `b` are both scalars or both 1-D arrays then a scalar is returned; otherwise an array is returned. ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` Raises ------ ValueError If both `a` and `b` are nonscalar and their last dimensions have different sizes. See Also -------- tensordot : Sum products over arbitrary axes. dot : Generalised matrix product, using second last dimension of `b`. einsum : Einstein summation convention. Notes ----- For vectors (1-D arrays) it computes the ordinary inner-product:: np.inner(a, b) = sum(a[:]*b[:]) More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`:: np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) or explicitly:: np.inner(a, b)[i0,...,ir-2,j0,...,js-2] = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) In addition `a` or `b` may be scalars, in which case:: np.inner(a,b) = a*b Examples -------- Ordinary inner product for vectors: >>> a = np.array([1,2,3]) >>> b = np.array([0,1,0]) >>> np.inner(a, b) 2 Some multidimensional examples: >>> a = np.arange(24).reshape((2,3,4)) >>> b = np.arange(4) >>> c = np.inner(a, b) >>> c.shape (2, 3) >>> c array([[ 14, 38, 62], [ 86, 110, 134]]) >>> a = np.arange(2).reshape((1,1,2)) >>> b = np.arange(6).reshape((3,2)) >>> c = np.inner(a, b) >>> c.shape (1, 1, 3) >>> c array([[[1, 3, 5]]]) An example where `b` is a scalar: >>> np.inner(np.eye(2), 7) array([[7., 0.], [0., 7.]]) """ return (a, b) @array_function_from_c_func_and_dispatcher(_multiarray_umath.where) def where(condition, x=None, y=None): """ where(condition, [x, y], /) Return elements chosen from `x` or `y` depending on `condition`. .. note:: When only `condition` is provided, this function is a shorthand for ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be preferred, as it behaves correctly for subclasses. The rest of this documentation covers only the case where all three arguments are provided. Parameters ---------- condition : array_like, bool Where True, yield `x`, otherwise yield `y`. x, y : array_like Values from which to choose. `x`, `y` and `condition` need to be broadcastable to some shape. Returns ------- out : ndarray An array with elements from `x` where `condition` is True, and elements from `y` elsewhere. See Also -------- choose nonzero : The function that is called when x and y are omitted Notes ----- If all the arrays are 1-D, `where` is equivalent to:: [xv if c else yv for c, xv, yv in zip(condition, x, y)] Examples -------- >>> a = np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.where(a < 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) This can be used on multidimensional arrays too: >>> np.where([[True, False], [True, True]], ... [[1, 2], [3, 4]], ... [[9, 8], [7, 6]]) array([[1, 8], [3, 4]]) The shapes of x, y, and the condition are broadcast together: >>> x, y = np.ogrid[:3, :4] >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast array([[10, 0, 0, 0], [10, 11, 1, 1], [10, 11, 12, 2]]) >>> a = np.array([[0, 1, 2], ... [0, 2, 4], ... [0, 3, 6]]) >>> np.where(a < 4, a, -1) # -1 is broadcast array([[ 0, 1, 2], [ 0, 2, -1], [ 0, 3, -1]]) """ return (condition, x, y) @array_function_from_c_func_and_dispatcher(_multiarray_umath.lexsort) def lexsort(keys, axis=None): """ lexsort(keys, axis=-1) Perform an indirect stable sort using a sequence of keys. Given multiple sorting keys, which can be interpreted as columns in a spreadsheet, lexsort returns an array of integer indices that describes the sort order by multiple columns. The last key in the sequence is used for the primary sort order, the second-to-last key for the secondary sort order, and so on. The keys argument must be a sequence of objects that can be converted to arrays of the same shape. If a 2D array is provided for the keys argument, its rows are interpreted as the sorting keys and sorting is according to the last row, second last row etc. Parameters ---------- keys : (k, N) array or tuple containing k (N,)-shaped sequences The `k` different "columns" to be sorted. The last column (or row if `keys` is a 2D array) is the primary sort key. axis : int, optional Axis to be indirectly sorted. By default, sort over the last axis. Returns ------- indices : (N,) ndarray of ints Array of indices that sort the keys along the specified axis. See Also -------- argsort : Indirect sort. ndarray.sort : In-place sort. sort : Return a sorted copy of an array. Examples -------- Sort names: first by surname, then by name. >>> surnames = ('Hertz', 'Galilei', 'Hertz') >>> first_names = ('Heinrich', 'Galileo', 'Gustav') >>> ind = np.lexsort((first_names, surnames)) >>> ind array([1, 2, 0]) >>> [surnames[i] + ", " + first_names[i] for i in ind] ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] Sort two columns of numbers: >>> a = [1,5,1,4,3,4,4] # First column >>> b = [9,4,0,4,0,2,1] # Second column >>> ind = np.lexsort((b,a)) # Sort by a, then by b >>> ind array([2, 0, 4, 6, 5, 3, 1]) >>> [(a[i],b[i]) for i in ind] [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] Note that sorting is first according to the elements of ``a``. Secondary sorting is according to the elements of ``b``. A normal ``argsort`` would have yielded: >>> [(a[i],b[i]) for i in np.argsort(a)] [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)] Structured arrays are sorted lexically by ``argsort``: >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], ... dtype=np.dtype([('x', int), ('y', int)])) >>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) array([2, 0, 4, 6, 5, 3, 1]) """ if isinstance(keys, tuple): return keys else: return (keys,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.can_cast) def can_cast(from_, to, casting=None): """ can_cast(from_, to, casting='safe') Returns True if cast between data types can occur according to the casting rule. If from is a scalar or array scalar, also returns True if the scalar value can be cast without overflow or truncation to an integer. Parameters ---------- from_ : dtype, dtype specifier, scalar, or array Data type, scalar, or array to cast from. to : dtype or dtype specifier Data type to cast to. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur. * 'no' means the data types should not be cast at all. * 'equiv' means only byte-order changes are allowed. * 'safe' means only casts which can preserve values are allowed. * 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. * 'unsafe' means any data conversions may be done. Returns ------- out : bool True if cast can occur according to the casting rule. Notes ----- .. versionchanged:: 1.17.0 Casting between a simple data type and a structured one is possible only for "unsafe" casting. Casting to multiple fields is allowed, but casting from multiple fields is not. .. versionchanged:: 1.9.0 Casting from numeric to string types in 'safe' casting mode requires that the string dtype length is long enough to store the maximum integer/float value converted. See also -------- dtype, result_type Examples -------- Basic examples >>> np.can_cast(np.int32, np.int64) True >>> np.can_cast(np.float64, complex) True >>> np.can_cast(complex, float) False >>> np.can_cast('i8', 'f8') True >>> np.can_cast('i8', 'f4') False >>> np.can_cast('i4', 'S4') False Casting scalars >>> np.can_cast(100, 'i1') True >>> np.can_cast(150, 'i1') False >>> np.can_cast(150, 'u1') True >>> np.can_cast(3.5e100, np.float32) False >>> np.can_cast(1000.0, np.float32) True Array scalar checks the value, array does not >>> np.can_cast(np.array(1000.0), np.float32) True >>> np.can_cast(np.array([1000.0]), np.float32) False Using the casting rules >>> np.can_cast('i8', 'i8', 'no') True >>> np.can_cast('<i8', '>i8', 'no') False >>> np.can_cast('<i8', '>i8', 'equiv') True >>> np.can_cast('<i4', '>i8', 'equiv') False >>> np.can_cast('<i4', '>i8', 'safe') True >>> np.can_cast('<i8', '>i4', 'safe') False >>> np.can_cast('<i8', '>i4', 'same_kind') True >>> np.can_cast('<i8', '>u4', 'same_kind') False >>> np.can_cast('<i8', '>u4', 'unsafe') True """ return (from_,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.min_scalar_type) def min_scalar_type(a): """ min_scalar_type(a, /) For scalar ``a``, returns the data type with the smallest size and smallest scalar kind which can hold its value. For non-scalar array ``a``, returns the vector's dtype unmodified. Floating point values are not demoted to integers, and complex values are not demoted to floats. Parameters ---------- a : scalar or array_like The value whose minimal data type is to be found. Returns ------- out : dtype The minimal data type. Notes ----- .. versionadded:: 1.6.0 See Also -------- result_type, promote_types, dtype, can_cast Examples -------- >>> np.min_scalar_type(10) dtype('uint8') >>> np.min_scalar_type(-260) dtype('int16') >>> np.min_scalar_type(3.1) dtype('float16') >>> np.min_scalar_type(1e50) dtype('float64') >>> np.min_scalar_type(np.arange(4,dtype='f8')) dtype('float64') """ return (a,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.result_type) def result_type(*arrays_and_dtypes): """ result_type(*arrays_and_dtypes) Returns the type that results from applying the NumPy type promotion rules to the arguments. Type promotion in NumPy works similarly to the rules in languages like C++, with some slight differences. When both scalars and arrays are used, the array's type takes precedence and the actual value of the scalar is taken into account. For example, calculating 3*a, where a is an array of 32-bit floats, intuitively should result in a 32-bit float output. If the 3 is a 32-bit integer, the NumPy rules indicate it can't convert losslessly into a 32-bit float, so a 64-bit float should be the result type. By examining the value of the constant, '3', we see that it fits in an 8-bit integer, which can be cast losslessly into the 32-bit float. Parameters ---------- arrays_and_dtypes : list of arrays and dtypes The operands of some operation whose result type is needed. Returns ------- out : dtype The result type. See also -------- dtype, promote_types, min_scalar_type, can_cast Notes ----- .. versionadded:: 1.6.0 The specific algorithm used is as follows. Categories are determined by first checking which of boolean, integer (int/uint), or floating point (float/complex) the maximum kind of all the arrays and the scalars are. If there are only scalars or the maximum category of the scalars is higher than the maximum category of the arrays, the data types are combined with :func:`promote_types` to produce the return value. Otherwise, `min_scalar_type` is called on each array, and the resulting data types are all combined with :func:`promote_types` to produce the return value. The set of int values is not a subset of the uint values for types with the same number of bits, something not reflected in :func:`min_scalar_type`, but handled as a special case in `result_type`. Examples -------- >>> np.result_type(3, np.arange(7, dtype='i1')) dtype('int8') >>> np.result_type('i4', 'c8') dtype('complex128') >>> np.result_type(3.0, -2) dtype('float64') """ return arrays_and_dtypes @array_function_from_c_func_and_dispatcher(_multiarray_umath.dot) def dot(a, b, out=None): """ dot(a, b, out=None) Dot product of two arrays. Specifically, - If both `a` and `b` are 1-D arrays, it is inner product of vectors (without complex conjugation). - If both `a` and `b` are 2-D arrays, it is matrix multiplication, but using :func:`matmul` or ``a @ b`` is preferred. - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred. - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over the last axis of `a` and `b`. - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a sum product over the last axis of `a` and the second-to-last axis of `b`:: dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) Parameters ---------- a : array_like First argument. b : array_like Second argument. out : ndarray, optional Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for `dot(a,b)`. This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible. Returns ------- output : ndarray Returns the dot product of `a` and `b`. If `a` and `b` are both scalars or both 1-D arrays then a scalar is returned; otherwise an array is returned. If `out` is given, then it is returned. Raises ------ ValueError If the last dimension of `a` is not the same size as the second-to-last dimension of `b`. See Also -------- vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. matmul : '@' operator as method with out parameter. linalg.multi_dot : Chained dot product. Examples -------- >>> np.dot(3, 4) 12 Neither argument is complex-conjugated: >>> np.dot([2j, 3j], [2j, 3j]) (-13+0j) For 2-D arrays it is the matrix product: >>> a = [[1, 0], [0, 1]] >>> b = [[4, 1], [2, 2]] >>> np.dot(a, b) array([[4, 1], [2, 2]]) >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) >>> np.dot(a, b)[2,3,2,1,2,2] 499128 >>> sum(a[2,3,2,:] * b[1,2,:,2]) 499128 """ return (a, b, out) @array_function_from_c_func_and_dispatcher(_multiarray_umath.vdot) def vdot(a, b): """ vdot(a, b, /) Return the dot product of two vectors. The vdot(`a`, `b`) function handles complex numbers differently than dot(`a`, `b`). If the first argument is complex the complex conjugate of the first argument is used for the calculation of the dot product. Note that `vdot` handles multidimensional arrays differently than `dot`: it does *not* perform a matrix product, but flattens input arguments to 1-D vectors first. Consequently, it should only be used for vectors. Parameters ---------- a : array_like If `a` is complex the complex conjugate is taken before calculation of the dot product. b : array_like Second argument to the dot product. Returns ------- output : ndarray Dot product of `a` and `b`. Can be an int, float, or complex depending on the types of `a` and `b`. See Also -------- dot : Return the dot product without using the complex conjugate of the first argument. Examples -------- >>> a = np.array([1+2j,3+4j]) >>> b = np.array([5+6j,7+8j]) >>> np.vdot(a, b) (70-8j) >>> np.vdot(b, a) (70+8j) Note that higher-dimensional arrays are flattened! >>> a = np.array([[1, 4], [5, 6]]) >>> b = np.array([[4, 1], [2, 2]]) >>> np.vdot(a, b) 30 >>> np.vdot(b, a) 30 >>> 1*4 + 4*1 + 5*2 + 6*2 30 """ return (a, b) @array_function_from_c_func_and_dispatcher(_multiarray_umath.bincount) def bincount(x, weights=None, minlength=None): """ bincount(x, /, weights=None, minlength=0) Count number of occurrences of each value in array of non-negative ints. The number of bins (of size 1) is one larger than the largest value in `x`. If `minlength` is specified, there will be at least this number of bins in the output array (though it will be longer if necessary, depending on the contents of `x`). Each bin gives the number of occurrences of its index value in `x`. If `weights` is specified the input array is weighted by it, i.e. if a value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead of ``out[n] += 1``. Parameters ---------- x : array_like, 1 dimension, nonnegative ints Input array. weights : array_like, optional Weights, array of the same shape as `x`. minlength : int, optional A minimum number of bins for the output array. .. versionadded:: 1.6.0 Returns ------- out : ndarray of ints The result of binning the input array. The length of `out` is equal to ``np.amax(x)+1``. Raises ------ ValueError If the input is not 1-dimensional, or contains elements with negative values, or if `minlength` is negative. TypeError If the type of the input is float or complex. See Also -------- histogram, digitize, unique Examples -------- >>> np.bincount(np.arange(5)) array([1, 1, 1, 1, 1]) >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) array([1, 3, 1, 1, 0, 0, 0, 1]) >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) >>> np.bincount(x).size == np.amax(x)+1 True The input array needs to be of integer dtype, otherwise a TypeError is raised: >>> np.bincount(np.arange(5, dtype=float)) Traceback (most recent call last): ... TypeError: Cannot cast array data from dtype('float64') to dtype('int64') according to the rule 'safe' A possible use of ``bincount`` is to perform sums over variable-size chunks of an array, using the ``weights`` keyword. >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights >>> x = np.array([0, 1, 1, 2, 2, 2]) >>> np.bincount(x, weights=w) array([ 0.3, 0.7, 1.1]) """ return (x, weights) @array_function_from_c_func_and_dispatcher(_multiarray_umath.ravel_multi_index) def ravel_multi_index(multi_index, dims, mode=None, order=None): """ ravel_multi_index(multi_index, dims, mode='raise', order='C') Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index. Parameters ---------- multi_index : tuple of array_like A tuple of integer arrays, one array for each dimension. dims : tuple of ints The shape of array into which the indices from ``multi_index`` apply. mode : {'raise', 'wrap', 'clip'}, optional Specifies how out-of-bounds indices are handled. Can specify either one mode or a tuple of modes, one mode per index. * 'raise' -- raise an error (default) * 'wrap' -- wrap around * 'clip' -- clip to the range In 'clip' mode, a negative index which would normally wrap will clip to 0 instead. order : {'C', 'F'}, optional Determines whether the multi-index should be viewed as indexing in row-major (C-style) or column-major (Fortran-style) order. Returns ------- raveled_indices : ndarray An array of indices into the flattened version of an array of dimensions ``dims``. See Also -------- unravel_index Notes ----- .. versionadded:: 1.6.0 Examples -------- >>> arr = np.array([[3,6,6],[4,5,1]]) >>> np.ravel_multi_index(arr, (7,6)) array([22, 41, 37]) >>> np.ravel_multi_index(arr, (7,6), order='F') array([31, 41, 13]) >>> np.ravel_multi_index(arr, (4,6), mode='clip') array([22, 23, 19]) >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')) array([12, 13, 13]) >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9)) 1621 """ return multi_index @array_function_from_c_func_and_dispatcher(_multiarray_umath.unravel_index) def unravel_index(indices, shape=None, order=None): """ unravel_index(indices, shape, order='C') Converts a flat index or array of flat indices into a tuple of coordinate arrays. Parameters ---------- indices : array_like An integer array whose elements are indices into the flattened version of an array of dimensions ``shape``. Before version 1.6.0, this function accepted just one index value. shape : tuple of ints The shape of the array to use for unraveling ``indices``. .. versionchanged:: 1.16.0 Renamed from ``dims`` to ``shape``. order : {'C', 'F'}, optional Determines whether the indices should be viewed as indexing in row-major (C-style) or column-major (Fortran-style) order. .. versionadded:: 1.6.0 Returns ------- unraveled_coords : tuple of ndarray Each array in the tuple has the same shape as the ``indices`` array. See Also -------- ravel_multi_index Examples -------- >>> np.unravel_index([22, 41, 37], (7,6)) (array([3, 6, 6]), array([4, 5, 1])) >>> np.unravel_index([31, 41, 13], (7,6), order='F') (array([3, 6, 6]), array([4, 5, 1])) >>> np.unravel_index(1621, (6,7,8,9)) (3, 1, 4, 1) """ return (indices,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.copyto) def copyto(dst, src, casting=None, where=None): """ copyto(dst, src, casting='same_kind', where=True) Copies values from one array to another, broadcasting as necessary. Raises a TypeError if the `casting` rule is violated, and if `where` is provided, it selects which elements to copy. .. versionadded:: 1.7.0 Parameters ---------- dst : ndarray The array into which values are copied. src : array_like The array from which values are copied. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur when copying. * 'no' means the data types should not be cast at all. * 'equiv' means only byte-order changes are allowed. * 'safe' means only casts which can preserve values are allowed. * 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. * 'unsafe' means any data conversions may be done. where : array_like of bool, optional A boolean array which is broadcasted to match the dimensions of `dst`, and selects elements to copy from `src` to `dst` wherever it contains the value True. """ return (dst, src, where) @array_function_from_c_func_and_dispatcher(_multiarray_umath.putmask) def putmask(a, mask, values): """ putmask(a, mask, values) Changes elements of an array based on conditional and input values. Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``. If `values` is not the same size as `a` and `mask` then it will repeat. This gives behavior different from ``a[mask] = values``. Parameters ---------- a : ndarray Target array. mask : array_like Boolean mask array. It has to be the same shape as `a`. values : array_like Values to put into `a` where `mask` is True. If `values` is smaller than `a` it will be repeated. See Also -------- place, put, take, copyto Examples -------- >>> x = np.arange(6).reshape(2, 3) >>> np.putmask(x, x>2, x**2) >>> x array([[ 0, 1, 2], [ 9, 16, 25]]) If `values` is smaller than `a` it is repeated: >>> x = np.arange(5) >>> np.putmask(x, x>1, [-33, -44]) >>> x array([ 0, 1, -33, -44, -33]) """ return (a, mask, values) @array_function_from_c_func_and_dispatcher(_multiarray_umath.packbits) def packbits(a, axis=None, bitorder='big'): """ packbits(a, /, axis=None, bitorder='big') Packs the elements of a binary-valued array into bits in a uint8 array. The result is padded to full bytes by inserting zero bits at the end. Parameters ---------- a : array_like An array of integers or booleans whose elements should be packed to bits. axis : int, optional The dimension over which bit-packing is done. ``None`` implies packing the flattened array. bitorder : {'big', 'little'}, optional The order of the input bits. 'big' will mimic bin(val), ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``. Defaults to 'big'. .. versionadded:: 1.17.0 Returns ------- packed : ndarray Array of type uint8 whose elements represent bits corresponding to the logical (0 or nonzero) value of the input elements. The shape of `packed` has the same number of dimensions as the input (unless `axis` is None, in which case the output is 1-D). See Also -------- unpackbits: Unpacks elements of a uint8 array into a binary-valued output array. Examples -------- >>> a = np.array([[[1,0,1], ... [0,1,0]], ... [[1,1,0], ... [0,0,1]]]) >>> b = np.packbits(a, axis=-1) >>> b array([[[160], [ 64]], [[192], [ 32]]], dtype=uint8) Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, and 32 = 0010 0000. """ return (a,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.unpackbits) def unpackbits(a, axis=None, count=None, bitorder='big'): """ unpackbits(a, /, axis=None, count=None, bitorder='big') Unpacks elements of a uint8 array into a binary-valued output array. Each element of `a` represents a bit-field that should be unpacked into a binary-valued output array. The shape of the output array is either 1-D (if `axis` is ``None``) or the same shape as the input array with unpacking done along the axis specified. Parameters ---------- a : ndarray, uint8 type Input array. axis : int, optional The dimension over which bit-unpacking is done. ``None`` implies unpacking the flattened array. count : int or None, optional The number of elements to unpack along `axis`, provided as a way of undoing the effect of packing a size that is not a multiple of eight. A non-negative number means to only unpack `count` bits. A negative number means to trim off that many bits from the end. ``None`` means to unpack the entire array (the default). Counts larger than the available number of bits will add zero padding to the output. Negative counts must not exceed the available number of bits. .. versionadded:: 1.17.0 bitorder : {'big', 'little'}, optional The order of the returned bits. 'big' will mimic bin(val), ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``. Defaults to 'big'. .. versionadded:: 1.17.0 Returns ------- unpacked : ndarray, uint8 type The elements are binary-valued (0 or 1). See Also -------- packbits : Packs the elements of a binary-valued array into bits in a uint8 array. Examples -------- >>> a = np.array([[2], [7], [23]], dtype=np.uint8) >>> a array([[ 2], [ 7], [23]], dtype=uint8) >>> b = np.unpackbits(a, axis=1) >>> b array([[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) >>> c = np.unpackbits(a, axis=1, count=-3) >>> c array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0]], dtype=uint8) >>> p = np.packbits(b, axis=0) >>> np.unpackbits(p, axis=0) array([[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) True """ return (a,) @array_function_from_c_func_and_dispatcher(_multiarray_umath.shares_memory) def shares_memory(a, b, max_work=None): """ shares_memory(a, b, /, max_work=None) Determine if two arrays share memory. .. warning:: This function can be exponentially slow for some inputs, unless `max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``. If in doubt, use `numpy.may_share_memory` instead. Parameters ---------- a, b : ndarray Input arrays max_work : int, optional Effort to spend on solving the overlap problem (maximum number of candidate solutions to consider). The following special values are recognized: max_work=MAY_SHARE_EXACT (default) The problem is solved exactly. In this case, the function returns True only if there is an element shared between the arrays. Finding the exact solution may take extremely long in some cases. max_work=MAY_SHARE_BOUNDS Only the memory bounds of a and b are checked. Raises ------ numpy.TooHardError Exceeded max_work. Returns ------- out : bool See Also -------- may_share_memory Examples -------- >>> x = np.array([1, 2, 3, 4]) >>> np.shares_memory(x, np.array([5, 6, 7])) False >>> np.shares_memory(x[::2], x) True >>> np.shares_memory(x[::2], x[1::2]) False Checking whether two arrays share memory is NP-complete, and runtime may increase exponentially in the number of dimensions. Hence, `max_work` should generally be set to a finite number, as it is possible to construct examples that take extremely long to run: >>> from numpy.lib.stride_tricks import as_strided >>> x = np.zeros([192163377], dtype=np.int8) >>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049)) >>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1)) >>> np.shares_memory(x1, x2, max_work=1000) Traceback (most recent call last): ... numpy.TooHardError: Exceeded max_work Running ``np.shares_memory(x1, x2)`` without `max_work` set takes around 1 minute for this case. It is possible to find problems that take still significantly longer. """ return (a, b) @array_function_from_c_func_and_dispatcher(_multiarray_umath.may_share_memory) def may_share_memory(a, b, max_work=None): """ may_share_memory(a, b, /, max_work=None) Determine if two arrays might share memory A return of True does not necessarily mean that the two arrays share any element. It just means that they *might*. Only the memory bounds of a and b are checked by default. Parameters ---------- a, b : ndarray Input arrays max_work : int, optional Effort to spend on solving the overlap problem. See `shares_memory` for details. Default for ``may_share_memory`` is to do a bounds check. Returns ------- out : bool See Also -------- shares_memory Examples -------- >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9])) False >>> x = np.zeros([3, 4]) >>> np.may_share_memory(x[:,0], x[:,1]) True """ return (a, b) @array_function_from_c_func_and_dispatcher(_multiarray_umath.is_busday) def is_busday(dates, weekmask=None, holidays=None, busdaycal=None, out=None): """ is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None) Calculates which of the given dates are valid days, and which are not. .. versionadded:: 1.7.0 Parameters ---------- dates : array_like of datetime64[D] The array of dates to process. weekmask : str or array_like of bool, optional A seven-element array indicating which of Monday through Sunday are valid days. May be specified as a length-seven list or array, like [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for weekdays, optionally separated by white space. Valid abbreviations are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional An array of dates to consider as invalid dates. They may be specified in any order, and NaT (not-a-time) dates are ignored. This list is saved in a normalized form that is suited for fast calculations of valid days. busdaycal : busdaycalendar, optional A `busdaycalendar` object which specifies the valid days. If this parameter is provided, neither weekmask nor holidays may be provided. out : array of bool, optional If provided, this array is filled with the result. Returns ------- out : array of bool An array with the same shape as ``dates``, containing True for each valid day, and False for each invalid day. See Also -------- busdaycalendar : An object that specifies a custom set of valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range. Examples -------- >>> # The weekdays are Friday, Saturday, and Monday ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) array([False, False, True]) """ return (dates, weekmask, holidays, out) @array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_offset) def busday_offset(dates, offsets, roll=None, weekmask=None, holidays=None, busdaycal=None, out=None): """ busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None) First adjusts the date to fall on a valid day according to the ``roll`` rule, then applies offsets to the given dates counted in valid days. .. versionadded:: 1.7.0 Parameters ---------- dates : array_like of datetime64[D] The array of dates to process. offsets : array_like of int The array of offsets, which is broadcast with ``dates``. roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional How to treat dates that do not fall on a valid day. The default is 'raise'. * 'raise' means to raise an exception for an invalid day. * 'nat' means to return a NaT (not-a-time) for an invalid day. * 'forward' and 'following' mean to take the first valid day later in time. * 'backward' and 'preceding' mean to take the first valid day earlier in time. * 'modifiedfollowing' means to take the first valid day later in time unless it is across a Month boundary, in which case to take the first valid day earlier in time. * 'modifiedpreceding' means to take the first valid day earlier in time unless it is across a Month boundary, in which case to take the first valid day later in time. weekmask : str or array_like of bool, optional A seven-element array indicating which of Monday through Sunday are valid days. May be specified as a length-seven list or array, like [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for weekdays, optionally separated by white space. Valid abbreviations are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional An array of dates to consider as invalid dates. They may be specified in any order, and NaT (not-a-time) dates are ignored. This list is saved in a normalized form that is suited for fast calculations of valid days. busdaycal : busdaycalendar, optional A `busdaycalendar` object which specifies the valid days. If this parameter is provided, neither weekmask nor holidays may be provided. out : array of datetime64[D], optional If provided, this array is filled with the result. Returns ------- out : array of datetime64[D] An array with a shape from broadcasting ``dates`` and ``offsets`` together, containing the dates with offsets applied. See Also -------- busdaycalendar : An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_count : Counts how many valid days are in a half-open date range. Examples -------- >>> # First business day in October 2011 (not accounting for holidays) ... np.busday_offset('2011-10', 0, roll='forward') numpy.datetime64('2011-10-03') >>> # Last business day in February 2012 (not accounting for holidays) ... np.busday_offset('2012-03', -1, roll='forward') numpy.datetime64('2012-02-29') >>> # Third Wednesday in January 2011 ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') numpy.datetime64('2011-01-19') >>> # 2012 Mother's Day in Canada and the U.S. ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') numpy.datetime64('2012-05-13') >>> # First business day on or after a date ... np.busday_offset('2011-03-20', 0, roll='forward') numpy.datetime64('2011-03-21') >>> np.busday_offset('2011-03-22', 0, roll='forward') numpy.datetime64('2011-03-22') >>> # First business day after a date ... np.busday_offset('2011-03-20', 1, roll='backward') numpy.datetime64('2011-03-21') >>> np.busday_offset('2011-03-22', 1, roll='backward') numpy.datetime64('2011-03-23') """ return (dates, offsets, weekmask, holidays, out) @array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_count) def busday_count(begindates, enddates, weekmask=None, holidays=None, busdaycal=None, out=None): """ busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None) Counts the number of valid days between `begindates` and `enddates`, not including the day of `enddates`. If ``enddates`` specifies a date value that is earlier than the corresponding ``begindates`` date value, the count will be negative. .. versionadded:: 1.7.0 Parameters ---------- begindates : array_like of datetime64[D] The array of the first dates for counting. enddates : array_like of datetime64[D] The array of the end dates for counting, which are excluded from the count themselves. weekmask : str or array_like of bool, optional A seven-element array indicating which of Monday through Sunday are valid days. May be specified as a length-seven list or array, like [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for weekdays, optionally separated by white space. Valid abbreviations are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional An array of dates to consider as invalid dates. They may be specified in any order, and NaT (not-a-time) dates are ignored. This list is saved in a normalized form that is suited for fast calculations of valid days. busdaycal : busdaycalendar, optional A `busdaycalendar` object which specifies the valid days. If this parameter is provided, neither weekmask nor holidays may be provided. out : array of int, optional If provided, this array is filled with the result. Returns ------- out : array of int An array with a shape from broadcasting ``begindates`` and ``enddates`` together, containing the number of valid days between the begin and end dates. See Also -------- busdaycalendar : An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days. Examples -------- >>> # Number of weekdays in January 2011 ... np.busday_count('2011-01', '2011-02') 21 >>> # Number of weekdays in 2011 >>> np.busday_count('2011', '2012') 260 >>> # Number of Saturdays in 2011 ... np.busday_count('2011', '2012', weekmask='Sat') 53 """ return (begindates, enddates, weekmask, holidays, out) @array_function_from_c_func_and_dispatcher( _multiarray_umath.datetime_as_string) def datetime_as_string(arr, unit=None, timezone=None, casting=None): """ datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind') Convert an array of datetimes into an array of strings. Parameters ---------- arr : array_like of datetime64 The array of UTC timestamps to format. unit : str One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`. timezone : {'naive', 'UTC', 'local'} or tzinfo Timezone information to use when displaying the datetime. If 'UTC', end with a Z to indicate UTC time. If 'local', convert to the local timezone first, and suffix with a +-#### timezone offset. If a tzinfo object, then do as with 'local', but use the specified timezone. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'} Casting to allow when changing between datetime units. Returns ------- str_arr : ndarray An array of strings the same shape as `arr`. Examples -------- >>> import pytz >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') >>> d array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30', '2002-10-27T07:30'], dtype='datetime64[m]') Setting the timezone to UTC shows the same information, but with a Z suffix >>> np.datetime_as_string(d, timezone='UTC') array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z', '2002-10-27T07:30Z'], dtype='<U35') Note that we picked datetimes that cross a DST boundary. Passing in a ``pytz`` timezone object will print the appropriate offset >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400', '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39') Passing in a unit will change the precision >>> np.datetime_as_string(d, unit='h') array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'], dtype='<U32') >>> np.datetime_as_string(d, unit='s') array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00', '2002-10-27T07:30:00'], dtype='<U38') 'casting' can be used to specify whether precision can be changed >>> np.datetime_as_string(d, unit='h', casting='safe') Traceback (most recent call last): ... TypeError: Cannot create a datetime string as units 'h' from a NumPy datetime with units 'm' according to the rule 'safe' """ return (arr,)
the-stack_0_3464
# Third party from github import UnknownObjectException # Local from utils import ( set_up_github_client, get_cc_organization, get_team_slug_name ) PERMISSIONS = { 'Project Contributor': None, 'Project Collaborator': 'triage', 'Project Core Committer': 'push', 'Project Maintainer': 'maintain' } def create_teams_for_data(databag): client = set_up_github_client() organization = get_cc_organization(client) print("Creating and populating teams...") projects = databag["projects"] for project in projects: project_name = project["name"] print(f" Creating and populating teams for project {project_name}...") roles = project["roles"] for role, members in roles.items(): if PERMISSIONS[role] is None: print(f" Skipping {role} as it has no privileges.") continue print(f" Finding team for role {role}...") team = map_role_to_team(organization, project_name, role) print(" Done.") print(f" Populating repos for team {team.name}...") repos = project["repos"] map_team_to_repos(organization, team, repos, True) set_team_repo_permissions(team, PERMISSIONS[role]) print(" Done.") print(f" Populating members for team {team.name}...") members = [member["github"] for member in members] map_team_to_members(client, team, members, True) print(" Done.") print(" Done.") print("Done.") def map_team_to_members(client, team, final_user_logins, non_destructive=False): """ Map the team to the given set of members. Any members that are not already a part of the team will be added and any additional members that are a part of the team will be removed, unless chosen not to. @param client: the GitHub client @param team: the Team object representing the team @param final_user_logins: the list of users to associate with the team @param non_destructive: whether to trim extra repos or preserve them """ initial_users = team.get_members() initial_user_logins = [user.login for user in initial_users] if not non_destructive: users_to_drop = [ member for member in initial_users if member.login not in final_user_logins ] for user in users_to_drop: team.remove_membership(user) users_to_add = [ client.get_user(login) for login in final_user_logins if login not in initial_user_logins ] for user in users_to_add: team.add_membership(user) current_login = client.get_user().login if current_login not in final_user_logins: current_user = client.get_user(current_login) team.remove_membership(current_user) def map_team_to_repos(organization, team, final_repo_names, non_destructive=False): """ Map the team to the given set of repositories. Any repositories that are not already a part of the team will be added and any additional repositories that are a part of the team will be removed, unless chosen not to. @param organization: the Organisation object of which the team is a part @param team: the Team object representing the team @param final_repo_names: the list of repo names to associate with the team @param non_destructive: whether to trim extra repos or preserve them """ initial_repos = team.get_repos() initial_repo_names = [repo.name for repo in initial_repos] if not non_destructive: repos_to_drop = [ repo for repo in initial_repos if repo.name not in final_repo_names ] for repo in repos_to_drop: team.remove_from_repos(repo) repos_to_add = [ organization.get_repo(repo_name) for repo_name in final_repo_names if repo_name not in initial_repo_names ] for repo in repos_to_add: team.add_to_repos(repo) def set_team_repo_permissions(team, permission): """ Set the given permission for each repository belonging to the team. The permissions are determined by the role corresponding to team. @param team: the team to update the permissions for @param permission: the permission to set on each repo assigned to the team """ repos = team.get_repos() for repo in repos: print(f" Populating {permission} permission on {repo} repo...") team.set_repo_permission(repo, permission) print(" Done.") def map_role_to_team(organization, project_name, role, create_if_absent=True): """ Map the given role in the given project to a team. Creates the team if one such does not already exist. @param organization: the Organisation object of which the team is a part @param project_name: the name of the project to which the team belongs @param role: the role held by folks in the team @param create_if_absent: whether to create the team if it does not exist @return: the team associated with the role """ team_slug, team_name = get_team_slug_name(project_name, role) properties = { 'name': team_name, 'description': (f'Community Team for {project_name} ' f'containing folks with the role "{role}"'), 'privacy': 'closed' } try: team = organization.get_team_by_slug(team_slug) print(" Team exists, reconciling...") if team.description == properties['description']: del properties['description'] if team.privacy == properties['privacy']: del properties['privacy'] if properties: team.edit(**properties) print(" Done.") except UnknownObjectException: if not create_if_absent: print(" Did not exist, not creating.") team = None else: print(" Did not exist, creating...") team = organization.create_team(**properties) print(" Done.") return team
the-stack_0_3465
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import os import argparse import itertools from pathlib import Path from typing import Iterator, List, Optional, Any import numpy as np import pandas as pd from matplotlib import pyplot as plt from matplotlib import cm from ..common import tools from ..common.typetools import PathLike # pylint: disable=too-many-locals _DPI = 100 # %% Basic tools def _make_style_generator() -> Iterator[str]: lines = itertools.cycle(["-", "--", ":", "-."]) # 4 markers = itertools.cycle("ov^<>8sp*hHDd") # 13 colors = itertools.cycle("bgrcmyk") # 7 return (l + m + c for l, m, c in zip(lines, markers, colors)) class NameStyle(dict): """Provides a style for each name, and keeps to it """ def __init__(self) -> None: super().__init__() self._gen = _make_style_generator() def __getitem__(self, name: str) -> Any: if name not in self: self[name] = next(self._gen) return super().__getitem__(name) def _make_winners_df(df: pd.DataFrame, all_optimizers: List[str]) -> tools.Selector: """Finds mean loss over all runs for each of the optimizers, and creates a matrix winner_ij = 1 if opt_i is better (lower loss) then opt_j (and .5 for ties) """ if not isinstance(df, tools.Selector): df = tools.Selector(df) all_optim_set = set(all_optimizers) assert all(x in all_optim_set for x in df.unique("optimizer_name")) assert all(x in df.columns for x in ["optimizer_name", "loss"]) winners = tools.Selector(index=all_optimizers, columns=all_optimizers, data=0.) grouped = df.loc[:, ["optimizer_name", "loss"]].groupby(["optimizer_name"]).mean() df_optimizers = list(grouped.index) values = np.array(grouped) diffs = values - values.T # loss_ij = 1 means opt_i beats opt_j once (beating means getting a lower loss/regret) winners.loc[df_optimizers, df_optimizers] = (diffs < 0) + .5 * (diffs == 0) return winners def _make_sorted_winrates_df(victories: pd.DataFrame) -> pd.DataFrame: """Converts a dataframe counting number of victories into a sorted winrate dataframe. The algorithm which performs better than all other algorithms comes first. """ assert all(x == y for x, y in zip(victories.index, victories.columns)) winrates = victories / (victories + victories.T) mean_win = winrates.mean(axis=1).sort_values(ascending=False) return winrates.loc[mean_win.index, mean_win.index] # %% plotting functions def remove_errors(df: pd.DataFrame) -> tools.Selector: df = tools.Selector(df) if "error" not in df.columns: # backward compatibility return df # type: ignore # errors with no recommendation errordf = df.select(error=lambda x: isinstance(x, str) and x, loss=np.isnan) for _, row in errordf.iterrows(): print(f'Removing "{row["optimizer_name"]}" with dimension {row["dimension"]}: got error "{row["error"]}".') # error with recoreded recommendation handlederrordf = df.select(error=lambda x: isinstance(x, str) and x, loss=lambda x: not np.isnan(x)) for _, row in handlederrordf.iterrows(): print(f'Keeping non-optimal recommendation of "{row["optimizer_name"]}" ' f'with dimension {row["dimension"]} which raised "{row["error"]}".') err_inds = set(errordf.index) output = df.loc[[i for i in df.index if i not in err_inds], [c for c in df.columns if c != "error"]] assert not output.loc[:, "loss"].isnull().values.any(), "Some nan values remain while there should not be any!" output = tools.Selector(output.reset_index(drop=True)) return output # type: ignore def create_plots(df: pd.DataFrame, output_folder: PathLike, max_combsize: int = 1) -> None: """Saves all representing plots to the provided folder Parameters ---------- df: pd.DataFrame the experiment data output_folder: PathLike path of the folder where the plots should be saved max_combsize: int maximum number of parameters to fix (combinations) when creating experiment plots """ df = remove_errors(df) df.loc[:, "loss"] = pd.to_numeric(df.loc[:, "loss"]) df = tools.Selector(df.fillna("N-A")) # remove NaN in non score values assert not any("Unnamed: " in x for x in df.columns), f"Remove the unnamed index column: {df.columns}" assert "error " not in df.columns, f"Remove error rows before plotting" required = {"optimizer_name", "budget", "loss", "elapsed_time", "elapsed_budget"} missing = required - set(df.columns) assert not missing, f"Missing fields: {missing}" output_folder = Path(output_folder) os.makedirs(output_folder, exist_ok=True) # check which descriptors do vary descriptors = sorted(set(df.columns) - (required | {"seed"})) # all other columns are descriptors to_drop = [x for x in descriptors if len(df.unique(x)) == 1] df = tools.Selector(df.loc[:, [x for x in df.columns if x not in to_drop]]) descriptors = sorted(set(df.columns) - (required | {"seed"})) # now those should be actual interesting descriptors print(f"Descriptors: {descriptors}") # # fight plot # choice of the combination variables to fix fight_descriptors = descriptors + ["budget"] # budget can be used as a descriptor for fight plots combinable = [x for x in fight_descriptors if len(df.unique(x)) > 1] # should be all now num_rows = 6 for fixed in list(itertools.chain.from_iterable(itertools.combinations(combinable, order) for order in range(max_combsize + 1))): # choice of the cases with values for the fixed variables for case in df.unique(fixed): print("\n# new case #", fixed, case) casedf = df.select(**dict(zip(fixed, case))) name = "fight_" + ",".join("{}{}".format(x, y) for x, y in zip(fixed, case)) + ".png" name = "fight_all.png" if name == "fight_.png" else name make_fight_plot(casedf, fight_descriptors, num_rows, output_folder / name) plt.close("all") # # xp plots # plot mean loss / budget for each optimizer for 1 context name_style = NameStyle() # keep the same style for each algorithm for case in df.unique(descriptors): subdf = df.select_and_drop(**dict(zip(descriptors, case))) description = ",".join("{}:{}".format(x, y) for x, y in zip(descriptors, case)) out_filepath = output_folder / "xpresults{}{}.png".format("_" if description else "", description.replace(":", "")) make_xpresults_plot(subdf, description, out_filepath, name_style) plt.close("all") def make_xpresults_plot(df: pd.DataFrame, title: str, output_filepath: Optional[PathLike] = None, name_style: Optional[dict] = None) -> None: """Creates a xp result plot out of the given dataframe: regret with respect to budget for each optimizer after averaging on all experiments (it is good practice to use a df which is filtered out for one set of input parameters) Parameters ---------- df: pd.DataFrame run data title: str title of the plot output_filepath: Path If present, saves the plot to the given path name_style: dict a dict or dict-like object providing a line style for each optimizer name. (can be helpful for consistency across plots) """ if name_style is None: name_style = NameStyle() df = tools.Selector(df.loc[:, ["optimizer_name", "budget", "loss"]]) groupeddf = df.groupby(["optimizer_name", "budget"]).mean() groupeddf_std = df.groupby(["optimizer_name", "budget"]).std().loc[groupeddf.index, :] # std is currently unused plt.clf() plt.xlabel("Budget") plt.ylabel("Loss") plt.grid(True, which='both') optim_vals = {} # extract name and coordinates for optim in df.unique("optimizer_name"): xvals = np.array(groupeddf.loc[optim, :].index) yvals = np.maximum(1e-30, np.array(groupeddf.loc[optim, :].loc[:, "loss"])) # avoid small vals for logplot stds = groupeddf_std.loc[optim, :].loc[:, "loss"] optim_name = optim.replace("Search", "").replace("oint", "t").replace("Optimizer", "") optim_vals[optim_name] = {"x": xvals, "y": yvals, "std": stds} # lower upper bound to twice stupid/idiot at most upperbound = max(np.max(vals["y"]) for vals in optim_vals.values()) for optim, vals in optim_vals.items(): if optim.lower() in ["stupid", "idiot"] or optim in ["Zero", "StupidRandom"]: upperbound = min(upperbound, 2 * np.max(vals["y"])) # plot from best to worst lowerbound = np.inf handles = [] sorted_optimizers = sorted(optim_vals, key=lambda x: optim_vals[x]["y"][-1], reverse=True) for k, optim_name in enumerate(sorted_optimizers): vals = optim_vals[optim_name] lowerbound = min(lowerbound, np.min(vals["y"])) handles.append(plt.loglog(vals["x"], vals["y"], name_style[optim_name], label=optim_name)) texts = [] if vals["x"].size and vals["y"][-1] < upperbound: angle = 30 - 60 * k / len(optim_vals) texts.append(plt.text(vals["x"][-1], vals["y"][-1], "{} ({:.3g})".format(optim_name, vals["y"][-1]), {'ha': 'left', 'va': 'top' if angle < 0 else 'bottom'}, rotation=angle)) if upperbound < np.inf: plt.gca().set_ylim(lowerbound, upperbound) # global info legend = plt.legend(fontsize=7, ncol=2, handlelength=3, loc='upper center', bbox_to_anchor=(0.5, -0.15)) plt.title(title) # plt.tight_layout() # plt.axis('tight') # plt.tick_params(axis='both', which='both') if output_filepath is not None: plt.savefig(str(output_filepath), bbox_extra_artists=[legend] + texts, bbox_inches='tight', dpi=_DPI) def make_fight_plot(df: tools.Selector, categories: List[str], num_rows: int, output_filepath: Optional[PathLike] = None) -> None: """Creates a fight plot out of the given dataframe, by iterating over all cases with fixed category variables. Parameters ---------- df: pd.DataFrame run data categories: list List of variables to fix for obtaining similar run conditions num_rows: int number of rows to plot (best algorithms) output_filepath: Path If present, saves the plot to the given path """ all_optimizers = list(df.unique("optimizer_name")) # optimizers for which no run exists are not shown num_rows = min(num_rows, len(all_optimizers)) victories = pd.DataFrame(index=all_optimizers, columns=all_optimizers, data=0.) # iterate on all sub cases subcases = df.unique(categories) for subcase in subcases: # TODO linearize this (precompute all subcases)? requires memory subdf = df.select(**dict(zip(categories, subcase))) victories += _make_winners_df(subdf, all_optimizers) winrates = _make_sorted_winrates_df(victories) mean_win = winrates.mean(axis=1) winrates.fillna(.5) # unplayed sorted_names = winrates.index # number of subcases actually computed is twice self-victories sorted_names = ["{} ({}/{})".format(n, int(2 * victories.loc[n, n]), len(subcases)) for n in sorted_names] data = np.array(winrates.iloc[:num_rows, :]) # make plot plt.close("all") fig = plt.figure() ax = fig.add_subplot(111) cax = ax.imshow(100 * data, cmap=cm.seismic, interpolation='none', vmin=0, vmax=100) ax.set_xticks(list(range(len(sorted_names)))) ax.set_xticklabels([s.replace("Search", "") for s in sorted_names], rotation=90, fontsize=7) ax.set_yticks(list(range(num_rows))) # pylint: disable=anomalous-backslash-in-string ax.set_yticklabels([(f"{name} ({100 * val:2.1f}\%)").replace("Search", "") for name, val in zip(mean_win.index[: num_rows], mean_win)], rotation=45, fontsize=7) plt.tight_layout() fig.colorbar(cax, orientation='vertical') if output_filepath is not None: plt.savefig(str(output_filepath), dpi=_DPI) def main() -> None: parser = argparse.ArgumentParser(description='Create plots from an experiment data file') parser.add_argument('filepath', type=str, help='filepath containing the experiment data') parser.add_argument('--output', type=str, default=None, help="Output path for the CSV file (default: a folder <filename>_plots next to the data file.") parser.add_argument('--max_combsize', type=int, default=3, help="maximum number of parameters to fix (combinations) when creating experiment plots") args = parser.parse_args() exp_df = tools.Selector.read_csv(args.filepath) output_dir = args.output if output_dir is None: output_dir = str(Path(args.filepath).with_suffix("")) + "_plots" create_plots(exp_df, output_folder=output_dir, max_combsize=args.max_combsize) if __name__ == '__main__': main()
the-stack_0_3467
#!/usr/bin/python # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # This script creates yaml files to build conda environments # For generating a conda file for running only python code: # $ python generate_conda_file.py # For generating a conda file for running python gpu: # $ python generate_conda_file.py --gpu # For generating a conda file for running pyspark: # $ python generate_conda_file.py --pyspark # For generating a conda file for running python gpu and pyspark: # $ python generate_conda_file.py --gpu --pyspark # For generating a conda file for running python gpu and pyspark with a particular version: # $ python generate_conda_file.py --gpu --pyspark-version 2.4.0 import argparse import textwrap from sys import platform HELP_MSG = """ To create the conda environment: $ conda env create -f {conda_env}.yaml To update the conda environment: $ conda env update -f {conda_env}.yaml To register the conda environment in Jupyter: $ conda activate {conda_env} $ python -m ipykernel install --user --name {conda_env} --display-name "Python ({conda_env})" """ CHANNELS = ["defaults", "conda-forge", "pytorch", "fastai"] CONDA_BASE = { "bottleneck": "bottleneck==1.2.1", "dask": "dask>=0.17.1", "fastparquet": "fastparquet>=0.1.6", "ipykernel": "ipykernel>=4.6.1", "jupyter": "jupyter>=1.0.0", "matplotlib": "matplotlib>=2.2.2", "mock": "mock==2.0.0", "numpy": "numpy>=1.13.3", "pandas": "pandas>=0.23.4", "pip": "pip>=19.0.3", "python": "python==3.6.8", "pytest": "pytest>=3.6.4", "pytorch": "pytorch-cpu>=1.0.0", "seaborn": "seaborn>=0.8.1", "scikit-learn": "scikit-learn==0.19.1", "scipy": "scipy>=1.0.0", "scikit-surprise": "scikit-surprise>=1.0.6", "swig": "swig==3.0.12", "tensorflow": "tensorflow==1.12.0", "lightgbm": "lightgbm==2.2.1", "cornac": "cornac>=1.1.2", "fastai": "fastai==1.0.46", "papermill": "papermill==0.19.1", } CONDA_PYSPARK = {"pyarrow": "pyarrow>=0.8.0", "pyspark": "pyspark==2.3.1"} CONDA_GPU = { "numba": "numba>=0.38.1", "pytorch": "pytorch>=1.0.0", "tensorflow": "tensorflow-gpu==1.12.0", } PIP_BASE = { "azureml-sdk[notebooks,tensorboard]": "azureml-sdk[notebooks,tensorboard]==1.0.18", "azure-storage": "azure-storage>=0.36.0", "black": "black>=18.6b4", "category_encoders": "category_encoders>=1.3.0", "dataclasses": "dataclasses>=0.6", "hyperopt": "hyperopt==0.1.1", "idna": "idna==2.7", "locustio": "locustio==0.11.0", "memory-profiler": "memory-profiler>=0.54.0", "nbconvert": "nbconvert==5.5.0", "pydocumentdb": "pydocumentdb>=2.3.3", "pymanopt": "pymanopt==0.2.3", "tqdm": "tqdm==4.31.1", } PIP_GPU = {"nvidia-ml-py3": "nvidia-ml-py3>=7.352.0"} PIP_PYSPARK = {"databricks-cli": "databricks-cli==0.8.6"} PIP_DARWIN = { "nni": "nni==0.5.2.1.1", } PIP_LINUX = { "nni": "nni==0.5.2.1.1", } PIP_WIN32 = {} if __name__ == "__main__": parser = argparse.ArgumentParser( description=textwrap.dedent( """ This script generates a conda file for different environments. Plain python is the default, but flags can be used to support PySpark and GPU functionality""" ), epilog=HELP_MSG, formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument("--name", help="specify name of conda environment") parser.add_argument( "--gpu", action="store_true", help="include packages for GPU support" ) parser.add_argument( "--pyspark", action="store_true", help="include packages for PySpark support" ) parser.add_argument( "--pyspark-version", help="provide specific version of PySpark to use" ) args = parser.parse_args() # check pyspark version if args.pyspark_version is not None: args.pyspark = True pyspark_version_info = args.pyspark_version.split(".") if len(pyspark_version_info) != 3 or any( [not x.isdigit() for x in pyspark_version_info] ): raise TypeError( "PySpark version input must be valid numeric format (e.g. --pyspark-version=2.3.1)" ) else: args.pyspark_version = "2.3.1" # set name for environment and output yaml file conda_env = "reco_base" if args.gpu and args.pyspark: conda_env = "reco_full" elif args.gpu: conda_env = "reco_gpu" elif args.pyspark: conda_env = "reco_pyspark" # overwrite environment name with user input if args.name is not None: conda_env = args.name # update conda and pip packages based on flags provided conda_packages = CONDA_BASE pip_packages = PIP_BASE if args.pyspark: conda_packages.update(CONDA_PYSPARK) conda_packages["pyspark"] = "pyspark=={}".format(args.pyspark_version) pip_packages.update(PIP_PYSPARK) if args.gpu: conda_packages.update(CONDA_GPU) pip_packages.update(PIP_GPU) # check for os platform support if platform == 'darwin': pip_packages.update(PIP_DARWIN) elif platform.startswith('linux'): pip_packages.update(PIP_LINUX) elif platform == 'win32': pip_packages.update(PIP_WIN32) else: raise Exception('Unsupported platform, must be Windows, Linux, or macOS') # write out yaml file conda_file = "{}.yaml".format(conda_env) with open(conda_file, "w") as f: for line in HELP_MSG.format(conda_env=conda_env).split("\n"): f.write("# {}\n".format(line)) f.write("name: {}\n".format(conda_env)) f.write("channels:\n") for channel in CHANNELS: f.write("- {}\n".format(channel)) f.write("dependencies:\n") for conda_package in conda_packages.values(): f.write("- {}\n".format(conda_package)) f.write("- pip:\n") for pip_package in pip_packages.values(): f.write(" - {}\n".format(pip_package)) print("Generated conda file: {}".format(conda_file)) print(HELP_MSG.format(conda_env=conda_env))
the-stack_0_3468
# from __future__ import absolute_import # from __future__ import division # from __future__ import print_function import os import time os.environ["CUDA_VISIBLE_DEVICES"] = "1" import numpy as np # import cv2 import tensorflow as tf from tensorflow.data import Iterator from Dataset import SegDataLoader, VocRgbDataLoader, VocDataLoader, LfwRgbDataLoader, ImageNetRgbDataLoader from visulize import save_test_images from utils import rgb2yuv_tf, yuv2rgb_tf from model import Discriminator, encode_net, decode_net from ResNet import resnet_nopooling class Model(): def __init__(self): self.run_time = time.strftime("%m%d-%H%M") # self.learning_rate = 0.0001 self.starter_learning_rate = 0.001 self.epoches = 70 self.log_path = 'logs/'+self.run_time + '/' config = tf.ConfigProto() config.gpu_options.allow_growth = True self.sess = tf.InteractiveSession(config=config) self.secret_tensor = tf.placeholder(shape=[None, 256, 256, 3], dtype=tf.float32, name="secret_tensor") self.cover_tensor = tf.placeholder(shape=[None, 256, 256, 3], dtype=tf.float32, name="cover_tensor") self.cover_yuv = rgb2yuv_tf(self.cover_tensor) self.secret_yuv = rgb2yuv_tf(self.secret_tensor) self.global_step_tensor = tf.Variable(0, trainable=False, name='global_step') # self.test_op = self.prepare_test_graph(self.secret_tensor, self.cover_tensor) def get_hiding_network_op(self, cover_tensor, secret_tensor, is_training): concat_input = tf.concat([cover_tensor, secret_tensor], axis=-1, name='images_features_concat') # output = resnet_nopooling(concat_input, name='encode', n_class=3, dilate=[2,4,8,16], is_training=is_training) output = resnet_nopooling(concat_input, name='encode', n_class=3, is_training=is_training) return output def get_reveal_network_op(self, container_tensor, is_training): output = resnet_nopooling(container_tensor, name='decode', n_class=3, is_training=is_training) return output def get_noise_layer_op(self,tensor,std=.1): # with tf.variable_scope("noise_layer"): # return tensor + tf.random_normal(shape=tf.shape(tensor), mean=0.0, stddev=std, dtype=tf.float32) return tensor def get_loss_op(self,secret_true,secret_pred,cover_true,cover_pred): # D_real_secret = Discriminator(secret_true) # D_fake_secret = Discriminator(secret_pred, reusing=True) # D_real = Discriminator(cover_true, reusing=True) # D_fake = Discriminator(cover_pred, reusing=True) # D_real_secret = Discriminator(secret_true, name='secret', reusing=False) # D_fake_secret = Discriminator(secret_pred, name='secret', reusing=True) # D_real = Discriminator(cover_true, name='cover', reusing=False) # D_fake = Discriminator(cover_pred, name='cover', reusing=True) # # D_real = tf.concat([D_real, D_real_secret], axis=0, name='gan_true_concat') # D_fake = tf.concat([D_fake, D_fake_secret], axis=0, name='gan_pred_concat') # # D_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_real, labels=tf.ones_like(D_real)) + tf.nn.sigmoid_cross_entropy_with_logits(logits=D_fake, labels=tf.zeros_like(D_fake))) # G_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_fake, labels=tf.ones_like(D_fake))) with tf.variable_scope("huber_losses"): # secret_mse = tf.losses.mean_squared_error(secret_true,secret_pred) # cover_mse = tf.losses.mean_squared_error(cover_true,cover_pred) # secret_mse = tf.reduce_mean(tf.losses.huber_loss(secret_true, secret_pred, delta=0.5)) # cover_mse = tf.reduce_mean(tf.losses.huber_loss(cover_true, cover_pred, delta=0.5)) secret_mse = tf.reduce_mean(tf.losses.absolute_difference(secret_true, secret_pred)) cover_mse = tf.reduce_mean(tf.losses.absolute_difference(cover_true, cover_pred)) with tf.variable_scope("ssim_losses"): #secret_ssim = 1. - tf.reduce_mean(tf.image.ssim(secret_true, secret_pred, max_val=1.0)) #cover_ssim = 1. - tf.reduce_mean(tf.image.ssim(cover_true, cover_pred, max_val=1.0)) secret_ssim = 1. - (tf.reduce_mean(tf.image.ssim(secret_true[:,:,:,:1],secret_pred[:,:,:,:1], max_val=1.0)) + tf.reduce_mean(tf.image.ssim(secret_true[:,:,:,1:2],secret_pred[:,:,:,1:2], max_val=1.0)) + tf.reduce_mean(tf.image.ssim(secret_true[:,:,:,2:],secret_pred[...,2:], max_val=1.0)))/3. cover_ssim = 1. - (tf.reduce_mean(tf.image.ssim(cover_true[:,:,:,:1],cover_pred[:,:,:,:1], max_val=1.0)) + tf.reduce_mean(tf.image.ssim(cover_true[:,:,:,1:2],cover_pred[:,:,:,1:2], max_val=1.0)) + tf.reduce_mean(tf.image.ssim(cover_true[:,:,:,2:],cover_pred[:,:,:,2:], max_val=1.0)))/3. # D_final_loss = cover_mse + secret_mse + secret_ssim + cover_ssim + D_loss # D_final_loss = D_loss G_final_loss = 5*cover_mse + 5*secret_mse + secret_ssim + cover_ssim # G_final_loss = cover_mse + secret_mse + secret_ssim + cover_ssim # return D_final_loss, G_final_loss, D_loss, G_loss, secret_mse, cover_mse, secret_ssim, cover_ssim return G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim def get_tensor_to_img_op(self,tensor): with tf.variable_scope("",reuse=True): # t = tensor*tf.convert_to_tensor([0.229, 0.224, 0.225]) + tf.convert_to_tensor([0.485, 0.456, 0.406]) tensor = yuv2rgb_tf(tensor) return tf.clip_by_value(tensor,0,1) # return tf.clip_by_value(tensor,0,255) def prepare_training_graph(self,secret_tensor,cover_tensor,global_step_tensor): hidden = self.get_hiding_network_op(cover_tensor=cover_tensor, secret_tensor=secret_tensor, is_training=True) reveal_output_op = self.get_reveal_network_op(hidden, is_training=True) G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim = self.get_loss_op(secret_tensor,reveal_output_op,cover_tensor,hidden) global_variables = tf.global_variables() gan_varlist = [i for i in global_variables if i.name.startswith('Discriminator')] en_de_code_varlist = [i for i in global_variables if i not in gan_varlist] update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): # train_op = optimiser.minimize(loss, global_step=global_step) # D_minimize_op = tf.train.AdamOptimizer(self.learning_rate).minimize(D_final_loss, var_list=gan_varlist, global_step=global_step_tensor) G_minimize_op = tf.train.AdamOptimizer(self.learning_rate).minimize(G_final_loss, var_list=en_de_code_varlist, global_step=global_step_tensor) # G_minimize_op = tf.train.AdamOptimizer(self.learning_rate).minimize(G_final_loss, global_step=global_step_tensor) # tf.summary.scalar('D_loss', D_final_loss,family='train') tf.summary.scalar('G_loss', G_final_loss,family='train') tf.summary.scalar('secret_mse', secret_mse,family='train') tf.summary.scalar('cover_mse', cover_mse,family='train') tf.summary.scalar('learning_rate', self.learning_rate,family='train') tf.summary.scalar('secret_ssim', secret_ssim) tf.summary.scalar('cover_ssim', cover_ssim) tf.summary.image('secret',self.get_tensor_to_img_op(secret_tensor),max_outputs=1,family='train') tf.summary.image('cover',self.get_tensor_to_img_op(cover_tensor),max_outputs=1,family='train') tf.summary.image('hidden',self.get_tensor_to_img_op(hidden),max_outputs=1,family='train') # tf.summary.image('hidden_noisy',self.get_tensor_to_img_op(noise_add_op),max_outputs=1,family='train') tf.summary.image('revealed',self.get_tensor_to_img_op(reveal_output_op),max_outputs=1,family='train') merged_summary_op = tf.summary.merge_all() return G_minimize_op, G_final_loss, merged_summary_op, secret_mse,cover_mse, secret_ssim, cover_ssim def prepare_test_graph(self,secret_tensor,cover_tensor): # y_output, hiding_output_op = self.get_hiding_network_op(cover_tensor=cover_tensor,secret_tensor=secret_tensor, is_training=True) hidden = self.get_hiding_network_op(cover_tensor=cover_tensor,secret_tensor=secret_tensor, is_training=False) # reveal_output_op = self.get_reveal_network_op(y_output, is_training=True) reveal_output_op = self.get_reveal_network_op(hidden, is_training=False) G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim = self.get_loss_op(secret_tensor,reveal_output_op,cover_tensor,hidden) # tf.summary.scalar('loss', loss_op,family='test') # tf.summary.scalar('reveal_net_loss', secret_loss_op,family='test') # tf.summary.scalar('cover_net_loss', cover_loss_op,family='test') # # tf.summary.image('secret',self.get_tensor_to_img_op(secret_tensor),max_outputs=1,family='test') # tf.summary.image('cover',self.get_tensor_to_img_op(cover_tensor),max_outputs=1,family='test') # tf.summary.image('hidden',self.get_tensor_to_img_op(hiding_output_op),max_outputs=1,family='test') # tf.summary.image('revealed',self.get_tensor_to_img_op(reveal_output_op),max_outputs=1,family='test') # merged_summary_op = tf.summary.merge_all() return hidden, reveal_output_op, G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim def save_chkp(self,path): global_step = self.sess.run(self.global_step_tensor) self.saver.save(self.sess,path,global_step) def load_chkp(self,path): self.saver.restore(self.sess,path) print("LOADED") def train(self): with tf.device('/cpu:0'): # segdl = VocRgbDataLoader('/home/jion/moliq/Documents/VOC2012/JPEGImages/', 4, (256, 256), (256, 256), 'voc_train.txt', split='train') # segdl_val = VocRgbDataLoader('/home/jion/moliq/Documents/VOC2012/JPEGImages/', 4, (256, 256), (256, 256), 'voc_valid.txt', split='val') #segdl = LfwRgbDataLoader('/home/jion/moliq/Documents/lfw/', 2, (256, 256), (256, 256), # 'dataset/lfw_train.txt', split='train') #segdl_val = LfwRgbDataLoader('/home/jion/moliq/Documents/lfw/', 2, (256, 256), (256, 256), # 'dataset/lfw_valid.txt', split='val') segdl = ImageNetRgbDataLoader('/home/jion/moliq/Documents/imagenet/ILSVRC2012_img_val/', 4, (256, 256), (256, 256), 'dataset/imagenet_train.txt', split='train') segdl_val = ImageNetRgbDataLoader('/home/jion/moliq/Documents/imagenet/ILSVRC2012_img_test/', 4, (256, 256), (256, 256), 'dataset/imagenet_valid.txt', split='val') iterator = Iterator.from_structure(segdl.data_tr.output_types, segdl.data_tr.output_shapes) iterator_val = Iterator.from_structure(segdl_val.data_tr.output_types, segdl_val.data_tr.output_shapes) next_batch = iterator.get_next() next_batch_val = iterator_val.get_next() training_init_op = iterator.make_initializer(segdl.data_tr) training_init_op_val = iterator_val.make_initializer(segdl_val.data_tr) steps_per_epoch = segdl.data_len / segdl.batch_size steps_per_epoch_val = segdl_val.data_len / segdl_val.batch_size self.learning_rate = tf.train.exponential_decay(self.starter_learning_rate, self.global_step_tensor, steps_per_epoch*15, 0.1, staircase=True) self.train_op_G, G_final_loss, self.summary_op, self.secret_mse, self.cover_mse, self.secret_ssim, self.cover_ssim = \ self.prepare_training_graph(self.secret_yuv, self.cover_yuv, self.global_step_tensor) if not os.path.exists(self.log_path): os.makedirs(self.log_path) self.writer = tf.summary.FileWriter(self.log_path, self.sess.graph) self.sess.run(tf.global_variables_initializer()) self.saver = tf.train.Saver(max_to_keep=30) # beta1_power = self.sess.graph.get_tensor_by_name('beta1_power:0') # out = self.sess.run(beta1_power) # print('beta1_power ', out) # exclude_vars = ['beta1_power:0', 'beta2_power:0', 'global_step:0'] # exclude_vars = [''] # restore_variables = [i for i in tf.global_variables() if not i.name in exclude_vars] saver = tf.train.Saver() loader = tf.train.latest_checkpoint('logs/0509-0030') saver.restore(self.sess, loader) print('loaded pretrained model') #beta1_power = self.sess.graph.get_tensor_by_name('beta1_power:0') #out = self.sess.run(beta1_power) #print('beta1_power ', out) for epoch in range(1, 1+self.epoches): print('epoch %d'%epoch) self.sess.run(training_init_op) for i in range(steps_per_epoch): cover_tensor, secret_tensor = self.sess.run(next_batch) _, G_loss, secret_mse, cover_mse, secret_ssim, cover_ssim, summary, global_step = \ self.sess.run([self.train_op_G, G_final_loss, self.secret_mse, self.cover_mse, self.secret_ssim, self.cover_ssim, self.summary_op, self.global_step_tensor], feed_dict={self.secret_tensor: secret_tensor, self.cover_tensor: cover_tensor}) self.writer.add_summary(summary, global_step) # if i % 5 == 0: # _, D_loss, summary = \ # self.sess.run([self.train_op_D, D_final_loss, self.summary_op], # feed_dict={self.secret_tensor: secret_tensor,self.cover_tensor: cover_tensor}) # self.writer.add_summary(summary, global_step) if i % 30 == 0: print('Epoch [{}/{}] Step [{}/{}] G_Loss {:.4f} encoder_ssim {:.4f} encoder_mse {:.4f}' ' decoder_ssim {:.4f} decoder_mse {:.4f} '.format( epoch, self.epoches, i, steps_per_epoch, G_loss, cover_ssim, cover_mse, secret_ssim, secret_mse )) # run validation self.sess.run(training_init_op_val) # D_loss_val_this_epoch = [] G_loss_val_this_epoch = [] secret_ssim_this_epoch = [] cover_ssim_this_epoch = [] for i in range(steps_per_epoch_val): cover_tensor_val, secret_tensor_val = self.sess.run(next_batch_val) G_loss, secret_mse, cover_mse, secret_ssim, cover_ssim = \ self.sess.run([G_final_loss, self.secret_mse,self.cover_mse, self.secret_ssim, self.cover_ssim], feed_dict={self.secret_tensor: secret_tensor_val, self.cover_tensor: cover_tensor_val}) # D_loss_val_this_epoch.append(D_loss) G_loss_val_this_epoch.append(G_loss) secret_ssim_this_epoch.append(secret_ssim) cover_ssim_this_epoch.append(cover_ssim) # mean_D_loss_val_this_epoch = sum(D_loss_val_this_epoch) / len(D_loss_val_this_epoch) mean_G_loss_val_this_epoch = sum(G_loss_val_this_epoch) / len(G_loss_val_this_epoch) mean_secret_ssim_this_epoch = sum(secret_ssim_this_epoch) / len(secret_ssim_this_epoch) mean_cover_ssim_this_epoch = sum(cover_ssim_this_epoch) / len(cover_ssim_this_epoch) # print('global step: %d, validation loss: %.4f'%(global_step, mean_loss_val_this_epoch)) print('VALIDATION Epoch {} global step {} G_Loss {:.4f} encoder_ssim {:.4f} decoder_ssim {:.4f}'.format( epoch, global_step, mean_G_loss_val_this_epoch, mean_cover_ssim_this_epoch, mean_secret_ssim_this_epoch)) # self.save_chkp(self.log_path+'%d_%.3f.ckpt'%(epoch, mean_loss_val_this_epoch)) self.save_chkp(self.log_path) def test_performance(self, log_path): hiding_output_op, reveal_output_op, G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim = \ self.prepare_test_graph(self.secret_yuv, self.cover_yuv) loader = tf.train.latest_checkpoint(log_path) # from tensorflow.python.tools import inspect_checkpoint as chkp # chkp.print_tensors_in_checkpoint_file(loader, tensor_name='', all_tensors=True) # from inspect_checkpoint import print_tensors_in_checkpoint_file # print_tensors_in_checkpoint_file(loader, tensor_name='', all_tensors=True) # variables = [i for i in tf.global_variables() if i.name not in ['global_step:0']] # saver_variables_dict = {value.name[:-2]:value for value in variables} # custom_saver = tf.train.Saver(saver_variables_dict) # custom_saver.restore(self.sess, loader) # print('load model %s'%loader) # self.saver = tf.train.Saver(var_list=tf.global_variables()) self.saver = tf.train.Saver() self.saver.restore(self.sess, loader) print('load model %s'%loader) with tf.device('/cpu:0'): # segdl_val = VocRgbDataLoader('/home/jion/moliq/Documents/VOC2012/JPEGImages/', 16, (256, 256), (256, 256), 'voc_valid.txt', split='val') segdl_val = LfwRgbDataLoader('/home/jion/moliq/Documents/lfw/', 16, (256, 256), (256, 256), 'dataset/lfw_valid.txt', split='val') iterator_val = Iterator.from_structure(segdl_val.data_tr.output_types, segdl_val.data_tr.output_shapes) next_batch_val = iterator_val.get_next() training_init_op_val = iterator_val.make_initializer(segdl_val.data_tr) steps_per_epoch_val = segdl_val.data_len / segdl_val.batch_size loss_val_this_epoch = [] secret_mse_val_this_epoch = [] cover_mse_val_this_epoch = [] secret_ssim_this_epoch = [] cover_ssim_this_epoch = [] self.sess.run(training_init_op_val) # self.saver.restore(self.sess, loader) # print('load model %s'%loader) for i in range(steps_per_epoch_val): cover_tensor_val, secret_tensor_val = self.sess.run(next_batch_val) stego, secret_reveal, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value = \ self.sess.run([hiding_output_op, reveal_output_op, G_final_loss, secret_mse, cover_mse, secret_ssim, cover_ssim], feed_dict={self.secret_tensor: secret_tensor_val, self.cover_tensor: cover_tensor_val}) cover_names = segdl_val.imgs_files[i*segdl_val.batch_size:(i+1)*segdl_val.batch_size] secret_names = segdl_val.labels_files[i*segdl_val.batch_size:(i+1)*segdl_val.batch_size] loss_val_this_epoch.append(loss_value) secret_mse_val_this_epoch.append(secret_mse_value) cover_mse_val_this_epoch.append(cover_mse_value) secret_ssim_this_epoch.append(secret_ssim_value) cover_ssim_this_epoch.append(cover_ssim_value) if i%10 == 0: print('%d %.3f %.3f %.3f %.3f %.3f'%(i, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value)) save_test_images(cover_names, secret_names, cover_tensor_val, secret_tensor_val, stego, secret_reveal, log_path) # np.save('%d %.3f %.3f %.3f %.3f %.3f_cover.npy'%(i, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value), cover_tensor_val) # np.save('%d %.3f %.3f %.3f %.3f %.3f_secret.npy'%(i, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value), secret_tensor_val) # np.save('%d %.3f %.3f %.3f %.3f %.3f_stego.npy'%(i, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value), stego) # np.save('%d %.3f %.3f %.3f %.3f %.3f_secret_reveal.npy'%(i, loss_value, secret_mse_value, cover_mse_value, secret_ssim_value, cover_ssim_value), secret_reveal) # mean_loss_val_this_epoch = sum(loss_val_this_epoch) / len(loss_val_this_epoch) # mean_secret_mse_val_this_epoch = sum(secret_mse_val_this_epoch) / len(secret_mse_val_this_epoch) # mean_cover_mse_val_this_epoch = sum(cover_mse_val_this_epoch) / len(cover_mse_val_this_epoch) # mean_secret_ssim_this_epoch = sum(secret_ssim_this_epoch) / len(secret_ssim_this_epoch) # mean_cover_ssim_this_epoch = sum(cover_ssim_this_epoch) / len(cover_ssim_this_epoch) mean_loss_val_this_epoch = np.mean(loss_val_this_epoch) mean_secret_mse_val_this_epoch = np.mean(secret_mse_val_this_epoch) mean_cover_mse_val_this_epoch = np.mean(cover_mse_val_this_epoch) mean_secret_ssim_this_epoch = np.mean(secret_ssim_this_epoch) mean_cover_ssim_this_epoch = np.mean(cover_ssim_this_epoch) print('validation loss: %.4f' % mean_loss_val_this_epoch) print('secret mse: %.4f' % mean_secret_mse_val_this_epoch) print('cover mse : %.4f' % mean_cover_mse_val_this_epoch) print('secret ssim: %.4f' % mean_secret_ssim_this_epoch) print('cover ssim: %.4f' % mean_cover_ssim_this_epoch) if __name__ == '__main__': train_model = Model() train_model.train() # train_model.test_performance(train_model.log_path) # train_model.test_performance('logs/0427-1506') # train_model.test_performance('logs/0428-2048') # train_model.test_performance('logs/0505-1617')
the-stack_0_3472
import setuptools with open('README.md', 'r') as fh: long_description = fh.read() setuptools.setup( name='pico_sdk', version='0.1.4', author='Meaty Solutions', author_email='[email protected]', description='High performance, gap-free streaming from any Pico Technology oscilloscope', long_description=long_description, long_description_content_type='text/markdown', url='https://github.com/meatysolutions/pico-sdk-bindings', package_data={'': ['artifacts/*', 'artifacts/*/*']}, packages=setuptools.find_packages(), install_requires=['numpy'], classifiers=[ 'Programming Language :: Python :: 3', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', ], python_requires='>=3.6', )
the-stack_0_3473
import torch import torch.nn as nn def standardize(x, bn_stats): if bn_stats is None: return x bn_mean, bn_var = bn_stats view = [1] * len(x.shape) view[1] = -1 x = (x - bn_mean.view(view)) / torch.sqrt(bn_var.view(view) + 1e-5) # if variance is too low, just ignore x *= (bn_var.view(view) != 0).float() return x def clip_data(data, max_norm): norms = torch.norm(data.reshape(data.shape[0], -1), dim=-1) scale = (max_norm / norms).clamp(max=1.0) data *= scale.reshape(-1, 1, 1, 1) return data def get_num_params(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) class StandardizeLayer(nn.Module): def __init__(self, bn_stats): super(StandardizeLayer, self).__init__() self.bn_stats = bn_stats def forward(self, x): return standardize(x, self.bn_stats) class ClipLayer(nn.Module): def __init__(self, max_norm): super(ClipLayer, self).__init__() self.max_norm = max_norm def forward(self, x): return clip_data(x, self.max_norm) class CIFAR10_CNN(nn.Module): def __init__(self, in_channels=3, input_norm=None, **kwargs): super(CIFAR10_CNN, self).__init__() self.in_channels = in_channels self.features = None self.classifier = None self.norm = None self.build(input_norm, **kwargs) def build(self, input_norm=None, num_groups=None, bn_stats=None, size=None): if self.in_channels == 3: if size == "small": cfg = [16, 16, 'M', 32, 32, 'M', 64, 'M'] else: cfg = [32, 32, 'M', 64, 64, 'M', 128, 128, 'M'] self.norm = nn.Identity() else: if size == "small": cfg = [16, 16, 'M', 32, 32] else: cfg = [64, 'M', 64] if input_norm is None: self.norm = nn.Identity() elif input_norm == "GroupNorm": self.norm = nn.GroupNorm(num_groups, self.in_channels, affine=False) else: self.norm = lambda x: standardize(x, bn_stats) layers = [] act = nn.Tanh c = self.in_channels for v in cfg: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: conv2d = nn.Conv2d(c, v, kernel_size=3, stride=1, padding=1) layers += [conv2d, act()] c = v self.features = nn.Sequential(*layers) if self.in_channels == 3: hidden = 128 self.classifier = nn.Sequential(nn.Linear(c * 4 * 4, hidden), act(), nn.Linear(hidden, 10)) else: self.classifier = nn.Linear(c * 4 * 4, 10) def forward(self, x): if self.in_channels != 3: x = self.norm(x.view(-1, self.in_channels, 8, 8)) x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x class MNIST_CNN(nn.Module): def __init__(self, in_channels=1, input_norm=None, **kwargs): super(MNIST_CNN, self).__init__() self.in_channels = in_channels self.features = None self.classifier = None self.norm = None self.build(input_norm, **kwargs) def build(self, input_norm=None, num_groups=None, bn_stats=None, size=None): if self.in_channels == 1: ch1, ch2 = (16, 32) if size is None else (32, 64) cfg = [(ch1, 8, 2, 2), 'M', (ch2, 4, 2, 0), 'M'] self.norm = nn.Identity() else: ch1, ch2 = (16, 32) if size is None else (32, 64) cfg = [(ch1, 3, 2, 1), (ch2, 3, 1, 1)] if input_norm == "GroupNorm": self.norm = nn.GroupNorm(num_groups, self.in_channels, affine=False) elif input_norm == "BN": self.norm = lambda x: standardize(x, bn_stats) else: self.norm = nn.Identity() layers = [] c = self.in_channels for v in cfg: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=1)] else: filters, k_size, stride, pad = v conv2d = nn.Conv2d(c, filters, kernel_size=k_size, stride=stride, padding=pad) layers += [conv2d, nn.Tanh()] c = filters self.features = nn.Sequential(*layers) hidden = 32 self.classifier = nn.Sequential(nn.Linear(c * 4 * 4, hidden), nn.Tanh(), nn.Linear(hidden, 10)) def forward(self, x): if self.in_channels != 1: x = self.norm(x.view(-1, self.in_channels, 7, 7)) x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x class ScatterLinear(nn.Module): def __init__(self, in_channels, hw_dims, input_norm=None, classes=10, clip_norm=None, **kwargs): super(ScatterLinear, self).__init__() self.K = in_channels self.h = hw_dims[0] self.w = hw_dims[1] self.fc = None self.norm = None self.clip = None self.build(input_norm, classes=classes, clip_norm=clip_norm, **kwargs) def build(self, input_norm=None, num_groups=None, bn_stats=None, clip_norm=None, classes=10): self.fc = nn.Linear(self.K * self.h * self.w, classes) if input_norm is None: self.norm = nn.Identity() elif input_norm == "GroupNorm": self.norm = nn.GroupNorm(num_groups, self.K, affine=False) else: self.norm = lambda x: standardize(x, bn_stats) if clip_norm is None: self.clip = nn.Identity() else: self.clip = ClipLayer(clip_norm) def forward(self, x): x = self.norm(x.view(-1, self.K, self.h, self.w)) x = self.clip(x) x = x.reshape(x.size(0), -1) x = self.fc(x) return x CNNS = { "cifar10": CIFAR10_CNN, "fmnist": MNIST_CNN, "mnist": MNIST_CNN, }
the-stack_0_3477
# python3 # Copyright 2020 DeepMind Technologies Limited. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """ImageNet dataset with typical pre-processing.""" import enum from typing import Generator, Mapping, Optional, Sequence, Text, Tuple import jax import numpy as np import tensorflow.compat.v2 as tf import tensorflow_datasets as tfds Batch = Mapping[Text, np.ndarray] MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) STDDEV_RGB = (0.229 * 255, 0.224 * 255, 0.225 * 255) class Split(enum.Enum): """Imagenet dataset split.""" TRAIN = 1 TRAIN_AND_VALID = 2 VALID = 3 TEST = 4 @classmethod def from_string(cls, name: Text) -> 'Split': return {'TRAIN': Split.TRAIN, 'TRAIN_AND_VALID': Split.TRAIN_AND_VALID, 'VALID': Split.VALID, 'VALIDATION': Split.VALID, 'TEST': Split.TEST}[name.upper()] @property def num_examples(self): return {Split.TRAIN_AND_VALID: 1281167, Split.TRAIN: 1271167, Split.VALID: 10000, Split.TEST: 50000}[self] def load( split: Split, *, is_training: bool, batch_dims: Sequence[int], bfloat16: bool = False, ) -> Generator[Batch, None, None]: """Loads the given split of the dataset.""" if is_training: start, end = _shard(split, jax.host_id(), jax.host_count()) else: start, end = _shard(split, 0, 1) tfds_split = tfds.core.ReadInstruction(_to_tfds_split(split), from_=start, to=end, unit='abs') ds = tfds.load('imagenet2012:5.*.*', split=tfds_split, decoders={'image': tfds.decode.SkipDecoding()}) total_batch_size = np.prod(batch_dims) options = ds.options() options.experimental_threading.private_threadpool_size = 48 options.experimental_threading.max_intra_op_parallelism = 1 if is_training: options.experimental_deterministic = False if is_training: if jax.host_count() > 1: # Only cache if we are reading a subset of the dataset. ds = ds.cache() ds = ds.repeat() ds = ds.shuffle(buffer_size=10 * total_batch_size, seed=0) else: if split.num_examples % total_batch_size != 0: raise ValueError(f'Test/valid must be divisible by {total_batch_size}') def preprocess(example): image = _preprocess_image(example['image'], is_training) if bfloat16: image = tf.cast(image, tf.bfloat16) label = tf.cast(example['label'], tf.int32) return {'images': image, 'labels': label} ds = ds.map(preprocess, num_parallel_calls=tf.data.experimental.AUTOTUNE) for batch_size in reversed(batch_dims): ds = ds.batch(batch_size) ds = ds.prefetch(tf.data.experimental.AUTOTUNE) yield from tfds.as_numpy(ds) def _to_tfds_split(split: Split) -> tfds.Split: """Returns the TFDS split appropriately sharded.""" # NOTE: Imagenet did not release labels for the test split used in the # competition, so it has been typical at DeepMind to consider the VALID # split the TEST split and to reserve 10k images from TRAIN for VALID. if split in (Split.TRAIN, Split.TRAIN_AND_VALID, Split.VALID): return tfds.Split.TRAIN else: assert split == Split.TEST return tfds.Split.VALIDATION def _shard(split: Split, shard_index: int, num_shards: int) -> Tuple[int, int]: """Returns [start, end) for the given shard index.""" assert shard_index < num_shards arange = np.arange(split.num_examples) shard_range = np.array_split(arange, num_shards)[shard_index] start, end = shard_range[0], (shard_range[-1] + 1) if split == Split.TRAIN: # Note that our TRAIN=TFDS_TRAIN[10000:] and VALID=TFDS_TRAIN[:10000]. offset = Split.VALID.num_examples start += offset end += offset return start, end def _preprocess_image( image_bytes: tf.Tensor, is_training: bool, ) -> tf.Tensor: """Returns processed and resized images.""" if is_training: image = _decode_and_random_crop(image_bytes) image = tf.image.random_flip_left_right(image) else: image = _decode_and_center_crop(image_bytes) assert image.dtype == tf.uint8 # NOTE: Bicubic resize (1) casts uint8 to float32 and (2) resizes without # clamping overshoots. This means values returned will be outside the range # [0.0, 255.0] (e.g. we have observed outputs in the range [-51.1, 336.6]). image = tf.image.resize(image, [224, 224], tf.image.ResizeMethod.BICUBIC) image = _normalize_image(image) return image def _normalize_image(image: tf.Tensor) -> tf.Tensor: """Normalize the image to zero mean and unit variance.""" image -= tf.constant(MEAN_RGB, shape=[1, 1, 3], dtype=image.dtype) image /= tf.constant(STDDEV_RGB, shape=[1, 1, 3], dtype=image.dtype) return image def _distorted_bounding_box_crop( image_bytes: tf.Tensor, *, jpeg_shape: tf.Tensor, bbox: tf.Tensor, min_object_covered: float, aspect_ratio_range: Tuple[float, float], area_range: Tuple[float, float], max_attempts: int, ) -> tf.Tensor: """Generates cropped_image using one of the bboxes randomly distorted.""" bbox_begin, bbox_size, _ = tf.image.sample_distorted_bounding_box( jpeg_shape, bounding_boxes=bbox, min_object_covered=min_object_covered, aspect_ratio_range=aspect_ratio_range, area_range=area_range, max_attempts=max_attempts, use_image_if_no_bounding_boxes=True) # Crop the image to the specified bounding box. offset_y, offset_x, _ = tf.unstack(bbox_begin) target_height, target_width, _ = tf.unstack(bbox_size) crop_window = tf.stack([offset_y, offset_x, target_height, target_width]) image = tf.image.decode_and_crop_jpeg(image_bytes, crop_window, channels=3) return image def _decode_and_random_crop(image_bytes: tf.Tensor) -> tf.Tensor: """Make a random crop of 224.""" jpeg_shape = tf.image.extract_jpeg_shape(image_bytes) bbox = tf.constant([0.0, 0.0, 1.0, 1.0], dtype=tf.float32, shape=[1, 1, 4]) image = _distorted_bounding_box_crop( image_bytes, jpeg_shape=jpeg_shape, bbox=bbox, min_object_covered=0.1, aspect_ratio_range=(3 / 4, 4 / 3), area_range=(0.08, 1.0), max_attempts=10) if tf.reduce_all(tf.equal(jpeg_shape, tf.shape(image))): # If the random crop failed fall back to center crop. image = _decode_and_center_crop(image_bytes, jpeg_shape) return image def _decode_and_center_crop( image_bytes: tf.Tensor, jpeg_shape: Optional[tf.Tensor] = None, ) -> tf.Tensor: """Crops to center of image with padding then scales.""" if jpeg_shape is None: jpeg_shape = tf.image.extract_jpeg_shape(image_bytes) image_height = jpeg_shape[0] image_width = jpeg_shape[1] padded_center_crop_size = tf.cast( ((224 / (224 + 32)) * tf.cast(tf.minimum(image_height, image_width), tf.float32)), tf.int32) offset_height = ((image_height - padded_center_crop_size) + 1) // 2 offset_width = ((image_width - padded_center_crop_size) + 1) // 2 crop_window = tf.stack([offset_height, offset_width, padded_center_crop_size, padded_center_crop_size]) image = tf.image.decode_and_crop_jpeg(image_bytes, crop_window, channels=3) return image
the-stack_0_3478
"""Perform inference on one or more datasets.""" import argparse import cv2 import os import pprint import sys import time from six.moves import cPickle as pickle import torch import _init_paths # pylint: disable=unused-import from core.config import cfg, merge_cfg_from_file, merge_cfg_from_list, assert_and_infer_cfg #from core.test_engine_rel import run_inference, get_features_for_centroids import utils.logging from datasets import task_evaluation_rel as task_evaluation from evaluation.generate_detections_csv import generate_csv_file_from_det_obj, generate_topk_csv_from_det_obj, generate_boxes_csv_from_det_obj from evaluation.frequency_based_analysis_of_methods import get_metrics_from_csv, get_many_medium_few_scores, get_wordsim_metrics_from_csv import numpy as np import json # OpenCL may be enabled by default in OpenCV3; disable it because it's not # thread safe and causes unwanted GPU memory allocations. cv2.ocl.setUseOpenCL(False) def parse_args(): """Parse in command line arguments""" parser = argparse.ArgumentParser(description='Test a Fast R-CNN network') parser.add_argument( '--dataset', help='training dataset') parser.add_argument( '--cfg', dest='cfg_file', required=True, help='optional config file') parser.add_argument( '--load_ckpt', help='path of checkpoint to load') parser.add_argument( '--load_detectron', help='path to the detectron weight pickle file') parser.add_argument( '--output_dir', help='output directory to save the testing results. If not provided, ' 'defaults to [args.load_ckpt|args.load_detectron]/../test.') parser.add_argument( '--set', dest='set_cfgs', help='set config keys, will overwrite config in the cfg_file.' ' See lib/core/config.py for all options', default=[], nargs='*') parser.add_argument( '--range', help='start (inclusive) and end (exclusive) indices', type=int, nargs=2) parser.add_argument( '--multi-gpu-testing', help='using multiple gpus for inference', action='store_true') parser.add_argument( '--vis', dest='vis', help='visualize detections', action='store_true') parser.add_argument( '--do_val', dest='do_val', help='do evaluation', action='store_true') parser.add_argument( '--use_gt_boxes', dest='use_gt_boxes', help='use gt boxes for sgcls/prdcls', action='store_true') parser.add_argument( '--use_gt_labels', dest='use_gt_labels', help='use gt boxes for sgcls/prdcls', action='store_true') parser.add_argument( '--cutoff_medium', dest='cutoff_medium', help='ratio of medium classes', type=float, default=0.80) parser.add_argument( '--cutoff_many', dest='cutoff_many', help='ratio of many classes', type=float, default=0.95) parser.add_argument( '--seed', dest='seed', help='Value of seed here will overwrite seed in cfg file', type=int) return parser.parse_args() def get_obj_and_prd_categories(): from datasets.dataset_catalog_rel import ANN_FN3 from datasets.dataset_catalog_rel import DATASETS predicates_path = DATASETS[cfg.TEST.DATASETS[0]][ANN_FN3] objects_path = DATASETS[cfg.TEST.DATASETS[0]][ANN_FN3].replace('predicates', 'objects', 1) logger.info('Loading predicates from: ' + predicates_path) logger.info('Loading objects from: ' + objects_path) with open(predicates_path) as f: prd_categories = json.load(f) with open(objects_path) as f: obj_categories = json.load(f) return obj_categories, prd_categories def get_obj_and_prd_frequencies(): if cfg.DATASET == 'gvqa10k': freq_prd_path = cfg.DATA_DIR + '/gvqa/reduced_data/10k/seed{}/predicates_freqs.json'.format( cfg.RNG_SEED) freq_obj_path = cfg.DATA_DIR + '/gvqa/reduced_data/10k/seed{}/objects_freqs.json'.format( cfg.RNG_SEED) elif cfg.DATASET == 'gvqa20k': freq_prd_path = cfg.DATA_DIR + '/gvqa/reduced_data/20k/seed{}/predicates_freqs.json'.format( cfg.RNG_SEED) freq_obj_path = cfg.DATA_DIR + '/gvqa/reduced_data/20k/seed{}/objects_freqs.json'.format( cfg.RNG_SEED) elif cfg.DATASET == 'gvqa': freq_prd_path = cfg.DATA_DIR + '/gvqa/seed{}/predicates_freqs.json'.format( cfg.RNG_SEED) freq_obj_path = cfg.DATA_DIR + '/gvqa/seed{}/objects_freqs.json'.format( cfg.RNG_SEED) elif cfg.DATASET == 'vg80k': freq_prd_path = cfg.DATA_DIR + '/vg/predicates_freqs.json' freq_obj_path = cfg.DATA_DIR + '/vg/objects_freqs.json' elif cfg.DATASET == 'vg8k': freq_prd_path = cfg.DATA_DIR + '/vg8k/seed{}/train_predicates_freqs.json'.format( cfg.RNG_SEED) freq_obj_path = cfg.DATA_DIR + '/vg8k/seed{}/train_objects_freqs.json'.format( cfg.RNG_SEED) else: raise NotImplementedError logger.info('Loading predicates frequencies from: ' + freq_prd_path) logger.info('Loading objects frequencies from: ' + freq_obj_path) prd_freq_dict = json.load(open(freq_prd_path)) obj_freq_dict = json.load(open(freq_obj_path)) return obj_freq_dict, prd_freq_dict if __name__ == '__main__': logger = utils.logging.setup_logging(__name__) args = parse_args() logger.info('Called with args:') logger.info(args) cfg.VIS = args.vis if args.cfg_file is not None: merge_cfg_from_file(args.cfg_file) if args.set_cfgs is not None: merge_cfg_from_list(args.set_cfgs) cfg.DATASET = args.dataset if args.dataset == "vrd": cfg.TEST.DATASETS = ('vrd_val',) cfg.MODEL.NUM_CLASSES = 101 cfg.MODEL.NUM_PRD_CLASSES = 70 # exclude background elif args.dataset == "vg": cfg.TEST.DATASETS = ('vg_val',) cfg.MODEL.NUM_CLASSES = 151 cfg.MODEL.NUM_PRD_CLASSES = 50 # exclude background elif args.dataset == "vg80k": cfg.TEST.DATASETS = ('vg80k_test',) cfg.MODEL.NUM_CLASSES = 53305 # includes background cfg.MODEL.NUM_PRD_CLASSES = 29086 # excludes background elif args.dataset == "vg8k": cfg.TEST.DATASETS = ('vg8k_test',) cfg.MODEL.NUM_CLASSES = 5331 # includes background cfg.MODEL.NUM_PRD_CLASSES = 2000 # excludes background elif args.dataset == "gvqa20k": cfg.TEST.DATASETS = ('gvqa20k_test',) cfg.MODEL.NUM_CLASSES = 1704 # includes background cfg.MODEL.NUM_PRD_CLASSES = 310 # exclude background elif args.dataset == "gvqa10k": cfg.TEST.DATASETS = ('gvqa10k_test',) cfg.MODEL.NUM_CLASSES = 1704 # includes background cfg.MODEL.NUM_PRD_CLASSES = 310 # exclude background elif args.dataset == "gvqa": cfg.TEST.DATASETS = ('gvqa_test',) cfg.MODEL.NUM_CLASSES = 1704 # includes background cfg.MODEL.NUM_PRD_CLASSES = 310 # exclude background else: # For subprocess call assert cfg.TEST.DATASETS, 'cfg.TEST.DATASETS shouldn\'t be empty' if args.seed: cfg.RNG_SEED = args.seed assert_and_infer_cfg() data_dir = '{}/{}/'.format(cfg.DATA_DIR, cfg.DATASET) ann_dir = '{}seed{}/'.format(data_dir, cfg.RNG_SEED) # The import has to happen after setting up the config to avoid loading default cfg values from core.test_engine_rel import run_inference obj_categories, prd_categories = get_obj_and_prd_categories() obj_freq_dict, prd_freq_dict = get_obj_and_prd_frequencies() if not cfg.MODEL.RUN_BASELINE: assert bool(args.load_ckpt) ^ bool(args.load_detectron), \ 'Exactly one of --load_ckpt and --load_detectron should be specified.' if args.output_dir is None: ckpt_path = args.load_ckpt if args.load_ckpt else args.load_detectron args.output_dir = os.path.join( os.path.dirname(os.path.dirname(ckpt_path)), 'test') logger.info('Automatically set output directory to %s', args.output_dir) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) logger.info('Testing with config:') logger.info(pprint.pformat(cfg)) # For test_engine.multi_gpu_test_net_on_dataset args.test_net_file, _ = os.path.splitext(__file__) # manually set args.cuda args.cuda = True #print('Generating Centroids') #all_results = get_features_for_centroids(args) #print('Done!') if args.use_gt_boxes: if args.use_gt_labels: det_file = os.path.join(args.output_dir, 'rel_detections_gt_boxes_prdcls.pkl') csv_file = os.path.join(args.output_dir, 'rel_detections_gt_boxes_prdcls.csv') else: det_file = os.path.join(args.output_dir, 'rel_detections_gt_boxes_sgcls.pkl') csv_file = os.path.join(args.output_dir, 'rel_detections_gt_boxes_sgcls.csv') else: det_file = os.path.join(args.output_dir, 'rel_detections.pkl') csv_file = os.path.join(args.output_dir, 'rel_detections.csv') if os.path.exists(det_file): logger.info('Loading results from {}'.format(det_file)) with open(det_file, 'rb') as f: all_results = pickle.load(f) # logger.info('Starting evaluation now...') # task_evaluation.eval_rel_results(all_results, args.output_dir, args.do_val) else: if not torch.cuda.is_available(): sys.exit("Need a CUDA device to run the code.") assert (torch.cuda.device_count() == 1) ^ bool(args.multi_gpu_testing) all_results = run_inference( args, ind_range=args.range, multi_gpu_testing=args.multi_gpu_testing, check_expected_results=True) all_results = all_results[0] print('all_results', len(all_results)) print('all_results', all_results[0].keys()) #all_results = all_results[0] freq_prd = (np.zeros(cfg.MODEL.NUM_PRD_CLASSES)) freq_obj = (np.zeros(cfg.MODEL.NUM_CLASSES)) generate_csv_file_from_det_obj(all_results, csv_file, obj_categories, prd_categories, obj_freq_dict, prd_freq_dict) logger.info('Saved CSV to: ' + csv_file) get_metrics_from_csv(csv_file, get_mr=True) cutoffs = [args.cutoff_medium, args.cutoff_many] get_many_medium_few_scores(csv_file, cutoffs, cfg.DATASET, data_dir, ann_dir, syn=True) csv_file_topk = os.path.join(os.path.dirname(csv_file), 'rel_detections_gt_boxes_prdcls_topk.csv') generate_topk_csv_from_det_obj(all_results, csv_file_topk, obj_categories, prd_categories, 250) logger.info('Saved topk CSV to: ' + csv_file_topk) csv_file_boxes = os.path.join(os.path.dirname(csv_file), 'rel_detections_gt_boxes_prdcls_boxes.csv') generate_boxes_csv_from_det_obj(all_results, csv_file_boxes, obj_categories, prd_categories, obj_freq_dict, prd_freq_dict) logger.info('Saved boxes CSV to: ' + csv_file_boxes) if cfg.DATASET.find('gvqa') >= 0: from evaluation.add_word_similarity_to_csv import add_similarity_to_detections logger.info('Adding word similarity to CSV') add_similarity_to_detections(csv_file) csv_file_w = os.path.join(os.path.dirname(csv_file), 'rel_detections_gt_boxes_prdcls_wrd_sim.csv') get_wordsim_metrics_from_csv(csv_file_w)
the-stack_0_3481
import pandas as pd import datetime import copy import requests from data.dataloader.base import BaseLoader class Covid19IndiaLoader(BaseLoader): """Dataloader that gets casecount data from 'https://api.covid19india.org' We use the JSON api and not the CSV api Different API are accessed and then converted into pd.DataFrames Full list of dataframes are given in the docstrings of pull_dataframes Args: BaseLoader (abstract class): Abstract Data Loader Class """ def __init__(self): super().__init__() def _load_data_json(self): """Returns dataframes from data.json df_tested : dataframe of testing data df_statewise : dataframe of statewise data (today's snapshot) df_india_time_series : dataframe of india cases (time series) Returns: [pd.DataFrame]: list of dataframes """ # Parse data.json file data = requests.get('https://api.covid19india.org/data.json').json() # Create dataframe for testing data df_tested = pd.DataFrame.from_dict(data['tested']) # Create dataframe for statewise data df_statewise = pd.DataFrame.from_dict(data['statewise']) # Create dataframe for time series data df_india_time_series = pd.DataFrame.from_dict(data['cases_time_series']) df_india_time_series['date'] = pd.to_datetime([datetime.datetime.strptime( x.split(' ')[0] + ' ' + x.split(' ')[1][:3] + ' 2020', '%d %b %Y') for x in df_india_time_series['date']]) return df_tested, df_statewise, df_india_time_series def _load_state_district_wise_json(self): """Loads dataframes from the state_district_wise.json file df_districtwise : Today's snapshot of district-wise cases statecode_to_state_dict : Mapping statecode to state name Returns: pd.DataFrame, dict: df_districtwise, statecode_to_state_dict """ # Load state_district_wise.json file data = requests.get('https://api.covid19india.org/state_district_wise.json').json() # Create statecode_to_state_dict df_statecode = pd.DataFrame.from_dict(data) df_statecode = df_statecode.drop(['districtData']).T statecode_to_state_dict = dict( zip(df_statecode['statecode'], df_statecode.index)) # Create df_districtwise states = data.keys() for state in states: for district, district_dict in data[state]['districtData'].items(): delta_dict = dict([('delta_'+k, v) for k, v in district_dict['delta'].items()]) data[state]['districtData'][district].update(delta_dict) del data[state]['districtData'][district]['delta'] columns = ['state', 'district', 'active', 'confirmed', 'deceased', 'recovered', 'migratedother', 'delta_confirmed', 'delta_deceased', 'delta_recovered'] df_districtwise = pd.DataFrame(columns=columns) for state in states: df = pd.DataFrame.from_dict( data[state]['districtData']).T.reset_index() del df['notes'] df.rename({'index': 'district'}, axis=1, inplace=True) df['state'] = state df = df[columns] df_districtwise = pd.concat([df_districtwise, df], ignore_index=True) return df_districtwise, statecode_to_state_dict def _load_raw_data_json(self, NUM_RAW_DFS=30): """Loads raw_data from raw_data{i}.json df_raw : patient level information Args: NUM_RAW_DFS (int, optional): Number of raw data json files to consider. Defaults to 30. """ # Parse raw_data.json file raw_data_dataframes = [] for i in range(1, NUM_RAW_DFS+1): try: data = requests.get(f'https://api.covid19india.org/raw_data{i}.json').json() raw_data_dataframes.append(pd.DataFrame.from_dict(data['raw_data'])) except Exception: break df_raw = pd.concat(raw_data_dataframes, ignore_index=True) return df_raw def _load_districts_daily_json(self): """Loads history of cases district wise from districts_daily.json Returns: pd.DataFrame: df_districts """ data = requests.get('https://api.covid19india.org/districts_daily.json').json() df_districts = pd.DataFrame(columns=['notes', 'active', 'confirmed', 'deceased', 'recovered', 'date', 'state', 'district']) for state in data['districtsDaily'].keys(): for dist in data['districtsDaily'][state].keys(): df = pd.DataFrame.from_dict(data['districtsDaily'][state][dist]) df['state'] = state df['district'] = dist df_districts = pd.concat([df_districts, df], ignore_index=True) df_districts = df_districts[['state', 'district', 'date', 'active', 'confirmed', 'deceased', 'recovered', 'notes']] numeric_cols = ['active', 'confirmed', 'deceased', 'recovered'] df_districts[numeric_cols] = df_districts[numeric_cols].apply( pd.to_numeric) return df_districts def _load_data_all_json_district(self, statecode_to_state_dict): """Loads history of cases district wise from data-all.json Args: statecode_to_state_dict (dict): dict mapping state code to state name Returns: pd.DataFrame: df_districts_all """ data = requests.get('https://api.covid19india.org/v4/data-all.json').json() for date in data.keys(): date_dict = data[date] # Remove all the states which don't have district data in them date_dict = {state : state_dict for state, state_dict in date_dict.items() \ if 'districts' in state_dict.keys()} data[date] = date_dict # Remove all the dates which have 0 states with district data after pruning data = {date : date_dict for date, date_dict in data.items() if len(date_dict) > 0} # Make the districts key data the only data available for the state key for date in data.keys(): for state in data[date].keys(): # Make the districts key dict the main dict itself for a particular date, state data[date][state] = data[date][state]['districts'] state_dict = data[date][state] # Keep only those district dicts for which cumulative data (total key) is available state_dict = {dist : dist_dict for dist, dist_dict in state_dict.items() \ if 'total' in dist_dict.keys()} data[date][state] = state_dict # Make the total key dict the main dict itself for a particular date, state, dist for district in data[date][state].keys(): data[date][state][district] = data[date][state][district]['total'] # For a particular date, state, dist, only keep those keys for which have confirmed, recovered, deceased are all available state_dict = {dist: dist_dict for dist, dist_dict in state_dict.items() \ if {'confirmed', 'recovered', 'deceased'} <= dist_dict.keys()} data[date][state] = state_dict # Remove all the states for a particular date which don't have district that satisfied above criteria date_dict = data[date] date_dict = {state : state_dict for state, state_dict in date_dict.items() if len(state_dict) > 0} data[date] = date_dict # Remove all the dates which have 0 states with district data after pruning data = {date : date_dict for date, date_dict in data.items() if len(date_dict) > 0} df_districts_all = pd.DataFrame(columns=['date', 'state', 'district', 'confirmed', 'active', 'recovered', 'deceased', 'tested', 'migrated']) for date in data.keys(): for state in data[date].keys(): df_date_state = pd.DataFrame.from_dict(data[date][state]).T.reset_index() df_date_state = df_date_state.rename({'index' : 'district'}, axis='columns') df_date_state['active'] = df_date_state['confirmed'] - \ (df_date_state['recovered'] + df_date_state['deceased']) df_date_state['state'] = statecode_to_state_dict[state] df_date_state['date'] = date df_districts_all = pd.concat([df_districts_all, df_date_state], ignore_index=True, sort=False) numeric_cols = ['confirmed', 'active', 'recovered', 'deceased', 'tested', 'migrated'] df_districts_all.loc[:, numeric_cols] = df_districts_all.loc[:, numeric_cols].apply(pd.to_numeric) return df_districts_all def _load_data_all_json_state(self, statecode_to_state_dict): """Loads history of cases state wise from data-all.json Args: statecode_to_state_dict (dict): dict mapping state code to state name Returns: pd.DataFrame: df_state_all """ data = requests.get('https://api.covid19india.org/v4/data-all.json').json() for date in data.keys(): date_dict = data[date] # Remove all the states which don't have district data in them date_dict = {state : state_dict for state, state_dict in date_dict.items() if 'districts' in state_dict.keys()} data[date] = date_dict # Remove all the dates which have 0 states with district data after pruning data = {date : date_dict for date, date_dict in data.items() if len(date_dict) > 0} # Make the districts key data the only data available for the state key for date in data.keys(): for state in data[date].keys(): # Make the districts key dict the main dict itself for a particular date, state data[date][state] = data[date][state]['total'] date_dict = {state: state_dict for state, state_dict in data[date].items() \ if {'confirmed', 'recovered', 'deceased'} <= state_dict.keys()} data[date] = date_dict # Remove all the dates which have 0 states with district data after pruning data = {date: date_dict for date, date_dict in data.items() if len(date_dict) > 0} df_states_all = pd.DataFrame(columns=['date', 'state', 'confirmed', 'active', 'recovered', 'deceased', 'tested', 'migrated']) for date in data.keys(): df_date = pd.DataFrame.from_dict(data[date]).T.reset_index() df_date = df_date.rename({'index': 'state'}, axis='columns') df_date['active'] = df_date['confirmed'] - (df_date['recovered'] + df_date['deceased']) df_date['state'] = pd.Series([statecode_to_state_dict[state_code] for state_code in df_date['state']]) df_date['date'] = date df_states_all = pd.concat([df_states_all, df_date], ignore_index=True) numeric_cols = ['confirmed', 'active', 'recovered', 'deceased', 'tested', 'migrated'] df_states_all.loc[:, numeric_cols] = df_states_all.loc[:, numeric_cols].apply(pd.to_numeric) return df_states_all def _load_districts_csv(self): df = pd.read_csv('https://api.covid19india.org/csv/latest/districts.csv') df.columns = [x.lower() for x in df.columns] df['active'] = df['confirmed'] - (df['recovered'] + df['deceased']) numeric_cols = ['confirmed', 'active', 'recovered', 'deceased', 'tested', 'other'] df.loc[:, numeric_cols] = df.loc[:, numeric_cols].apply(pd.to_numeric) df = df.fillna(0) df['date'] = pd.to_datetime(df['date'], format="%Y-%m-%d") return df def pull_dataframes(self, load_raw_data=False, load_districts_daily=False, **kwargs): """ This function parses multiple JSONs from covid19india.org It then converts the data into pandas dataframes It returns the following dataframes as a dict : - df_tested : Time series of people tested in India - df_statewise : Today's snapshot of cases in India, statewise - df_india_time_series : Time series of cases in India (nationwide) - df_districtwise : Today's snapshot of cases in India, districtwise - df_raw_data : Patient level information of cases - df_districts_daily : History of cases district wise obtained from districts_daily.json - df_districts_all : History of cases district wise obtained from data_all.json - df_states_all : History of cases state wise obtained from data_all.json """ # List of dataframes to return dataframes = {} df_tested, df_statewise, df_india_time_series = self._load_data_json() dataframes['df_tested'] = df_tested dataframes['df_statewise'] = df_statewise dataframes['df_india_time_series'] = df_india_time_series df_districtwise, statecode_to_state_dict = self._load_state_district_wise_json() dataframes['df_districtwise'] = df_districtwise if load_raw_data: df_raw = self._load_raw_data_json() dataframes['df_raw_data'] = df_raw if load_districts_daily: df_districts = self._load_districts_daily_json() dataframes['df_districts_daily'] = df_districts df_districts_all = self._load_data_all_json_district(statecode_to_state_dict) dataframes['df_districts_all'] = df_districts_all df_states_all = self._load_data_all_json_state(statecode_to_state_dict) dataframes['df_states_all'] = df_states_all df_districts = self._load_districts_csv() dataframes['df_districts'] = df_districts return dataframes def pull_dataframes_cached(self, reload_data=False, label=None, **kwargs): return super().pull_dataframes_cached(reload_data=reload_data, label=label, **kwargs) def get_data(self, state='Maharashtra', district='Mumbai', use_dataframe='data_all', reload_data=False, **kwargs): """Main function serving as handshake between data and fitting modules Args: state (str, optional): State to fit on. Defaults to 'Maharashtra'. district (str, optional): District to fit on. If given, get_data_district is called. Else, get_data_state is called. Defaults to 'Mumbai'. use_dataframe (str, optional): Which dataframe to use for districts. Can be data_all/districts_daily. Defaults to 'data_all'. reload_data (bool, optional): arg for pull_dataframes_cached. If true, data is pulled afresh, rather than using the cache. Defaults to False. Returns: dict { str : pd.DataFrame } : Processed dataframe """ if not district is None: return {"data_frame": self.get_data_district(state, district, use_dataframe, reload_data, **kwargs)} else: return {"data_frame": self.get_data_state(state, reload_data, **kwargs)} def get_data_state(self, state='Delhi', reload_data=False, **kwargs): """Helper function for get_data. Returns state data Args: state (str, optional): State to fit on. Defaults to 'Delhi'. reload_data (bool, optional): arg for pull_dataframes_cached. If true, data is pulled afresh, rather than using the cache. Defaults to False. Returns: dict { str : pd.DataFrame } : Processed dataframe """ dataframes = self.pull_dataframes_cached(reload_data=reload_data, **kwargs) df_states = copy.copy(dataframes['df_states_all']) df_state = df_states[df_states['state'] == state] df_state['date'] = pd.to_datetime(df_state['date']) df_state = df_state.rename({'confirmed': 'total'}, axis='columns') df_state.reset_index(inplace=True, drop=True) return df_state def get_data_district(self, state='Karnataka', district='Bengaluru', use_dataframe='data_all', reload_data=False, **kwargs): """Helper function for get_data. Returns district data Args: state (str, optional): State to fit on. Defaults to 'Karnataka'. district (str, optional): District to fit on. Defaults to 'Bengaluru'. use_dataframe (str, optional) : Which dataframe to use. Can be `data_all`/`districts_daily`. reload_data (bool, optional): arg for pull_dataframes_cached. If true, data is pulled afresh, rather than using the cache. Defaults to False. Returns: dict { str : pd.DataFrame } : Processed dataframe """ dataframes = self.pull_dataframes_cached(reload_data=reload_data, **kwargs) if use_dataframe == 'data_all': df_districts = copy.copy(dataframes['df_districts_all']) df_district = df_districts.loc[(df_districts['state'] == state) & ( df_districts['district'] == district)] df_district.loc[:, 'date'] = pd.to_datetime(df_district.loc[:, 'date']) df_district = df_district.rename({'confirmed': 'total'}, axis='columns') del df_district['migrated'] df_district.reset_index(inplace=True, drop=True) return df_district if use_dataframe == 'districts_daily': df_districts = copy.copy(dataframes['df_districts_daily']) df_district = df_districts.loc[(df_districts['state'] == state) & ( df_districts['district'] == district)] del df_district['notes'] df_district.loc[:, 'date'] = pd.to_datetime(df_district.loc[:, 'date']) df_district = df_district.loc[df_district['date'] >= '2020-04-24', :] df_district = df_district.rename({'confirmed': 'total'}, axis='columns') df_district.reset_index(inplace=True, drop=True) return df_district
the-stack_0_3482
import sys import logging from collections import namedtuple logging.basicConfig(stream=sys.stderr, level=logging.WARNING) class Parser(object): """Defines the common interface for parser objects. Parser transofrm natural text into graphbrain hyperedges. """ def __init__(self, lemmas=False): self.lemmas = lemmas self.atom2token = {} self.cur_text = None # to be created by derived classes self.lang = None self.nlp = None # named tuple used to pass parser state internally self._ParseState = namedtuple('_ParseState', ['extra_edges', 'tokens', 'child_tokens', 'positions', 'children', 'entities']) def _post_process(edge): raise NotImplementedError() def _parse_token(token): raise NotImplementedError() def _parse_sentence(self, sent): self.atom2token = {} main_edge, extra_edges = self._parse_token(sent.root) main_edge, _ = self._post_process(main_edge) return {'main_edge': main_edge, 'extra_edges': extra_edges, 'text': str(sent).strip(), 'spacy_sentence': sent} def parse(self, text): """Transforms the given text into hyperedges + aditional information. Returns a sequence of dictionaries, with one dictionary for each sentence found in the text. Each dictionary contains the following fields: -> main_edge: the hyperedge corresponding to the sentence. -> extra_edges: aditional edges, e.g. connecting atoms that appear in the main_edge to their lemmas. -> text: the string of natural language text corresponding to the main_edge, i.e.: the sentence itself. -> spacy_sentence: the spaCy structure representing the sentence enriched with NLP annotations. """ self.cur_text = text doc = self.nlp(text.strip()) return tuple(self._parse_sentence(sent) for sent in doc.sents)
the-stack_0_3483
# -*- coding: utf-8 -*- from hypothesis import assume, given import hypothesis.strategies as st import pytest from matchpy.expressions.expressions import Arity, Operation, Symbol, Wildcard, Pattern from matchpy.functions import ReplacementRule, replace, replace_all, substitute, replace_many, is_match from matchpy.matching.one_to_one import match_anywhere from matchpy.matching.one_to_one import match as match_one_to_one from matchpy.matching.many_to_one import ManyToOneReplacer from .common import * @pytest.mark.parametrize( ' expr, pattern, do_match', [ (a, a, True), (a, b, False), (f(a), f(x_), True), ] ) # yapf: disable def test_is_match(expr, pattern, do_match): assert is_match(expr, Pattern(pattern)) == do_match class TestSubstitute: @pytest.mark.parametrize( ' expression, substitution, expected_result, replaced', [ (a, {}, a, False), (a, {'x': b}, a, False), (x_, {'x': b}, b, True), (x_, {'x': [a, b]}, [a, b], True), (y_, {'x': b}, y_, False), (f(x_), {'x': b}, f(b), True), (f(x_), {'y': b}, f(x_), False), (f(x_), {}, f(x_), False), (f(a, x_), {'x': b}, f(a, b), True), (f(x_), {'x': [a, b]}, f(a, b), True), (f(x_), {'x': []}, f(), True), (f(x_, c), {'x': [a, b]}, f(a, b, c), True), (f(x_, y_), {'x': a, 'y': b}, f(a, b), True), (f(x_, y_), {'x': [a, c], 'y': b}, f(a, c, b), True), (f(x_, y_), {'x': a, 'y': [b, c]}, f(a, b, c), True), (Pattern(f(x_)), {'x': a}, f(a), True) ] ) # yapf: disable def test_substitute(self, expression, substitution, expected_result, replaced): result = substitute(expression, substitution) assert result == expected_result, "Substitution did not yield expected result" if replaced: assert result is not expression, "When substituting, the original expression may not be modified" else: assert result is expression, "When nothing is substituted, the original expression has to be returned" def many_replace_wrapper(expression, position, replacement): return replace_many(expression, [(position, replacement)]) class TestReplaceTest: @pytest.mark.parametrize('replace', [replace, many_replace_wrapper]) @pytest.mark.parametrize( ' expression, position, replacement, expected_result', [ (a, (), b, b), (f(a), (), b, b), (a, (), f(b), f(b)), (f(a), (), f(b), f(b)), (f(a), (0, ), b, f(b)), (f(a, b), (0, ), c, f(c, b)), (f(a, b), (1, ), c, f(a, c)), (f(a), (0, ), [b, c], f(b, c)), (f(a, b), (0, ), [b, c], f(b, c, b)), (f(a, b), (1, ), [b, c], f(a, b, c)), (f(f(a)), (0, ), b, f(b)), (f(f(a)), (0, 0), b, f(f(b))), (f(f(a, b)), (0, 0), c, f(f(c, b))), (f(f(a, b)), (0, 1), c, f(f(a, c))), (f(f(a, b), f(a, b)), (0, 0), c, f(f(c, b), f(a, b))), (f(f(a, b), f(a, b)), (0, 1), c, f(f(a, c), f(a, b))), (f(f(a, b), f(a, b)), (1, 0), c, f(f(a, b), f(c, b))), (f(f(a, b), f(a, b)), (1, 1), c, f(f(a, b), f(a, c))), (f(f(a, b), f(a, b)), (0, ), c, f(c, f(a, b))), (f(f(a, b), f(a, b)), (1, ), c, f(f(a, b), c)), ] ) # yapf: disable def test_substitution_match(self, replace, expression, position, replacement, expected_result): result = replace(expression, position, replacement) assert result == expected_result, "Replacement did not yield expected result ({!r} {!r} -> {!r})".format( expression, position, replacement ) assert result is not expression, "Replacement modified the original expression" @pytest.mark.parametrize('replace', [replace, many_replace_wrapper]) def test_too_big_position_error(self, replace): with pytest.raises(IndexError): replace(a, (0, ), b) with pytest.raises(IndexError): replace(f(a), (0, 0), b) with pytest.raises(IndexError): replace(f(a), (1, ), b) with pytest.raises(IndexError): replace(f(a, b), (2, ), b) class TestReplaceManyTest: @pytest.mark.parametrize( ' expression, replacements, expected_result', [ (f(a, b), [((0, ), b), ((1, ), a)], f(b, a)), (f(a, b), [((0, ), [c, c]), ((1, ), a)], f(c, c, a)), (f(a, b), [((0, ), b), ((1, ), [c, c])], f(b, c, c)), (f(f2(a, b), c), [((0, 0), b), ((0, 1), a)], f(f2(b, a), c)), (f_c(c, f2(a, b)), [((1, 0), b), ((1, 1), a)], f_c(c, f2(b, a))), (f(f2(a, b), f2(c)), [((1, 0), b), ((0, 1), a)], f(f2(a, a), f2(b))), (f(f2(a, b), f2(c)), [((0, 1), a), ((1, 0), b)], f(f2(a, a), f2(b))), (f_c(f2(c), f2(a, b)), [((0, 0), b), ((1, 1), a)], f_c(f2(b), f2(a, a))), (f_c(f2(c), f2(a, b)), [((1, 1), a), ((0, 0), b)], f_c(f2(b), f2(a, a))), ] ) # yapf: disable def test_substitution_match(self, expression, replacements, expected_result): result = replace_many(expression, replacements) assert result == expected_result, "Replacement did not yield expected result ({!r} -> {!r})".format( expression, replacements ) assert result is not expression, "Replacement modified the original expression" def test_inconsistent_position_error(self): with pytest.raises(IndexError): replace_many(f(a), [((), b), ((0, ), b)]) with pytest.raises(IndexError): replace_many(a, [((), b), ((0, ), b)]) with pytest.raises(IndexError): replace_many(a, [((0, ), b), ((1, ), b)]) def test_empty_replace(self): expression = f(a, b) result = replace_many(expression, []) assert expression is result, "Empty replacements should not change the expression." @pytest.mark.parametrize( ' expression, pattern, expected_results', [ # Substitution Position (f(a), f(x_), [({'x': a}, ())]), (f(a), x_, [({'x': f(a)}, ()), ({'x': a}, (0, ))]), (f(a, f2(b), f2(f2(c), f2(a), f2(f2(b))), f2(c), c), f2(x_), [({'x': b}, (1, )), ({'x': c}, (2, 0)), ({'x': a}, (2, 1)), ({'x': f2(b)}, (2, 2)), ({'x': b}, (2, 2, 0)), ({'x': c}, (3, ))]) ] ) # yapf: disable def test_match_anywhere(expression, pattern, expected_results): expression = expression pattern = Pattern(pattern) results = list(match_anywhere(expression, pattern)) assert len(results) == len(expected_results), "Invalid number of results" for result in expected_results: assert result in results, "Results differ from expected" def test_match_anywhere_error(): with pytest.raises(ValueError): next(match_anywhere(f(x_), f(x_))) def test_match_error(): with pytest.raises(ValueError): next(match_one_to_one(f(x_), f(x_))) def _many_to_one_replace(expression, rules): return ManyToOneReplacer(*rules).replace(expression) @pytest.mark.parametrize( 'replacer', [replace_all, _many_to_one_replace] ) def test_logic_simplify(replacer): LAnd = Operation.new('and', Arity.variadic, 'LAnd', associative=True, one_identity=True, commutative=True) LOr = Operation.new('or', Arity.variadic, 'LOr', associative=True, one_identity=True, commutative=True) LXor = Operation.new('xor', Arity.variadic, 'LXor', associative=True, one_identity=True, commutative=True) LNot = Operation.new('not', Arity.unary, 'LNot') LImplies = Operation.new('implies', Arity.binary, 'LImplies') Iff = Operation.new('iff', Arity.binary, 'Iff') ___ = Wildcard.star() a1 = Symbol('a1') a2 = Symbol('a2') a3 = Symbol('a3') a4 = Symbol('a4') a5 = Symbol('a5') a6 = Symbol('a6') a7 = Symbol('a7') a8 = Symbol('a8') a9 = Symbol('a9') a10 = Symbol('a10') a11 = Symbol('a11') LBot = Symbol(u'⊥') LTop = Symbol(u'⊤') expression = LImplies( LAnd( Iff( Iff(LOr(a1, a2), LOr(LNot(a3), Iff(LXor(a4, a5), LNot(LNot(LNot(a6)))))), LNot( LAnd( LAnd(a7, a8), LNot( LXor( LXor(LOr(a9, LAnd(a10, a11)), a2), LAnd(LAnd(a11, LXor(a2, Iff(a5, a5))), LXor(LXor(a7, a7), Iff(a9, a4))) ) ) ) ) ), LImplies( Iff( Iff(LOr(a1, a2), LOr(LNot(a3), Iff(LXor(a4, a5), LNot(LNot(LNot(a6)))))), LNot( LAnd( LAnd(a7, a8), LNot( LXor( LXor(LOr(a9, LAnd(a10, a11)), a2), LAnd(LAnd(a11, LXor(a2, Iff(a5, a5))), LXor(LXor(a7, a7), Iff(a9, a4))) ) ) ) ) ), LNot( LAnd( LImplies( LAnd(a1, a2), LNot( LXor( LOr( LOr( LXor(LImplies(LAnd(a3, a4), LImplies(a5, a6)), LOr(a7, a8)), LXor(Iff(a9, a10), a11) ), LXor(LXor(a2, a2), a7) ), Iff(LOr(a4, a9), LXor(LNot(a6), a6)) ) ) ), LNot(Iff(LNot(a11), LNot(a9))) ) ) ) ), LNot( LAnd( LImplies( LAnd(a1, a2), LNot( LXor( LOr( LOr( LXor(LImplies(LAnd(a3, a4), LImplies(a5, a6)), LOr(a7, a8)), LXor(Iff(a9, a10), a11) ), LXor(LXor(a2, a2), a7) ), Iff(LOr(a4, a9), LXor(LNot(a6), a6)) ) ) ), LNot(Iff(LNot(a11), LNot(a9))) ) ) ) rules = [ # xor(x,⊥) → x ReplacementRule( Pattern(LXor(x__, LBot)), lambda x: LXor(*x) ), # xor(x, x) → ⊥ ReplacementRule( Pattern(LXor(x_, x_, ___)), lambda x: LBot ), # and(x,⊤) → x ReplacementRule( Pattern(LAnd(x__, LTop)), lambda x: LAnd(*x) ), # and(x,⊥) → ⊥ ReplacementRule( Pattern(LAnd(__, LBot)), lambda: LBot ), # and(x, x) → x ReplacementRule( Pattern(LAnd(x_, x_, y___)), lambda x, y: LAnd(x, *y) ), # and(x, xor(y, z)) → xor(and(x, y), and(x, z)) ReplacementRule( Pattern(LAnd(x_, LXor(y_, z_))), lambda x, y, z: LXor(LAnd(x, y), LAnd(x, z)) ), # implies(x, y) → not(xor(x, and(x, y))) ReplacementRule( Pattern(LImplies(x_, y_)), lambda x, y: LNot(LXor(x, LAnd(x, y))) ), # not(x) → xor(x,⊤) ReplacementRule( Pattern(LNot(x_)), lambda x: LXor(x, LTop) ), # or(x, y) → xor(and(x, y), xor(x, y)) ReplacementRule( Pattern(LOr(x_, y_)), lambda x, y: LXor(LAnd(x, y), LXor(x, y)) ), # iff(x, y) → not(xor(x, y)) ReplacementRule( Pattern(Iff(x_, y_)), lambda x, y: LNot(LXor(x, y)) ), ] # yapf: disable result = replacer(expression, rules) assert result == LBot
the-stack_0_3484
from ast import Mod import cv2 import numpy as np import os from matplotlib import pyplot def edit(): #Read the image image = cv2.imread('Media/sample.jpg') #greyscale filter def greyscale(img): greyscale = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) return greyscale # brightness adjustment def bright(img, beta_value ): img_bright = cv2.convertScaleAbs(img, beta=beta_value) return img_bright #sharp effect def sharpen(img): kernel = np.array([[-1, -1, -1], [-1, 9.5, -1], [-1, -1, -1]]) img_sharpen = cv2.filter2D(img, -1, kernel) return img_sharpen #sepia effect def sepia(img): img_sepia = np.array(img, dtype=np.float64) # converting to float to prevent loss img_sepia = cv2.transform(img_sepia, np.matrix([[0.272, 0.534, 0.131], [0.349, 0.686, 0.168], [0.393, 0.769, 0.189]])) # multipying image with special sepia matrix img_sepia[np.where(img_sepia > 255)] = 255 # normalizing values greater than 255 to 255 img_sepia = np.array(img_sepia, dtype=np.uint8) return img_sepia #grey pencil sketch effect def pencil_sketch_grey(img): #inbuilt function to create sketch effect in colour and greyscale sk_gray, sk_color = cv2.pencilSketch(img, sigma_s=60, sigma_r=0.07, shade_factor=0.1) return sk_gray #colour pencil sketch effect def pencil_sketch_col(img): #inbuilt function to create sketch effect in colour and greyscale sk_gray, sk_color = cv2.pencilSketch(img, sigma_s=60, sigma_r=0.07, shade_factor=0.1) return sk_color #HDR effect def HDR(img): hdr = cv2.detailEnhance(img, sigma_s=12, sigma_r=0.15) return hdr # invert filter def invert(img): inv = cv2.bitwise_not(img) return inv #defining a function from scipy.interpolate import UnivariateSpline def LookupTable(x, y): spline = UnivariateSpline(x, y) return spline(range(256)) #summer effect def Summer(img): increaseLookupTable = LookupTable([0, 64, 128, 256], [0, 80, 160, 256]) decreaseLookupTable = LookupTable([0, 64, 128, 256], [0, 50, 100, 256]) blue_channel, green_channel, red_channel = cv2.split(img) red_channel = cv2.LUT(red_channel, increaseLookupTable).astype(np.uint8) blue_channel = cv2.LUT(blue_channel, decreaseLookupTable).astype(np.uint8) sum= cv2.merge((blue_channel, green_channel, red_channel )) return sum #winter effect def Winter(img): increaseLookupTable = LookupTable([0, 64, 128, 256], [0, 80, 160, 256]) decreaseLookupTable = LookupTable([0, 64, 128, 256], [0, 50, 100, 256]) blue_channel, green_channel, red_channel = cv2.split(img) red_channel = cv2.LUT(red_channel, decreaseLookupTable).astype(np.uint8) blue_channel = cv2.LUT(blue_channel, increaseLookupTable).astype(np.uint8) win= cv2.merge((blue_channel, green_channel, red_channel)) return win #making the greyscale image a1 = greyscale(image) filename = 'greyscale.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a1) #making the more bright image #positive beta value a2 = bright(image, 60) filename = 'more_bright.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a2) #making the less bright image #negative beta value a3 = bright(image, -60) filename = 'less_bright.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a3) #making the sharp image a4 = sharpen(image) filename = 'sharpen.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a4) #making the sepia image a5 = sepia(image) filename = 'sepia.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a5) #making the grey pencil sketch a6 = pencil_sketch_grey(image) filename = 'pencil_grey.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a6) #making the colour pencil sketch a7 = pencil_sketch_col(image) filename = 'pencil_col.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a7) #making the hdr img a8 = HDR(image) filename = 'HDR.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a8) #making the invert img a9 = invert(image) filename = 'invert.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a9) #making the summer img a11 = Summer(image) filename = 'Summer.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a11) #making the winter img a10 = Winter(image) filename = 'Winter.jpg' # Using cv2.imwrite() method # Saving the image cv2.imwrite(f'Edited/{filename}', a10) os.startfile('Edited')
the-stack_0_3485
#!/usr/bin/env python # -*- coding: utf-8 -*- import json from alipay.aop.api.constant.ParamConstants import * class KoubeiMarketingCampaignMemberRelationUnbindModel(object): def __init__(self): self._member_template_id = None self._out_member_no = None self._request_id = None self._user_id = None @property def member_template_id(self): return self._member_template_id @member_template_id.setter def member_template_id(self, value): self._member_template_id = value @property def out_member_no(self): return self._out_member_no @out_member_no.setter def out_member_no(self, value): self._out_member_no = value @property def request_id(self): return self._request_id @request_id.setter def request_id(self, value): self._request_id = value @property def user_id(self): return self._user_id @user_id.setter def user_id(self, value): self._user_id = value def to_alipay_dict(self): params = dict() if self.member_template_id: if hasattr(self.member_template_id, 'to_alipay_dict'): params['member_template_id'] = self.member_template_id.to_alipay_dict() else: params['member_template_id'] = self.member_template_id if self.out_member_no: if hasattr(self.out_member_no, 'to_alipay_dict'): params['out_member_no'] = self.out_member_no.to_alipay_dict() else: params['out_member_no'] = self.out_member_no if self.request_id: if hasattr(self.request_id, 'to_alipay_dict'): params['request_id'] = self.request_id.to_alipay_dict() else: params['request_id'] = self.request_id if self.user_id: if hasattr(self.user_id, 'to_alipay_dict'): params['user_id'] = self.user_id.to_alipay_dict() else: params['user_id'] = self.user_id return params @staticmethod def from_alipay_dict(d): if not d: return None o = KoubeiMarketingCampaignMemberRelationUnbindModel() if 'member_template_id' in d: o.member_template_id = d['member_template_id'] if 'out_member_no' in d: o.out_member_no = d['out_member_no'] if 'request_id' in d: o.request_id = d['request_id'] if 'user_id' in d: o.user_id = d['user_id'] return o
the-stack_0_3487
from __future__ import print_function import random import string import subprocess import time from configparser import SafeConfigParser import MySQLdb from django.contrib.auth.mixins import LoginRequiredMixin from django.core.mail import EmailMessage from django.http import JsonResponse from django.views.generic import View from billing.models import Transaction, ItemCount, RestrictedRequest from digitalmarket.mixins import AjaxRequiredMixin from notifications.models import NotificationItem from flows.models import Flow #NP_PATH = '/home/zxc/Desktop/frontend/src/np' #CHECKOUT_LOG_PATH = '/home/zxc/Desktop/checkout_log' class CheckoutAjaxView(LoginRequiredMixin, AjaxRequiredMixin, View): """ View for the checkout function Add password, send email, send notification, send flow, deal with restricted permission """ # Added: sending message to the broker def _sendAdminEmail(self, user, seller, topic, prod_num, message, request_file, restricted_active, request, product_obj): config = SafeConfigParser() config.read('/code/config.ini') db = MySQLdb.connect(host=config.get('main', 'mysql_host'), # your host, usually localhost user=config.get('main', 'mysql_name'), # your username passwd=config.get('main', 'mysql_pw'), # your password db=config.get('main', 'mysql_db')) # your database cur = db.cursor() log = config.get('main', 'checkout_log_path') NP_PATH = config.get('main', 'np_path') username = user.username user_email = user.email topic = topic # Password with 6 characters (lower case + number) original_password = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(12)) if not cur.execute("select (1) from users where username = %s limit 1", (username,)): command = NP_PATH + ' ' + '-p' + ' ' + original_password command_bytes = command.encode('utf-8') pw_bytes = subprocess.Popen(command_bytes, stdout=subprocess.PIPE, shell=True).communicate()[0] password = pw_bytes.decode().rstrip('\n') cur.execute("insert into users (username,pw,user_id) values (%s,%s,%s)", (username, password, user.id)) # stdout: ignore '\n' # Send password to email subject = 'Your new password' msg = "Your password to I3 is: " + original_password email = EmailMessage(subject, msg, to=[user_email]) email.send() # Record email as notification notification_box = request.user.get_notification_box() notification_item = NotificationItem( notification_box=notification_box, subject=subject, body=msg) notification_item.save() # To do: make topic as a product obj that can be linked to flow_obj = Flow.objects.create( user=request.user, topic=topic, direction='in', state='inactive') flow_obj.save() # send to the user which topic is able to pub/sub # when the topic is unrestricted: insert to acls and send confirmation back to buyer if not restricted_active: subject = 'New product purchased' msg = 'Now you can subscribe to topic: ' + topic + '.' email = EmailMessage(subject, msg, to=[user_email]) email.send() # Record email as notification notification_box = request.user.get_notification_box() notification_item = NotificationItem( notification_box=notification_box, subject=subject, body=msg) notification_item.save() subject = 'New buyer of an unrestricted topic' msg = 'Buyer ' + username + ' just bought product ' + topic + '.' email = EmailMessage(subject, msg, to=[seller.email]) email.send() # Record email as notification notification_box = seller.get_notification_box() notification_item = NotificationItem( notification_box=notification_box, subject=subject, body=msg) notification_item.save() # insert into acls table rw = 1 # seller: can read and write if product_obj.sensor_type >= 2: rw = 2 cur.execute("insert into acls (username,topic,rw,user_id, topic_id) values (%s,%s,%s,%s,%s)", (username, topic, str(rw), user.id, product_obj.id)) # write new sub info to log with open(log, 'a') as f: f.write(str(time.time()) + ': New Sub ' + username + ' ' + topic + ' ' + str(prod_num) + '\n') else: restricted_request_obj = RestrictedRequest( seller=product_obj.seller, requester=request.user, product=product_obj, price=product_obj.price, quantity=prod_num, intention=message, attachment=request_file ) restricted_request_obj.save() subject = 'New product purchased (to be confirmed)' msg = 'Waiting seller to confirm purchase of ' + topic + '.' email = EmailMessage(subject, msg, to=[user_email]) email.send() # Record email as notification notification_box = request.user.get_notification_box() notification_item = NotificationItem( notification_box=notification_box, subject=subject, body=msg) notification_item.save() subject = 'New buyer of a restricted topic' msg = 'Buyer ' + username + ' just bought product ' + topic + '. You need to approve the purchase.' email = EmailMessage(subject, msg, to=[seller.email]) email.send() # Record email as notification notification_box = seller.get_notification_box() notification_item = NotificationItem( notification_box=notification_box, subject=subject, body=msg) notification_item.save() db.commit() def post(self, request, *args, **kwargs): # TODO: add credit card processing user = request.user cart = user.get_cart() if cart.num_items() == 0: data = { 'success': False, 'errMsg': 'Your cart is empty' } return JsonResponse(data=data) processed_items = [] for item in cart.all_items(): # TODO: how to handle restricted? transaction = Transaction( buyer=request.user, seller=item.product.seller, product=item.product, price=item.product.get_price * item.quantity, quantity=item.quantity, ) transaction.save() item_count = ItemCount( buyer=request.user, product=item.product, order=item.quantity, quantity=item.quantity, ) item_count.save() try: self._sendAdminEmail(user, item.product.seller, item.product.title, item.quantity, item.intention, item.attachment, item.product.restricted_active, request, item.product) processed_items.append(item) except: # TODO: log error, recover, try again? pass links = [] for item in processed_items: download_link = item.product.get_download() preview_link = download_link + "?preview=True" link = { "download": download_link, "preview": preview_link, } links.append(link) item.delete() data = { 'success': True, 'links': links } return JsonResponse(data=data) class RequestsAjaxView(LoginRequiredMixin, AjaxRequiredMixin, View): """ seller decides whether to approve or decline the buy product request return Json object for frontend Ajax call """ def post(self, request, *args, **kwargs): request_id = kwargs['pk'] restricted_request = RestrictedRequest.objects.get(pk=request_id) if restricted_request.seller != request.user: data = { 'success': False, 'errMsg': 'Request not found', 'errCode': '404' } else: task = kwargs['task'] if task == 'approve': restricted_request.success = 1 else: restricted_request.success = 0 restricted_request.replied = True restricted_request.save() data = { 'success': True } return JsonResponse(data=data)
the-stack_0_3488
import gym from gym.spaces import Box, Discrete, Tuple import logging import random import numpy as np logger = logging.getLogger(__name__) # Agent has to traverse the maze from the starting position S -> F # Observation space [x_pos, y_pos, wind_direction] # Action space: stay still OR move in current wind direction MAP_DATA = """ ########################### # S # # ### # # ### # # ### # # F # ###########################""" class MazeEnv(gym.Env): def __init__(self, env_config={}): self.map = [m for m in MAP_DATA.split("\n") if m] self.x_dim = len(self.map) self.y_dim = len(self.map[0]) logger.info("Loaded map {} {}".format(self.x_dim, self.y_dim)) for x in range(self.x_dim): for y in range(self.y_dim): if self.map[x][y] == "S": self.start_pos = (x, y) elif self.map[x][y] == "F": self.end_pos = (x, y) logger.info("Start pos {} end pos {}".format(self.start_pos, self.end_pos)) # self.observation_space = Tuple([ # Box(0, 100, shape=(2, )), # (x, y) # Discrete(4), # wind direction (N, E, S, W) # ]) self.observation_space = Box(0, 100, shape=(2,)) self.action_space = Discrete(4) # whether to move or not self.viewer = None self.h = len(self.map) self.w = len(self.map[0]) self.frame = 255 * np.ones((self.h, self.w, 3), dtype=np.uint8) self.bg = 255 * np.ones((self.h, self.w, 3), dtype=np.uint8) for ridx in range(self.h): for cidx in range(self.w): if self.map[ridx][cidx] == "#": self.bg[ridx, cidx, :] = [255, 0, 0] self.frame = self.bg.copy() self.member = None def reset(self): # self.wind_direction = random.choice([0, 1, 2, 3]) self.pos = self.start_pos self.num_steps = 0 return np.array(self.pos) def step(self, action, verbose=False): # if action == 1: # self.pos = self._get_new_pos(self.pos, self.wind_direction) # self.wind_direction = random.choice([0, 1, 2, 3]) self.pos = self._get_new_pos(self.pos, action) self.num_steps += 1 at_goal = self.pos == self.end_pos done = at_goal or self.num_steps >= 200 if verbose: print(f"step: {self.num_steps}, pos: {self.pos}") return (np.array(self.pos), 1 * int(at_goal), done, {}) def _get_new_pos(self, pos, direction): if direction == 0: new_pos = (pos[0] - 1, pos[1]) elif direction == 1: new_pos = (pos[0], pos[1] + 1) elif direction == 2: new_pos = (pos[0] + 1, pos[1]) elif direction == 3: new_pos = (pos[0], pos[1] - 1) if (new_pos[0] >= 0 and new_pos[0] < self.x_dim and new_pos[1] >= 0 and new_pos[1] < self.y_dim and self.map[new_pos[0]][new_pos[1]] != "#"): return new_pos else: return pos # did not move def set_member(self, member): self.member = member def member_color(self): if self.member == 0: return [51, 255, 69] elif self.member == 1: return [255, 190, 51] else: raise ValueError def _get_image(self, alpha=0.995): frame_t = self.bg.copy() frame_t[self.pos] = self.member_color() # frame[self.end_pos] = [0, 0, 255] # self.frame = (alpha * self.frame + (1 - alpha) * frame_t).astype(np.uint8) self.frame[self.pos] = self.member_color() return np.concatenate([frame_t, self.frame], axis=1) def render(self, mode='human'): img = self._get_image() if mode == 'rgb_array': return img elif mode == 'human': from gym.envs.classic_control import rendering if self.viewer is None: self.viewer = rendering.SimpleImageViewer() self.viewer.imshow(img) return self.viewer.isopen
the-stack_0_3490
import logging import os import sys import time import click from .investing import Investing from .sendtext import SendText __version__ = "0.0.4" def setup_logging(): """Create a basic console based logger object. Args: None Returns: logger (logging.logger): Logger object. """ log_handler = logging.StreamHandler() log_handler.setFormatter( logging.Formatter( "%(asctime)s [%(levelname)5s] %(funcName)4s() - %(message)s", "%Y-%m-%d %H:%M:%S", ) ) logger = logging.getLogger(__name__) logger.addHandler(log_handler) logger.setLevel(logging.INFO) return logger def run( instrument: Investing, send_message: SendText, lower: float, upper: float, threshold: float, ) -> tuple: instrument.fetch() logger.debug("Fetched page successfully.") price = instrument.price() logger.debug(f"Price of {instrument.name} is ${price}.") if price >= upper or price <= lower: logger.info(f"Price {price} breached price band [{lower}, {upper}].") logger.debug(f"Resetting price band with threshold value {threshold}.") upper = price * (1 + threshold / 10000) lower = price * (1 - threshold / 10000) logger.info(f"Resetting price band to [{lower}, {upper}].") logger.debug("Sending text.") send_message.send(f"{instrument.name} price is {price}.") return (lower, upper) @click.command( context_settings=dict(help_option_names=["-h", "--help"]), options_metavar="[options...]", ) @click.argument("to_num", metavar="[to number]") @click.argument("from_num", metavar="[from number]") @click.argument("market", metavar="[market]") @click.argument("contract", metavar="[contract]") @click.argument("priceband", metavar="[priceband]") @click.option("--symbol", "-s", help="Contract symbol. [default: contract]") @click.option( "--threshold", "-t", help="Threshold in bps.", default=100.0, show_default=True ) @click.option( "--interval", "-i", help="Interval to perform check (mins).", default=1.0, show_default=True, ) @click.option( "--sub-market", "-m", help="E.g. crypto is market and bitcoin is sub market." ) @click.option("--debug", "-d", is_flag=True, help="Print debug messages.") def main( to_num, from_num, interval, threshold, debug=None, symbol=None, market=None, contract=None, priceband=None, sub_market=None, ): """Utiltiy script to notify if instrument price fluctuates out of price band. """ global logger logger = setup_logging() if debug: logger.setLevel(logging.DEBUG) logger.debug("Logging set to debug.") if ("TWILIO_AUTH_TOKEN" in os.environ) and ("TWILIO_ACCOUNT_SID" in os.environ): pass else: logger.error("TWILIO_AUTH_TOKEN and/or TWILIO_ACCOUNT_SID not defined.") sys.exit(1) lower, upper = list(map(float, priceband.split("-"))) if sub_market: end_point = market + "/" + sub_market + "/" + contract else: end_point = market + "/" + contract logger.debug(f"{end_point} end point will be queried.") instrument = Investing(end_point, symbol) text_client = SendText(from_num, to_num) while True: try: lower, upper = run(instrument, text_client, lower, upper, threshold) time.sleep(60 * interval) except KeyboardInterrupt: logger.info("Caught interrupt, exiting...") sys.exit() if __name__ == "__main__": main()
the-stack_0_3491
#Given a list of numbers and a number k, return whether any two numbers from the list add up to k. #For example, given [10, 15, 3, 7] and k of 17, return true since 10 + 7 is 17. #Bonus: Can you do this in one pass? if __name__ == "__main__": l = list( int(i) for i in input().split(' ')) k = int(input()) found = False for el in range(len(l)): check = k - l[el] if check in l: found = Tru print(found)