Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

39ec9a70f64ddc65a70eb731b8421b2083d1e79f

py

Python

src/aerocloud/packages.py

Aerometrex/aerocloud-python-client

0bd15432bb0f81fc5e9ca03c48b9b15c8e8ed438

src/aerocloud/packages.py

Aerometrex/aerocloud-python-client

0bd15432bb0f81fc5e9ca03c48b9b15c8e8ed438

src/aerocloud/packages.py

Aerometrex/aerocloud-python-client

0bd15432bb0f81fc5e9ca03c48b9b15c8e8ed438

import os from enum import Enum class AppPackage(Enum): # Add packages here as required. LASTOOLS = "lastools" def getPackageDirectory(package: AppPackage, version: str = None): "Gets the directory where the specified package is installed." varName = f'AZ_BATCH_APP_PACKAGE_{package.value}' if version != None: varName = f'{varName}#{version}' return os.environ[varName]

39ef2ca7f17378b96bb6865f18c59fdf8633759c

py

Python

src/nodeforge/StartEngine.py

nsk89/nodeforge

51e798092cfaf52112cfdc96af359633741da799

src/nodeforge/StartEngine.py

nsk89/nodeforge

51e798092cfaf52112cfdc96af359633741da799

2018-10-21T05:30:32.000Z

2018-10-31T05:53:18.000Z

src/nodeforge/StartEngine.py

nsk89/nodeforge

51e798092cfaf52112cfdc96af359633741da799

2018-10-31T05:56:34.000Z

2018-10-31T05:57:36.000Z

""" This file should be imported at the bottom of configure.py TODO: All of this may be moved into a single function in the future so people can choose a reactor in configure.py """ from twisted.internet import reactor from twisted.internet.task import LoopingCall from threading import currentThread, Thread # Check to see if main thread is alive mainthread = currentThread() def checkExit(): if not mainthread.isAlive(): reactor.stop() # Every second, make sure that the interface thread is alive. LoopingCall(checkExit).start(1) # start the network loop in a new thread Thread(target=lambda : reactor.run(installSignalHandlers=0)).start()

39ef5804d073f8e1a8698f5b8f98bbb0a09926ef

py

Python

src/asit.py

6H057WH1P3/Asit

4dce80e3c4c05c4f56563110c59bae55e61aeaae

src/asit.py

6H057WH1P3/Asit

4dce80e3c4c05c4f56563110c59bae55e61aeaae

2015-09-16T17:54:13.000Z

2015-09-18T06:54:33.000Z

src/asit.py

6H057WH1P3/Asit

4dce80e3c4c05c4f56563110c59bae55e61aeaae

import random import time import requests class Account: # C'tor def __init__(self, language, world, user, password, ability): # def standard class variables self.cookie = "" self.language = language self.world = world self.user = user self.password = password self.ability = ability # preparing header and basic url for get and post requests if language == "de": self.basic_url = "http://welt" + self.world + ".freewar.de/freewar/internal/" self.header = {"Host": "welt" + self.world + ".freewar.de", "Connection": "keep-alive", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64)"} elif language == "en": self.basic_url = "http://world" + self.world + ".freewar.com/freewar/internal/" self.header = {"Host": "world" + self.world + ".freewar.com", "Connection": "keep-alive", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64)"} def login(self): print("\t[*] Logging in") login_url = self.basic_url + "index.php" # really annoying if self.language == "de": login_submit = "Einloggen" elif self.language == "en": login_submit = "Login" # login payload / post parameters login_payload = {"name": self.user, "password": self.password, "submit": login_submit} # login request login_request = requests.post(login_url, data = login_payload, headers = self.header) # nesseccary for session management in other requests self.cookie = login_request.cookies print("\t[+] Login successful") return 0 # nesseccary to access all other links in fw main window after login def redirect(self): print("\t[*] Redirecting") redirect_url = self.basic_url + "frset.php" requests.get(redirect_url, headers = self.header, cookies = self.cookie) print("\t[+] Redirect successful") return 0 # function to train characters abilities def train(self): # the training sequence print("\t[*] Training") train_url = self.basic_url + "ability.php" train_payload = {"action": "train", "ability_id": self.ability} requests.get(train_url, params = train_payload, headers = self.header, cookies = self.cookie) print("\t[+] Training successful") # preparing for the training status request status_payload = {"action": "show_ability", "ability_id": self.ability} # requesting content of main frame status_request = requests.get(train_url, params = status_payload, headers = self.header, cookies = self.cookie) if self.language == "de": search_parameters = ["Aktuelle Stufe: ", "Maximale Stufe: "] # TODO: online den genauen text nachschlagen elif self.language == "en": search_parameters = ["actual level: ", "maximal level: "] output = "\t[*] Actual level: " first = True # looking for search parameters in http response for search_text in search_parameters: # exception handling try: position = status_request.text.find(search_text) if (position == -1): raise RuntimeError("Bad Request") except RuntimeError: print("\t[-] Could not found ability level.") return 1 # TODO: Hier gehts weiter text_length = len(search_text) ability_level = status_request.text[position + text_length : position + text_length + 3] # geting a clean output ability_level = ability_level.strip("<") ability_level = ability_level.strip("/") ability_level = ability_level.strip("b") output += ability_level if first: first = False output += " / " print(output) return 0 # function to pick up accounts oil if he's on the right field for that def oil(self): print("\t[*] Picking up oil") # requesting content of main frame main_url = self.basic_url + "main.php" main_request = requests.get(main_url, headers = self.header, cookies = self.cookie) # something called exception handling try: position = main_request.text.find("checkid=") if (position == -1): raise RuntimeError("wrong position") except RuntimeError: print("\t[-] Oil isn't ready yet or account is on the wrong position.") return 1 # pincking up the oil oil_url = self.basic_url + "main.php" oil_payload = {"arrive_eval": "drink", "checkid": main_request.text[position + 8 : position + 15]} requests.get(oil_url, params = oil_payload, headers = self.header, cookies = self.cookie) return 0 # for a clean session def logout(self): print("\t[*] Logging out") logout_url = self.basic_url + "logout.php" requests.get(logout_url, headers = self.header, cookies = self.cookie) print("\t[+] Logged out") return 0 def automatic_sit(self): try: self.login() self.redirect() self.train() self.oil() self.logout() except: print("[!] Connection Error.") return 1 class ManageAccounts: def __init__(self, account_path): self.accounts = [] self.later = [] # filling the list of credentials with open(account_path, "r") as account_file: for line in account_file: splitted_line = line.strip("\n").split(", ") #print(splitted_line) if len(splitted_line) == 5: self.accounts.append(splitted_line) def manage(self): while len(self.accounts) > 0: for language, world, user, password, ability in self.accounts: # skipping credentials of the same world skip = False for account in self.accounts: if (account[1] == world) and (account[2] != user): self.later.append(account) self.accounts.remove(account) skip = True if skip: continue # if not skipped, handling the credential print("\n[*] World: " + world + " Account: " + user + " Server: " + language) FWAccount = Account(language, world, user, password, ability) if FWAccount.automatic_sit(): return 1 # writing memorized credentials back to be handled if len(self.later) > 0: random_time = random.randint(180, 300) print("[*] Wating " + str(random_time) + " Seconds to log other accounts savely.") time.sleep(random_time) self.accounts = self.later self.later.clear() else: self.accounts.clear()

39f17c6cf9e734ea907636289c61a9999dc0de12

py

Python

src/core/views.py

Ao99/django-boilerplate

7fa8078b67655698a4070ce58c10d2226fe1d59b

src/core/views.py

Ao99/django-boilerplate

7fa8078b67655698a4070ce58c10d2226fe1d59b

src/core/views.py

Ao99/django-boilerplate

7fa8078b67655698a4070ce58c10d2226fe1d59b

from django.shortcuts import render from django.views import View # Create your views here. class CoreView(View): template_name = 'core/home.html' def get(self, request, *args, **kwargs): return render(request, self.template_name, {})

39f26329f53e08a2340c221abdf702988c619417

py

Python

hashvis.py

boredzo/hashvis

74a017c7fa9b6d48e43172ffd15fc19ccfb060e1

2015-12-02T14:26:52.000Z

2018-01-21T15:18:59.000Z

hashvis.py

boredzo/hashvis

74a017c7fa9b6d48e43172ffd15fc19ccfb060e1

2015-12-04T06:00:42.000Z

2016-07-09T21:40:53.000Z

hashvis.py

boredzo/hashvis

74a017c7fa9b6d48e43172ffd15fc19ccfb060e1

#!/usr/bin/python # -*- coding: utf-8 -*- """hashvis by Peter Hosey Reads from standard input or files, and prints what it reads, along with colorized versions of any hashes or signatures found in each line. The goal here is visual comparability. You should be able to tell whether two hashes are the same at a glance, rather than having to closely compare digits (or, more probably, not bother and just assume the hashes match!). The more obvious of the two methods used is shaping the output: Each hash will be represented as a rectangle of an aspect ratio determined by the hash. You may thus end up with one that's tall and one that's wide, or one that's square (if the hash length is a square number) and one that isn't. If two hashes are the same shape (or if you passed --oneline), another difference is that each byte is represented by a different pair of foreground and background colors. You should thus be able to compare the color-patterns rather than having to look at individual digits. """ # #mark - Imports and utilities import sys import os import re import base64 import binascii import cmath as math range = xrange def factors(n): "Yield every pair of factors of n (x,y where n/x == y and n/y == x), except for (1,n) and (n,1)." limit = math.sqrt(n).real if n == 1: yield (1, 1) return for i in range(1, int(limit + 1)): if n % i == 0: pair = (i, n/i) yield pair opposite_pair = (pair[1], pair[0]) #If n is square, one of the pairs will be (sqrt, sqrt). We want to yield that only once. All other pairs, we want to yield both ways round. if pair != opposite_pair: yield opposite_pair def except_one(pairs): "Given a sequence of pairs (x, y), yield every pair where neither x nor y is 1." for pair in pairs: if 1 not in pair: yield pair # #mark - Parsing MD5_exp = re.compile(r'^MD5 \(.*\) = ([0-9a-fA-F]+)') fingerprint_exp = re.compile(r'^(?:R|ECD)SA key fingerprint is (?:(?:MD5:)?(?P<hex>[:0-9a-fA-F]+)|SHA256:(?P<base64>[+/0-9a-zA-Z]+))\.') commit_exp = re.compile(r'^commit ([0-9a-fA-F]+)') more_base64_padding_than_anybody_should_ever_need = '=' * 64 def extract_hash_from_line(input_line): "Returns a tuple of the extracted hash as hex, and whether it was originally hex (vs, say, base64). The hash may be None if none was found in the input." if input_line[:1] == 'M': match = MD5_exp.match(input_line) if match: return match.group(1), True else: return '', False elif input_line[:1] in 'RE': match = fingerprint_exp.match(input_line) if match: hex = match.group('hex') if hex: return hex, True b64str = match.group('base64') if b64str: # Pacify the base64 module, which wants *some* padding (at least sometimes) but doesn't care how much. b64str += more_base64_padding_than_anybody_should_ever_need # Re-encode to hex for processing downstream. Arguably a refactoring opportunity… return binascii.b2a_hex(base64.b64decode(b64str)), False return '', False elif input_line[:7] == 'commit ': match = commit_exp.match(input_line) if match: return match.group(1), True if input_line: try: hash, not_the_hash = input_line.split(None, 1) except ValueError: # Insufficient fields. This line doesn't contain any whitespace. Use the entire line. hash = input_line hash = hash.strip().replace('-', '') try: int(hash, 16) except ValueError: # Not a hex number. return None, False else: return hash, True def parse_hex(hex): hex = hex.lstrip(':-') while hex: byte_hex, hex = hex[:2], hex[2:].lstrip(':-') yield int(byte_hex, 16) # #mark - Representation def fgcolor(idx, deep_color=False): if deep_color: return '\x1b[38;5;{0}m'.format(idx) idx = ((idx >> 4) & 0xf) # 90 is bright foreground; 30 is dull foreground. if idx < 0x8: base = 30 else: base = 90 idx = idx - 0x8 return '\x1b[{0}m'.format(base + idx) def bgcolor(idx, deep_color=False): if deep_color: idx = ((idx & 0xf) << 4) | ((idx & 0xf0) >> 4) # This add 128 and mod 256 is important, because it ensures double-digits such as 00 remain different colors. return '\x1b[48;5;{0}m'.format((idx + 128) % 256) else: idx = (idx & 0xf) # 100 is bright background; 40 is dull background. if idx < 0x8: base = 40 else: base = 100 idx = idx - 0x8 return '\x1b[{0}m'.format(base + idx) BOLD = '\x1b[1m' RESET = '\x1b[0m' def hash_to_pic(hash, only_ever_one_line=False, represent_as_hex=False, deep_color=False, _underlying_fgcolor=fgcolor, _underlying_bgcolor=bgcolor): def fgcolor(idx): return _underlying_fgcolor(idx, deep_color) def bgcolor(idx): return _underlying_bgcolor(idx, deep_color) bytes = parse_hex(hash) characters = list('0123456789abcdef') if represent_as_hex else [ '▚', '▞', '▀', '▌', ] if not only_ever_one_line: pairs = list((w, h) for (w, h) in except_one(factors(len(hash) / 2)) if w >= h) if not pairs: # Prefer (w, 1) over (1, h) if we have that choice. pairs = list((w, h) for (w, h) in factors(len(hash) / 2) if w >= h) output_chunks = [] last_byte = 0 character_idx = None for b in bytes: def find_character(b): character_idx = b % len(characters) return characters[character_idx] if not represent_as_hex: output_chunks.append(fgcolor(b) + bgcolor(b) + find_character(b)) else: output_chunks.append(fgcolor(b) + bgcolor(b) + find_character(b >> 4) + find_character(b & 0xf)) last_byte = b if only_ever_one_line: pixels_per_row, num_rows = len(hash) / 2, 1 else: pixels_per_row, num_rows = pairs[last_byte % len(pairs)] while output_chunks: yield BOLD + ''.join(output_chunks[:pixels_per_row]) + RESET del output_chunks[:pixels_per_row] if __name__ == '__main__': # #mark - Self-tests run_tests = False if run_tests: # A square number. Should contain a diagonal pair (in this case, (16,16)). factors_of_256 = set(factors(256)) assert factors_of_256 == set([(256, 1), (16, 16), (8, 32), (2, 128), (64, 4), (1, 256), (32, 8), (128, 2), (4, 64)]) # A rectangular number: not square, but still composite. No diagonal pair here. factors_of_12 = set(factors(12)) assert factors_of_12 == set([(2, 6), (12, 1), (1, 12), (6, 2), (4, 3), (3, 4)]) assert (1, 256) in factors_of_256 assert (256, 1) in factors_of_256 assert (1, 256) not in except_one(factors_of_256) assert (256, 1) not in except_one(factors_of_256) # A prime number. Should have exactly one pair of factors. factors_of_5 = set(factors(5)) assert factors_of_5 == set([(1, 5), (5, 1)]) assert list(parse_hex('ab15e')) == [0xab, 0x15, 0x0e] assert list(parse_hex(':::ab:15:e')) == [0xab, 0x15, 0x0e] assert extract_hash_from_line('RSA key fingerprint is b8:79:03:7d:00:44:98:6e:67:a0:59:1a:01:21:36:38.\n') == ('b8:79:03:7d:00:44:98:6e:67:a0:59:1a:01:21:36:38', True) assert extract_hash_from_line('RSA key fingerprint is b8:79:03:7d:00:44:98:6e:67:a0:59:1a:01:21:36:38.') == ('b8:79:03:7d:00:44:98:6e:67:a0:59:1a:01:21:36:38', True) #Alternate output example from https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Authentication_Keys : assert extract_hash_from_line('RSA key fingerprint is MD5:10:4a:ec:d2:f1:38:f7:ea:0a:a0:0f:17:57:ea:a6:16.') == ('10:4a:ec:d2:f1:38:f7:ea:0a:a0:0f:17:57:ea:a6:16', True) # Also from https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Authentication_Keys : assert extract_hash_from_line('ECDSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.\n') == ('2cf162318aeb098415b1550fce3387bfe663cb10879556093015457ab5423fb9', False), extract_hash_from_line('ECDSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.\n') assert extract_hash_from_line('ECDSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.') == ('2cf162318aeb098415b1550fce3387bfe663cb10879556093015457ab5423fb9', False), extract_hash_from_line('ECDSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.') # Mix and match RSA and ECDSA with MD5 and SHA256: assert extract_hash_from_line('ECDSA key fingerprint is MD5:10:4a:ec:d2:f1:38:f7:ea:0a:a0:0f:17:57:ea:a6:16.') == ('10:4a:ec:d2:f1:38:f7:ea:0a:a0:0f:17:57:ea:a6:16', True) assert extract_hash_from_line('RSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.\n') == ('2cf162318aeb098415b1550fce3387bfe663cb10879556093015457ab5423fb9', False), extract_hash_from_line('RSA key fingerprint is SHA256:LPFiMYrrCYQVsVUPzjOHv+ZjyxCHlVYJMBVFerVCP7k.\n') #UUID assert extract_hash_from_line('E6CD379E-12CD-4E00-A83A-B06E74CF03B8') == ('E6CD379E12CD4E00A83AB06E74CF03B8', True), extract_hash_from_line('E6CD379E-12CD-4E00-A83A-B06E74CF03B8') assert extract_hash_from_line('e6cd379e-12cd-4e00-a83a-b06e74cf03b8') == ('e6cd379e12cd4e00a83ab06e74cf03b8', True), extract_hash_from_line('e6cd379e-12cd-4e00-a83a-b06e74cf03b8') assert extract_hash_from_line('MD5 (hashvis.py) = e21c7b846f76826d52a0ade79ef9cb49\n') == ('e21c7b846f76826d52a0ade79ef9cb49', True) assert extract_hash_from_line('MD5 (hashvis.py) = e21c7b846f76826d52a0ade79ef9cb49') == ('e21c7b846f76826d52a0ade79ef9cb49', True) assert extract_hash_from_line('8b948e9c85fdf68f872017d7064e839c hashvis.py\n') == ('8b948e9c85fdf68f872017d7064e839c', True) assert extract_hash_from_line('8b948e9c85fdf68f872017d7064e839c hashvis.py') == ('8b948e9c85fdf68f872017d7064e839c', True) assert extract_hash_from_line('2c9997ce32cb35823b2772912e221b350717fcb2d782c667b8f808be44ae77ba1a7b94b4111e386c64a2e87d15c64a2fc2177cd826b9a0fba6b348b4352ed924 hashvis.py\n') == ('2c9997ce32cb35823b2772912e221b350717fcb2d782c667b8f808be44ae77ba1a7b94b4111e386c64a2e87d15c64a2fc2177cd826b9a0fba6b348b4352ed924', True) assert extract_hash_from_line('2c9997ce32cb35823b2772912e221b350717fcb2d782c667b8f808be44ae77ba1a7b94b4111e386c64a2e87d15c64a2fc2177cd826b9a0fba6b348b4352ed924 hashvis.py') == ('2c9997ce32cb35823b2772912e221b350717fcb2d782c667b8f808be44ae77ba1a7b94b4111e386c64a2e87d15c64a2fc2177cd826b9a0fba6b348b4352ed924', True) assert extract_hash_from_line('#!/usr/bin/python\n')[0] is None # Protip: Use vis -co to generate these. (line,) = hash_to_pic('78', represent_as_hex=True, deep_color=False) assert line == '\033[1m\033[37m\033[100m78\033[0m', repr(line) (line,) = hash_to_pic('7f', represent_as_hex=True, deep_color=False) assert line == '\033[1m\033[37m\033[107m7f\033[0m', repr(line) assert list(hash_to_pic('aebece', deep_color=False)) != list(hash_to_pic('deeefe', deep_color=False)), (list(hash_to_pic('aebece', deep_color=False)), list(hash_to_pic('deeefe', deep_color=False))) assert list(hash_to_pic('eaebec', deep_color=False)) != list(hash_to_pic('edeeef', deep_color=False)), (list(hash_to_pic('eaebec', deep_color=False)), list(hash_to_pic('edeeef', deep_color=False))) sys.exit(0) # #mark - Main use_256color = os.getenv('TERM') == 'xterm-256color' import argparse parser = argparse.ArgumentParser(description="Visualize hexadecimal input (hashes, UUIDs, etc.) as an arrangement of color blocks.") parser.add_argument('--one-line', '--oneline', action='store_true', help="Unconditionally produce a rectangle 1 character tall. The default is to choose a pair of width and height based upon one of the bytes of the input.") parser.add_argument('--color-test', '--colortest', action='store_true', help="Print the 16-color, 256-color foreground, and 256-color background color palettes, then exit.") options, args = parser.parse_known_args() if options.color_test: for x in range(16): print fgcolor(x, deep_color=False), print bgcolor(x, deep_color=False), else: print for x in range(256): sys.stdout.write(fgcolor(x, deep_color=True) + bgcolor(x, deep_color=True) + '%02x' % (x,)) else: print RESET import sys sys.exit(0) import fileinput for input_line in fileinput.input(args): print input_line.rstrip('\n') hash, is_hex = extract_hash_from_line(input_line) if hash: for output_line in hash_to_pic(hash, only_ever_one_line=options.one_line, represent_as_hex=is_hex, deep_color=use_256color): print output_line

39f2718894e3565b21d9ad13de2638c2e9273b26

py

Python

euler_7_nth_prime.py

igorakkerman/euler-challenge

1fdedce439520fc31a2e5fb66abe23b6f99f04db

euler_7_nth_prime.py

igorakkerman/euler-challenge

1fdedce439520fc31a2e5fb66abe23b6f99f04db

euler_7_nth_prime.py

igorakkerman/euler-challenge

1fdedce439520fc31a2e5fb66abe23b6f99f04db

# https://projecteuler.net/problem=7 import math def sieve(xmax): p = {i for i in range(2, xmax + 1)} for i in range(2, xmax): r = {j * i for j in range(2, int(xmax / i) + 1)} p -= r return sorted(p) print(sum(sieve(2000000)))

39f3a173967eb82662e3417309654bea4d1eda7a

py

Python

docker/ubuntu/16-04/ub_limonero/migrations/versions/32053847c4db_add_new_types.py

eubr-atmosphere/jenkins

a9065584d810238c6fa101d92d12c131d1d317cb

docker/ubuntu/16-04/ub_limonero/migrations/versions/32053847c4db_add_new_types.py

eubr-atmosphere/jenkins

a9065584d810238c6fa101d92d12c131d1d317cb

docker/ubuntu/16-04/ub_limonero/migrations/versions/32053847c4db_add_new_types.py

eubr-atmosphere/jenkins

a9065584d810238c6fa101d92d12c131d1d317cb

"""Add new types Revision ID: 32053847c4db Revises: 05a62958a9cc Create Date: 2019-06-11 10:36:14.456629 """ from alembic import context from sqlalchemy.orm import sessionmaker # revision identifiers, used by Alembic. revision = '32053847c4db' down_revision = '05a62958a9cc' branch_labels = None depends_on = None all_commands = [ (""" ALTER TABLE data_source CHANGE `format` `format` ENUM( 'CSV','CUSTOM','GEO_JSON','HAR_IMAGE_FOLDER','HDF5','DATA_FOLDER', 'IMAGE_FOLDER', 'JDBC','JSON','NETCDF4','PARQUET','PICKLE','SHAPEFILE', 'TAR_IMAGE_FOLDER','TEXT', 'VIDEO_FOLDER', 'UNKNOWN','XML_FILE') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL;""", """ ALTER TABLE data_source CHANGE `format` `format` ENUM( 'CSV','CUSTOM','GEO_JSON','HDF5','JDBC','JSON', 'NETCDF4','PARQUET','PICKLE','SHAPEFILE','TEXT', 'UNKNOWN','XML_FILE') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL;""" ), (""" ALTER TABLE `storage` CHANGE `type` `type` ENUM( 'HDFS','OPHIDIA','ELASTIC_SEARCH','MONGODB','POSTGIS','HBASE', 'CASSANDRA','JDBC','LOCAL') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL;""", """ ALTER TABLE `storage` CHANGE `type` `type` ENUM( 'HDFS','OPHIDIA','ELASTIC_SEARCH','MONGODB','POSTGIS','HBASE', 'CASSANDRA','JDBC') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL;""", ), ( """ALTER TABLE `model` CHANGE `type` `type` ENUM( 'KERAS','SPARK_ML_REGRESSION','SPARK_MLLIB_CLASSIFICATION', 'SPARK_ML_CLASSIFICATION','UNSPECIFIED') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL; """, """ALTER TABLE `model` CHANGE `type` `type` ENUM( 'KERAS','SPARK_ML_REGRESSION','SPARK_MLLIB_CLASSIFICATION', 'SPARK_ML_CLASSIFICATION','UNSPECIFIED') CHARSET utf8 COLLATE utf8_unicode_ci NOT NULL; """ ) ] def upgrade(): ctx = context.get_context() session = sessionmaker(bind=ctx.bind)() connection = session.connection() try: for cmd in all_commands: if isinstance(cmd[0], (unicode, str)): connection.execute(cmd[0]) elif isinstance(cmd[0], list): for row in cmd[0]: connection.execute(row) else: cmd[0]() except: session.rollback() raise session.commit() def downgrade(): ctx = context.get_context() session = sessionmaker(bind=ctx.bind)() connection = session.connection() connection.execute('SET foreign_key_checks = 0;') try: for cmd in reversed(all_commands): if isinstance(cmd[1], (unicode, str)): connection.execute(cmd[1]) elif isinstance(cmd[1], list): for row in cmd[1]: connection.execute(row) else: cmd[1]() except: session.rollback() raise connection.execute('SET foreign_key_checks = 1;') session.commit()

39f4f90e9b80ade83346acbec06fcedbaeda8cb3

py

Python

advanced_tools/__init__.py

kvdogan/advanced_tools

7e93232374980d83fda8051496a190188c11fe0d

advanced_tools/__init__.py

kvdogan/advanced_tools

7e93232374980d83fda8051496a190188c11fe0d

advanced_tools/__init__.py

kvdogan/advanced_tools

7e93232374980d83fda8051496a190188c11fe0d

from advanced_tools.IO_path_utils import * from advanced_tools.algorithm_utils import *

39f5a45cf3414a12f90b8d040d893593304736d0

py

Python

sets-master/sets-master/sets/utility.py

FedericoMolinaChavez/tesis-research

d77cc621d452c9ecf48d9ac80349b41aeb842412

sets-master/sets-master/sets/utility.py

FedericoMolinaChavez/tesis-research

d77cc621d452c9ecf48d9ac80349b41aeb842412

2021-03-09T20:33:57.000Z

2022-02-18T12:56:32.000Z

sets-master/sets-master/sets/utility.py

FedericoMolinaChavez/tesis-research

d77cc621d452c9ecf48d9ac80349b41aeb842412

import os import pickle import functools import errno import shutil from urllib.request import urlopen #import definitions def read_config(schema='data/schema.yaml', name='sets'): filename = '.{}rc'.format(name) paths = [ os.path.join(os.curdir, filename), os.path.expanduser(os.path.join('~', filename)), os.environ.get('{}_CONFIG'.format(name.upper())), ] schema = os.path.join(os.path.dirname(__file__), schema) parser = definitions.Parser(schema) for path in paths: if path and os.path.isfile(path): return parser(path) return parser('{}') def disk_cache(basename, directory, method=False): """ Function decorator for caching pickleable return values on disk. Uses a hash computed from the function arguments for invalidation. If 'method', skip the first argument, usually being self or cls. The cache filepath is 'directory/basename-hash.pickle'. """ directory = os.path.expanduser(directory) ensure_directory(directory) def wrapper(func): @functools.wraps(func) def wrapped(*args, **kwargs): key = (tuple(args), tuple(kwargs.items())) # Don't use self or cls for the invalidation hash. if method and key: key = key[1:] filename = '{}-{}.pickle'.format(basename, hash(key)) filepath = os.path.join(directory, filename) if os.path.isfile(filepath): with open(filepath, 'rb') as handle: return pickle.load(handle) result = func(*args, **kwargs) with open(filepath, 'wb') as handle: pickle.dump(result, handle) return result return wrapped return wrapper def download(url, directory, filename=None): """ Download a file and return its filename on the local file system. If the file is already there, it will not be downloaded again. The filename is derived from the url if not provided. Return the filepath. """ if not filename: _, filename = os.path.split(url) directory = os.path.expanduser(directory) ensure_directory(directory) filepath = os.path.join(directory, filename) if os.path.isfile(filepath): return filepath print('Download', filepath) with urlopen(url) as response, open(filepath, 'wb') as file_: shutil.copyfileobj(response, file_) return filepath def ensure_directory(directory): """ Create the directories along the provided directory path that do not exist. """ directory = os.path.expanduser(directory) try: os.makedirs(directory) except OSError as e: if e.errno != errno.EEXIST: raise e

f2cdba45917fad7ff9ab33f608fa9dbb603aec4b

py

Python

src/test_fps.py

pjenpoomjai/tfpose-herokuNEW

7d1085a3fcb02c0f6d16ed7f2cf1ad8daff103ea

src/test_fps.py

pjenpoomjai/tfpose-herokuNEW

7d1085a3fcb02c0f6d16ed7f2cf1ad8daff103ea

src/test_fps.py

pjenpoomjai/tfpose-herokuNEW

7d1085a3fcb02c0f6d16ed7f2cf1ad8daff103ea

import cv2 import time import numpy as np import imutils camera= 0 cam = cv2.VideoCapture(camera) fgbg = cv2.createBackgroundSubtractorMOG2(history=1000,varThreshold=0,detectShadows=False) width=600 height=480 fps_time = 0 while True: ret_val,image = cam.read() image = cv2.resize(image,(width,height)) image = cv2.GaussianBlur(image, (5, 5), 0) fgmask = fgbg.apply(image) # image = fgbg.apply(image,learningRate=0.001) # image = imutils.resize(image, width=500) # gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cnts = cv2.findContours(fgmask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] # loop over the contours x_left = -1 y_left = -1 x_right = -1 y_right = -1 for c in cnts: # if the contour is too small, ignore it # if cv2.contourArea(c) > 500: # continue # compute the bounding box for the contour, draw it on the frame, # and update the text (x, y, w, h) = cv2.boundingRect(c) if x_left ==-1 : x_left = x y_left = y if x < x_left: x_left = x if y < y_left: y_left = y if x+w > x_right: x_right = x+w if y+h > y_right: y_right = y+h # cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2) if (x_left==0 and y_left==0 and x_right==width and y_right==height)==False: cv2.rectangle(image, (x_left, y_left), (x_right, y_right), (0, 255, 0), 2) # cv2.putText(image, # "FPS: %f [press 'q'to quit]" % (1.0 / (time.time() - fps_time)), # (10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, # (0, 255, 0), 2) cv2.imshow('tf-pose-estimation result',fgmask) cv2.imshow('tf-pose-estimation result2',image) fps_time = time.time() if cv2.waitKey(1)==ord('q'): cam.release() cv2.destroyAllWindows() break

f2ce254695f631034aa335be9147cb99e06d1cfc

py

Python

Python/367.ValidPerfectSquare.py

nizD/LeetCode-Solutions

7f4ca37bab795e0d6f9bfd9148a8fe3b62aa5349

2020-10-05T18:47:29.000Z

2022-03-31T19:44:46.000Z

Python/367.ValidPerfectSquare.py

nizD/LeetCode-Solutions

7f4ca37bab795e0d6f9bfd9148a8fe3b62aa5349

2020-10-05T18:13:05.000Z

2022-03-31T23:16:35.000Z

Python/367.ValidPerfectSquare.py

nizD/LeetCode-Solutions

7f4ca37bab795e0d6f9bfd9148a8fe3b62aa5349

2020-10-05T18:22:51.000Z

2022-03-29T06:06:20.000Z

#Given a positive integer num, write a function which returns True if num is a perfect square else False. class Solution(object): def isPerfectSquare(self, num): low=0 high=num #Starting from zero till the number we need to check for perfect square while(low<=high): #Calulating middle value by using right shift operator mid=(low+high)>>1 #If the square of the middle value is equal to the number then it is a perfect square else not if(mid*mid==num): return True #If the square of the middle value is less than the number we increment the low variable else the high variable is decremented. #The loop will continue till the low value becomes more than the high value or the number is a perfect square then True will be #returned elif(mid*mid<num): low=mid+1 else: high=mid-1 return False

f2d302744caca38acace037f6391b1ffee2c8630

py

Python

src/minescrubber/controller.py

alok1974/minescrubber

0c18d960b385a4a59ac0cf38bc69271a23c667e7

2020-08-11T23:08:34.000Z

2020-08-11T23:08:34.000Z

src/minescrubber/controller.py

alok1974/minescrubber

0c18d960b385a4a59ac0cf38bc69271a23c667e7

src/minescrubber/controller.py

alok1974/minescrubber

0c18d960b385a4a59ac0cf38bc69271a23c667e7

from minescrubber_core import abstract from . import mainwindow class UI(abstract.UI): def __init__(self): self.main_window = mainwindow.MainWidget() def init_board(self, board): self.main_window.init_board(board) def refresh(self, board, init_image=True): self.main_window.refresh(board=board, init_image=init_image) def game_over(self, board): self.main_window.game_over(board=board) def game_solved(self, board): self.main_window.game_solved(board=board) def run(self): self.main_window.show() @property def new_game_signal(self): return self.main_window.NEW_GAME_SIGNAL @property def cell_selected_signal(self): return self.main_window.CELL_SELECTED_SIGNAL @property def cell_flagged_signal(self): return self.main_window.CELL_FLAGGED_SIGNAL @property def wiring_method_name(self): return 'connect' class Controller(abstract.Controller): def pre_callback(self): import sys from PySide2 import QtWidgets QtWidgets.QApplication(sys.argv) def post_callback(self): import sys from PySide2 import QtWidgets app = ( QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv) ) sys.exit(app.exec_()) def run(): controller = Controller() controller.run(ui_class=UI)

f2d339d173f754cc9a0dd3025640fbb292c58b5b

py

Python

CADRE/power_dymos/__init__.py

johnjasa/CADRE

a4ffd61582b8474953fc309aa540838a14f29dcf

CADRE/power_dymos/__init__.py

johnjasa/CADRE

a4ffd61582b8474953fc309aa540838a14f29dcf

CADRE/power_dymos/__init__.py

johnjasa/CADRE

a4ffd61582b8474953fc309aa540838a14f29dcf

from .power_group import PowerGroup

f2d47c8b76e7230c4405127adcd43ba0cfb587fd

py

Python

client/elementtype.py

Schille/weimar-graphstore

76b47f98fba419ec6290628b56a202c60d8f2d46

2016-08-27T04:51:01.000Z

2020-09-05T01:34:41.000Z

client/elementtype.py

Schille/weimar-graphstore

76b47f98fba419ec6290628b56a202c60d8f2d46

client/elementtype.py

Schille/weimar-graphstore

76b47f98fba419ec6290628b56a202c60d8f2d46

""" .. module:: elementtype.py :platform: Linux .. moduleauthor:: Michael Schilonka <michael@schilonka.de> """ import logging class ElementType(object): ''' The ElementType class is an in-memory representation of a graph element type. It provides some functions to operate on all entities of the same type and keeps the description of the structured attributes. ''' def __init__(self, type_svr, type_name, graph_name): self._type_svr = type_svr self._typename = type_name self._graphname = graph_name def get_type_definition(self): ''' Returns a dictionary comprising the structured attributes of this graph element type. Return: The created type declaration (dict). ''' return self._type_svr.get_type_definition(self._graphname, self._typename) def get_type_name(self): ''' Returns the type name of this object. Return: The type name (str). ''' return self._typename def count(self): ''' Returns the number of graph elements associated with this type. Return: Count of related graph elements (int). ''' return self._type_svr.count(self._graphname, self._typename) #TDOD provide search method on these elements class VertexType(ElementType, object): ''' The VertexType. ''' def __init__(self, type_svr, vertex_type, graph_name): vertex_type = 'vertex:' + vertex_type super(VertexType, self).__init__(type_svr, vertex_type, graph_name) def get_vertices(self): pass def remove(self): ''' Removes this element type and all associated elements. ''' self._type_svr.remove(self._graphname, self._typename) class EdgeType(ElementType, object): ''' The EdgeType. ''' def __init__(self, type_svr, edge_type, graph_name): edge_type = 'edge:' + edge_type super(EdgeType, self).__init__(type_svr, edge_type, graph_name) def get_edges(self): pass def remove(self): ''' Removes this element type and all associated elements. ''' self._type_svr.remove(self._graphname, self._typename)

f2d4d9817772d3d480a3be486cdd4fa4ac3b04f2

py

Python

src/OTLMOW/OTLModel/Classes/Infiltratievoorziening.py

davidvlaminck/OTLClassPython

71330afeb37c3ea6d9981f521ff8f4a3f8b946fc

2022-02-01T08:58:11.000Z

2022-02-08T13:35:17.000Z

src/OTLMOW/OTLModel/Classes/Infiltratievoorziening.py

davidvlaminck/OTLMOW

71330afeb37c3ea6d9981f521ff8f4a3f8b946fc

src/OTLMOW/OTLModel/Classes/Infiltratievoorziening.py

davidvlaminck/OTLMOW

71330afeb37c3ea6d9981f521ff8f4a3f8b946fc

# coding=utf-8 from OTLMOW.OTLModel.Classes.Put import Put from OTLMOW.OTLModel.Classes.PutRelatie import PutRelatie from OTLMOW.GeometrieArtefact.VlakGeometrie import VlakGeometrie # Generated with OTLClassCreator. To modify: extend, do not edit class Infiltratievoorziening(Put, PutRelatie, VlakGeometrie): """Voorziening voor infiltratie van onvervuild water.""" typeURI = 'https://wegenenverkeer.data.vlaanderen.be/ns/onderdeel#Infiltratievoorziening' """De URI van het object volgens https://www.w3.org/2001/XMLSchema#anyURI.""" def __init__(self): Put.__init__(self) PutRelatie.__init__(self) VlakGeometrie.__init__(self)

f2d563db44644c1403a6f057432f77eaa66bdff6

py

Python

Chapter04/chapter4.py

Kushalshingote/Hands-On-Generative-Adversarial-Networks-with-Keras

fccada4810ba1fe8b79c5a74420a590c95623b52

2019-05-27T23:38:53.000Z

2021-12-19T00:31:13.000Z

Chapter04/chapter4.py

Kushalshingote/Hands-On-Generative-Adversarial-Networks-with-Keras

fccada4810ba1fe8b79c5a74420a590c95623b52

2019-05-29T21:01:32.000Z

2020-07-30T12:00:02.000Z

Chapter04/chapter4.py

Kushalshingote/Hands-On-Generative-Adversarial-Networks-with-Keras

fccada4810ba1fe8b79c5a74420a590c95623b52

2019-05-12T04:20:54.000Z

2022-03-03T19:46:06.000Z

# get the training data D, sample the Generator with random z to produce r N = X_train z = np.random.uniform(-1, 1, (1, z_dim)) r = G.predict_on_batch(z) # define our distance measure S to be L1 S = lambda n, r: np.sum(np.abs(n - r)) # compute the distances between the reference and the samples in N using the measure D distances = [D(n, r) for n in N] # find the indices of the most similar samples and select them from N nearest_neighbors_index = np.argpartition(distances, k) nearest_neighbors_images = N[nearest_neighbors_index] # generate fake images from the discriminator n_fake_images = 5000 z = np.random.uniform(-1, 1, (n_fake_images, z_dim)) x = G.predict_on_batch(z) def compute_inception_score(x, inception_model, n_fake_images, z_dim): # probability of y given x p_y_given_x = inception_model.predict_on_batch(x) # marginal probability of y q_y = np.mean(p_y_given_x, axis=0) inception_scores = p_y_given_x * (np.log(p_y_given_x) - np.log(q_y) inception_score = np.exp(np.mean(inception_scores)) return inception_score def get_mean_and_covariance(data): mean = np.mean(data, axis=0) covariance = np.cov(data, rowvar=False) # rowvar? return mean, covariance def compute_frechet_inception_distance(mean_r, mean_f, cov_r, cov_f): l2_mean = np.sum((mean_r - mean_f)**2) cov_mean, _ = np.trace(scipy.linalg.sqrtm(np.dot(cov_r, cov_f))) return l2_mu + np.trace(cov_r) + np.trace(cov_f) - 2 * np.trace(cov_mean)

f2d5d419d88204df9613b1050b9f75f4f36ef80c

py

Python

naspi/naspi.py

fgiroult321/simple-nas-pi

6d1a13523f1f20ebe26f780c758a3ff15be899ff

naspi/naspi.py

fgiroult321/simple-nas-pi

6d1a13523f1f20ebe26f780c758a3ff15be899ff

naspi/naspi.py

fgiroult321/simple-nas-pi

6d1a13523f1f20ebe26f780c758a3ff15be899ff

import os import boto3 # import subprocess from subprocess import Popen, PIPE from time import sleep import json import ast from datetime import datetime, time, timedelta, date import logging import logging.handlers import sys, getopt import glob import shutil logger = logging.getLogger() logger.setLevel(logging.INFO) def main(): ### Order of tasks # # 0 check disks are here, catch output # # 1 sync to replica disk, catch output # # 2 sync to aws, catch output # # 3 compare disks files vs replica, catch oputput # # 4 compare disks files vs s3, catch out # # # Run option # -l, --system : only analyze_disks & get_server_metrics , every 5m # -a, --analyze : analyze_s3_files & analyze_local_files, every 1 or 3 hours # -s, --sync : run_s3_syncs & run_local_syncs, every night # -d, --syncdelete : run_s3_syncs & run_local_syncs with delete no cron #### exception handling in logger: sys.excepthook = handle_exception valid_modes = ["system","analyze","sync","syncdelete","synclocal","syncs3","backup","osbackup","init_config"] mode = '' config = '' usage_message = 'naspi -c /path/to/config.json -m <system|analyze|sync|syncdelete|synclocal|syncs3|backup|osbackup|init_config>' try: opts, args = getopt.getopt(sys.argv[1:],"hm:c:",["mode=","config="]) # except getopt.GetoptError: except Exception as e: print(usage_message) sys.exit(2) for opt, arg in opts: if opt == '-h': print(usage_message) sys.exit() elif opt in ("-m", "--mode"): mode = arg elif opt in ("-c", "--config"): config = arg # # # checking values passed if not mode: print("Error, mode is mandatory !!") print(usage_message) sys.exit(2) elif not config: print("Error, config file is mandatory !!") print(usage_message) sys.exit(2) elif mode not in valid_modes: print("Wrong mode selected, correct modes are : {}".format(valid_modes)) print(usage_message) sys.exit(2) # logger.info("Context info : ") # logger.info(os.getcwd()) # logger.info(__file__) if mode == "init_config": output = init_config_file(config) sys.exit(0) else: #### Configuration loading disks_list,folder_to_sync_locally,folders_to_sync_s3,configuration = load_configuration(config) global NUMBER_DAYS_RETENTION global MIN_DELAY_BETWEEN_SYNCS_SECONDS global working_dir NUMBER_DAYS_RETENTION = configuration.get('NUMBER_DAYS_RETENTION') MIN_DELAY_BETWEEN_SYNCS_SECONDS = configuration.get('MIN_DELAY_BETWEEN_SYNCS_SECONDS') working_dir = configuration.get('working_dir') home_dir = os.environ['HOME'] global export_path_cmd export_path_cmd = 'export PATH={}/.local/bin:$PATH'.format(home_dir) ### Logging setup # Change root logger level from WARNING (default) to NOTSET in order for all messages to be delegated. logging.getLogger('').setLevel(logging.NOTSET) # Add file rotatin handler, with level DEBUG rotatingHandler = logging.handlers.RotatingFileHandler(filename='{}/nas_monitor.log'.format(working_dir), maxBytes=1000000, backupCount=5) rotatingHandler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') rotatingHandler.setFormatter(formatter) logging.getLogger('').addHandler(rotatingHandler) global logger logger = logging.getLogger("naspi." + __name__) logger.info("") logger.info("") logger.info("----------------------------------------------------------------------------------------") logger.info("----------------------------------------------------------------------------------------") logger.info("### Starting Nas Monitor") logger.info('Mode is {} and config file is {}'.format(mode,config)) output = open_or_init_output_file(working_dir) if mode == "backup": output = backup_naspi(configuration['backup'],output) if mode == "osbackup": output = os_backup(configuration['backup'],output) if mode == "system": output = analyze_disks(disks_list,output) output = get_server_metrics(output) if mode == "synclocal": output = analyze_local_files(folder_to_sync_locally, output) output = run_local_syncs(folder_to_sync_locally,configuration,output) output = analyze_local_files(folder_to_sync_locally, output) # File stored to s3 once per hour like local sync (TODO can be improved with a dedicated mode and cron) res_s3 = write_and_cleanup_output_file_to_s3(output,'archive-fgi') if mode == "syncs3": output = analyze_s3_files(folders_to_sync_s3, output) output = run_s3_syncs(folders_to_sync_s3,configuration,output) output = analyze_s3_files(folders_to_sync_s3, output) if mode == "sync": output = run_s3_syncs(folders_to_sync_s3,configuration,output) output = run_local_syncs(folder_to_sync_locally,configuration,output) if mode == "analyze" or mode == "sync": output = analyze_s3_files(folders_to_sync_s3, output) output = analyze_local_files(folder_to_sync_locally, output) result = write_and_cleanup_output_file(output,configuration) # res_s3 = write_and_cleanup_output_file_to_s3(output,'archive-fgi') logger.info(json.dumps(output)) #### #### function defs #### def handle_exception(exc_type, exc_value, exc_traceback): if issubclass(exc_type, KeyboardInterrupt): sys.__excepthook__(exc_type, exc_value, exc_traceback) return logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)) def load_configuration(conf_file): try: f = open(conf_file, "r") dict_conf = json.loads(f.read()) f.close() return( dict_conf['disks_list'], dict_conf['folder_to_sync_locally'], dict_conf['folders_to_sync_s3'], dict_conf['naspi_configuration'] ) except FileNotFoundError as e: print("Conf file not found, provide a file named {}".format(conf_file)) raise(e) # sys.exit(2) def today_time(): today = datetime.today() d1 = today.strftime("%Y-%m-%d %H:%M:%S") return(d1) def today_date(): today = datetime.today() d1 = today.strftime("%Y-%m-%d") return(d1) def date_diff_in_seconds(dt2, dt1): timediff = dt2 - dt1 return timediff.days * 24 * 3600 + timediff.seconds def run_shell_command(command): message = "" logger.info("### Running {}".format(command)) df_out = Popen(command, shell=True, stdout=PIPE, stderr=PIPE ) sleep(.2) retcode = df_out.poll() while retcode is None: # Process running # logger.info("### Process not finished, waiting...") sleep(10) retcode = df_out.poll() # Here, `proc` has finished with return code `retcode` if retcode != 0: """Error handling.""" logger.info("### Error !") message = df_out.stderr.read().decode("utf-8") logger.info(retcode) logger.info(message) return(retcode,message) message = df_out.stdout.read().decode("utf-8") logger.info(retcode) logger.info(message) return(retcode,message) def open_or_init_output_file(working_dir): today = today_date() try: f = open("{}/naspi_status_{}.json".format(working_dir,today), "r") dict_output = json.loads(f.read()) f.close() except FileNotFoundError: logger.info("File for today does not exist, initializing it") dict_output = {} dict_output['disks'] = {} dict_output['disks']['disk-list'] = [] dict_output['local_sync'] = {} dict_output['local_sync']['success'] = True dict_output['s3_sync'] = {} dict_output['s3_sync']['success'] = True dict_output['server'] = {} return(dict_output) def init_config_file(file_name): print("initializing config file {}".format(file_name)) if os.path.exists(file_name): print("Error, config file {} already exists !!".format(file_name)) sys.exit(2) else: dict_conf = {} dict_conf['disks_list'] = [] dict_conf['folder_to_sync_locally'] = [] dict_conf['folders_to_sync_s3'] = [] dict_conf['naspi_configuration'] = {} dict_conf['naspi_configuration']['working_dir'] = "" dict_conf['naspi_configuration']['NUMBER_DAYS_RETENTION'] = 7 dict_conf['naspi_configuration']['MIN_DELAY_BETWEEN_SYNCS_SECONDS'] = 14400 dict_conf['naspi_configuration']['backup'] = {} dict_conf['naspi_configuration']['backup']['files_to_backup'] = [] dict_conf['naspi_configuration']['backup']['backup_location'] = "" dict_conf['naspi_configuration']['backup']['os_backup_location'] = "" f = open("{}".format(file_name), "w") f.write(json.dumps(dict_conf,indent=4)) f.close() return("ok") def write_and_cleanup_output_file_to_s3(output,bucket): s3_client = boto3.client('s3',region_name='eu-west-1') today = today_date() response = s3_client.put_object( Body=json.dumps(output), Bucket=bucket, Key="status/naspi_status_{}.json".format(today) ) return(response) def write_and_cleanup_output_file(output,configuration): NUMBER_DAYS_RETENTION = configuration.get('NUMBER_DAYS_RETENTION') working_dir = configuration.get('working_dir') today = today_date() f = open("{}/naspi_status_{}.json".format(working_dir,today), "w") f.write(json.dumps(output,indent=4)) f.close() existing_output_files = glob.glob('{}/naspi_status_*.json'.format(working_dir)) existing_output_files.sort() for out_file in existing_output_files: if out_file not in existing_output_files[-NUMBER_DAYS_RETENTION:]: logger.info("Deleting {}".format(out_file)) os.remove(out_file) return("done") def analyze_disks(disks_list,output): output['disks']['all_disks_ok'] = True output['disks']['disk-list'] = [] retcode,message = run_shell_command('df -kh | tail -n +2') #logger.info(message) all_disks_present = True for disk in disks_list: disk_output = {} if disk in message: logger.info("### disk {} is here".format(disk)) usage = message.split(disk)[0][-4:] logger.info("### usage : {}".format(usage)) disk_output['name'] = disk disk_output['occupied_%'] = usage disk_output['present'] = True output['disks']['disk-list'].append(disk_output) else: logger.info("### disk {} not here".format(disk)) all_disks_present = False disk_output['name'] = disk disk_output['occupied_%'] = "NA" disk_output['present'] = False output['disks']['disk-list'].append(disk_output) if not all_disks_present: logger.info("### some disks are missing") output['disks']['all_disks_ok'] = False output['disks']['last_run'] = today_time() return(output) def acquire_sync_lock(output,local_or_s3,configuration): # Make sure only one sync process runs at a time can_run = True MIN_DELAY_BETWEEN_SYNCS_SECONDS = configuration.get('MIN_DELAY_BETWEEN_SYNCS_SECONDS') if 'last_started' in output[local_or_s3]: started_time = datetime.strptime(output[local_or_s3]['last_started'], '%Y-%m-%d %H:%M:%S') else: started_time = datetime.strptime('2020-12-25 12:00:00', '%Y-%m-%d %H:%M:%S') now_time = datetime.now() logger.info(" %d seconds from previous run" %(date_diff_in_seconds(now_time, started_time))) if 'locked' in output[local_or_s3] and output[local_or_s3]['locked'] == True and date_diff_in_seconds(now_time, started_time) < MIN_DELAY_BETWEEN_SYNCS_SECONDS: logger.info("Can't run sync as another process might be running") can_run = False else: logger.info("Acquiring lock for {}".format(local_or_s3)) output[local_or_s3]['locked'] = True output[local_or_s3]['last_started'] = today_time() logger.info(output) # Acquire lock and write it to disk: result = write_and_cleanup_output_file(output,configuration) return(can_run,output) def run_s3_syncs(folders_to_sync_s3,configuration, output): can_run,output = acquire_sync_lock(output, 's3_sync',configuration) if can_run: success = True for folder in folders_to_sync_s3: exclusions_flags = '' if 'exclude' in folder: for exclusion in folder['exclude']: exclusions_flags = exclusions_flags + ' --exclude "{}/*" '.format(exclusion) # command = 'aws s3 sync {} {} {} --storage-class DEEP_ARCHIVE --dryrun'.format(folder['source_folder'],folder['dest_folder'],exclusions_flags) command = 'aws s3 sync {} {} {} --storage-class DEEP_ARCHIVE --only-show-errors'.format(folder['source_folder'],folder['dest_folder'],exclusions_flags) ret,msg = run_shell_command('{}; {}'.format(export_path_cmd,command)) if ret != 0: success = False output['s3_sync']['success'] = success output['s3_sync']['last_run'] = today_time() output['s3_sync']['locked'] = False else: logger.info("/!\ Cant run the sync, there is a sync process ongoing") return(output) def count_files_in_dir(folder,exclude_list): exclude_directories = set(exclude_list) #directory (only names) want to exclude total_file = 0 for dname, dirs, files in os.walk(folder): #this loop though directies recursively dirs[:] = [d for d in dirs if d not in exclude_directories] # exclude directory if in exclude list total_file += len(files) logger.info("Files in {} : {}".format(folder,total_file)) return(total_file) def analyze_s3_files(folders_to_sync_s3, output): output['s3_sync']['files_source'] = 0 output['s3_sync']['files_dest'] = 0 output['s3_sync']['folders'] = [] for folder in folders_to_sync_s3: one_folder = {} one_folder['source_folder'] = folder['source_folder'] # Get local files count if 'exclude' in folder: exclude_directories = set(folder['exclude']) #directory (only names) want to exclude else: exclude_directories = [] total_file = 0 for dname, dirs, files in os.walk(folder['source_folder']): #this loop though directies recursively dirs[:] = [d for d in dirs if d not in exclude_directories] # exclude directory if in exclude list # print(len(files)) total_file += len(files) logger.info("Files in {} : {}".format(folder['source_folder'],total_file)) one_folder['source_count'] = total_file output['s3_sync']['files_source'] += total_file # Get s3 files count ret,msg = run_shell_command('{}; aws s3 ls {} --recursive --summarize | grep "Total Objects"'.format(export_path_cmd,folder['dest_folder'])) output['s3_sync']['files_dest'] += int(msg.split(': ')[1]) one_folder['dest_folder'] = folder['dest_folder'] one_folder['dest_count'] = int(msg.split(': ')[1]) output['s3_sync']['folders'].append(one_folder) output['s3_sync']['files_delta'] = output['s3_sync']['files_source'] - output['s3_sync']['files_dest'] logger.info("Analyze s3 file output : {}".format(json.dumps(output))) return(output) def run_local_syncs(folder_to_sync_locally,configuration, output): # rsync -anv dir1 dir2 # n = dryrun, v = verbose # will create dir2/dir1 can_run,output = acquire_sync_lock(output, 'local_sync', configuration) if can_run: success = True for folder in folder_to_sync_locally: delete = "" if folder['delete']: delete = "--delete" ret,msg = run_shell_command('mkdir -p {}'.format(folder['dest_folder'])) ret,msg = run_shell_command('rsync -aq {} {} {}'.format(folder['source_folder'],folder['dest_folder'],delete)) if ret != 0: success = False output['local_sync']['success'] = success output['local_sync']['last_run'] = today_time() output['local_sync']['locked'] = False else: logger.info("/!\ Cant run the sync, there is a sync process ongoing") return(output) def analyze_local_files(folder_to_sync_locally, output): output['local_sync']['files_source'] = 0 output['local_sync']['files_dest'] = 0 output['local_sync']['folders'] = [] for folder in folder_to_sync_locally: one_folder = {} one_folder['source_folder'] = folder['source_folder'] src_count = count_files_in_dir(folder['source_folder'],['']) output['local_sync']['files_source'] += src_count one_folder['source_count'] = src_count dest_folder = "{}/{}".format(folder['dest_folder'],folder['source_folder'].split("/")[-1]) one_folder['dest_folder'] = dest_folder dest_count = count_files_in_dir(dest_folder,['']) output['local_sync']['files_dest'] += dest_count one_folder['dest_count'] = dest_count output['local_sync']['folders'].append(one_folder) output['local_sync']['files_delta'] = output['local_sync']['files_source'] - output['local_sync']['files_dest'] logger.info("Analyze local file output : {}".format(json.dumps(output))) return(output) def get_server_metrics(output): # get cpu usage ret,msg = run_shell_command('top -bn 1 | grep Cpu | head -c 14 | tail -c 5') output['server']['cpu_%'] = msg ret,msg = run_shell_command('free -m | grep Mem | head -c 32 | tail -c 5') output['server']['ram_Mo'] = msg ret,msg = run_shell_command('vcgencmd measure_temp | head -c 11 | tail -c 6') output['server']['temp_c'] = msg output['server']['last_run'] = today_time() return(output) def backup_naspi(backup,output): backup_location = backup.get('backup_location') backup_dir = "{}{}".format(backup_location,today_date()) ret,msg = run_shell_command('mkdir -p {}'.format(backup_dir)) files_to_backup = backup.get("files_to_backup") for entry in files_to_backup: if os.path.isdir(entry): ret,msg = run_shell_command('rsync -aqR {} {}'.format(entry,backup_dir)) else: subdir = entry.rsplit('/',1)[0] ret,msg = run_shell_command('mkdir -p {}{}'.format(backup_dir,subdir)) ret,msg = run_shell_command('rsync -aq {} {}{}'.format(entry,backup_dir,entry)) # old bkp cleanup existing_backup_dir = glob.glob('{}/*'.format(backup_location)) existing_backup_dir.sort() for out_file in existing_backup_dir: if out_file not in existing_backup_dir[-10:]: print("Deleting {}".format(out_file)) shutil.rmtree(out_file,ignore_errors=True) return(output) def os_backup(backup,output): os_backup_location = backup.get('os_backup_location') backup_name = "osbkp-{}.img".format(today_date()) # sudo dd if=/dev/mmcblk0 of=/disks/Elements/os_bkp/osbkp18082021.img bs=1M # sudo ./pishrink.sh -z osbkp18082021.img ret,msg = run_shell_command('sudo dd if=/dev/mmcblk0 of={}/{} bs=1M'.format(os_backup_location,backup_name)) if not os.path.exists("{}/pishrink.sh".format(working_dir)): ret,msg = run_shell_command('wget https://raw.githubusercontent.com/Drewsif/PiShrink/master/pishrink.sh -P {}'.format(working_dir)) # wget https://raw.githubusercontent.com/Drewsif/PiShrink/master/pishrink.sh ret,msg = run_shell_command('sudo chmod +x {}/pishrink.sh'.format(working_dir)) # sudo chmod +x pishrink.sh ret,msg = run_shell_command('sudo bash {}/pishrink.sh -z {}/{}'.format(working_dir,os_backup_location,backup_name)) ret,msg = run_shell_command('sudo chown pi:pi *.img.gz') # old bkp cleanup existing_backup_dir = glob.glob('{}/*'.format(os_backup_location)) existing_backup_dir.sort() for out_file in existing_backup_dir: if out_file not in existing_backup_dir[-4:]: print("Deleting {}".format(out_file)) shutil.rmtree(out_file,ignore_errors=True) return(output) if __name__=='__main__': main() # main(sys.argv[1:])

f2d7e6c6a86e1314f1b2716ac6227b1dc354be91

py

Python

fawkes/differentiator_lowkey.py

biergaiqiao/Oriole-Thwarting-Privacy-against-Trustworthy-Deep-Learning-Models

ffadb82b666e8c1561a036a10d9922db8a3266cc

2021-05-18T01:14:44.000Z

2021-05-18T01:14:44.000Z

fawkes/differentiator_lowkey.py

biergaiqiao/Oriole-Thwarting-Privacy-against-Trustworthy-Deep-Learning-Models

ffadb82b666e8c1561a036a10d9922db8a3266cc

fawkes/differentiator_lowkey.py

biergaiqiao/Oriole-Thwarting-Privacy-against-Trustworthy-Deep-Learning-Models

ffadb82b666e8c1561a036a10d9922db8a3266cc

2021-05-18T01:14:47.000Z

2021-05-18T01:14:47.000Z

#!/usr/bin/env python # -*- coding: utf-8 -*- # @Date : 2020-10-21 # @Author : Emily Wenger (ewenger@uchicago.edu) import time import numpy as np import tensorflow as tf import tensorflow_addons as tfa from keras.utils import Progbar class FawkesMaskGeneration: # if the attack is trying to mimic a target image or a neuron vector MIMIC_IMG = True # number of iterations to perform gradient descent MAX_ITERATIONS = 10000 # larger values converge faster to less accurate results LEARNING_RATE = 1e-2 # the initial constant c to pick as a first guess INITIAL_CONST = 1 # pixel intensity range INTENSITY_RANGE = 'imagenet' # threshold for distance L_THRESHOLD = 0.03 # whether keep the final result or the best result KEEP_FINAL = False # max_val of image MAX_VAL = 255 MAXIMIZE = False IMAGE_SHAPE = (224, 224, 3) RATIO = 1.0 LIMIT_DIST = False LOSS_TYPE = 'features' # use features (original Fawkes) or gradients (Witches Brew) to run Fawkes? def __init__(self, bottleneck_model_ls, mimic_img=MIMIC_IMG, batch_size=1, learning_rate=LEARNING_RATE, max_iterations=MAX_ITERATIONS, initial_const=INITIAL_CONST, intensity_range=INTENSITY_RANGE, l_threshold=L_THRESHOLD, max_val=MAX_VAL, keep_final=KEEP_FINAL, maximize=MAXIMIZE, image_shape=IMAGE_SHAPE, verbose=1, ratio=RATIO, limit_dist=LIMIT_DIST, loss_method=LOSS_TYPE): assert intensity_range in {'raw', 'imagenet', 'inception', 'mnist'} # constant used for tanh transformation to avoid corner cases self.it = 0 self.tanh_constant = 2 - 1e-6 self.MIMIC_IMG = mimic_img self.LEARNING_RATE = learning_rate self.MAX_ITERATIONS = max_iterations self.initial_const = initial_const self.batch_size = batch_size self.intensity_range = intensity_range self.l_threshold = l_threshold self.max_val = max_val self.keep_final = keep_final self.verbose = verbose self.maximize = maximize self.learning_rate = learning_rate self.ratio = ratio self.limit_dist = limit_dist self.single_shape = list(image_shape) self.bottleneck_models = bottleneck_model_ls self.loss_method = loss_method self.input_shape = tuple([self.batch_size] + self.single_shape) self.bottleneck_shape = tuple([self.batch_size] + self.single_shape) # the variable we're going to optimize over self.modifier = tf.Variable(np.ones(self.input_shape, dtype=np.float32) * 1e-6) self.const = tf.Variable(np.ones(batch_size) * self.initial_const, dtype=np.float32) self.mask = tf.Variable(np.ones(batch_size), dtype=np.bool) @staticmethod def resize_tensor(input_tensor, model_input_shape): if input_tensor.shape[1:] == model_input_shape or model_input_shape[1] is None: return input_tensor resized_tensor = tf.image.resize(input_tensor, model_input_shape[:2]) return resized_tensor def input_space_process(self, img): if self.intensity_range == 'imagenet': mean = np.repeat([[[[103.939, 116.779, 123.68]]]], self.batch_size, axis=0) raw_img = (img - mean) else: raw_img = img return raw_img def reverse_input_space_process(self, img): if self.intensity_range == 'imagenet': mean = np.repeat([[[[103.939, 116.779, 123.68]]]], self.batch_size, axis=0) raw_img = (img + mean) else: raw_img = img return raw_img def clipping(self, imgs): imgs = self.reverse_input_space_process(imgs) imgs = np.clip(imgs, 0, self.max_val) imgs = self.input_space_process(imgs) return imgs def calc_dissim(self, source_raw, source_mod_raw): return 0.0, 0.0, 0.0 # msssim_split = tf.image.ssim(source_raw, source_mod_raw, max_val=255.0) # dist_raw = (1.0 - tf.stack(msssim_split)) / 2.0 # dist = tf.maximum(dist_raw - self.l_threshold, 0.0) # # dist_raw_sum = tf.reduce_sum(tf.where(self.mask, dist_raw, tf.zeros_like(dist_raw))) # dist_raw_sum = tf.reduce_sum(dist_raw) # # dist_sum = tf.reduce_sum(tf.where(self.mask, dist, tf.zeros_like(dist))) # dist_sum = tf.reduce_sum(dist) # return dist, dist_sum, dist_raw_sum def calc_bottlesim(self, tape, source_raw, target_raw, source_filtered, original_raw): """ original Fawkes loss function. """ bottlesim = 0.0 bottlesim_sum = 0.0 # make sure everything is the right size. model_input_shape = self.single_shape cur_aimg_input = self.resize_tensor(source_raw, model_input_shape) cur_source_filtered = self.resize_tensor(source_filtered, model_input_shape) # cur_timg_input = self.resize_tensor(target_raw, model_input_shape) for bottleneck_model in self.bottleneck_models: if tape is not None: try: tape.watch(bottleneck_model.variables) except AttributeError: tape.watch(bottleneck_model.model.variables) # get the respective feature space reprs. bottleneck_a = bottleneck_model(cur_aimg_input) bottleneck_filter = bottleneck_model(cur_source_filtered) bottleneck_s = bottleneck_model(original_raw) # compute the differences. bottleneck_diff = bottleneck_a - bottleneck_s bottleneck_diff_filter = bottleneck_filter - bottleneck_s # get scale factor. scale_factor = tf.sqrt(tf.reduce_sum(tf.square(bottleneck_s), axis=1)) scale_factor_filter = tf.sqrt(tf.reduce_sum(tf.square(bottleneck_diff_filter), axis=1)) # compute the loss cur_bottlesim = tf.reduce_sum(tf.square(bottleneck_diff), axis=1) cur_bottlesim_filter = tf.reduce_sum(tf.square(bottleneck_diff_filter), axis=1) cur_bottlesim = cur_bottlesim / scale_factor cur_bottlesim_filter = cur_bottlesim_filter / scale_factor_filter bottlesim += cur_bottlesim + cur_bottlesim_filter bottlesim_sum += tf.reduce_sum(cur_bottlesim) + tf.reduce_sum(cur_bottlesim_filter) return bottlesim, bottlesim_sum def compute_feature_loss(self, tape, aimg_raw, simg_raw, aimg_input, timg_input, simg_input, aimg_filtered): """ Compute input space + feature space loss. """ input_space_loss, input_space_loss_sum, input_space_loss_raw_sum = self.calc_dissim(aimg_raw, simg_raw) feature_space_loss, feature_space_loss_sum = self.calc_bottlesim(tape, aimg_input, timg_input, aimg_filtered, simg_input) if self.maximize: loss = self.const * input_space_loss - feature_space_loss else: if self.it < self.MAX_ITERATIONS: loss = self.const * input_space_loss + 1000 * feature_space_loss # - feature_space_loss_orig else: loss = self.const * 100 * input_space_loss + feature_space_loss # loss_sum = tf.reduce_sum(tf.where(self.mask, loss, tf.zeros_like(loss))) loss_sum = tf.reduce_sum(loss) # return loss_sum, input_space_loss, feature_space_loss, input_space_loss_sum, input_space_loss_raw_sum, feature_space_loss_sum return loss_sum, 0, feature_space_loss, 0, 0, feature_space_loss_sum def attack(self, source_imgs, target_imgs, weights=None): """ Main function that runs cloak generation. """ if weights is None: weights = np.ones([source_imgs.shape[0]] + list(self.bottleneck_shape[1:])) assert weights.shape[1:] == self.bottleneck_shape[1:] assert source_imgs.shape[1:] == self.input_shape[1:] assert source_imgs.shape[0] == weights.shape[0] if self.MIMIC_IMG: assert target_imgs.shape[1:] == self.input_shape[1:] assert source_imgs.shape[0] == target_imgs.shape[0] else: assert target_imgs.shape[1:] == self.bottleneck_shape[1:] assert source_imgs.shape[0] == target_imgs.shape[0] start_time = time.time() adv_imgs = [] print('%d batches in total' % int(np.ceil(len(source_imgs) / self.batch_size))) for idx in range(0, len(source_imgs), self.batch_size): # print('processing image %d at %s' % (idx + 1, datetime.datetime.now())) adv_img = self.attack_batch(source_imgs[idx:idx + self.batch_size], target_imgs[idx:idx + self.batch_size]) adv_imgs.extend(adv_img) elapsed_time = time.time() - start_time print('protection cost %f s' % elapsed_time) return np.array(adv_imgs) def attack_batch(self, source_imgs, target_imgs): """ TF2 method to generate the cloak. """ # preprocess images. global progressbar nb_imgs = source_imgs.shape[0] mask = [True] * nb_imgs + [False] * (self.batch_size - nb_imgs) self.mask = np.array(mask, dtype=np.bool) LR = self.learning_rate # make sure source/target images are an array source_imgs = np.array(source_imgs, dtype=np.float32) target_imgs = np.array(target_imgs, dtype=np.float32) # metrics to test best_bottlesim = [0] * nb_imgs if self.maximize else [np.inf] * nb_imgs best_adv = np.zeros(source_imgs.shape) total_distance = [0] * nb_imgs finished_idx = set() # make the optimizer optimizer = tf.keras.optimizers.Adam(self.learning_rate) # optimizer = tf.keras.optimizers.Adadelta(self.learning_rate) # get the modifier self.modifier = tf.Variable(np.ones(self.input_shape, dtype=np.float32) * 1e-4) # self.modifier = tf.Variable(np.random.uniform(-8.0, 8.0, self.input_shape), dtype=tf.float32) if self.verbose == 0: progressbar = Progbar( self.MAX_ITERATIONS, width=30, verbose=1 ) # watch relevant variables. simg_tanh = tf.Variable(source_imgs, dtype=np.float32) timg_tanh = tf.Variable(target_imgs, dtype=np.float32) # simg_tanh = self.reverse_input_space_process(simg_tanh) # timg_tanh = self.reverse_input_space_process(timg_tanh) # run the attack self.it = 0 below_thresh = False while self.it < self.MAX_ITERATIONS: self.it += 1 with tf.GradientTape(persistent=True) as tape: tape.watch(self.modifier) tape.watch(simg_tanh) tape.watch(timg_tanh) aimg_raw = simg_tanh + self.modifier aimg_filtered_raw = simg_tanh + tfa.image.gaussian_filter2d(self.modifier, [7, 7], 3.0) final_filtered_raw = simg_tanh + tfa.image.gaussian_filter2d(self.modifier, [1, 1], 2.0) simg_raw = simg_tanh timg_raw = timg_tanh # Convert further preprocess for bottleneck aimg_input = self.input_space_process(aimg_raw) aimg_filtered = self.input_space_process(aimg_filtered_raw) timg_input = self.input_space_process(timg_raw) simg_input = self.input_space_process(simg_raw) # aimg_input = aimg_raw # timg_input = timg_raw # simg_input = simg_raw # get the feature space loss. loss, input_dist, internal_dist, input_dist_sum, input_dist_raw_sum, internal_dist_sum = self.compute_feature_loss( tape, aimg_raw, simg_raw, aimg_input, timg_input, simg_input, aimg_filtered) # compute gradients grad = tape.gradient(loss, [self.modifier]) # grad[0] = grad[0] * 1e11 grad[0] = tf.sign(grad[0]) * 0.6375 # optimizer.apply_gradients(zip(grad, [self.modifier])) self.modifier = self.modifier - grad[0] self.modifier = tf.clip_by_value(self.modifier, -12.0, 12.0) for e, (feature_d, mod_img) in enumerate(zip(internal_dist, final_filtered_raw)): if e >= nb_imgs: break if (feature_d < best_bottlesim[e] and (not self.maximize)) or ( feature_d > best_bottlesim[e] and self.maximize): # print('found improvement') best_bottlesim[e] = feature_d best_adv[e] = mod_img # compute whether or not your perturbation is too big. # thresh_over = input_dist_sum / self.batch_size / self.l_threshold * 100 # if self.it != 0 and (self.it % (self.MAX_ITERATIONS // 3) == 0): # LR = LR * 0.8 # np.array([LR * 0.8]) # optimizer.learning_rate = LR # print("LR: {}".format(LR)) # print iteration result # if self.it % 10 == 0: if self.verbose == 1: thresh_over = input_dist_sum / self.batch_size / self.l_threshold * 100 # import pdb # pdb.set_trace() print( "ITER {:0.0f} Total Loss: {:.4f} perturb: {:0.4f} ({:0.4f} over, {:0.4f} raw); sim: {:.4f}".format( self.it, loss, input_dist_sum, thresh_over, input_dist_raw_sum, internal_dist_sum / nb_imgs)) if self.verbose == 0: progressbar.update(self.it) # DONE: print results if self.verbose == 1: thresh_over = input_dist_sum / self.batch_size / self.l_threshold * 100 print( "END after {} iterations: Total Loss: {} perturb: {:0.4f} ({:0.4f} over, {:0.4f} raw); sim: {}".format( self.it, loss, input_dist_sum, thresh_over, input_dist_raw_sum, internal_dist_sum / nb_imgs)) print("\n") best_adv = self.clipping(best_adv[:nb_imgs]) return best_adv

f2d93f0a50f1963382d3895bbaf47dcf3e2de6e0

py

Python

routes/class_incoming.py

fingerecho/proms-4.0

6c3a1fd62c9394761664e100fc1dde50fd79dc11

2019-11-23T03:56:28.000Z

2019-12-03T15:48:34.000Z

routes/class_incoming.py

fingerecho/proms-4.0

6c3a1fd62c9394761664e100fc1dde50fd79dc11

routes/class_incoming.py

fingerecho/proms-4.0

6c3a1fd62c9394761664e100fc1dde50fd79dc11

2019-04-12T18:09:35.000Z

2020-03-14T14:38:45.000Z

from abc import ABCMeta, abstractmethod import database from . import w_l class IncomingClass(metaclass=ABCMeta): @abstractmethod def __init__(self, request): self.request = request self.graph = None self.uri = None self.named_graph_uri = None self.error_messages = None @abstractmethod def valid(self): pass @abstractmethod def determine_uri(self): pass def stored(self): """ Add an item to PROMS""" if self.graph is None or self.named_graph_uri is None: msg = 'The graph and the named_grapoh_uri properties of this class instance must not be None when trying ' \ 'to store this instance in the provenance DB.' self.error_messages = msg return False try: w_l(str(self.graph)) w_l(str(self.named_graph_uri)) database.insert(self.graph, self.named_graph_uri) return True except Exception as e: self.error_messages = ['Could not connect to the provenance database'] return False

f2da20f8cd9ede45ff2e1e9791b316945d38036c

py

Python

openwater/utils/decorator.py

jeradM/openwater

740b7e76622a1ee909b970d9e5c612a840466cec

openwater/utils/decorator.py

jeradM/openwater

740b7e76622a1ee909b970d9e5c612a840466cec

openwater/utils/decorator.py

jeradM/openwater

740b7e76622a1ee909b970d9e5c612a840466cec

from typing import Callable def blocking(func: Callable): setattr(func, "_ow_blocking", True) return func def is_blocking(func: Callable): return getattr(func, "_ow_blocking", False) is True def nonblocking(func: Callable) -> Callable: setattr(func, "_ow_nonblocking", True) return func def is_nonblocking(func: Callable) -> bool: return getattr(func, "_ow_nonblocking", False) is True

f2db2b20dcde6fe54280e2d0105ffc23c0015da0

py

Python

setup.py

TDGerve/ramCOH

328f27891906e7207344fb3c5a685648a0924dd2

2022-03-08T12:30:55.000Z

2022-03-29T19:46:59.000Z

setup.py

TDGerve/ramCOH

328f27891906e7207344fb3c5a685648a0924dd2

setup.py

TDGerve/ramCOH

328f27891906e7207344fb3c5a685648a0924dd2

import setuptools setuptools.setup( name= 'ramCOH', version= '0.1', description= '...', author= 'Thomas van Gerve', packages= setuptools.find_packages( exclude= ['examples'] ), # package_dir= {'' : 'petroPy'}, package_data= {'ramCOH': ['static/*']}, install_requires= [ 'pandas', 'matplotlib', 'numpy', 'scipy', 'csaps' ] )

f2dd43c40f9fe338eecf074d6dac1c0de992c516

py

Python

chess.py

jrj92280/python-eve-backend

c0566cdef5e5c75e2b75e59bde804e0d4ce407e3

chess.py

jrj92280/python-eve-backend

c0566cdef5e5c75e2b75e59bde804e0d4ce407e3

chess.py

jrj92280/python-eve-backend

c0566cdef5e5c75e2b75e59bde804e0d4ce407e3

from chess_game._board import make_board from chess_game.chess_game import ChessGame from chess_game.play_game import get_user_input, game_event_loop if __name__ == "__main__": game_board = make_board() # pawn = Pawn('x', 'y', None, None, None) # pawn.move() print('Chess') print(' : Rules') print(' : input - piece''s position x,y, second x,y = destination') print(" : x = row number 1 though 8") print(" : y = column number 1 though 8") player1_name = get_user_input(' : Enter player one name', is_move=False) player2_name = get_user_input(' : Enter player two name', is_move=False) print('------------------------------------------------') chess_game = ChessGame(game_board, player1_name, player2_name) game_event_loop(chess_game)

f2dda34548b86bf17367a72a0ef32f5325649770

py

Python

python/binary_tree/104.maximum-depth-of-binary-tree.py

Nobodylesszb/LeetCode

0e902f6bff4834a93ce64cf9c57fd64297e63523

python/binary_tree/104.maximum-depth-of-binary-tree.py

Nobodylesszb/LeetCode

0e902f6bff4834a93ce64cf9c57fd64297e63523

python/binary_tree/104.maximum-depth-of-binary-tree.py

Nobodylesszb/LeetCode

0e902f6bff4834a93ce64cf9c57fd64297e63523

""" Given a binary tree, find its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. Note: A leaf is a node with no children. Example: Given binary tree [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 return its depth = 3. """ import Math class Solution: def findDeep(self,root): if not root: return 0 if not root.left or root.right: return 1 return 1+ Math.max(self.findDeep(root.left),self.findDeep(root.right))

f2de6356f341ba86e79ed1873bc9d766068dfedf

py

Python

strstr/3-2.py

stonemary/lintcode_solutions

f41fd0e56fb88ab54d0ab624977bff1623a6d33a

strstr/3-2.py

stonemary/lintcode_solutions

f41fd0e56fb88ab54d0ab624977bff1623a6d33a

strstr/3-2.py

stonemary/lintcode_solutions

f41fd0e56fb88ab54d0ab624977bff1623a6d33a

# time 15 mins # used time 15 mins # time 15 mins # used time 15 mins # this is actually a correct solution # the code i submitted a day ago, which passed lintcode, is actually wrong after i looked KMP up # the previous version does not take care of the situations where the target contains repeatitive elements class Solution: def strStr(self, source, target): ## try O(n) with no bug if source is None or target is None: return -1 source_pointer = 0 target_pointer = 0 last_target_begining_match = None while source_pointer < len(source): if target_pointer == len(target): return source_pointer - len(target) if source[source_pointer] == target[target_pointer]: if target_pointer != 0 and target[target_pointer] == target[0] and last_target_begining_match is None: last_target_begining_match = target_pointer target_pointer += 1 else: if last_target_begining_match is not None: target_pointer = last_target_begining_match + 1 last_target_begining_match = None elif source[source_pointer] == target[0]: target_pointer = 1 else: target_pointer = 0 source_pointer += 1 else: if target_pointer == len(target): return source_pointer - len(target) return -1

f2e1fc7cc5cf4031b844d0facd03421c1cb64cd2

py

Python

ProyectoFinal.py

T0N1R/Recommendation-System-python-neo4J

09dd1bbefa7e436a1aeedf9ccc9160719ec3a353

ProyectoFinal.py

T0N1R/Recommendation-System-python-neo4J

09dd1bbefa7e436a1aeedf9ccc9160719ec3a353

ProyectoFinal.py

T0N1R/Recommendation-System-python-neo4J

09dd1bbefa7e436a1aeedf9ccc9160719ec3a353

# -*- coding: cp1252 -*- # -*- coding: utf-8 -*- """ Algoritmos y Estructuras de Datos Proyecto Final Antonio Reyes #17273 Esteban Cabrera #17781 Miguel #17102 """ import random import xlrd file_location = "C:/Users/Antonio/Desktop/Recommendation-System-python-neo4J-master/Database.xlsx" workbook = xlrd.open_workbook(file_location) sheet = workbook.sheet_by_index(0) from neo4jrestclient.client import GraphDatabase db = GraphDatabase("http://localhost:7474",username="neo4j", password="1111") dataB = db.labels.create("Database") gen = db.labels.create("Genero") #se crea un diccionario (como vimos en hashmaps) database = {} #donde se guardan los generos de las series que ya se vieron historial = [] #en el for se puede poner sheet.nrows para imprimir todo def add_Excel(): lista_gen = [] for x in range(sheet.nrows): name = sheet.cell_value(x,0) gen1 = sheet.cell_value(x,1) gen2 = sheet.cell_value(x,2) gen3 = sheet.cell_value(x,3) lista_gen = [] lista_gen.append(gen1) lista_gen.append(gen2) lista_gen.append(gen3) lista_gen.sort() gen1 = lista_gen[0] gen2 = lista_gen[1] gen3 = lista_gen[2] generos = [] generos.append(gen1) generos.append(gen2) generos.append(gen3) database[name] = generos unidad = db.nodes.create(nombre=name, genero1=gen1, genero2=gen2, genero3=gen3) dataB.add(unidad) try: unidad.relationships.create("contains", gen.get(genero=gen1)[0]) gen.get(genero=gen1)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen1) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen1)[0]) gen.get(genero=gen1)[0].relationships.create("contains", unidad) try: unidad.relationships.create("contains", gen.get(genero=gen2)[0]) gen.get(genero=gen2)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen2) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen2)[0]) gen.get(genero=gen2)[0].relationships.create("contains", unidad) try: unidad.relationships.create("contains", gen.get(genero=gen3)[0]) gen.get(genero=gen3)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen3) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen3)[0]) gen.get(genero=gen3)[0].relationships.create("contains", unidad) def add_database(): listaOrden = [] name = raw_input("Insert name: ") gen1 = raw_input("Insert genre1 ") gen2 = raw_input("Insert genre2: ") gen3 = raw_input("Insert genre3: ") listaOrden.append(gen1) listaOrden.append(gen2) listaOrden.append(gen3) listaOrden.sort() gen1 = listaOrden[0] gen2 = listaOrden[1] gen3 = listaOrden[2] unidad = db.nodes.create(nombre=name, genero1=gen1, genero2=gen2, genero3=gen3) dataB.add(unidad) try: unidad.relationships.create("contains", gen.get(genero=gen1)[0]) gen.get(genero=gen1)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen1) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen1)[0]) gen.get(genero=gen1)[0].relationships.create("contains", unidad) try: unidad.relationships.create("contains", gen.get(genero=gen2)[0]) gen.get(genero=gen2)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen2) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen2)[0]) gen.get(genero=gen2)[0].relationships.create("contains", unidad) try: unidad.relationships.create("contains", gen.get(genero=gen3)[0]) gen.get(genero=gen3)[0].relationships.create("contains", unidad) except Exception: genNode = db.nodes.create(genero=gen3) gen.add(genNode) unidad.relationships.create("contains", gen.get(genero=gen3)[0]) gen.get(genero=gen3)[0].relationships.create("contains", unidad) database[name] = [gen1,gen2,gen3] def watch(): name = raw_input("Insert name: ") try: query = "MATCH (n:Database) WHERE n.nombre='"+name+"' RETURN n.genero1, n.genero2, n.genero3" results = db.query(query, data_contents=True) a = results.rows for x in a: historial.append(x[0]) historial.append(x[1]) historial.append(x[2]) except Exception: print("The movie or TV show you were looking for is not in the database, you can add it by going to option 1") popular_topics(name) #se utiliza el código mostrado en este link para mostrar los generos que se repiten más veces #https://stackoverflow.com/questions/3594514/how-to-find-most-common-elements-of-a-list def popular_topics(name): nombre = name #diccionario que determinará cuales son los 5 generos más vistos top_5 = [] #por cada genero en la lista.... word_counter = {} for word in historial: if word in word_counter: word_counter[word] += 1 else: word_counter[word] = 1 popular_words = sorted(word_counter, key = word_counter.get, reverse = True) top_5 = popular_words[:5] #se ordenan los generos en orden alfabetico lista = [] print "Most watched genres: " for x in top_5: lista.append(x) print x print "We recommend: " print "-----------------" print "-----------------" try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero1:'"+top_5[0]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero2:'"+top_5[0]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero3:'"+top_5[0]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero1:'"+top_5[1]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero2:'"+top_5[1]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero3:'"+top_5[1]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero1:'"+top_5[2]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero2:'"+top_5[2]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass try: query = "match (n:Database{nombre:'"+nombre+"'})-[:contains*1..3]->(a:Database{genero3:'"+top_5[2]+"'}) return collect(distinct a.nombre)" #query = "MATCH (n:Database {genero1:'"+top_5[0]+"', genero2:'"+top_5[1]+"', genero3:'"+top_5[2]+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) #print results a = results.rows #print len(a[0][0]) b = [] print a[0][0][0] for x in a[0][0]: if x not in b: b.append(x) valor = random.sample(range(0, len(b)+1), 3) print b[valor[0]] print b[valor[1]] print b[valor[2]] except Exception: pass #YourList.OrderBy(x => rnd.Next()).Take(5) #recomendation(name, top_5[0], top_5[1], top_5[2], top_5[3]) #método para mostrar todas las series y peliculas de un genero def show_genre(): genre = raw_input("Insert genre: ") try: query = "MATCH (n:Database {genero1:'"+genre+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) a = results.rows b = [] for x in a: if x not in b: b.append(x) print x except Exception: pass try: query = "MATCH (n:Database {genero2:'"+genre+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) a = results.rows b = [] for x in a: if x not in b: b.append(x) print x except Exception: pass try: query = "MATCH (n:Database {genero3:'"+genre+"'}) RETURN n.nombre" results = db.query(query, data_contents=True) a = results.rows b = [] for x in a: if x not in b: b.append(x) print x except Exception: pass #****************************************************************************************************** #******************************************************************************************************* def menu(): print("0. Add movies and TV shows to from Excel to Database") print("1. Add move or TV show to Database") print("2. Watch movie or TV Show") print("3. List of movies and TV shows by genre") print("9. Exit") menu() opcion = input("Option: ") print ("**********************************") print ("**********************************") while(opcion != 9): if(opcion == 0): add_Excel() print ("**********************************") print ("**********************************") print ("Values added to Database") menu() opcion = input("Option: ") elif(opcion == 1): add_database() print ("**********************************") print ("**********************************") menu() opcion = input("Option: ") elif(opcion == 2): watch() print ("**********************************") print ("**********************************") menu() opcion = input("Option: ") elif(opcion == 3): show_genre() print ("**********************************") print ("**********************************") menu() opcion = input("Option: ") else: print("This option is not valid") print ("**********************************") print ("**********************************") menu() opcion = input("Option: ") print ("Thanks for using the program")

f2e37e6fb52ee6d2e740ecb159b5517384b2a2c4

py

Python

www/async_flask/__init__.py

StarAhri/flask

facd476065c945f3467d4bfd7bc4ca910cc27d74

www/async_flask/__init__.py

StarAhri/flask

facd476065c945f3467d4bfd7bc4ca910cc27d74

www/async_flask/__init__.py

StarAhri/flask

facd476065c945f3467d4bfd7bc4ca910cc27d74

from flask import Flask import time from _thread import get_ident app=Flask(__name__) @app.route("/") def hello_world(): time.sleep(20) return "hello world!"+str(get_ident()) @app.route("/index") def hello(): time.sleep(1) return "Hello"+str(get_ident()) if __name__=="__main__": app.run(port=6003)

f2e440f4b6da4c3dc8c1545aee15d9066fc4d3f5

py

Python

codility-python/util/test_strings.py

mforoni/codility

be5005e96612dd7bb33b88bb76a590d28084b032

codility-python/util/test_strings.py

mforoni/codility

be5005e96612dd7bb33b88bb76a590d28084b032

codility-python/util/test_strings.py

mforoni/codility

be5005e96612dd7bb33b88bb76a590d28084b032

import unittest import util.strings as strings class TestStrings(unittest.TestCase): def test_first_index_of(self): self.assertEqual(1, strings.first_index_of('1', "0103003004")) self.assertEqual(20, strings.first_index_of('f', "post this text on a form")) def test_last_index_of(self): self.assertEqual(9, strings.last_index_of('1', "01030030014")) self.assertEqual(20, strings.last_index_of('f', "post this text on a form")) def test_indexes_of(self): self.assertEqual([1, 9], strings.indexes_of('1', "01030030014")) self.assertEqual([20, 30], strings.indexes_of('f', "post this text on a fantastic form")) if __name__ == '__main__': unittest.main()

f2e49a7f41a62f84a3de746b66ce03eb20e0b955

py

Python

ipython/data/parseSource/input.py

cainja/RMG-Py

f9ad0f4244e476a28768c8a4a37410ad55bcd556

2020-01-14T09:12:22.000Z

2020-01-14T09:12:22.000Z

ipython/data/parseSource/input.py

speth/RMG-Py

1d2c2b684580396e984459d9347628a5ceb80e2e

2016-06-06T18:18:49.000Z

2019-11-17T03:21:10.000Z

ipython/data/parseSource/input.py

speth/RMG-Py

1d2c2b684580396e984459d9347628a5ceb80e2e

2017-09-22T15:47:37.000Z

2021-12-30T23:51:47.000Z

# Data sources database( thermoLibraries = ['primaryThermoLibrary'], reactionLibraries = [('C3', False)], seedMechanisms = ['GRI-Mech3.0'], kineticsDepositories = ['training'], kineticsFamilies = 'default', kineticsEstimator = 'rate rules', ) # List of species species( label='ethane', reactive=True, structure=SMILES("CC"), ) species( label='N2', reactive=False, structure=adjacencyList(""" 1 N u0 p1 c0 {2,T} 2 N u0 p1 c0 {1,T} """), ) # Reaction systems simpleReactor( temperature=(1350,'K'), pressure=(1.0,'bar'), initialMoleFractions={ "ethane": 0.1, "N2": 0.9 }, terminationConversion={ 'ethane': 0.9, }, terminationTime=(1e6,'s'), ) simulator( atol=1e-16, rtol=1e-8, ) model( toleranceKeepInEdge=0.0, toleranceMoveToCore=0.1, toleranceInterruptSimulation=0.1, maximumEdgeSpecies=100000, ) options( units='si', saveRestartPeriod=None, generateOutputHTML=True, generatePlots=False, saveEdgeSpecies=True, saveSimulationProfiles=True, verboseComments=True, ) pressureDependence( method='modified strong collision', maximumGrainSize=(0.5,'kcal/mol'), minimumNumberOfGrains=250, temperatures=(300,2200,'K',2), pressures=(0.01,100,'bar',3), interpolation=('Chebyshev', 6, 4), maximumAtoms=15, )

f2e593a65e27e8bb4c6dbcd20c5d00538ad0aa1c

py

Python

simbench/__init__.py

BaraaUniKassel/simbench

eca679bbef2b7c61d4a42dd9d9716ad969ff6f77

simbench/__init__.py

BaraaUniKassel/simbench

eca679bbef2b7c61d4a42dd9d9716ad969ff6f77

simbench/__init__.py

BaraaUniKassel/simbench

eca679bbef2b7c61d4a42dd9d9716ad969ff6f77

# Copyright (c) 2019-2021 by University of Kassel, Tu Dortmund, RWTH Aachen University and Fraunhofer # Institute for Energy Economics and Energy System Technology (IEE) Kassel and individual # contributors (see AUTHORS file for details). All rights reserved. __version__ = "1.3.0" __author__ = "smeinecke" import os sb_dir = os.path.dirname(os.path.realpath(__file__)) from simbench.converter import * from simbench.networks import *

f2e72fd64f8c76f1c9fc74fe2d074f594b42d146

py

Python

src/output_module.py

abhishekpandeyIT/Virtual_Intelligent_Personal_Agent

786261fbcf1468bcbaee9f6d17aea3f3cc06f81e

src/output_module.py

abhishekpandeyIT/Virtual_Intelligent_Personal_Agent

786261fbcf1468bcbaee9f6d17aea3f3cc06f81e

src/output_module.py

abhishekpandeyIT/Virtual_Intelligent_Personal_Agent

786261fbcf1468bcbaee9f6d17aea3f3cc06f81e

import assistantResume from speak_module import speak from database import speak_is_on def output(o): # For command line input if speak_is_on(): speak(o) print(assistantResume.name +": "+o+"\n")

f2ed016efef1c89871a2e33d8718c95390697abc

py

Python

vk_bot/needrework/relation.py

triangle1984/vk-bot

39dea7bf8043e791ef079ea1ac6616f95d5b5312

2019-11-05T12:32:04.000Z

2019-11-15T14:29:46.000Z

vk_bot/needrework/relation.py

anar66/vk-bot

39dea7bf8043e791ef079ea1ac6616f95d5b5312

2019-12-11T20:26:31.000Z

2019-12-11T20:26:31.000Z

vk_bot/needrework/relation.py

triangle1984/vk-bot

39dea7bf8043e791ef079ea1ac6616f95d5b5312

2019-11-20T14:20:30.000Z

2022-02-05T10:37:01.000Z

import vk_api from vk_api.utils import get_random_id from vk_bot.core.sql.vksql import * def relationmeet(text, vk, event): check = checkrelation('waitmeet', event.object.from_id) if check == None: check = checkrelation('relation', event.object.from_id) if check == None: userid = "".join(text[2][3:]) userid = userid.split('|')[0] check = checkrelation('relation', userid) if check == None: check = checkrelation('waitmeet', userid) if check == None: tableadd("waitmeet", "id, id2", (f"{event.object.from_id}, {userid}")) vk.messages.send(user_id=int(userid), random_id=get_random_id(), message=f"*id{event.object.from_id}(Пользователь) предложил тебе встречаться!\nНапиши: '/отношения принять' или '/отношения отклонить'") else: return "Этому пользователю уже кто-то предложил встречатся!" else: return "Этот пользователь уже встречается с кем-то!" else: return "Ай-яй-яй! Изменять нехорошо" else: return "Ты уже отправил приглашение!" def reject(event, vk): check = checktable('waitmeet', 'id2', event.object.from_id) if check == None: return 'У тебя нет предложений встречаться!' else: userid = checktable('waitmeet', 'id2', event.object.from_id) vk.messages.send(user_id=int(userid['id']), random_id=get_random_id(), message=f"*id{event.object.from_id}(Пользователь) отклонил твое предложение :()") tablerm('waitmeet', "id2", event.object.from_id) return "Вы отклонили предложение" def accept(event, vk): check = checktable('waitmeet', 'id2', event.object.from_id) if check == None: return 'У тебя нет предложений встречаться!' else: relationaccept(event.object.from_id) tablerm('waitmeet', "id2", event.object.from_id) userid = checktable('relation', 'id2', event.object.from_id) vk.messages.send(user_id=int(userid['id']), random_id=get_random_id(), message=f"*id{event.object.from_id}(Пользователь) принял твое предложение! Поздравляем!") return "Вы приняли предложение! Поздравляем!" def test(event, vk, message, case): check = checkrelation('relation', event.object.from_id) if check == None: return {'message': 'Ты ни с кем не встречаешься :('} else: userid = checktable('relation', 'id', event.object.from_id) if userid == None: userid = checktable('relation', 'id2', event.object.from_id) if userid['id2'] == event.object.from_id: userid = f"*id{userid['id']}({vk.users.get(user_ids=userid['id'], name_case=case)[0]['first_name']})" return {'message':f"{message} {userid}"} elif userid['id'] == event.object.from_id: userid = f"*id{userid['id2']}({vk.users.get(user_ids=userid['id2'], name_case=case)[0]['first_name']})" return {'message':f"{message} {userid}"} def relation(event, vk, text): try: if text[1] == "принять": return {"message": accept(event, vk)} elif text[1] == "отклонить": return {"message": reject(event, vk)} elif text[:2] == ['/отношения', 'встречаться']: return {"message": relationmeet(text, vk, event)} except IndexError: return test(event, vk, "Ты встречаешься с", "ins")

f2ed7a6bb514c982bc41d3c33e724e9e6365650e

py

Python

wallpaperdownloader/main.py

k-vinogradov/wallpaper-downloader

568c6a1e3a2307f710bf6fe313b39da2d620213a

wallpaperdownloader/main.py

k-vinogradov/wallpaper-downloader

568c6a1e3a2307f710bf6fe313b39da2d620213a

wallpaperdownloader/main.py

k-vinogradov/wallpaper-downloader

568c6a1e3a2307f710bf6fe313b39da2d620213a

"""Wallpaper Downloader Main Module.""" import argparse import asyncio import logging import sys from datetime import datetime from wallpaperdownloader.downloader import download, LOGGER_NAME def abort(*args): """Print message to the stderr and exit the program.""" print(*args, file=sys.stderr) sys.exit(1) def check_args(args): """Check if arguments are valid.""" month, year = (args.month, args.year) if month < 1 or month > 12: abort("Invalid month number %d", month) date_string = f"{year:04}{month:02}" if date_string < "201205": abort("There are no wallpapers older than May 2012") if date_string > datetime.now().strftime("%Y%M"): abort("Too early... come a bit later") def configure_logger(level): """Configure console log output.""" logger = logging.getLogger(LOGGER_NAME) handler = logging.StreamHandler() logger.setLevel(level) handler.setLevel(level) logger.addHandler(handler) def main(): """Run WD main routine.""" parser = argparse.ArgumentParser( description="Download wallpapers from www.smashingmagazine.com" ) parser.add_argument("month", type=int, help="Month number") parser.add_argument("year", type=int, help="Year") parser.add_argument("resolution", type=str, help="Image resolution") parser.add_argument( "-v", "--verbose", action="store_true", help="Enable verbose output" ) args = parser.parse_args() check_args(args) configure_logger(logging.DEBUG if args.verbose else logging.INFO) year, month, res = (args.year, args.month, args.resolution) asyncio.get_event_loop().run_until_complete(download(year, month, res)) if __name__ == "__main__": main()

f2ee02add396584dc919e32b6bdd9a63f34df039

py

Python

Lib/site-packages/hackedit/app/common.py

fochoao/cpython

3dc84b260e5bced65ebc2c45c40c8fa65f9b5aa9

Lib/site-packages/hackedit/app/common.py

fochoao/cpython

3dc84b260e5bced65ebc2c45c40c8fa65f9b5aa9

2021-05-03T18:02:23.000Z

2022-03-12T12:01:04.000Z

Lib/site-packages/hackedit/app/common.py

fochoao/cpython

3dc84b260e5bced65ebc2c45c40c8fa65f9b5aa9

""" Functions shared across the main window, the welcome window and the system tray. """ import os import qcrash.api as qcrash from PyQt5 import QtWidgets from hackedit.app import templates, settings from hackedit.app.dialogs.dlg_about import DlgAbout from hackedit.app.dialogs.dlg_template_answers import DlgTemplateVars from hackedit.app.dialogs.preferences import DlgPreferences from hackedit.app.wizards.new import WizardNew def show_about(window): """ Shows the about dialog on the parent window :param window: parent window. """ DlgAbout.show_about(window) def check_for_update(*args, **kwargs): """ Checks for update. :param window: parent window :param show_up_to_date_msg: True to show a message box when the app is up to date. """ # todo: improve this: make an update wizard that update both hackedit # and its packages (to ensure compatiblity) # if pip_tools.check_for_update('hackedit', __version__): # answer = QtWidgets.QMessageBox.question( # window, 'Check for update', # 'A new version of HackEdit is available...\n' # 'Would you like to install it now?') # if answer == QtWidgets.QMessageBox.Yes: # try: # status = pip_tools.graphical_install_package( # 'hackedit', autoclose_dlg=True) # except RuntimeError as e: # QtWidgets.qApp.processEvents() # QtWidgets.QMessageBox.warning( # window, 'Update failed', # 'Failed to update hackedit: %r' % e) # else: # QtWidgets.qApp.processEvents() # if status: # QtWidgets.QMessageBox.information( # window, 'Check for update', # 'Update completed with sucess, the application ' # 'will now restart...') # window.app.restart() # else: # QtWidgets.QMessageBox.warning( # window, 'Update failed', # 'Failed to update hackedit') # else: # _logger().debug('HackEdit up to date') # if show_up_to_date_msg: # QtWidgets.QMessageBox.information( # window, 'Check for update', 'HackEdit is up to date.') pass def open_folder(window, app): path = QtWidgets.QFileDialog.getExistingDirectory( window, _('Open directory'), settings.last_open_dir()) if path: settings.set_last_open_dir(os.path.dirname(path)) app.open_path(path, sender=window) def report_bug(window, title='', traceback=None, issue_description=''): qcrash.show_report_dialog( issue_title=title, traceback=traceback, parent=window, include_log=traceback is not None, include_sys_info=traceback is not None, issue_description=issue_description) return True def edit_preferences(window, app): DlgPreferences.edit_preferences(window, app) def not_implemented_action(window): QtWidgets.QMessageBox.information( window, _('Not implementeded'), _('This action has not been implemented yet...')) def create_new(app, window, current_project=None): source, template, dest_dir, single_file = WizardNew.get_parameters( window, current_project) if source is not None: create_new_from_template(source, template, dest_dir, single_file, window, app) def create_new_from_template(source, template, dest_dir, single_file, window, app): from .main_window import MainWindow try: variables = template['variables'] except KeyError: answers = {} else: answers = DlgTemplateVars.get_answers(variables, parent=window) if answers is None: # canceled by user return None files = templates.create(template, dest_dir, answers) if not files: # should not happen unless the template is empty return None if single_file: path = files[0] else: path = dest_dir from hackedit.app.welcome_window import WelcomeWindow if isinstance(window, WelcomeWindow): sender = None else: sender = window if single_file and isinstance(window, MainWindow): window.open_file(path) else: app.open_path(path, sender=sender) return path

f2ee858e562eab312d062843fa52105cd18f06ef

py

Python

pygame_menu/locals.py

apuly/pygame-menu

77bf8f2c8913de5a24674ee0d0d2c7c9b816a58b

2017-05-01T20:00:08.000Z

2022-03-29T13:49:16.000Z

pygame_menu/locals.py

apuly/pygame-menu

77bf8f2c8913de5a24674ee0d0d2c7c9b816a58b

2017-11-05T17:42:48.000Z

2022-03-27T21:13:33.000Z

pygame_menu/locals.py

apuly/pygame-menu

77bf8f2c8913de5a24674ee0d0d2c7c9b816a58b

2017-05-02T20:42:24.000Z

2022-03-24T16:17:38.000Z

""" pygame-menu https://github.com/ppizarror/pygame-menu LOCALS Local constants. License: ------------------------------------------------------------------------------- The MIT License (MIT) Copyright 2017-2021 Pablo Pizarro R. @ppizarror 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. ------------------------------------------------------------------------------- """ __all__ = [ # Alignment 'ALIGN_CENTER', 'ALIGN_LEFT', 'ALIGN_RIGHT', # Data types 'INPUT_FLOAT', 'INPUT_INT', 'INPUT_TEXT', # Positioning 'POSITION_CENTER', 'POSITION_EAST', 'POSITION_NORTH', 'POSITION_NORTHEAST', 'POSITION_SOUTHWEST', 'POSITION_SOUTH', 'POSITION_SOUTHEAST', 'POSITION_NORTHWEST', 'POSITION_WEST', # Orientation 'ORIENTATION_HORIZONTAL', 'ORIENTATION_VERTICAL', # Scrollarea 'SCROLLAREA_POSITION_BOTH_HORIZONTAL', 'SCROLLAREA_POSITION_BOTH_VERTICAL', 'SCROLLAREA_POSITION_FULL', # Cursors 'CURSOR_ARROW', 'CURSOR_CROSSHAIR', 'CURSOR_HAND', 'CURSOR_IBEAM', 'CURSOR_NO', 'CURSOR_SIZEALL', 'CURSOR_SIZENESW', 'CURSOR_SIZENS', 'CURSOR_SIZENWSE', 'CURSOR_SIZEWE', 'CURSOR_WAIT', 'CURSOR_WAITARROW', # Event compatibility 'FINGERDOWN', 'FINGERMOTION', 'FINGERUP' ] import pygame as __pygame # Alignment ALIGN_CENTER = 'align-center' ALIGN_LEFT = 'align-left' ALIGN_RIGHT = 'align-right' # Input data type INPUT_FLOAT = 'input-float' INPUT_INT = 'input-int' INPUT_TEXT = 'input-text' # Position POSITION_CENTER = 'position-center' POSITION_EAST = 'position-east' POSITION_NORTH = 'position-north' POSITION_NORTHEAST = 'position-northeast' POSITION_NORTHWEST = 'position-northwest' POSITION_SOUTH = 'position-south' POSITION_SOUTHEAST = 'position-southeast' POSITION_SOUTHWEST = 'position-southwest' POSITION_WEST = 'position-west' # Menu ScrollArea position SCROLLAREA_POSITION_BOTH_HORIZONTAL = 'scrollarea-position-both-horizontal' SCROLLAREA_POSITION_BOTH_VERTICAL = 'scrollarea_position-both-vertical' SCROLLAREA_POSITION_FULL = 'scrollarea-position-full' # Orientation ORIENTATION_HORIZONTAL = 'orientation-horizontal' ORIENTATION_VERTICAL = 'orientation-vertical' # Cursors CURSOR_ARROW = None if not hasattr(__pygame, 'SYSTEM_CURSOR_ARROW') else __pygame.SYSTEM_CURSOR_ARROW CURSOR_CROSSHAIR = None if not hasattr(__pygame, 'SYSTEM_CURSOR_CROSSHAIR') else __pygame.SYSTEM_CURSOR_CROSSHAIR CURSOR_HAND = None if not hasattr(__pygame, 'SYSTEM_CURSOR_HAND') else __pygame.SYSTEM_CURSOR_HAND CURSOR_IBEAM = None if not hasattr(__pygame, 'SYSTEM_CURSOR_IBEAM') else __pygame.SYSTEM_CURSOR_IBEAM CURSOR_NO = None if not hasattr(__pygame, 'SYSTEM_CURSOR_NO') else __pygame.SYSTEM_CURSOR_NO CURSOR_SIZEALL = None if not hasattr(__pygame, 'SYSTEM_CURSOR_SIZEALL') else __pygame.SYSTEM_CURSOR_SIZEALL CURSOR_SIZENESW = None if not hasattr(__pygame, 'SYSTEM_CURSOR_SIZENESW') else __pygame.SYSTEM_CURSOR_SIZENESW CURSOR_SIZENS = None if not hasattr(__pygame, 'SYSTEM_CURSOR_SIZENS') else __pygame.SYSTEM_CURSOR_SIZENS CURSOR_SIZENWSE = None if not hasattr(__pygame, 'SYSTEM_CURSOR_SIZENWSE') else __pygame.SYSTEM_CURSOR_SIZENWSE CURSOR_SIZEWE = None if not hasattr(__pygame, 'SYSTEM_CURSOR_SIZEWE') else __pygame.SYSTEM_CURSOR_SIZEWE CURSOR_WAIT = None if not hasattr(__pygame, 'SYSTEM_CURSOR_WAIT') else __pygame.SYSTEM_CURSOR_WAIT CURSOR_WAITARROW = None if not hasattr(__pygame, 'SYSTEM_CURSOR_WAITARROW') else __pygame.SYSTEM_CURSOR_WAITARROW # Events compatibility with lower pygame versions FINGERDOWN = -1 if not hasattr(__pygame, 'FINGERDOWN') else __pygame.FINGERDOWN FINGERMOTION = -1 if not hasattr(__pygame, 'FINGERMOTION') else __pygame.FINGERMOTION FINGERUP = -1 if not hasattr(__pygame, 'FINGERUP') else __pygame.FINGERUP

f2efb530b1ef641d5c0b78f798aa8a3ec91dbadc

py

Python

functions/constants.py

Katolus/functions

c4aff37231432ce6ef4ed6b37c8b5baaede5975a

2022-03-08T08:46:44.000Z

2022-03-19T07:52:11.000Z

functions/constants.py

Katolus/functions

c4aff37231432ce6ef4ed6b37c8b5baaede5975a

2021-10-30T05:48:54.000Z

2022-03-06T10:57:00.000Z

functions/constants.py

Katolus/functions

c4aff37231432ce6ef4ed6b37c8b5baaede5975a

import os import sys from enum import Enum from enum import unique from typing import List # Set system constants based on the current platform if sys.platform.startswith("win32"): DEFAULT_SYSTEM_CONFIG_PATH = os.path.join(os.environ["APPDATA"], "config") elif sys.platform.startswith("linux"): DEFAULT_SYSTEM_CONFIG_PATH = os.path.join(os.environ["HOME"], ".config") elif sys.platform.startswith("darwin"): DEFAULT_SYSTEM_CONFIG_PATH = os.path.join( os.environ["HOME"], "Library", "Application Support" ) else: DEFAULT_SYSTEM_CONFIG_PATH = os.path.join(os.environ["HOME"], "config") # System configuration PACKAGE_BASE_CONFIG_FOLDER = "ventress-functions" PACKAGE_CONFIG_DIR_PATH = os.path.join( DEFAULT_SYSTEM_CONFIG_PATH, PACKAGE_BASE_CONFIG_FOLDER ) DEFAULT_LOG_FILENAME = "functions.log" DEFAULT_LOG_FILEPATH = os.path.join(PACKAGE_CONFIG_DIR_PATH, DEFAULT_LOG_FILENAME) # Project constants PROJECT_VENDOR = "ventress" PROJECT_MARK = "ventress-functions" class ConfigName(str, Enum): """Represents various availabel names for a config file""" BASE = "config.json" class RequiredFile(str, Enum): """Enum for required file names in a function's directory""" CONFIG = "config.json" DOCKERFILE = "Dockerfile" DOCKERIGNORE = ".dockerignore" ENTRY_POINT = "main.py" REQUIREMENTS = "requirements.txt" class LoggingLevel(str, Enum): DEBUG = "debug" ERROR = "error" INFO = "info" WARNING = "warning" class FunctionType(str, Enum): """Represents the various types of functions that can be run""" HTTP = "http" PUBSUB = "pubsub" @classmethod def options(cls) -> List[str]: """Returns a list of all the function types""" return [enum.value for enum in cls] class LocalStatus(str, Enum): """Represents the status of a function locally""" ADDED = "added" BUILT = "new build" INVALID = "invalid" NEW = "new" REMOVED = "removed" RUNNING = "running" STOPPED = "stopped" UNKNOWN = "unknown" @classmethod def build_statuses(cls) -> List[str]: """Returns a list of statuses which mean that the image is built""" return [ cls.BUILT, cls.RUNNING, cls.STOPPED, ] class CloudStatus(str, Enum): """Represents the status of a function on the cloud""" DELETED = "deleted" DEPLOYED = "deployed" UNKNOWN = "unknown" @property def is_deployed(self) -> bool: return self == CloudStatus.DEPLOYED @unique class CloudProvider(str, Enum): """Represents the various cloud providers supported by the functions package""" # AWS = "aws" # AZURE = "azure" GCP = "gcp" # LOCAL = "local" # OPENFASS = "openfass" # OPENSTACK = "openstack" @classmethod def all(cls) -> List[str]: """Returns all the available service types""" return [enum.value for enum in cls] @unique class CloudServiceType(str, Enum): CLOUD_FUNCTION = "cloud_function" @classmethod def all(cls) -> List[str]: """Returns all the available service types""" return [enum.value for enum in cls]

f2f174769c76e5752b21c530463b089bffb53275

py

Python

mkmk/extend.py

tundra/mkmk

4ca7a3e337dcc3345fb01ea205ae05c397f396b0

mkmk/extend.py

tundra/mkmk

4ca7a3e337dcc3345fb01ea205ae05c397f396b0

mkmk/extend.py

tundra/mkmk

4ca7a3e337dcc3345fb01ea205ae05c397f396b0

#- Copyright 2014 GOTO 10. #- Licensed under the Apache License, Version 2.0 (see LICENSE). ## Utilities used for creating build extensions. from abc import ABCMeta, abstractmethod # Abstract superclass of the tool sets loaded implicitly into each context. # There can be many of these, one for each context. class ToolSet(object): __metaclass__ = ABCMeta def __init__(self, context): self.context = context # Returns the context this tool set belongs to. def get_context(self): return self.context # Controller for this kind of extension. There is only one of these for each # kind of extension. class ToolController(object): __metaclass__ = ABCMeta def __init__(self, env): self.env = env # Returns the build environment. def get_environment(self): return self.env # Gives this controller an opportunity to add some extra custom flags. By # default does nothing. def add_custom_flags(self, parser): pass # Returns a toolset instance, given a concrete context. @abstractmethod def get_tools(self, context): pass

f2f29f0872d8843eb8b228cb03ec5eb0946af9b8

py

Python

tracklib/model/model.py

xueyuelei/tracklib

d33912baf1bebd1605d5e9c8dfc31484c96628cc

2020-03-04T11:36:19.000Z

2020-06-21T16:49:45.000Z

tracklib/model/model.py

xueyuelei/tracklib

d33912baf1bebd1605d5e9c8dfc31484c96628cc

tracklib/model/model.py

xueyuelei/tracklib

d33912baf1bebd1605d5e9c8dfc31484c96628cc

# -*- coding: utf-8 -*- ''' REFERENCES: [1] Y. Bar-Shalom, X. R. Li, and T. Kirubarajan, "Estimation with Applications to Tracking and Navigation," New York: John Wiley and Sons, Inc, 2001. [2] R. A. Singer, "Estimating Optimal Tracking Filter Performance for Manned Maneuvering Targets," in IEEE Transactions on Aerospace and Electronic Systems, vol. AES-6, no. 4, pp. 473-483, July 1970. [3] X. Rong Li and V. P. Jilkov, "Survey of maneuvering target tracking. Part I. Dynamic models," in IEEE Transactions on Aerospace and Electronic Systems, vol. 39, no. 4, pp. 1333-1364, Oct. 2003. [4] W. Koch, "Tracking and Sensor Data Fusion: Methodological Framework and Selected Applications," Heidelberg, Germany: Springer, 2014. [5] Mo Longbin, Song Xiaoquan, Zhou Yiyu, Sun Zhong Kang and Y. Bar-Shalom, "Unbiased converted measurements for tracking," in IEEE Transactions on Aerospace and Electronic Systems, vol. 34, no. 3, pp. 1023-1027, July 1998 ''' from __future__ import division, absolute_import, print_function __all__ = [ 'F_poly', 'F_singer', 'F_van_keuk', 'Q_poly_dc', 'Q_poly_dd', 'Q_singer', 'Q_van_keuk', 'H_pos_only', 'R_pos_only', 'F_cv', 'f_cv', 'f_cv_jac', 'Q_cv_dc', 'Q_cv_dd', 'H_cv', 'h_cv', 'h_cv_jac', 'R_cv', 'F_ca', 'f_ca', 'f_ca_jac', 'Q_ca_dc', 'Q_ca_dd', 'H_ca', 'h_ca', 'h_ca_jac', 'R_ca', 'F_ct', 'f_ct', 'f_ct_jac', 'Q_ct', 'h_ct', 'h_ct_jac', 'R_ct', 'convert_meas', 'model_switch', 'trajectory_cv', 'trajectory_ca', 'trajectory_ct', 'trajectory_generator', 'trajectory_with_pd', 'trajectory_to_meas' ] import numbers import numpy as np import scipy.linalg as lg import scipy.stats as st import scipy.special as sl from tracklib.utils import sph2cart, pol2cart def F_poly(order, axis, T): ''' This polynomial transition matrix is used with discretized continuous-time models as well as direct discrete-time models. see section 6.2 and 6.3 in [1]. Parameters ---------- order : int The order of the filter. If order=2, then it is constant velocity, 3 means constant acceleration, 4 means constant jerk, etc. axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. Returns ------- F : ndarray The state transition matrix under a linear dynamic model of the given order and axis. ''' assert (order >= 1) assert (axis >= 1) F_base = np.zeros((order, order)) tmp = np.arange(order) F_base[0, :] = T**tmp / sl.factorial(tmp) for row in range(1, order): F_base[row, row:] = F_base[0, :order - row] F = np.kron(np.eye(axis), F_base) return F def F_singer(axis, T, tau=20): ''' Get the singer model transition matrix, see section 8.2 in [1]. Parameters ---------- axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. tau : float The time constant of the target acceleration autocorrelation, that is, the decorrelation time is approximately 2*tau. A reasonable range of tau for Singer's model is between 5 and 20 seconds. Typical values of tau for aircraft are 20s for slow turn and 5s for an evasive maneuver. If this parameter is omitted, the default value of 20 is used.The time constant is assumed the same for all dimensions of motion, so this parameter is scalar. Returns ------- F : ndarray The state transition matrix under a Gauss-Markov dynamic model of the given axis. ''' assert (axis >= 1) alpha = 1 / tau F_base = np.zeros((3, 3)) aT = alpha * T eaT = np.exp(-aT) F_base[0, 0] = 1 F_base[0, 1] = T F_base[0, 2] = (aT - 1 + eaT) * tau**2 F_base[1, 1] = 1 F_base[1, 2] = (1 - eaT) * tau F_base[2, 2] = eaT F = np.kron(np.eye(axis), F_base) return F def F_van_keuk(axis, T, tau=20): ''' Get the state transition matrix for the van Keuk dynamic model. This is a direct discrete-time model such that the acceleration advances in each dimension over time as a[k+1]=exp(-T/tau)a[k]+std*sqrt(1-exp(-2*T/tau))*v[k], see section 2.2.1 in [4] Parameters ---------- axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. tau : float The time constant of the target acceleration autocorrelation, that is, the decorrelation time is approximately 2*tau. A reasonable range of tau for Singer's model is between 5 and 20 seconds. Typical values of tau for aircraft are 20s for slow turn and 5s for an evasive maneuver. If this parameter is omitted, the default value of 20 is used.The time constant is assumed the same for all dimensions of motion, so this parameter is scalar. Returns ------- F : ndarray The state transition matrix under a Gauss-Markov dynamic model of the given axis. ''' assert (axis >= 1) F_base = F_poly(3, 1, T) F_base[-1, -1] = np.exp(-T / tau) F = np.kron(np.eye(axis), F_base) return F def Q_poly_dc(order, axis, T, std): ''' Process noise covariance matrix used with discretized continuous-time models. see section 6.2 in [1]. Parameters ---------- order : int The order of the filter. If order=2, then it is constant velocity, 3 means constant acceleration, 4 means constant jerk, etc. axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. std : number, list The standard deviation (square root of intensity) of continuous-time porcess noise Returns ------- Q : ndarray Process noise convariance ''' assert (order >= 1) assert (axis >= 1) if isinstance(std, numbers.Number): std = [std] * axis sel = np.arange(order - 1, -1, -1) col, row = np.meshgrid(sel, sel) Q_base = T**(col + row + 1) / (sl.factorial(col) * sl.factorial(row) * (col + row + 1)) Q = np.kron(np.diag(std)**2, Q_base) return Q def Q_poly_dd(order, axis, T, std, ht=0): ''' Process noise covariance matrix used with direct discrete-time models. see section 6.3 in [1]. Parameters ---------- order : int The order of the filter. If order=2, then it is constant velocity, 3 means constant acceleration, 4 means constant jerk, etc. axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. std : number, list The standard deviation of discrete-time porcess noise ht : int ht means that the order of the noise is `ht` greater than the highest order of the state, e.g., if the highest order of state is acceleration, then ht=0 means that the noise is of the same order as the highest order of state, that is, the noise is acceleration and the model is DWPA, see section 6.3.3 in [1]. If the highest order is velocity, the ht=1 means the noise is acceleration and the model is DWNA, see section 6.3.2 in [1]. Returns ------- Q : ndarray Process noise convariance Notes ----- For the model to which the alpha filter applies, we have order=0, ht=2. Likewise, for the alpha-beta filter, order=1, ht=1 and for the alpha- beta-gamma filter, order=2, ht=0 ''' assert (order >= 1) assert (axis >= 1) if isinstance(std, numbers.Number): std = [std] * axis sel = np.arange(ht + order - 1, ht - 1, -1) L = T**sel / sl.factorial(sel) Q_base = np.outer(L, L) Q = np.kron(np.diag(std)**2, Q_base) return Q def Q_singer(axis, T, std, tau=20): ''' Process noise covariance matrix used with Singer models. see section 8.2 in [1] Parameters ---------- axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. std : number, list std is the instantaneous standard deviation of the acceleration knowm as Ornstein-Uhlenbeck process, which can be obtained by assuming it to be 1. Equal to a maxmum acceleration a_M with probability p_M and -a_M with the same probability 2. Equal to zero with probability p_0 3. Uniformly distributed in [-a_M, a_M] with the remaining probability mass All parameters mentioned above are chosen by the designer. So the expected std^2 is (a_M^2 / 3)*(1 + 4*p_M - p_0) tau : float The time constant of the target acceleration autocorrelation, that is, the decorrelation time is approximately 2*tau. A reasonable range of tau for Singer's model is between 5 and 20 seconds. Typical values of tau for aircraft are 20s for slow turn and 5s for an evasive maneuver. If this parameter is omitted, the default value of 20 is used.The time constant is assumed the same for all dimensions of motion, so this parameter is scalar. Returns ------- Q : ndarray Process noise convariance ''' assert (axis >= 1) if isinstance(std, numbers.Number): std = [std] * axis alpha = 1 / tau aT = alpha * T eaT = np.exp(-aT) e2aT = np.exp(-2 * aT) q11 = tau**4 * (1 - e2aT + 2 * aT + 2 * aT**3 / 3 - 2 * aT**2 - 4 * aT * eaT) q12 = tau**3 * (e2aT + 1 - 2 * eaT + 2 * aT * eaT - 2 * aT + aT**2) q13 = tau**2 * (1 - e2aT - 2 * aT * eaT) q22 = tau**2 * (4 * eaT - 3 - e2aT + 2 * aT) q23 = tau * (e2aT + 1 - 2 * eaT) q33 = 1 - e2aT Q_base = np.array([[q11, q12, q13], [q12, q22, q23], [q13, q23, q33]], dtype=float) Q = np.kron(np.diag(std)**2, Q_base) return Q def Q_van_keuk(axis, T, std, tau=20): ''' Process noise covariance matrix for a Van Keuk dynamic model, see section 2.2.1 in [4] Parameters ---------- axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. T : float The time-duration of the propagation interval. std : number, list std is the instantaneous standard deviation of the acceleration knowm as Ornstein-Uhlenbeck process, which can be obtained by assuming it to be 1. Equal to a maxmum acceleration a_M with probability p_M and -a_M with the same probability 2. Equal to zero with probability p_0 3. Uniformly distributed in [-a_M, a_M] with the remaining probability mass All parameters mentioned above are chosen by the designer. So the expected std^2 is (a_M^2 / 3)*(1 + 4*p_M - p_0) tau : float The time constant of the target acceleration autocorrelation, that is, the decorrelation time is approximately 2*tau. A reasonable range of tau for Singer's model is between 5 and 20 seconds. Typical values of tau for aircraft are 20s for slow turn and 5s for an evasive maneuver. If this parameter is omitted, the default value of 20 is used. The time constant is assumed the same for all dimensions of motion, so this parameter is scalar. Returns ------- Q : ndarray Process noise convariance ''' assert (axis >= 1) if isinstance(std, numbers.Number): std = [std] * axis Q_base = np.diag([0., 0., 1.]) Q_base = (1 - np.exp(-2 * T / tau)) * Q_base Q = np.kron(np.diag(std)**2, Q_base) return Q def H_pos_only(order, axis): ''' Position-only measurement matrix is used with discretized continuous-time models as well as direct discrete-time models. see section 6.5 in [1]. Parameters ---------- order : int The order of the filter. If order=2, then it is constant velocity, 3 means constant acceleration, 4 means constant jerk, etc. axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. Returns ------- H : ndarray the measurement or obervation matrix ''' assert (order >= 1) assert (axis >= 1) H = np.eye(order * axis) H = H[::order] return H def R_pos_only(axis, std): ''' Position-only measurement noise covariance matrix and the noise of each axis is assumed to be uncorrelated. Parameters ---------- axis : int Motion directions in Cartesian coordinate. If axis=1, it means x-axis, 2 means x-axis and y-axis, etc. Returns ------- R : ndarray the measurement noise covariance matrix ''' assert (axis >= 1) if isinstance(std, numbers.Number): std = [std] * axis R = np.diag(std)**2 return R def F_cv(axis, T): return F_poly(2, axis, T) def f_cv(axis, T): F = F_cv(axis, T) def f(x, u=None): return np.dot(F, x) return f def f_cv_jac(axis, T): F = F_cv(axis, T) def fjac(x, u=None): return F return fjac def Q_cv_dc(axis, T, std): return Q_poly_dc(2, axis, T, std) def Q_cv_dd(axis, T, std): return Q_poly_dd(2, axis, T, std, ht=1) def H_cv(axis): return H_pos_only(2, axis) def h_cv(axis): H = H_cv(axis) def h(x): return np.dot(H, x) return h def h_cv_jac(axis): H = H_cv(axis) def hjac(x): return H return hjac def R_cv(axis, std): return R_pos_only(axis, std) def F_ca(axis, T): return F_poly(3, axis, T) def f_ca(axis, T): F = F_ca(axis, T) def f(x, u=None): return np.dot(F, x) return f def f_ca_jac(axis, T): F = F_ca(axis, T) def fjac(x, u=None): return F return fjac def Q_ca_dc(axis, T, std): return Q_poly_dc(3, axis, T, std) def Q_ca_dd(axis, T, std): return Q_poly_dd(3, axis, T, std, ht=0) def H_ca(axis): return H_pos_only(3, axis) def h_ca(axis): H = H_ca(axis) def h(x): return np.dot(H, x) return h def h_ca_jac(axis): H = H_ca(axis) def hjac(x): return H return hjac def R_ca(axis, std): return R_pos_only(axis, std) def F_ct(axis, turnrate, T): assert (axis >= 2) omega = np.deg2rad(turnrate) if np.fabs(omega) >= np.sqrt(np.finfo(omega).eps): wt = omega * T sin_wt = np.sin(wt) cos_wt = np.cos(wt) sin_div = sin_wt / omega cos_div = (cos_wt - 1) / omega else: sin_wt = 0 cos_wt = 1 sin_div = T cos_div = 0 F = np.array([[1, sin_div, 0, cos_div], [0, cos_wt, 0, -sin_wt], [0, -cos_div, 1, sin_div], [0, sin_wt, 0, cos_wt]], dtype=float) if axis == 3: zblock = F_cv(1, T) F = lg.block_diag(F, zblock) return F def f_ct(axis, T): assert (axis >= 2) def f(x, u=None): omega = np.deg2rad(x[4]) if np.fabs(omega) >= np.sqrt(np.finfo(omega).eps): wt = omega * T sin_wt = np.sin(wt) cos_wt = np.cos(wt) sin_div = sin_wt / omega cos_div = (cos_wt - 1) / omega else: sin_wt = 0 cos_wt = 1 sin_div = T cos_div = 0 F = np.array([[1, sin_div, 0, cos_div], [0, cos_wt, 0, -sin_wt], [0, -cos_div, 1, sin_div], [0, sin_wt, 0, cos_wt]], dtype=float) F = lg.block_diag(F, 1) if axis == 3: zblock = F_cv(1, T) F = lg.block_diag(F, zblock) return np.dot(F, x) return f def f_ct_jac(axis, T): assert (axis >= 2) def fjac(x, u=None): omega = np.deg2rad(x[4]) if np.fabs(omega) >= np.sqrt(np.finfo(omega).eps): wt = omega * T sin_wt = np.sin(wt) cos_wt = np.cos(wt) sin_div = sin_wt / omega cos_div = (cos_wt - 1) / omega f0 = np.deg2rad(((wt * cos_wt - sin_wt) * x[1] + (1 - cos_wt - wt * sin_wt) * x[3]) / omega**2) f1 = np.deg2rad((-x[1] * sin_wt - x[3] * cos_wt) * T) f2 = np.deg2rad((wt * (x[1] * sin_wt + x[3] * cos_wt) - (x[1] * (1 - cos_wt) + x[3] * sin_wt)) / omega**2) f3 = np.deg2rad((x[1]*cos_wt - x[3]*sin_wt) * T) else: sin_wt = 0 cos_wt = 1 sin_div = T cos_div = 0 f0 = np.deg2rad(-x[3] * T**2 / 2) f1 = np.deg2rad(-x[3] * T) f2 = np.deg2rad(x[1] * T**2 / 2) f3 = np.deg2rad(x[1] * T) F = np.array([[1, sin_div, 0, cos_div], [0, cos_wt, 0, -sin_wt], [0, -cos_div, 1, sin_div], [0, sin_wt, 0, cos_wt]], dtype=float) F = lg.block_diag(F, 1) F[0, -1] = f0 F[1, -1] = f1 F[2, -1] = f2 F[3, -1] = f3 if axis == 3: zblock = F_cv(1, T) F = lg.block_diag(F, zblock) return F return fjac def Q_ct(axis, T, std): assert (axis >= 2) if isinstance(std, numbers.Number): std = [std] * (axis + 1) # omega block = np.array([T**2 / 2, T], dtype=float).reshape(-1, 1) L = lg.block_diag(block, block, T) Q = np.diag(std)**2 if axis == 3: L = lg.block_diag(L, block) return L @ Q @ L.T def h_ct(axis): assert (axis >= 2) if axis == 3: H = H_pos_only(2, 3) else: H = H_pos_only(2, 2) H = np.insert(H, 4, 0, axis=1) def h(x): return np.dot(H, x) return h def h_ct_jac(axis): assert (axis >= 2) if axis == 3: H = H_pos_only(2, 3) else: H = H_pos_only(2, 2) H = np.insert(H, 4, 0, axis=1) def hjac(x): return H return hjac def R_ct(axis, std): assert (axis >= 2) return R_pos_only(axis, std) def convert_meas(z, R, elev=False): if elev: # coverted measurement r, az, el = z[0], z[1], z[2] var_r, var_az, var_el = R[0, 0], R[1, 1], R[2, 2] lamb_az = np.exp(-var_az / 2) lamb_el = np.exp(-var_el / 2) z_cart = np.array(sph2cart(r, az, el), dtype=float) z_cart[0] = z_cart[0] / lamb_az / lamb_el z_cart[1] = z_cart[1] / lamb_az / lamb_el z_cart[2] = z_cart[2] / lamb_el # coverted covariance r11 = (1 / (lamb_az * lamb_el)**2 - 2) * (r * np.cos(az) * np.cos(el))**2 + (r**2 + var_r) * (1 + lamb_az**4 * np.cos(2 * az)) * (1 + lamb_el**4 * np.cos(2 * el)) / 4 r22 = (1 / (lamb_az * lamb_el)**2 - 2) * (r * np.sin(az) * np.cos(el))**2 + (r**2 + var_r) * (1 - lamb_az**4 * np.cos(2 * az)) * (1 + lamb_el**4 * np.cos(2 * el)) / 4 r33 = (1 / lamb_el**2 - 2) * (r * np.sin(el))**2 + (r**2 + var_r) * (1 - lamb_el**4 * np.cos(2 * el)) / 2 r12 = (1 / (lamb_az * lamb_el)**2 - 2) * r**2 * np.sin(az) * np.cos(az) * np.cos(el)**2 + (r**2 + var_r) * lamb_az**4 * np.sin(2 * az) * (1 + lamb_el**4 * np.cos(2 * el)) / 4 r13 = (1 / (lamb_az * lamb_el**2) - 1 / lamb_az - lamb_az) * r**2 * np.cos(az) * np.sin(el) * np.cos(el) + (r**2 + var_r) * lamb_az * lamb_el**4 * np.cos(az) * np.sin(2 * el) / 2 r23 = (1 / (lamb_az * lamb_el**2) - 1 / lamb_az - lamb_az) * r**2 * np.sin(az) * np.sin(el) * np.cos(el) + (r**2 + var_r) * lamb_az * lamb_el**4 * np.sin(az) * np.sin(2 * el) / 2 R_cart = np.array([[r11, r12, r13], [r12, r22, r23], [r13, r23, r33]], dtype=float) else: # coverted measurement r, az = z[0], z[1] var_r, var_az = R[0, 0], R[1, 1] lamb_az = np.exp(-var_az / 2) z_cart = np.array(pol2cart(r, az), dtype=float) / lamb_az # coverted covariance r11 = (r**2 + var_r) / 2 * (1 + lamb_az**4 * np.cos(2 * az)) + (1 / lamb_az**2 - 2) * (r * np.cos(az))**2 r22 = (r**2 + var_r) / 2 * (1 - lamb_az**4 * np.cos(2 * az)) + (1 / lamb_az**2 - 2) * (r * np.sin(az))**2 r12 = (r**2 + var_r) / 2 * lamb_az**4 * np.sin(2 * az) + (1 / lamb_az**2 - 2) * r**2 * np.sin(az) * np.cos(az) R_cart = np.array([[r11, r12], [r12, r22]], dtype=float) return z_cart, R_cart def state_switch(state, type_in, type_out): dim = len(state) state = state.copy() if type_in == 'cv': axis = dim // 2 if type_out == 'cv': return state elif type_out == 'ca': ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[:, sel] stmp = np.dot(slct, state) return stmp elif type_out == 'ct': slct = np.eye(5, 4) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) stmp = np.dot(slct, state) return stmp else: raise ValueError('unknown output type: %s' % type_out) elif type_in == 'ca': axis = dim // 3 if type_out == 'cv': ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[sel] stmp = np.dot(slct, state) return stmp elif type_out == 'ca': return state elif type_out == 'ct': # ca to cv ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[sel] stmp = np.dot(slct, state) # cv to ct slct = np.eye(5, 4) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) stmp = np.dot(slct, stmp) return stmp else: raise ValueError('unknown output type: %s' % type_out) elif type_in == 'ct': axis = dim // 2 if type_out == 'cv': slct = np.eye(4, 5) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) stmp = np.dot(slct, state) return stmp elif type_out == 'ca': # ct to cv slct = np.eye(4, 5) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) stmp = np.dot(slct, state) # cv to ca ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[:, sel] stmp = np.dot(slct, stmp) return stmp elif type_out == 'ct': return state else: raise ValueError('unknown output type: %s' % type_out) else: raise ValueError('unknown input type: %s' % type_in) def cov_switch(cov, type_in, type_out): dim = len(cov) cov = cov.copy() uncertainty = 100 if type_in == 'cv': axis = dim // 2 if type_out == 'cv': return cov elif type_out == 'ca': ca_dim = 3 * axis sel_diff = range(2, ca_dim, 3) sel = np.setdiff1d(range(ca_dim), sel_diff) slct = np.eye(ca_dim)[:, sel] ctmp = slct @ cov @ slct.T ctmp[sel_diff, sel_diff] = uncertainty return ctmp elif type_out == 'ct': slct = np.eye(5, 4) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) ctmp = slct @ cov @ slct.T ctmp[4, 4] = uncertainty return ctmp else: raise ValueError('unknown output type: %s' % type_out) elif type_in == 'ca': axis = dim // 3 if type_out == 'cv': ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[sel] ctmp = slct @ cov @ slct.T return ctmp elif type_out == 'ca': return cov elif type_out == 'ct': # ca to cv ca_dim = 3 * axis sel = np.setdiff1d(range(ca_dim), range(2, ca_dim, 3)) slct = np.eye(ca_dim)[sel] ctmp = slct @ cov @ slct.T # cv to ct slct = np.eye(5, 4) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) ctmp = slct @ ctmp @ slct.T ctmp[4, 4] = uncertainty return ctmp else: raise ValueError('unknown output type: %s' % type_out) elif type_in == 'ct': axis = dim // 2 if type_out == 'cv': slct = np.eye(4, 5) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) ctmp = slct @ cov @ slct.T return ctmp elif type_out == 'ca': # ct to cv slct = np.eye(4, 5) if axis == 3: slct = lg.block_diag(slct, np.eye(2)) ctmp = slct @ cov @ slct.T # cv to ca ca_dim = 3 * axis sel_diff = range(2, ca_dim, 3) sel = np.setdiff1d(range(ca_dim), sel_diff) slct = np.eye(ca_dim)[:, sel] ctmp = slct @ ctmp @ slct.T ctmp[sel_diff, sel_diff] = uncertainty return ctmp elif type_out == 'ct': return cov else: raise ValueError('unknown output type: %s' % type_out) else: raise ValueError('unknown input type: %s' % type_in) def model_switch(x, type_in, type_out): dim = len(x) if isinstance(x, np.ndarray): if len(x.shape) == 1: state = state_switch(x, type_in, type_out) return state elif len(x.shape) == 2: cov = cov_switch(x, type_in, type_out) return cov else: raise ValueError("shape of 'x' must be 1 or 2") elif hasattr(x, '__getitem__'): state = state_switch(x[0], type_in, type_out) cov = cov_switch(x[1], type_in, type_out) return state, cov else: raise TypeError("error 'x' type: '%s'" % x.__class__.__name__) def trajectory_cv(state, interval, length, velocity): head = state.copy() dim = head.size order = 2 axis = dim // order traj_cv = np.zeros((length, dim)) vel = velocity cur_vel = head[1:dim:order] if isinstance(vel, numbers.Number): vel *= (cur_vel / lg.norm(cur_vel)) else: vel = [cur_vel[i] if vel[i] is None else vel[i] for i in range(axis)] cur_vel[:] = vel # it will also change the head head_cv = head F = F_cv(axis, interval) for i in range(length): head = np.dot(F, head) traj_cv[i] = head return traj_cv, head_cv def trajectory_ca(state, interval, length, acceleration): head = state.copy() dim = state.size order = 3 axis = dim // order traj_ca = np.zeros((length, dim)) acc = acceleration cur_vel = head[1:dim:order] cur_acc = head[2:dim:order] if isinstance(acc, numbers.Number): acc *= (cur_vel / lg.norm(cur_vel)) else: acc = [cur_acc[i] if acc[i] is None else acc[i] for i in range(axis)] cur_acc[:] = acc # it will also change the head head_ca = head F = F_ca(axis, interval) for i in range(length): head = np.dot(F, head) traj_ca[i] = head return traj_ca, head_ca def trajectory_ct(state, interval, length, turnrate, velocity=None): head = state.copy() dim = state.size order = 2 axis = dim // order traj_ct = np.zeros((length, dim)) if velocity is not None: vel = velocity cur_vel = head[1:dim:order] if isinstance(vel, numbers.Number): vel *= (cur_vel / lg.norm(cur_vel)) else: vel = [cur_vel[i] if vel[i] is None else vel[i] for i in range(axis)] cur_vel[:] = vel head_ct = head F = F_ct(axis, turnrate, interval) for i in range(length): head = np.dot(F, head) traj_ct[i] = head return traj_ct, head_ct def trajectory_generator(record): ''' record = { 'interval': [1, 1], 'start': [ [0, 0, 0], [0, 5, 0] ], 'pattern': [ [ {'model': 'cv', 'length': 100, 'velocity': [250, 250, 0]}, {'model': 'ct', 'length': 25, 'turnrate': 30} ], [ {'model': 'cv', 'length': 100, 'velocity': [250, 250, 0]}, {'model': 'ct', 'length': 30, 'turnrate': 30, 'velocity': 30} ] ], 'noise': [ 10 * np.eye(3), 10 * np.eye(3) ], 'pd': [ 0.9, 0.9 ], 'entries': 2 } ''' dim, order, axis = 9, 3, 3 ca_sel = range(dim) acc_sel = range(2, dim, order) cv_sel = np.setdiff1d(ca_sel, acc_sel) ct_sel = np.setdiff1d(ca_sel, acc_sel) insert_sel = [2, 4, 6] interval = record['interval'] start = record['start'] pattern = record['pattern'] noise = record['noise'] entries = record['entries'] trajs_state = [] for i in range(entries): head = np.kron(start[i], [1., 0., 0.]) state = np.kron(start[i], [1., 0., 0.]).reshape(1, -1) for pat in pattern[i]: if pat['model'] == 'cv': ret, head_cv = trajectory_cv(head[cv_sel], interval[i], pat['length'], pat['velocity']) ret = np.insert(ret, insert_sel, 0, axis=1) head = ret[-1, ca_sel] state[-1, acc_sel] = 0 # set the acceleration of previous state to zero state[-1, cv_sel] = head_cv # change the velocity of previous state state = np.vstack((state, ret)) elif pat['model'] == 'ca': ret, head_ca = trajectory_ca(head, interval[i], pat['length'], pat['acceleration']) head = ret[-1, ca_sel] state[-1, ca_sel] = head_ca # change the acceleartion of previous state state = np.vstack((state, ret)) elif pat['model'] == 'ct': if 'velocity' in pat: ret, head_ct = trajectory_ct(head[ct_sel], interval[i], pat['length'], pat['turnrate'], pat['velocity']) else: ret, head_ct = trajectory_ct(head[ct_sel], interval[i], pat['length'], pat['turnrate']) ret = np.insert(ret, insert_sel, 0, axis=1) head = ret[-1, ca_sel] state[-1, acc_sel] = 0 state[-1, ct_sel] = head_ct state = np.vstack((state, ret)) else: raise ValueError('invalid model') trajs_state.append(state) # add noise trajs_meas = [] for i in range(entries): H = H_ca(axis) traj_len = trajs_state[i].shape[0] noi = st.multivariate_normal.rvs(cov=noise[i], size=traj_len) trajs_meas.append(np.dot(trajs_state[i], H.T) + noi) return trajs_state, trajs_meas def trajectory_with_pd(trajs_meas, pd=0.8): for traj in trajs_meas: traj_len = traj.shape[0] remove_idx = st.uniform.rvs(size=traj_len) >= pd traj[remove_idx] = np.nan return trajs_meas def trajectory_to_meas(trajs_meas, lamb=0): trajs_num = len(trajs_meas) min_x, max_x = np.inf, -np.inf min_y, max_y = np.inf, -np.inf min_z, max_z = np.inf, -np.inf max_traj_len = 0 for traj in trajs_meas: min_x, max_x = min(min_x, traj[:, 0].min()), max(max_x, traj[:, 0].max()) min_y, max_y = min(min_y, traj[:, 1].min()), max(max_y, traj[:, 1].max()) min_z, max_z = min(min_z, traj[:, 2].min()), max(max_z, traj[:, 2].max()) max_traj_len = max(max_traj_len, len(traj)) trajs = [] for i in range(max_traj_len): tmp = [] for j in range(trajs_num): if i >= len(trajs_meas[j]) or np.any(np.isnan(trajs_meas[j][i])): continue tmp.append(trajs_meas[j][i]) clutter_num = st.poisson.rvs(lamb) for j in range(clutter_num): x = np.random.uniform(min_x, max_x) y = np.random.uniform(min_y, max_y) z = np.random.uniform(min_z, max_z) tmp.append(np.array([x, y, z], dtype=float)) tmp = np.array(tmp, dtype=float).reshape(-1, 3) trajs.append(tmp) return trajs

f2f2ed4004131258cff5093c7d766ecf35ed6781

py

Python

orders/migrations/0005_auto_20210619_0848.py

garrett-rh/Slice-of-a-Pizza

0e30e3a27b0e65e77cd52db1ef7db0470dea7a3f

2020-05-15T10:20:13.000Z

2021-04-03T12:38:37.000Z

orders/migrations/0005_auto_20210619_0848.py

garrett-rh/Slice-of-a-Pizza

0e30e3a27b0e65e77cd52db1ef7db0470dea7a3f

2020-05-15T10:39:42.000Z

2021-11-26T03:01:19.000Z

orders/migrations/0005_auto_20210619_0848.py

garrett-rh/Slice-of-a-Pizza

0e30e3a27b0e65e77cd52db1ef7db0470dea7a3f

2021-11-12T12:10:57.000Z

2021-11-12T12:10:57.000Z

# Generated by Django 3.2.4 on 2021-06-19 08:48 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('orders', '0004_auto_20210619_0847'), ] operations = [ migrations.AlterField( model_name='dinner_platters', name='Tops', field=models.ManyToManyField(related_name='DPAddons', to='orders.Topping'), ), migrations.AlterField( model_name='regular_pizza', name='toppings', field=models.ManyToManyField(blank=True, related_name='rpAddons', to='orders.Topping'), ), migrations.AlterField( model_name='sicilian_pizza', name='Tops', field=models.ManyToManyField(blank=True, related_name='spAddons', to='orders.Topping'), ), ]

f2f3e2812670f2833f39a5b2980f1ac2b7819f19

py

Python

benchbuild/engine.py

sturmianseq/benchbuild

e3cc1a24e877261e90baf781aa67a9d6f6528dac

2017-10-05T08:59:35.000Z

2021-05-29T01:43:07.000Z

benchbuild/engine.py

sturmianseq/benchbuild

e3cc1a24e877261e90baf781aa67a9d6f6528dac

2016-07-12T08:11:43.000Z

2022-03-28T07:10:11.000Z

benchbuild/engine.py

sturmianseq/benchbuild

e3cc1a24e877261e90baf781aa67a9d6f6528dac

2016-06-17T12:13:35.000Z

2022-01-04T16:09:12.000Z

""" Orchestrate experiment execution. """ import typing as tp import attr from benchbuild.experiment import Experiment from benchbuild.project import Project from benchbuild.utils import actions, tasks ExperimentCls = tp.Type[Experiment] Experiments = tp.List[ExperimentCls] ProjectCls = tp.Type[Project] Projects = tp.List[ProjectCls] ExperimentProject = tp.Tuple[ExperimentCls, ProjectCls] Actions = tp.Sequence[actions.Step] StepResults = tp.List[actions.StepResult] @attr.s class Experimentator: experiments: Experiments = attr.ib() projects: Projects = attr.ib() _plan: tp.Sequence[actions.Step] = attr.ib(init=False, default=None) def plan(self) -> Actions: if not self._plan: self._plan = tasks.generate_plan(self.experiments, self.projects) return self._plan @property def num_actions(self) -> int: p = self.plan() return sum([len(child) for child in p]) def start(self) -> StepResults: p = self.plan() # Prepare project environment. return tasks.execute_plan(p) def print_plan(self) -> None: p = self.plan() print("Number of actions to execute: {}".format(self.num_actions)) print(*p)

f2f4e04a8614d8edbaff0777a5f1c47f01d09f5f

py

Python

misc_code/fcn_loss_layer.py

kbardool/mrcnn3

f4cbb1e34de97ab08558b56fb7362647436edbd7

2018-08-07T13:56:32.000Z

2021-04-06T11:07:20.000Z

misc_code/fcn_loss_layer.py

kbardool/Contextual-Inference-V2

f4cbb1e34de97ab08558b56fb7362647436edbd7

misc_code/fcn_loss_layer.py

kbardool/Contextual-Inference-V2

f4cbb1e34de97ab08558b56fb7362647436edbd7

2019-02-01T06:52:18.000Z

2019-02-01T06:52:18.000Z

""" Mask R-CNN Dataset functions and classes. Copyright (c) 2017 Matterport, Inc. Licensed under the MIT License (see LICENSE for details) Written by Waleed Abdulla """ import numpy as np import tensorflow as tf import keras.backend as KB import keras.layers as KL import keras.initializers as KI import keras.engine as KE import mrcnn.utils as utils from mrcnn.loss import smooth_l1_loss import pprint pp = pprint.PrettyPrinter(indent=2, width=100) ##----------------------------------------------------------------------- ## FCN loss ##----------------------------------------------------------------------- def fcn_loss_graph(target_masks, pred_masks): # def fcn_loss_graph(input): # target_masks, pred_masks = input """Mask binary cross-entropy loss for the masks head. target_masks: [batch, height, width, num_classes]. pred_masks: [batch, height, width, num_classes] float32 tensor """ # Reshape for simplicity. Merge first two dimensions into one. print('\n fcn_loss_graph ' ) print(' target_masks shape :', target_masks.get_shape()) print(' pred_masks shape :', pred_masks.get_shape()) mask_shape = tf.shape(target_masks) print(' mask_shape shape :', mask_shape.shape) target_masks = KB.reshape(target_masks, (-1, mask_shape[1], mask_shape[2])) print(' target_masks shape :', target_masks.shape) pred_shape = tf.shape(pred_masks) print(' pred_shape shape :', pred_shape.shape) pred_masks = KB.reshape(pred_masks, (-1, pred_shape[1], pred_shape[2])) print(' pred_masks shape :', pred_masks.get_shape()) # Compute binary cross entropy. If no positive ROIs, then return 0. # shape: [batch, roi, num_classes] # Smooth-L1 Loss loss = KB.switch(tf.size(target_masks) > 0, smooth_l1_loss(y_true=target_masks, y_pred=pred_masks), tf.constant(0.0)) loss = KB.mean(loss) loss = KB.reshape(loss, [1, 1]) print(' loss type is :', type(loss)) return loss ##----------------------------------------------------------------------- ## FCN loss for L2 Normalized graph ##----------------------------------------------------------------------- def fcn_norm_loss_graph(target_masks, pred_masks): ''' Mask binary cross-entropy loss for the masks head. target_masks: [batch, height, width, num_classes]. pred_masks: [batch, height, width, num_classes] float32 tensor ''' print(type(target_masks)) pp.pprint(dir(target_masks)) # Reshape for simplicity. Merge first two dimensions into one. print('\n fcn_norm_loss_graph ' ) print(' target_masks shape :', target_masks.shape) print(' pred_masks shape :', pred_masks.shape) print('\n L2 normalization ------------------------------------------------------') output_shape=KB.int_shape(pred_masks) print(' output shape is :' , output_shape, ' ', pred_masks.get_shape(), pred_masks.shape, tf.shape(pred_masks)) output_flatten = KB.reshape(pred_masks, (pred_masks.shape[0], -1, pred_masks.shape[-1]) ) output_norm1 = KB.l2_normalize(output_flatten, axis = 1) output_norm = KB.reshape(output_norm1, KB.shape(pred_masks) ) print(' output_flatten : ', KB.int_shape(output_flatten) , ' Keras tensor ', KB.is_keras_tensor(output_flatten) ) print(' output_norm1 : ', KB.int_shape(output_norm1) , ' Keras tensor ', KB.is_keras_tensor(output_norm1) ) print(' output_norm final : ', KB.int_shape(output_norm) , ' Keras tensor ', KB.is_keras_tensor(output_norm) ) pred_masks1 = output_norm print('\n L2 normalization ------------------------------------------------------') gauss_flatten = KB.reshape(target_masks, (target_masks.shape[0], -1, target_masks.shape[-1]) ) gauss_norm1 = KB.l2_normalize(gauss_flatten, axis = 1) gauss_norm = KB.reshape(gauss_norm1, KB.shape(target_masks)) print(' guass_flatten : ', KB.int_shape(gauss_flatten), 'Keras tensor ', KB.is_keras_tensor(gauss_flatten) ) print(' gauss_norm shape : ', KB.int_shape(gauss_norm1) , 'Keras tensor ', KB.is_keras_tensor(gauss_norm1) ) print(' gauss_norm final shape: ', KB.int_shape(gauss_norm) , 'Keras tensor ', KB.is_keras_tensor(gauss_norm) ) print(' complete') target_masks1 = gauss_norm mask_shape = tf.shape(target_masks1) print(' mask_shape shape :', mask_shape.shape) target_masks1 = KB.reshape(target_masks1, (-1, mask_shape[1], mask_shape[2])) print(' target_masks shape :', target_masks1.shape) pred_shape = tf.shape(pred_masks1) print(' pred_shape shape :', pred_shape.shape) pred_masks1 = KB.reshape(pred_masks1, (-1, pred_shape[1], pred_shape[2])) print(' pred_masks shape :', pred_masks1.get_shape()) # Compute binary cross entropy. If no positive ROIs, then return 0. # shape: [batch, roi, num_classes] # Smooth-L1 Loss loss = KB.switch(tf.size(target_masks1) > 0, smooth_l1_loss(y_true=target_masks1, y_pred=pred_masks1), tf.constant(0.0)) loss = KB.mean(loss) loss = KB.reshape(loss, [1, 1]) print(' loss type is :', type(loss)) return loss class FCNLossLayer(KE.Layer): """ Returns: ------- """ def __init__(self, config=None, **kwargs): super().__init__(**kwargs) print('>>> FCN Loss Layer : initialization') self.config = config def call(self, inputs): print('\n FCN Loss Layer : call') print(' target_masks .shape/type :', inputs[0].shape) # , type(inputs[0])) print(' pred_masks shape/type :', inputs[1].shape) # , type(inputs[1])) target_masks = inputs[0] pred_masks = inputs[1] loss = KB.placeholder(shape=(1), dtype = 'float32', name = 'fcn_loss') norm_loss = KB.placeholder(shape=(1), dtype = 'float32', name = 'fcn_norm_loss') loss = fcn_loss_graph(target_masks, pred_masks) norm_loss = fcn_norm_loss_graph(target_masks, pred_masks) return [loss, norm_loss] def compute_output_shape(self, input_shape): # may need to change dimensions of first return from IMAGE_SHAPE to MAX_DIM return [(1), (1)]

f2f6b4c27e7561e29dbb147f768e0c58a7d09bb7

py

Python

mysticbit/plots.py

Connossor/mystic-bit

f57f471d3d154560d23bc9eff17fd5b8f284684c

2018-11-23T20:13:53.000Z

2019-02-25T15:54:55.000Z

mysticbit/plots.py

Connossor/mystic-bit

f57f471d3d154560d23bc9eff17fd5b8f284684c

mysticbit/plots.py

Connossor/mystic-bit

f57f471d3d154560d23bc9eff17fd5b8f284684c

2018-11-23T20:55:44.000Z

2021-12-20T17:25:24.000Z

import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns def plot_well_map(df_logs, fig_size=(10, 10)): """ Simple map of locations of nearby wells """ f, ax = plt.subplots(figsize=fig_size) df = df_logs.drop_duplicates(subset=['HACKANAME', 'X', 'Y']) plt.scatter(df['X'], df['Y']) plt.axis('scaled') for label, x, y in zip(df['HACKANAME'], df['X'], df['Y']): plt.annotate(label, xy=(x, y), xytext=(-10, 10), textcoords='offset points') return f, ax def make_log_plot(df_logs, well_name, cols=['GR', 'DT', 'CALI'], ztop=None, zbot=None, fig_size=(8, 12)): """ Single well log plot, both GR and Resistivity """ logs = df_logs[df_logs['HACKANAME'] == well_name] logs = logs.sort_values(by='TVDSS') if not ztop: ztop = logs.TVDSS.min() if not zbot: zbot = logs.TVDSS.max() f, ax = plt.subplots(nrows=1, ncols=len(cols), figsize=fig_size) for i in range(len(ax)): log_name = cols[i] ax[i].scatter(logs[log_name], logs['TVDSS'], marker='+') ax[i].set_xlabel(log_name) ax[i].set_ylim(ztop, zbot) ax[i].invert_yaxis() ax[i].grid() ax[i].locator_params(axis='x', nbins=3) if i > 0: ax[i].set_yticklabels([]) # ax[0].set_xlabel("GR") # ax[0].set_xlim(0, 150) # ax[1].set_xlabel("RESD") # ax[1].set_xscale('log') # ax[1].set_xlim(0.2, 2000) # ax[1].set_yticklabels([]) f.suptitle('Well: {}'.format(well_name), fontsize=14, y=0.94) return f, ax def add_predictions(ax, predictions): """ Add predicted bands onto plt axes""" # Scatter plot ax.scatter(predictions['value'], predictions['TVDSS'], marker='+') # Shaded bands tvds = predictions[predictions.model_name == 'high']['TVDSS'] x_hi = predictions[predictions.model_name == 'high']['value'] x_lo = predictions[predictions.model_name == 'low']['value'] ax.fill(np.concatenate([x_lo, x_hi[::-1]]), np.concatenate([tvds, tvds[::-1]]), alpha=0.5)

f2f8aa778931cc06d7071bcf8a708498a3154677

py

Python

cc_plugin_eustace/eustace_global_attrs.py

eustace-data/cc-plugin-eustace

4b44d287433b632ea6f859cd72d5dd4b8c361cee

cc_plugin_eustace/eustace_global_attrs.py

eustace-data/cc-plugin-eustace

4b44d287433b632ea6f859cd72d5dd4b8c361cee

cc_plugin_eustace/eustace_global_attrs.py

eustace-data/cc-plugin-eustace

4b44d287433b632ea6f859cd72d5dd4b8c361cee

#!/usr/bin/env python """ cc_plugin_eustace.eustace_global_attrs Compliance Test Suite: Check core global attributes in EUSTACE files """ import os from netCDF4 import Dataset # Import base objects from compliance checker from compliance_checker.base import Result, BaseNCCheck, GenericFile # Restrict which vocabs will load (for efficiency) os.environ["ESSV_VOCABS_ACTIVE"] = "eustace-team" # Import checklib import checklib.register.nc_file_checks_register as check_package class EUSTACEGlobalAttrsCheck(BaseNCCheck): register_checker = True name = 'eustace-global-attrs' _cc_spec = 'eustace-global-attrs' _cc_spec_version = '0.2' supported_ds = [GenericFile, Dataset] _cc_display_headers = { 3: 'Required', 2: 'Recommended', 1: 'Suggested' } def setup(self, ds): pass def check_cr01(self, ds): return check_package.ValidGlobalAttrsMatchFileNameCheck(kwargs={'delimiter': '_', 'order': 'institution_id,realm,frequency', 'extension': '.nc'}, level="HIGH", vocabulary_ref="eustace-team:eustace")(ds) def check_cr02(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': 'CF-1\\.6', 'attribute': 'Conventions'}, level="HIGH", vocabulary_ref="")(ds) def check_cr03(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'source'}, level="HIGH", vocabulary_ref="")(ds) def check_cr04(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': 'EUSTACE', 'attribute': 'project_id'}, level="HIGH", vocabulary_ref="")(ds) def check_cr05(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'contact'}, level="HIGH", vocabulary_ref="")(ds) def check_cr06(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'history'}, level="MEDIUM", vocabulary_ref="")(ds) def check_cr07(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'references'}, level="MEDIUM", vocabulary_ref="")(ds) def check_cr08(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{1,}', 'attribute': 'product_version'}, level="HIGH", vocabulary_ref="")(ds) def check_cr09(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'title'}, level="HIGH", vocabulary_ref="")(ds) def check_cr10(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{20,}', 'attribute': 'summary'}, level="HIGH", vocabulary_ref="")(ds) def check_cr11(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.{4,}', 'attribute': 'creator_name'}, level="HIGH", vocabulary_ref="")(ds) def check_cr12(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '.+@.+\\..+', 'attribute': 'creator_email'}, level="HIGH", vocabulary_ref="")(ds) def check_cr13(self, ds): return check_package.GlobalAttrVocabCheck(kwargs={'attribute': 'frequency', 'vocab_lookup': 'canonical_name'}, level="LOW", vocabulary_ref="eustace-team:eustace")(ds) def check_cr14(self, ds): return check_package.GlobalAttrVocabCheck(kwargs={'attribute': 'institution_id', 'vocab_lookup': 'canonical_name'}, level="HIGH", vocabulary_ref="eustace-team:eustace")(ds) def check_cr15(self, ds): return check_package.GlobalAttrRegexCheck(kwargs={'regex': '\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}.*', 'attribute': 'creation_date'}, level="MEDIUM", vocabulary_ref="")(ds)

f2fc68a089e1541439b963f873f1136d0c533af5

py

Python

final_project/machinetranslation/tests/tests.py

NicoFRizzo/xzceb-flask_eng_fr

71c8a4c970e7a179f496ff0960d5fae2bba0ffc1

final_project/machinetranslation/tests/tests.py

NicoFRizzo/xzceb-flask_eng_fr

71c8a4c970e7a179f496ff0960d5fae2bba0ffc1

final_project/machinetranslation/tests/tests.py

NicoFRizzo/xzceb-flask_eng_fr

71c8a4c970e7a179f496ff0960d5fae2bba0ffc1

import unittest import translator class TestTranslator(unittest.TestCase): def test_one_e2f(self): respopnse = translator.english_to_french('IBM Translator') self.assertEqual(respopnse, 'Traducteur IBM') def test_un_f2e(self): respopnse = translator.french_to_english('Traducteur IBM') self.assertEqual(respopnse, 'IBM Translator') def test_hello_2f(self): respopnse = translator.english_to_french('Hello') self.assertEqual(respopnse, 'Bonjour') def test_bonjour_2e(self): respopnse = translator.french_to_english('Bonjour') self.assertEqual(respopnse, 'Hello') if __name__ == "__main__": unittest.main()

f2fc8f6f95ceeb8cf32d3eeed59de008b87d73f7

py

Python

src/appi/oop/classes/class_attributes.py

Kaju-Bubanja/APPI

011afc872a0055ff56001547be6da73017042ad5

src/appi/oop/classes/class_attributes.py

Kaju-Bubanja/APPI

011afc872a0055ff56001547be6da73017042ad5

src/appi/oop/classes/class_attributes.py

Kaju-Bubanja/APPI

011afc872a0055ff56001547be6da73017042ad5

class Student: # class variables school_name = 'ABC School' # constructor def __init__(self, name, age): # instance variables self.name = name self.age = age s1 = Student("Harry", 12) # access instance variables print('Student:', s1.name, s1.age) # access class variable print('School name:', Student.school_name) # Modify instance variables s1.name = 'Jessa' s1.age = 14 print('Student:', s1.name, s1.age) # Modify class variables Student.school_name = 'XYZ School' print('School name:', Student.school_name)

f2fea27459e59001e49be2e7ed0478672dee266a

py

Python

clamor/rest/endpoints/__init__.py

TomSputz/Clamor

13222b90532938e6ebdbe8aea0430512e7d22817

2019-07-05T20:26:18.000Z

2020-09-18T12:44:16.000Z

clamor/rest/endpoints/__init__.py

TomSputz/Clamor

13222b90532938e6ebdbe8aea0430512e7d22817

2019-07-07T19:55:07.000Z

2019-08-20T22:07:31.000Z

clamor/rest/endpoints/__init__.py

TomSputz/Clamor

13222b90532938e6ebdbe8aea0430512e7d22817

2019-07-07T20:39:29.000Z

2020-11-06T10:12:20.000Z

# -*- coding: utf-8 -*- from . import base from .audit_log import * from .channel import * from .emoji import * from .gateway import * from .guild import * from .invite import * from .oauth import * from .user import * from .voice import * from .webhook import *

f2feb8df0aea648f82fd8f4f86ab95ad219d052f

py

Python

hamster2pdf.py

vleg1991/hamster2pdf

1dda22a39b65a0f24b76d278f3d708ac51d3c262

hamster2pdf.py

vleg1991/hamster2pdf

1dda22a39b65a0f24b76d278f3d708ac51d3c262

hamster2pdf.py

vleg1991/hamster2pdf

1dda22a39b65a0f24b76d278f3d708ac51d3c262

#!/usr/bin/python # -*- coding: utf-8 -*- import os import datetime import hamster.client import reports import argparse import pdfkit import gettext gettext.install('brainz', '../datas/translations/') # custom settings: reportTitle = "My Activities Report" activityFilter = "unfiled" def valid_date(s): try: return datetime.datetime.strptime(s, "%Y-%m-%d").date() except ValueError: msg = "Not a valid date: '{0}'.".format(s) raise argparse.ArgumentTypeError(msg) # find dates: today = datetime.date.today() first = today.replace(day=1) previousLast = first - datetime.timedelta(days=1) previousFirst = previousLast.replace(day=1) # assign arguments: parser = argparse.ArgumentParser(description="export the hamster database to pdf") parser.add_argument("--thismonth", action="store_true", help="export this month's records") parser.add_argument("--lastmonth", action="store_true", help="export last month's records") parser.add_argument("-s", dest="startDate", default=today, help="start date (default: today)", type=valid_date) parser.add_argument("-e", dest="endDate", default=today, help="end date (default: today)", type=valid_date) parser.add_argument("-o", dest="reportFile", default="report.pdf", help="output file (default: report.pdf)") # parse arguments: args = parser.parse_args() if args.thismonth: args.startDate = first args.endDate = today if args.lastmonth: args.startDate = previousFirst args.endDate = previousLast # prepare filenames: htmlFilename = os.path.splitext(args.reportFile)[0]+".html" pdfFilename = os.path.splitext(args.reportFile)[0]+".pdf" storage = hamster.client.Storage() facts = storage.get_facts(args.startDate, args.endDate) # generate report reports.simple(facts, args.startDate, args.endDate, htmlFilename) # convert .html to .pdf file: pdfkit.from_file(htmlFilename, pdfFilename)

f2ff24739f7d32b20b931df9776f794aac82539a

py

Python

SingleTon.py

SuperLeis/meituan

71d521826bc50cb8e7bee5617f84e2c26dce1394

2020-05-02T14:30:18.000Z

2020-05-02T14:30:18.000Z

SingleTon.py

SuperLeis/meituan

71d521826bc50cb8e7bee5617f84e2c26dce1394

SingleTon.py

SuperLeis/meituan

71d521826bc50cb8e7bee5617f84e2c26dce1394

from functools import wraps # created by PL # git hello world def single_ton(cls): _instance = {} @wraps(cls) def single(*args, **kwargs): if cls not in _instance: _instance[cls] = cls(*args, **kwargs) return _instance[cls] return single @single_ton class SingleTon(object): val = 123 def __init__(self, a): self.a = a if __name__ == '__main__': s = SingleTon(1) t = SingleTon(2) print (s is t) print (s.a, t.a) print (s.val, t.val) print ('test') print ("git test")

840025939ea1c2adbcc0cc3524f18c7230eb6fad

py

Python

exercicios-python/ex031.py

anavesilva/python-introduction

d85fb9381e348262584fd2942e4818ee822adbe5

exercicios-python/ex031.py

anavesilva/python-introduction

d85fb9381e348262584fd2942e4818ee822adbe5

exercicios-python/ex031.py

anavesilva/python-introduction

d85fb9381e348262584fd2942e4818ee822adbe5

# Custo da viagem distancia = float(input('Qual a distância da sua viagem? ')) valor1 = distancia * 0.5 valor2 = distancia * 0.45 print('Você está prestes a começar uma viagem de {}Km/h.'.format(distancia)) if distancia <= 200: print('O preço de sua passagem será de R${:.2f}.'.format(valor1)) else: print('O preço de sua passagem será de R${:.2f}.'.format(valor2))

8401761cbdcacb5f4d5eb5531d513247beb5261b

py

Python

datatest/differences.py

ajhynes7/datatest

78742e98de992807286655f5685a2dc33a7b452e

2016-05-12T13:22:49.000Z

2022-03-11T00:18:32.000Z

datatest/differences.py

ajhynes7/datatest

78742e98de992807286655f5685a2dc33a7b452e

2016-05-18T01:03:32.000Z

2022-02-17T13:48:43.000Z

datatest/differences.py

ajhynes7/datatest

78742e98de992807286655f5685a2dc33a7b452e

2016-05-22T11:35:19.000Z

2021-12-01T19:41:42.000Z

"""Difference classes.""" __all__ = [ 'BaseDifference', 'Missing', 'Extra', 'Invalid', 'Deviation', ] from cmath import isnan from datetime import timedelta from ._compatibility.builtins import * from ._compatibility import abc from ._compatibility.contextlib import suppress from ._utils import _make_token from ._utils import pretty_timedelta_repr NOVALUE = _make_token( 'NoValueType', '<no value>', 'Token to mark when a value does not exist.', truthy=False, ) NANTOKEN = _make_token( 'NanTokenType', '<nan token>', 'Token for comparing differences that contain not-a-number values.', ) def _nan_to_token(value): """Return NANTOKEN if *value* is NaN else return value unchanged.""" def func(x): with suppress(TypeError): if isnan(x): return NANTOKEN return x if isinstance(value, tuple): return tuple(func(x) for x in value) return func(value) def _safe_isnan(x): """Wrapper for isnan() so it won't fail on non-numeric values.""" try: return isnan(x) except TypeError: return False class BaseDifference(abc.ABC): """The base class for "difference" objects---all other difference classes are derived from this base. """ __slots__ = () @property @abc.abstractmethod def args(self): """The tuple of arguments given to the difference constructor. Some difference (like :class:`Deviation`) expect a certain number of arguments and assign a special meaning to the elements of this tuple, while others are called with only a single value. """ # Concrete method should return tuple of args used in __init__(). raise NotImplementedError def __eq__(self, other): if self.__class__ != other.__class__: return False self_args = tuple(_nan_to_token(x) for x in self.args) other_args = tuple(_nan_to_token(x) for x in other.args) return self_args == other_args def __ne__(self, other): # <- For Python 2.x support. There is return not self.__eq__(other) # no implicit relationship between # __eq__() and __ne__() in Python 2. def __hash__(self): try: return hash((self.__class__, self.args)) except TypeError as err: msg = '{0} in args tuple {1!r}'.format(str(err), self.args) hashfail = TypeError(msg) hashfail.__cause__ = getattr(err, '__cause__', None) # getattr for 2.x support raise hashfail def __repr__(self): cls_name = self.__class__.__name__ args_repr = ', '.join( getattr(x, '__name__', repr(x)) for x in self.args) return '{0}({1})'.format(cls_name, args_repr) class Missing(BaseDifference): """Created when *value* is missing from the data under test. In the following example, the required value ``'A'`` is missing from the data under test:: data = ['B', 'C'] requirement = {'A', 'B', 'C'} datatest.validate(data, requirement) Running this example raises the following error: .. code-block:: none :emphasize-lines: 2 ValidationError: does not satisfy set membership (1 difference): [ Missing('A'), ] """ __slots__ = ('_args',) def __init__(self, value): self._args = (value,) @property def args(self): return self._args class Extra(BaseDifference): """Created when *value* is unexpectedly found in the data under test. In the following example, the value ``'C'`` is found in the data under test but it's not part of the required values:: data = ['A', 'B', 'C'] requirement = {'A', 'B'} datatest.validate(data, requirement) Running this example raises the following error: .. code-block:: none :emphasize-lines: 2 ValidationError: does not satisfy set membership (1 difference): [ Extra('C'), ] """ __slots__ = ('_args',) def __init__(self, value): self._args = (value,) @property def args(self): return self._args class Invalid(BaseDifference): """Created when a value does not satisfy a function, equality, or regular expression requirement. In the following example, the value ``9`` does not satisfy the required function:: data = [2, 4, 6, 9] def is_even(x): return x % 2 == 0 datatest.validate(data, is_even) Running this example raises the following error: .. code-block:: none :emphasize-lines: 2 ValidationError: does not satisfy is_even() (1 difference): [ Invalid(9), ] """ __slots__ = ('_invalid', '_expected') def __init__(self, invalid, expected=NOVALUE): try: is_equal = invalid == expected except TypeError: is_equal = False if is_equal: msg = 'expects unequal values, got {0!r} and {1!r}' raise ValueError(msg.format(invalid, expected)) self._invalid = invalid self._expected = expected @property def args(self): if self._expected is NOVALUE: return (self._invalid,) return (self._invalid, self._expected) @property def invalid(self): """The invalid value under test.""" return self._invalid @property def expected(self): """The expected value (optional).""" return self._expected def __repr__(self): cls_name = self.__class__.__name__ invalid_repr = getattr(self._invalid, '__name__', repr(self._invalid)) if self._expected is not NOVALUE: expected_repr = ', expected={0}'.format( getattr(self._expected, '__name__', repr(self._expected))) else: expected_repr = '' return '{0}({1}{2})'.format(cls_name, invalid_repr, expected_repr) def _slice_datetime_repr_prefix(obj_repr): """Takes a default "datetime", "date", or "timedelta" repr and returns it with the module prefix sliced-off:: >>> _slice_datetime_repr_prefix('datetime.date(2020, 12, 25)') 'date(2020, 12, 25)' """ # The following implementation (using "startswith" and "[9:]") # may look clumsy but it can run up to 10 times faster than a # more concise "re.compile()" and "regex.sub()" approach. In # some situations, this function can get called many, many # times. DON'T GET CLEVER--KEEP THIS FUNCTION FAST. if obj_repr.startswith('datetime.datetime(') \ or obj_repr.startswith('datetime.date(') \ or obj_repr.startswith('datetime.timedelta('): return obj_repr[9:] return obj_repr class Deviation(BaseDifference): """Created when a quantative value deviates from its expected value. In the following example, the dictionary item ``'C': 33`` does not satisfy the required item ``'C': 30``:: data = {'A': 10, 'B': 20, 'C': 33} requirement = {'A': 10, 'B': 20, 'C': 30} datatest.validate(data, requirement) Running this example raises the following error: .. code-block:: none :emphasize-lines: 2 ValidationError: does not satisfy mapping requirement (1 difference): { 'C': Deviation(+3, 30), } """ __slots__ = ('_deviation', '_expected') def __init__(self, deviation, expected): try: if deviation + expected == expected: msg = 'deviation quantity must not be empty, got {0!r}' exc = ValueError(msg.format(deviation)) raise exc except TypeError: msg = ('Deviation arguments must be quantitative, ' 'got deviation={0!r}, expected={1!r}') exc = TypeError(msg.format(deviation, expected)) exc.__cause__ = None raise exc self._deviation = deviation self._expected = expected @property def args(self): return (self._deviation, self._expected) @property def deviation(self): """Quantative deviation from expected value.""" return self._deviation @property def expected(self): """The expected value.""" return self._expected def __repr__(self): cls_name = self.__class__.__name__ deviation = self._deviation if _safe_isnan(deviation): deviation_repr = "float('nan')" elif isinstance(deviation, timedelta): deviation_repr = pretty_timedelta_repr(deviation) else: try: deviation_repr = '{0:+}'.format(deviation) # Apply +/- sign except (TypeError, ValueError): deviation_repr = repr(deviation) expected = self._expected if _safe_isnan(expected): expected_repr = "float('nan')" else: expected_repr = repr(expected) if expected_repr.startswith('datetime.'): expected_repr = _slice_datetime_repr_prefix(expected_repr) return '{0}({1}, {2})'.format(cls_name, deviation_repr, expected_repr) def _make_difference(actual, expected, show_expected=True): """Returns an appropriate difference for *actual* and *expected* values that are known to be unequal. Setting *show_expected* to False, signals that the *expected* argument should be omitted when creating an Invalid difference (this is useful for reducing duplication when validating data against a single function or object). """ if actual is NOVALUE: return Missing(expected) if expected is NOVALUE: return Extra(actual) if isinstance(expected, bool) or isinstance(actual, bool): if show_expected: return Invalid(actual, expected) return Invalid(actual) try: deviation = actual - expected return Deviation(deviation, expected) except (TypeError, ValueError): if show_expected: return Invalid(actual, expected) return Invalid(actual)

8401c1577e1e3475bf83b16d801193d6422761d2

py

Python

dashboard/urls.py

playfulMIT/kimchi

66802cc333770932a8c8b1a44ea5d235d916a8f1

dashboard/urls.py

playfulMIT/kimchi

66802cc333770932a8c8b1a44ea5d235d916a8f1

2019-12-10T19:40:27.000Z

2022-02-10T11:51:06.000Z

dashboard/urls.py

playfulMIT/kimchi

66802cc333770932a8c8b1a44ea5d235d916a8f1

from django.conf.urls import include, url, re_path from rest_framework import routers from . import views urlpatterns = [ re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/versiontime", views.get_last_processed_time), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/players", views.get_player_list), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/sessions", views.get_player_to_session_map), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/puzzles", views.get_puzzles), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/puzzlekeys", views.get_puzzle_keys), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/snapshotsperpuzzle", views.get_snapshot_metrics), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/attempted", views.get_attempted_puzzles), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/completed", views.get_completed_puzzles), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/timeperpuzzle", views.get_time_per_puzzle), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/funnelperpuzzle", views.get_funnel_per_puzzle), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/shapesperpuzzle", views.get_shapes_per_puzzle), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/modesperpuzzle", views.get_modes_per_puzzle), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/levelsofactivity", views.get_levels_of_activity), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/sequencebetweenpuzzles", views.get_sequence_between_puzzles), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/mloutliers", views.get_machine_learning_outliers), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/persistence", views.get_persistence_by_attempt_data), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/puzzlepersistence", views.get_persistence_by_puzzle_data), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/insights", views.get_insights), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/difficulty", views.get_puzzle_difficulty_mapping), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/misconceptions", views.get_misconceptions_data), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/competency", views.get_competency_data), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/report/(?P<start>[0-9]+)/(?P<end>[0-9]+)", views.get_report_summary), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/report", views.get_report_summary), re_path(r"^api/dashboard/(?P<slug>[a-zA-Z0-9-_]+)/(?P<player>[a-zA-Z0-9-_.]+)/(?P<level>[a-zA-Z0-9-_.]+)/replayurls", views.get_replay_urls), re_path(r"^(?P<slug>[a-zA-Z0-9-_]+)/dashboard/", views.dashboard), re_path(r"^(?P<slug>[a-zA-Z0-9-_]+)/thesisdashboard/", views.thesis_dashboard) ]

8403354322f3d276144123191c8e910a521e71d2

py

Python

VQ2D/vq2d/baselines/predictor.py

emulhall/episodic-memory

27bafec6e09c108f0efe5ac899eabde9d1ac40cc

2021-10-16T02:39:17.000Z

2022-03-31T11:16:11.000Z

VQ2D/vq2d/baselines/predictor.py

emulhall/episodic-memory

27bafec6e09c108f0efe5ac899eabde9d1ac40cc

2022-03-23T04:53:36.000Z

2022-03-29T23:39:07.000Z

VQ2D/vq2d/baselines/predictor.py

emulhall/episodic-memory

27bafec6e09c108f0efe5ac899eabde9d1ac40cc

2021-11-25T19:17:29.000Z

2022-03-25T14:01:47.000Z

from typing import Any, Dict, List, Sequence import numpy as np import torch from detectron2.engine import DefaultPredictor class SiamPredictor(DefaultPredictor): def __call__( self, original_images: Sequence[np.ndarray], visual_crops: Sequence[np.ndarray], ) -> List[Dict[str, Any]]: """ Args: original_images (np.ndarray): a list of images of shape (H, W, C) (in BGR order). visual_crops (np.ndarray): a list of images of shape (H, W, C) (in BGR order) Returns: predictions (list[dict]): the output of the model for a list of images. See :doc:`/tutorials/models` for details about the format. """ with torch.no_grad(): # https://github.com/sphinx-doc/sphinx/issues/4258 # Apply pre-processing to image. inputs = [] for original_image, visual_crop in zip(original_images, visual_crops): if self.input_format == "RGB": # whether the model expects BGR inputs or RGB original_image = original_image[:, :, ::-1] visual_crop = visual_crop[:, :, ::-1] height, width = original_image.shape[:2] image = self.aug.get_transform(original_image).apply_image( original_image ) image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1)) reference = torch.as_tensor( visual_crop.astype("float32").transpose(2, 0, 1) ) inputs.append( { "image": image, "height": height, "width": width, "reference": reference, } ) predictions = self.model(inputs) return predictions