max_stars_repo_path
stringlengths
3
269
max_stars_repo_name
stringlengths
4
119
max_stars_count
int64
0
191k
id
stringlengths
1
7
content
stringlengths
6
1.05M
score
float64
0.23
5.13
int_score
int64
0
5
src/ftd/history.py
FabienTaxil/ftd
3
12788551
<reponame>FabienTaxil/ftd """History related utilities.""" import contextlib import functools import logging import sys import trace from maya import cmds from maya.api import OpenMaya __all__ = ["repeat", "undo", "undo_chunk", "undo_repeat", "traceit"] LOG = logging.getLogger(__name__) def repeat(func): """Decorate a function to make it repeatable. This means that in maya, when the shortcut ``ctrl+G`` is triggered, the decorate function will be executed again. """ @functools.wraps(func) def _wrapper(*args, **kwargs): # Store a partial version on the module variables so that it # can be executed later when the repeat action will be triggered. globals()["_callback"] = functools.partial(func, *args, **kwargs) # find the code to execute to call the function previously stored command = "_callback()" if __name__ != "__main__": command = "import {0};{0}.{1}".format(__name__, command) # Ddd the function to the repeat system of maya cmds.repeatLast( addCommandLabel="{f.__module__}.{f.__name__}".format(f=func), # The `addCommand` flag only accepts mel code :/ addCommand='python("{}")'.format(command), ) return func(*args, **kwargs) return _wrapper def undo(func): """The decorator version of the context manager :func:`ftd.context.undo`. The chunk will be named by the python path of the function e.g. ``ftd.interaction.undo``. See the context manager documentation for more information. """ @functools.wraps(func) def _wrapper(*args, **kwargs): with undo_chunk("{f.__module__}.{f.__name__}".format(f=func)): return func(*args, **kwargs) return _wrapper def undo_repeat(func): """Combine :func:`undo` and :func:`repeat` decorators.""" return repeat(undo(func)) @contextlib.contextmanager def undo_chunk(name=None): """Gather all the maya commands under the same undo chunk. Using the maya :func:`cmds.undoInfo` command to create the chunk can be dangerous if used incorrectly. If a chunk is opened but never closed (e.g. an error occurs during execution), the maya undo list may be corrupted, and some features may not work properly. This context manager will handle the issue and like the :func:`open` function, will ensure that the chunk is properly close whatever happen during the execution of the body. Examples: First, the default behaviour of Maya. When the undo is performed, the last node created is correctly undone, but the first one still exists in the scene: >>> from maya import cmds >>> _ = cmds.file(new=True, force=True) >>> _ = cmds.createNode("transform", name="A") >>> _ = cmds.createNode("transform", name="B") >>> cmds.undo() >>> cmds.objExists("B") False >>> cmds.objExists("A") True The undo chunk allows a block of commands to be collected within the same undo chunk which can be undo at once: >>> _ = cmds.file(new=True, force=True) >>> with undo_chunk(name="create_transform"): ... _ = cmds.createNode("transform", name="A") ... _ = cmds.createNode("transform", name="B") >>> cmds.undoInfo(query=True, undoName=True) 'create_transform' >>> cmds.undo() >>> cmds.objExists("B") False >>> cmds.objExists("A") False Arguments: name (str): The name with which the chunk can be identified. """ try: cmds.undoInfo(chunkName=name, openChunk=True) yield finally: cmds.undoInfo(chunkName=name, closeChunk=True) def traceit(func, path): """Trace the execution of the given function and make a report. Arguments: func (function): The function to execute and trace. path (str): The filepath where the report will be saved. """ stdin = sys.stdin stdout = sys.stdout with open(path, "w") as stream: sys.stdin = stream sys.stdout = stream try: tracer = trace.Trace(count=False, trace=True) tracer.runfunc(func) finally: sys.stdin = stdin sys.stdout = stdout
2.4375
2
holobot/discord/sdk/servers/models/member_data.py
rexor12/holobot
1
12788552
from dataclasses import dataclass from typing import Optional @dataclass class MemberData: user_id: str avatar_url: str name: str nick_name: Optional[str] @property def display_name(self) -> str: return self.nick_name if self.nick_name else self.name
3.03125
3
python/pyutils/pyutils/terminal_color.py
ASMlover/study
22
12788553
<reponame>ASMlover/study #!/usr/bin/env python # -*- coding: UTF-8 -*- # # Copyright (c) 2018 ASMlover. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # * Redistributions of source code must retain the above copyright # notice, this list ofconditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materialsprovided with the # distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. import ctypes import platform import sys __WINDOWS_PLATFORM = platform.system() == 'Windows' if __WINDOWS_PLATFORM: __STD_INPUTHANDLE = -10 __STD_OUTPUTHANDLE = -11 __STD_ERRORHANDLE = -12 __FOREGROUND_INTENSITY = 0x08 __FOREGROUND_BLUE = 0x01 __FOREGROUND_GREEN = 0x02 __FOREGROUND_RED = 0x04 __FOREGROUND_YELLOW = 0x06 __FOREGROUND_LIGHTBLUE = __FOREGROUND_BLUE | __FOREGROUND_INTENSITY __FOREGROUND_LIGHTGREEN = __FOREGROUND_GREEN | __FOREGROUND_INTENSITY __FOREGROUND_LIGHTRED = __FOREGROUND_RED | __FOREGROUND_INTENSITY __FOREGROUND_LIGHTYELLOW = __FOREGROUND_YELLOW | __FOREGROUND_INTENSITY __stdout_handle = ctypes.windll.kernel32.GetStdHandle(__STD_OUTPUTHANDLE) def __set_terminal_color(c, h=__stdout_handle): return ctypes.windll.kernel32.SetConsoleTextAttribute(h, c) def __reset_ternimal_color(): __set_terminal_color(__FOREGROUND_RED | __FOREGROUND_GREEN | __FOREGROUND_BLUE) def color_print(msg, c): __set_terminal_color(c) sys.stdout.write(msg + '\n') __reset_ternimal_color() else: __FOREGROUND_RESET = '\033[0m' __FOREGROUND_BLUE = '\033[34m' __FOREGROUND_GREEN = '\033[32m' __FOREGROUND_RED = '\033[31m' __FOREGROUND_YELLOW = '\033[33m' __FOREGROUND_LIGHTBLUE = '\033[94m' __FOREGROUND_LIGHTGREEN = '\033[92m' __FOREGROUND_LIGHTRED = '\033[91m' __FOREGROUND_LIGHTYELLOW = '\033[93m' def color_print(msg, c): sys.stdout.write(c) sys.stdout.write(msg + '\n') sys.stdout.write(__FOREGROUND_RESET) if __name__ == '__main__': color_print("Hello, world!", __FOREGROUND_RED) color_print("Hello, world!", __FOREGROUND_GREEN) color_print("Hello, world!", __FOREGROUND_BLUE) color_print("Hello, world!", __FOREGROUND_YELLOW) color_print("Hello, world!", __FOREGROUND_LIGHTRED) color_print("Hello, world!", __FOREGROUND_LIGHTGREEN) color_print("Hello, world!", __FOREGROUND_LIGHTBLUE) color_print("Hello, world!", __FOREGROUND_LIGHTYELLOW)
1.148438
1
Dynamic Programming/741. Cherry Pickup.py
beckswu/Leetcode
138
12788554
""" 741. Cherry Pickup """ class Solution: def cherryPickup(self, grid): """ :type grid: List[List[int]] :rtype: int """ n = len(grid) if grid[0][0] == -1 or grid[n-1][n-1] == -1: return 0 dp = [[-1,]*n for _ in range(n)] # 很重要, """ 因为比如[[1,-1,1],[-1,1,1],[1,1,1]], 如果初始化为0,k=1 后 , dp = [[-1,-1,0],[-1,-1,0],[0, 0,0]] 然后k = 2, i = 2, j = 2, 只能从(1,0) (1,0) 过来, dp[1][1] = -1,但是因为初始化为0,通过比较max,所以dp最后应该为-1,但是结果为0 """ dp[0][0] = grid[0][0] for k in range(1,2*n-1): for i in range(min(k,n-1),max(-1, k-n),-1): for j in range(min(k,n-1),max(-1, k-n),-1): if grid[i][k-i] == -1 or grid[j][k-j] == -1: dp[i][j] = -1 continue if i>0 : dp[i][j] = max(dp[i][j], dp[i-1][j]) #向下向右 if j>0 : dp[i][j] = max(dp[i][j], dp[i][j-1]) #向右向下 if i>0 and j>0: dp[i][j] = max(dp[i][j], dp[i-1][j-1]) #向下向下 if dp[i][j]<0 :continue dp[i][j] += grid[i][k-i] if i!=j: dp[i][j] += grid[j][k-j] return max(dp[-1][-1],0) class Solution: def cherryPickup(self, grid: List[List[int]]) -> int: n = len(grid) if grid[0][0] == -1 or grid[n-1][n-1] == -1: return 0 dp = [[-1,]*n for _ in range(n)] dp[0][0] = grid[0][0] for k in range(1,2*n-1): for i in range(n-1,-1,-1): for j in range(n-1,-1,-1): p, q = k-i, k -j if p < 0 or p >= n or q<0 or q>=n or grid[i][p] == -1 or grid[j][q] == -1: dp[i][j] = -1 continue if i>0 : dp[i][j] = max(dp[i][j], dp[i-1][j]) #向下向右 if j>0 : dp[i][j] = max(dp[i][j], dp[i][j-1]) #向右向下 if i>0 and j>0: dp[i][j] = max(dp[i][j], dp[i-1][j-1]) #向下向下 if dp[i][j]<0 :continue dp[i][j] += grid[i][p] if i!=j: dp[i][j] += grid[j][q] return max(dp[-1][-1],0) # Top-Down class Solution: def cherryPickup(self, grid: List[List[int]]) -> int: N = len(grid) lookup = {} def solve(x1, y1, x2, y2): # check if we reached bottom right corner if x1 == N-1 and y1 == N-1: return grid[x1][y1] if grid[x1][y1] != -1 else float("-inf") # out of the grid and thorn check if x1 == N or y1 == N or x2 == N or y2 == N or grid[x1][y1] == -1 or grid[x2][y2] == -1: return float("-inf") # memorization check lookup_key = (x1, y1, x2, y2) if lookup_key in lookup: return lookup[lookup_key] # pick your cherries if x1 == x2 and y1 == y2: cherries = grid[x1][y1] else: cherries = grid[x1][y1] + grid[x2][y2] res = cherries + max( solve(x1 + 1, y1, x2 + 1, y2), # right, right solve(x1, y1 + 1, x2, y2 + 1), # down, down solve(x1 + 1, y1, x2, y2 + 1), # right, down solve(x1, y1 + 1, x2 + 1, y2), # down, right ) lookup[lookup_key] = res return res res = solve(0, 0, 0, 0) return res if res > 0 else 0
3.375
3
Fair_OS.py
Anon-git-site/Fair-Over-Sampling
0
12788555
# -*- coding: utf-8 -*- #code adapted from https://github.com/analyticalmindsltd/smote_variants import numpy as np import time import logging import itertools from sklearn.neighbors import NearestNeighbors # setting the _logger format _logger = logging.getLogger('smote_variants') _logger.setLevel(logging.DEBUG) _logger_ch = logging.StreamHandler() _logger_ch.setFormatter(logging.Formatter( "%(asctime)s:%(levelname)s:%(message)s")) _logger.addHandler(_logger_ch) def mode(data): values, counts = np.unique(data, return_counts=True) return values[np.where(counts == max(counts))[0][0]] class StatisticsMixin: """ Mixin to compute class statistics and determine minority/majority labels """ def class_label_statistics(self, X, y): """ determines class sizes and minority and majority labels Args: X (np.array): features y (np.array): target labels """ unique, counts = np.unique(y, return_counts=True) self.class_stats = dict(zip(unique, counts)) self.min_label = unique[0] if counts[0] < counts[1] else unique[1] self.maj_label = unique[1] if counts[0] < counts[1] else unique[0] # shorthands self.min_label = self.min_label self.maj_label = self.maj_label def check_enough_min_samples_for_sampling(self, threshold=2): if self.class_stats[self.min_label] < threshold: m = ("The number of minority samples (%d) is not enough " "for sampling") m = m % self.class_stats[self.min_label] _logger.warning(self.__class__.__name__ + ": " + m) return False return True class RandomStateMixin: """ Mixin to set random state """ def set_random_state(self, random_state): """ sets the random_state member of the object Args: random_state (int/np.random.RandomState/None): the random state initializer """ self._random_state_init = random_state if random_state is None: self.random_state = np.random elif isinstance(random_state, int): self.random_state = np.random.RandomState(random_state) elif isinstance(random_state, np.random.RandomState): self.random_state = random_state elif random_state is np.random: self.random_state = random_state else: raise ValueError( "random state cannot be initialized by " + str(random_state)) class ParameterCheckingMixin: """ Mixin to check if parameters come from a valid range """ def check_in_range(self, x, name, r): """ Check if parameter is in range Args: x (numeric): the parameter value name (str): the parameter name r (list-like(2)): the lower and upper bound of a range Throws: ValueError """ if x < r[0] or x > r[1]: m = ("Value for parameter %s outside the range [%f,%f] not" " allowed: %f") m = m % (name, r[0], r[1], x) raise ValueError(self.__class__.__name__ + ": " + m) def check_out_range(self, x, name, r): """ Check if parameter is outside of range Args: x (numeric): the parameter value name (str): the parameter name r (list-like(2)): the lower and upper bound of a range Throws: ValueError """ if x >= r[0] and x <= r[1]: m = "Value for parameter %s in the range [%f,%f] not allowed: %f" m = m % (name, r[0], r[1], x) raise ValueError(self.__class__.__name__ + ": " + m) def check_less_or_equal(self, x, name, val): """ Check if parameter is less than or equal to value Args: x (numeric): the parameter value name (str): the parameter name val (numeric): value to compare to Throws: ValueError """ if x > val: m = "Value for parameter %s greater than %f not allowed: %f > %f" m = m % (name, val, x, val) raise ValueError(self.__class__.__name__ + ": " + m) def check_less_or_equal_par(self, x, name_x, y, name_y): """ Check if parameter is less than or equal to another parameter Args: x (numeric): the parameter value name_x (str): the parameter name y (numeric): the other parameter value name_y (str): the other parameter name Throws: ValueError """ if x > y: m = ("Value for parameter %s greater than parameter %s not" " allowed: %f > %f") m = m % (name_x, name_y, x, y) raise ValueError(self.__class__.__name__ + ": " + m) def check_less(self, x, name, val): """ Check if parameter is less than value Args: x (numeric): the parameter value name (str): the parameter name val (numeric): value to compare to Throws: ValueError """ if x >= val: m = ("Value for parameter %s greater than or equal to %f" " not allowed: %f >= %f") m = m % (name, val, x, val) raise ValueError(self.__class__.__name__ + ": " + m) def check_less_par(self, x, name_x, y, name_y): """ Check if parameter is less than another parameter Args: x (numeric): the parameter value name_x (str): the parameter name y (numeric): the other parameter value name_y (str): the other parameter name Throws: ValueError """ if x >= y: m = ("Value for parameter %s greater than or equal to parameter" " %s not allowed: %f >= %f") m = m % (name_x, name_y, x, y) raise ValueError(self.__class__.__name__ + ": " + m) def check_greater_or_equal(self, x, name, val): """ Check if parameter is greater than or equal to value Args: x (numeric): the parameter value name (str): the parameter name val (numeric): value to compare to Throws: ValueError """ if x < val: m = "Value for parameter %s less than %f is not allowed: %f < %f" m = m % (name, val, x, val) raise ValueError(self.__class__.__name__ + ": " + m) def check_greater_or_equal_par(self, x, name_x, y, name_y): """ Check if parameter is less than or equal to another parameter Args: x (numeric): the parameter value name_x (str): the parameter name y (numeric): the other parameter value name_y (str): the other parameter name Throws: ValueError """ if x < y: m = ("Value for parameter %s less than parameter %s is not" " allowed: %f < %f") m = m % (name_x, name_y, x, y) raise ValueError(self.__class__.__name__ + ": " + m) def check_greater(self, x, name, val): """ Check if parameter is greater than value Args: x (numeric): the parameter value name (str): the parameter name val (numeric): value to compare to Throws: ValueError """ if x <= val: m = ("Value for parameter %s less than or equal to %f not allowed" " %f < %f") m = m % (name, val, x, val) raise ValueError(self.__class__.__name__ + ": " + m) def check_greater_par(self, x, name_x, y, name_y): """ Check if parameter is greater than or equal to another parameter Args: x (numeric): the parameter value name_x (str): the parameter name y (numeric): the other parameter value name_y (str): the other parameter name Throws: ValueError """ if x <= y: m = ("Value for parameter %s less than or equal to parameter %s" " not allowed: %f <= %f") m = m % (name_x, name_y, x, y) raise ValueError(self.__class__.__name__ + ": " + m) def check_equal(self, x, name, val): """ Check if parameter is equal to value Args: x (numeric): the parameter value name (str): the parameter name val (numeric): value to compare to Throws: ValueError """ if x == val: m = ("Value for parameter %s equal to parameter %f is not allowed:" " %f == %f") m = m % (name, val, x, val) raise ValueError(self.__class__.__name__ + ": " + m) def check_equal_par(self, x, name_x, y, name_y): """ Check if parameter is equal to another parameter Args: x (numeric): the parameter value name_x (str): the parameter name y (numeric): the other parameter value name_y (str): the other parameter name Throws: ValueError """ if x == y: m = ("Value for parameter %s equal to parameter %s is not " "allowed: %f == %f") m = m % (name_x, name_y, x, y) raise ValueError(self.__class__.__name__ + ": " + m) def check_isin(self, x, name, li): """ Check if parameter is in list Args: x (numeric): the parameter value name (str): the parameter name li (list): list to check if parameter is in it Throws: ValueError """ if x not in li: m = "Value for parameter %s not in list %s is not allowed: %s" m = m % (name, str(li), str(x)) raise ValueError(self.__class__.__name__ + ": " + m) def check_n_jobs(self, x, name): """ Check n_jobs parameter Args: x (int/None): number of jobs name (str): the parameter name Throws: ValueError """ if not ((x is None) or (x is not None and isinstance(x, int) and not x == 0)): m = "Value for parameter n_jobs is not allowed: %s" % str(x) raise ValueError(self.__class__.__name__ + ": " + m) class ParameterCombinationsMixin: """ Mixin to generate parameter combinations """ @classmethod def generate_parameter_combinations(cls, dictionary, raw): """ Generates reasonable paramter combinations Args: dictionary (dict): dictionary of paramter ranges num (int): maximum number of combinations to generate """ if raw: return dictionary keys = sorted(list(dictionary.keys())) values = [dictionary[k] for k in keys] combinations = [dict(zip(keys, p)) for p in list(itertools.product(*values))] return combinations class NoiseFilter(StatisticsMixin, ParameterCheckingMixin, ParameterCombinationsMixin): """ Parent class of noise filtering methods """ def __init__(self): """ Constructor """ pass def remove_noise(self, X, y): """ Removes noise Args: X (np.array): features y (np.array): target labels """ pass def get_params(self, deep=False): """ Return parameters Returns: dict: dictionary of parameters """ return {} def set_params(self, **params): """ Set parameters Args: params (dict): dictionary of parameters """ for key, value in params.items(): setattr(self, key, value) return self class OverSampling(StatisticsMixin, ParameterCheckingMixin, ParameterCombinationsMixin, RandomStateMixin): """ Base class of oversampling methods """ categories = [] cat_noise_removal = 'NR' cat_dim_reduction = 'DR' cat_uses_classifier = 'Clas' cat_sample_componentwise = 'SCmp' cat_sample_ordinary = 'SO' cat_sample_copy = 'SCpy' cat_memetic = 'M' cat_density_estimation = 'DE' cat_density_based = 'DB' cat_extensive = 'Ex' cat_changes_majority = 'CM' cat_uses_clustering = 'Clus' cat_borderline = 'BL' cat_application = 'A' def __init__(self): pass def det_n_to_sample(self, strategy, n_maj, n_min): """ Determines the number of samples to generate Args: strategy (str/float): if float, the fraction of the difference of the minority and majority numbers to generate, like 0.1 means that 10% of the difference will be generated if str, like 'min2maj', the minority class will be upsampled to match the cardinality of the majority class """ if isinstance(strategy, float) or isinstance(strategy, int): return max([0, int((n_maj - n_min)*strategy)]) else: m = "Value %s for parameter strategy is not supported" % strategy raise ValueError(self.__class__.__name__ + ": " + m) def sample_between_points(self, x, y): """ Sample randomly along the line between two points. Args: x (np.array): point 1 y (np.array): point 2 Returns: np.array: the new sample """ return x + (y - x)*self.random_state.random_sample() def sample_between_points_componentwise(self, x, y, mask=None): """ Sample each dimension separately between the two points. Args: x (np.array): point 1 y (np.array): point 2 mask (np.array): array of 0,1s - specifies which dimensions to sample Returns: np.array: the new sample being generated """ if mask is None: return x + (y - x)*self.random_state.random_sample() else: return x + (y - x)*self.random_state.random_sample()*mask def sample_by_jittering(self, x, std): """ Sample by jittering. Args: x (np.array): base point std (float): standard deviation Returns: np.array: the new sample """ return x + (self.random_state.random_sample() - 0.5)*2.0*std def sample_by_jittering_componentwise(self, x, std): """ Sample by jittering componentwise. Args: x (np.array): base point std (np.array): standard deviation Returns: np.array: the new sample """ return x + (self.random_state.random_sample(len(x))-0.5)*2.0 * std def sample_by_gaussian_jittering(self, x, std): """ Sample by Gaussian jittering Args: x (np.array): base point std (np.array): standard deviation Returns: np.array: the new sample """ return self.random_state.normal(x, std) def sample(self, X, y): """ The samplig function reimplemented in child classes Args: X (np.matrix): features y (np.array): labels Returns: np.matrix, np.array: sampled X and y """ return X, y def fit_resample(self, X, y): """ Alias of the function "sample" for compatibility with imbalanced-learn pipelines """ return self.sample(X, y) def sample_with_timing(self, X, y): begin = time.time() X_samp, y_samp = self.sample(X, y) _logger.info(self.__class__.__name__ + ": " + ("runtime: %f" % (time.time() - begin))) return X_samp, y_samp def preprocessing_transform(self, X): """ Transforms new data according to the possible transformation implemented by the function "sample". Args: X (np.matrix): features Returns: np.matrix: transformed features """ return X def get_params(self, deep=False): """ Returns the parameters of the object as a dictionary. Returns: dict: the parameters of the object """ pass def set_params(self, **params): """ Set parameters Args: params (dict): dictionary of parameters """ for key, value in params.items(): setattr(self, key, value) return self def descriptor(self): """ Returns: str: JSON description of the current sampling object """ return str((self.__class__.__name__, str(self.get_params()))) def __str__(self): return self.descriptor() class FOS_1(OverSampling): #F4_SMOTE(OverSampling): categories = [OverSampling.cat_sample_ordinary, OverSampling.cat_extensive] def __init__(self, proportion=1.0, n_neighbors=5, n_jobs=1, random_state=None): super().__init__() self.check_greater_or_equal(proportion, "proportion", 0) self.check_greater_or_equal(n_neighbors, "n_neighbors", 1) self.check_n_jobs(n_jobs, 'n_jobs') self.proportion = proportion self.n_neighbors = n_neighbors self.n_jobs = n_jobs self.set_random_state(random_state) @classmethod def parameter_combinations(cls, raw=False): parameter_combinations = {'proportion': [0.1, 0.25, 0.5, 0.75, 1.0, 1.1,1.5, 2.0], 'n_neighbors': [3, 5, 7]} return cls.generate_parameter_combinations(parameter_combinations, raw) def sample(self, X, y,prot_idx, pv_mid_pt, prot_grp, maj_min, nsamp, pv_max,pv_min): _logger.info(self.__class__.__name__ + ": " + "Running sampling via %s" % self.descriptor()) self.class_label_statistics(X, y) if not self.check_enough_min_samples_for_sampling(): return X.copy(), y.copy() y = np.squeeze(y) n_to_sample = nsamp if maj_min == 0: X_min = X[y == self.min_label] y_min = y[y == self.min_label] prot = X_min[:,prot_idx] if prot_grp == 0: X_min = X_min[prot==prot_grp] y_min = y_min[prot==prot_grp] if prot_grp == 1: X_min = X_min[prot==prot_grp] y_min = y_min[prot==prot_grp] if maj_min == 1: X_min = X[y == self.maj_label] y_min = y[y == self.maj_label] prot = X_min[:,prot_idx] if prot_grp == 0: X_min = X_min[prot==prot_grp] y_min = y_min[prot==prot_grp] if prot_grp == 1: X_min = X_min[prot==prot_grp] y_min = y_min[prot==prot_grp] self.min_label = np.copy(self.maj_label) if n_to_sample == 0: return X.copy(), y.copy() # fitting the model n_neigh = min([len(X_min), self.n_neighbors+1]) nn = NearestNeighbors(n_neighbors=n_neigh, n_jobs=self.n_jobs) nn.fit(X_min) dist, ind = nn.kneighbors(X_min) if n_to_sample == 0: return X.copy(), y.copy() # generating samples #np.random.seed(seed=1) base_indices = self.random_state.choice(list(range(len(X_min))), n_to_sample) neighbor_indices = self.random_state.choice(list(range(1, n_neigh)), n_to_sample) X_base = X_min[base_indices] X_neighbor = X_min[ind[base_indices, neighbor_indices]] samples = X_base + np.multiply(self.random_state.rand(n_to_sample, 1), X_neighbor - X_base) return (np.vstack([X, samples]), np.hstack([y, np.hstack([self.min_label]*n_to_sample)])) def get_params(self, deep=False): return {'proportion': self.proportion, 'n_neighbors': self.n_neighbors, 'n_jobs': self.n_jobs, 'random_state': self._random_state_init} class FOS_2(OverSampling): #F3a_SMOTE(OverSampling): categories = [OverSampling.cat_sample_ordinary, OverSampling.cat_extensive] def __init__(self, proportion=1.0, n_neighbors=5, n_jobs=1, random_state=None): super().__init__() self.check_greater_or_equal(proportion, "proportion", 0) self.check_greater_or_equal(n_neighbors, "n_neighbors", 1) self.check_n_jobs(n_jobs, 'n_jobs') self.proportion = proportion self.n_neighbors = n_neighbors self.n_jobs = n_jobs self.set_random_state(random_state) @classmethod def parameter_combinations(cls, raw=False): parameter_combinations = {'proportion': [0.1, 0.25, 0.5, 0.75, 1.0, 1.1,1.5, 2.0], 'n_neighbors': [3, 5, 7]} return cls.generate_parameter_combinations(parameter_combinations, raw) def sample(self, X, y,prot_idx, pv_mid_pt, prot_grp, maj_min, nsamp): _logger.info(self.__class__.__name__ + ": " + "Running sampling via %s" % self.descriptor()) self.class_label_statistics(X, y) if not self.check_enough_min_samples_for_sampling(): return X.copy(), y.copy() n_to_sample = nsamp if maj_min == 0: X_min = X[y == self.min_label] y_min = y[y == self.min_label] prot = X_min[:,prot_idx] if prot_grp == 0: X_min1 = X_min[prot<pv_mid_pt] y_min1 = y_min[prot<pv_mid_pt] if prot_grp == 1: X_min1 = X_min[prot>pv_mid_pt] y_min1 = y_min[prot>pv_mid_pt] if maj_min == 1: X_min = X[y == self.maj_label] y_min = y[y == self.maj_label] prot = X_min[:,prot_idx] if prot_grp == 0: X_min1 = X_min[prot<pv_mid_pt] y_min1 = y_min[prot<pv_mid_pt] if prot_grp == 1: X_min1 = X_min[prot>pv_mid_pt] y_min1 = y_min[prot>pv_mid_pt] self.min_label = np.copy(self.maj_label) if n_to_sample == 0: return X.copy(), y.copy() # fitting the model n_neigh = min([len(X_min), self.n_neighbors+1]) nn = NearestNeighbors(n_neighbors=n_neigh, n_jobs=self.n_jobs) nn.fit(X_min) dist, ind = nn.kneighbors(X_min1) if n_to_sample == 0: return X.copy(), y.copy() # generating samples np.random.seed(seed=1) base_indices = self.random_state.choice(list(range(len(X_min1))), n_to_sample) neighbor_indices = self.random_state.choice(list(range(1, n_neigh)), n_to_sample) X_base = X_min1[base_indices] X_neighbor = X_min[ind[base_indices, neighbor_indices]] samples = X_base + np.multiply(self.random_state.rand(n_to_sample, 1), X_neighbor - X_base) return (np.vstack([X, samples]), np.hstack([y, np.hstack([self.min_label]*n_to_sample)])) def get_params(self, deep=False): return {'proportion': self.proportion, 'n_neighbors': self.n_neighbors, 'n_jobs': self.n_jobs, 'random_state': self._random_state_init}
2.640625
3
lambda_function.py
cloudbasic/Lambda-Update-Route53
0
12788556
<filename>lambda_function.py from __future__ import print_function import boto3, json, re HOSTED_ZONE_ID = 'YOUR_HOSTED_ZONE_ID' def lambda_handler(event, context): route53 = boto3.client('route53') dns_changes = { 'Changes': [ { 'Action': 'UPSERT', 'ResourceRecordSet': { 'Name': event['name'], 'Type': 'CNAME', 'ResourceRecords': [ { 'Value': event['value'] } ], 'TTL': 300 } } ] } print("Updating Route53") response = route53.change_resource_record_sets( HostedZoneId=HOSTED_ZONE_ID, ChangeBatch=dns_changes ) return {'status':response['ChangeInfo']['Status']}
2.375
2
lcd.py
zimolzak/Raspberry-Pi-newbie
0
12788557
#!/usr/bin/env python from telnetlib import Telnet import time tn = Telnet('192.168.1.4', 13666, None) tn.write("hello\n") tn.write("screen_add s1\n") tn.write("screen_set s1 -priority 1\n") tn.write("widget_add s1 w1 string\n") tn.write("widget_add s1 w2 string\n") def lcd_string(x, telnet_obj, delay=2): L = [] for i in range(len(x)): if i % (15+16) == 0: L.append(x[i:i+15+16]) for s in L: s1 = s[0:15] s2 = s[15:] telnet_obj.write("widget_set s1 w1 1 1 {" + s1 + "}\n") telnet_obj.write("widget_set s1 w2 1 2 {" + s2 + "}\n") time.sleep(delay)
2.84375
3
HackerRank/10 Days of Statistics/Day4B.py
ShubhamJagtap2000/competitive-programming-1
1
12788558
import math print(round((pow(0.88, 10) + (1.2*pow(0.88, 9)) + (45*pow(0.88, 8)*pow(0.12, 2))), 3)) print(round((1 - (pow(0.88, 10) + (1.2*pow(0.88, 9)))), 3))
3.5
4
tests/api/views/v1/test_api_execution.py
angry-tony/ceph-lcm-decapod
41
12788559
# -*- coding: utf-8 -*- # Copyright (c) 2016 Mirantis Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for /v1/execution API endpoint.""" import hashlib import unittest.mock import gridfs.grid_file import pytest from decapod_common.models import cluster from decapod_common.models import execution from decapod_common.models import execution_step from decapod_common.models import role from decapod_common.models import task @pytest.fixture def clean_execution_collection(configure_model, pymongo_connection): pymongo_connection.db.execution.remove({}) @pytest.fixture def valid_post_request(new_pcmodel): return { "playbook_configuration": { "id": new_pcmodel.model_id, "version": new_pcmodel.version } } @pytest.fixture def sudo_client(sudo_client_v1, public_playbook_name, sudo_role): role.PermissionSet.add_permission("playbook", public_playbook_name) sudo_role.add_permissions("playbook", [public_playbook_name]) sudo_role.save() return sudo_client_v1 @pytest.fixture def mock_task_class(monkeypatch): mocked = unittest.mock.MagicMock() monkeypatch.setattr(task, "PlaybookPluginTask", mocked) return mocked @pytest.fixture def new_execution_with_logfile(new_execution, execution_log_storage): def side_effect(model_id): if model_id != new_execution.model_id: return None mock = unittest.mock.MagicMock(spec=gridfs.grid_file.GridOut) mock.read.side_effect = b"LOG", b"" mock.__iter__.return_value = [b"LOG"] mock.content_type = "text/plain" mock.filename = "filename.log" mock.md5 = hashlib.md5(b"LOG").hexdigest() return mock execution_log_storage.get.side_effect = side_effect return new_execution def create_execution_step(execution_id, srv, state): db_model = { "execution_id": execution_id, "role": pytest.faux.gen_alpha(), "name": pytest.faux.gen_alpha(), "result": state.value, "error": {}, "server_id": srv.model_id, "time_started": pytest.faux.gen_integer(1, 100), "time_finished": pytest.faux.gen_integer(101) } execution_step.ExecutionStep.collection().insert_one(db_model) def test_post_access(sudo_client, client_v1, sudo_user, freeze_time, normal_user, valid_post_request): response = client_v1.post("/v1/execution/", data=valid_post_request) assert response.status_code == 401 assert response.json["error"] == "Unauthorized" client_v1.login(normal_user.login, "qwerty") response = client_v1.post("/v1/execution/", data=valid_post_request) assert response.status_code == 403 assert response.json["error"] == "Forbidden" response = sudo_client.post("/v1/execution/", data=valid_post_request) assert response.status_code == 200 def test_post_result(sudo_client, new_pcmodel, freeze_time, valid_post_request): response = sudo_client.post("/v1/execution/", data=valid_post_request) assert response.json["data"]["playbook_configuration"]["id"] \ == new_pcmodel.model_id assert response.json["data"]["playbook_configuration"]["version"] \ == new_pcmodel.version assert response.json["data"]["playbook_configuration"]["playbook_name"] \ == new_pcmodel.playbook_id assert response.json["data"]["state"] \ == execution.ExecutionState.created.name tsk = task.Task.get_by_execution_id( response.json["id"], task.TaskType.playbook.name) assert tsk assert not tsk.time_started assert not tsk.time_completed assert not tsk.time_failed assert not tsk.time_cancelled assert tsk.time_updated == int(freeze_time.return_value) assert tsk.time_created == int(freeze_time.return_value) def test_post_result_deleted_cluster(sudo_client, new_pcmodel, freeze_time, valid_post_request): clus = cluster.ClusterModel.create(pytest.faux.gen_alpha()) clus.delete() new_pcmodel.cluster = clus new_pcmodel.save() valid_post_request["playbook_configuration"]["version"] = \ new_pcmodel.version response = sudo_client.post("/v1/execution/", data=valid_post_request) assert response.status_code == 400 @pytest.mark.parametrize("what", ("id", "version")) def test_post_fake_playbook_configuration(what, sudo_client, valid_post_request): if what == "id": valid_post_request["playbook_configuration"]["id"] \ = pytest.faux.gen_uuid() else: valid_post_request["playbook_configuration"]["version"] \ = pytest.faux.gen_integer(3) response = sudo_client.post("/v1/execution/", data=valid_post_request) assert response.status_code == 400 assert response.json["error"] == "UnknownPlaybookConfiguration" def test_post_cannot_create_task(sudo_client, mock_task_class, valid_post_request, pymongo_connection, clean_execution_collection): mock_task_class.side_effect = Exception response = sudo_client.post("/v1/execution/", data=valid_post_request) assert response.status_code == 400 db_model = pymongo_connection.db.execution.find({}) db_model = list(db_model) assert len(db_model) == 2 db_model = max((mdl for mdl in db_model), key=lambda x: x["version"]) assert db_model["state"] == execution.ExecutionState.failed.name def test_delete_access(sudo_client, client_v1, sudo_user, freeze_time, normal_user, valid_post_request): resp = sudo_client.post("/v1/execution/", data=valid_post_request) assert resp.status_code == 200 response = client_v1.delete( "/v1/execution/{0}/".format(resp.json["id"])) assert response.status_code == 401 assert response.json["error"] == "Unauthorized" client_v1.login(normal_user.login, "qwerty") response = client_v1.delete( "/v1/execution/{0}/".format(resp.json["id"])) assert response.status_code == 403 assert response.json["error"] == "Forbidden" response = sudo_client.delete( "/v1/execution/{0}/".format(resp.json["id"])) assert response.status_code == 200 def test_delete_not_started(sudo_client, valid_post_request): resp = sudo_client.post("/v1/execution/", data=valid_post_request) resp = sudo_client.delete("/v1/execution/{0}/".format(resp.json["id"])) excmodel = execution.ExecutionModel.find_by_model_id(resp.json["id"]) assert excmodel.state == execution.ExecutionState.canceled def test_delete_started(sudo_client, valid_post_request): resp = sudo_client.post("/v1/execution/", data=valid_post_request) tsk = task.Task.get_by_execution_id(resp.json["id"], task.TaskType.playbook) tsk.start() excmodel = execution.ExecutionModel.find_by_model_id(resp.json["id"]) assert excmodel.state == execution.ExecutionState.started resp = sudo_client.delete("/v1/execution/{0}/".format(resp.json["id"])) assert resp.status_code == 200 excmodel = execution.ExecutionModel.find_by_model_id(resp.json["id"]) assert excmodel.state == execution.ExecutionState.canceling tsk = task.Task.get_by_execution_id(resp.json["id"], task.TaskType.cancel) assert tsk def test_api_get_access(sudo_client, client_v1, normal_user): response = client_v1.get("/v1/execution/") assert response.status_code == 401 assert response.json["error"] == "Unauthorized" client_v1.login(normal_user.login, "qwerty") response = client_v1.get("/v1/execution/") assert response.status_code == 403 assert response.json["error"] == "Forbidden" response = sudo_client.get("/v1/execution/") assert response.status_code == 200 def test_get(sudo_client, clean_execution_collection, valid_post_request): resp = sudo_client.post("/v1/execution/", data=valid_post_request) model_id = resp.json["id"] resp = sudo_client.get("/v1/execution/") assert resp.status_code == 200 assert resp.json["total"] == 1 assert len(resp.json["items"]) == 1 resp = sudo_client.get("/v1/execution/{0}/".format(model_id)) assert resp.status_code == 200 resp = sudo_client.get("/v1/execution/{0}/version/".format(model_id)) assert resp.status_code == 200 assert resp.json["total"] == 1 assert len(resp.json["items"]) == 1 resp = sudo_client.get("/v1/execution/{0}/version/1/".format(model_id)) assert resp.status_code == 200 @pytest.mark.parametrize("state", execution_step.ExecutionStepState) def test_get_execution_steps(state, sudo_client, new_server, valid_post_request): resp = sudo_client.post("/v1/execution/", data=valid_post_request) model_id = resp.json["id"] for _ in range(5): create_execution_step(model_id, new_server, state) resp = sudo_client.get("/v1/execution/{0}/steps/".format(model_id)) assert resp.status_code == 200 assert resp.json["total"] == 5 assert len(resp.json["items"]) == 5 assert all((item["data"]["execution_id"] == model_id) for item in resp.json["items"]) assert all((item["data"]["result"] == state.name) for item in resp.json["items"]) def test_get_execution_log_fail(sudo_client, client_v1, normal_user, new_execution_with_logfile): response = client_v1.get( "/v1/execution/{0}/log/".format(new_execution_with_logfile.model_id)) assert response.status_code == 401 assert response.json["error"] == "Unauthorized" client_v1.login(normal_user.login, "qwerty") response = client_v1.get( "/v1/execution/{0}/log/".format(new_execution_with_logfile.model_id)) assert response.status_code == 403 assert response.json["error"] == "Forbidden" response = sudo_client.get( "/v1/execution/{0}/log/".format(new_execution_with_logfile.model_id)) assert response.status_code == 200 @pytest.mark.parametrize("download", (True, False)) def test_get_execution_plain_text_log(download, sudo_client, new_execution_with_logfile): query = "?download=yes" if download else "" response = sudo_client.get( "/v1/execution/{0}/log/{1}".format( new_execution_with_logfile.model_id, query)) assert response.status_code == 200 assert response.headers.get("Content-Type").startswith("text/plain") assert response.headers.get("ETag") == "\"{0}\"".format( hashlib.md5(b"LOG").hexdigest() ) assert response.data == b"LOG" if download: assert response.headers["Content-Disposition"] == \ "attachment; filename=filename.log" else: assert "Content-Disposition" not in response.headers @pytest.mark.parametrize("download", (False,)) def test_get_execution_json_log(download, sudo_client, new_execution_with_logfile): query = "?download=yes" if download else "" response = sudo_client.get( "/v1/execution/{0}/log/{1}".format( new_execution_with_logfile.model_id, query), content_type="application/json" ) assert response.status_code == 200 if download: assert response.headers.get("Content-Type").startswith("text/plain") else: assert response.headers.get("Content-Type").startswith( "application/json") assert response.json == {"data": "LOG"} if download: assert response.headers["Content-Disposition"] == \ "attachment; filename=filename.log" else: assert "Content-Disposition" not in response.headers
1.71875
2
torchnlp/samplers/noisy_sorted_sampler.py
MPetrochuk/PyTorch-NLP
2,125
12788560
<reponame>MPetrochuk/PyTorch-NLP import random from torch.utils.data.sampler import Sampler from torchnlp.utils import identity def _uniform_noise(_): return random.uniform(-1, 1) class NoisySortedSampler(Sampler): """ Samples elements sequentially with noise. **Background** ``NoisySortedSampler`` is similar to a ``BucketIterator`` found in popular libraries like `AllenNLP` and `torchtext`. A ``BucketIterator`` pools together examples with a similar size length to reduce the padding required for each batch. ``BucketIterator`` also includes the ability to add noise to the pooling. **AllenNLP Implementation:** https://github.com/allenai/allennlp/blob/e125a490b71b21e914af01e70e9b00b165d64dcd/allennlp/data/iterators/bucket_iterator.py **torchtext Implementation:** https://github.com/pytorch/text/blob/master/torchtext/data/iterator.py#L225 Args: data (iterable): Data to sample from. sort_key (callable): Specifies a function of one argument that is used to extract a numerical comparison key from each list element. get_noise (callable): Noise added to each numerical ``sort_key``. Example: >>> from torchnlp.random import set_seed >>> set_seed(123) >>> >>> import random >>> get_noise = lambda i: round(random.uniform(-1, 1)) >>> list(NoisySortedSampler(range(10), sort_key=lambda i: i, get_noise=get_noise)) [0, 1, 2, 3, 5, 4, 6, 7, 9, 8] """ def __init__(self, data, sort_key=identity, get_noise=_uniform_noise): super().__init__(data) self.data = data self.sort_key = sort_key self.get_noise = get_noise def __iter__(self): zip_ = [] for i, row in enumerate(self.data): value = self.get_noise(row) + self.sort_key(row) zip_.append(tuple([i, value])) zip_ = sorted(zip_, key=lambda r: r[1]) return iter([item[0] for item in zip_]) def __len__(self): return len(self.data)
3.359375
3
gawseed/threatfeed/search/ssh.py
gawseed/threat-feed-tools
2
12788561
from gawseed.threatfeed.search.ip import IPSearch class SSHSearch(IPSearch): """Searches data for threats, but requires the auth_success field to be True. IE, only successful logins will be considered a match. Use the 'ip' module if you don't want this restriction applied.""" def __init__(self, conf, search_list, data_iterator, binary_search): super().__init__(conf, search_list, data_iterator, binary_search) # Really need a tri-nary option for this self._auth_success_key = self.config('auth_success_key', 'auth_success', help="When searching for authenticated ssh connections, use this column name to determine if authentication suceeded") self._auth_success_value = self.config('auth_success_value', True, help="The value that should match the authentication field identified by auth_success_key") def initialize(self): super().initialize() self._auth_success_key = self._data_iterator.encode_item(self._auth_success_key) if type(self._auth_success_value) == str: self._auth_success_value = self._data_iterator.encode_item(self._auth_success_value) def search(self, row): if not self._auth_success_key or self._auth_success_key not in row: return None if row[self._auth_success_key] != self._auth_success_value: return None return super().search(row) # pass the rest to the IP searcher
2.765625
3
survey/mixins/data_mixins.py
vahndi/quant-survey
2
12788562
from typing import Callable, Optional from numpy import nan from pandas import Series, isnull, Interval from pandas.core.dtypes.inference import is_number class ObjectDataMixin(object): _data: Optional[Series] _validate_data: Callable[[Series], None] def _set_data(self, data: Series): self.data = data @property def data(self) -> Series: return self._data @data.setter def data(self, data: Series): if data is None: self._data = None else: self._validate_data(data) self._data = data class NumericDataMixin(object): _data: Optional[Series] _validate_data: Callable[[Series], None] def _set_data(self, data: Series): self.data = data @property def data(self) -> Series: return self._data @data.setter def data(self, data: Series): if data is None: self._data = None else: self._validate_data(data) try: data = data.astype(int) except ValueError: data = data.astype(float) self._data = data class SingleCategoryDataMixin(object): _data: Optional[Series] name: str _validate_data: Callable[[Series], None] def _set_data(self, data: Series): if data is not None: self.data = data @property def data(self) -> Series: return self._data @data.setter def data(self, data: Series): if data is None: self._data = None else: data = Series( index=data.index, data=[nan if isnull(d) else d if type(d) is str else d if type(d) is Interval else str(int(d)) if is_number(d) and d == int(d) else str(d) for d in data.values], name=self.name ).astype('category') self._validate_data(data) self._data = data class MultiCategoryDataMixin(object): _data: Optional[Series] name: str _validate_data: Callable[[Series], None] def _set_data(self, data: Series): self.data = data @property def data(self) -> Series: return self._data @data.setter def data(self, data: Series): if data is None: self._data = None else: data = Series( index=data.index, data=[ nan if isnull(d) else nan if type(d) is str and d == '' else d if type(d) is str else str(d) for d in data.values ], name=self.name ) self._validate_data(data) self._data = data
2.765625
3
tests/comply/__init__.py
repsistance/keripy
26
12788563
""" Compliance test package """
0.953125
1
src/gae_flask_boilerplate/app.py
euri10/python-gae_flask_boilerplate
0
12788564
<filename>src/gae_flask_boilerplate/app.py<gh_stars>0 from gae_flask_boilerplate import create_app app = create_app('default')
1.390625
1
20-hs-redez-sem/groups/05-decentGames/src/DontGetAngry.py
Kyrus1999/BACnet
8
12788565
<gh_stars>1-10 import copy import json import os import random import socket import sys import xmlrpc.client import State from AbsGame import AbsGame, MY_IP from DGA import DGA from Exceptions import FileAlreadyExists from GameInformation import GameInformation class DontGetAngry(AbsGame): is_looping = True def _sync_log(self) -> None: pass def fetch(self): n = self.__ginfo.get_seq() self._fetch_lines(self.__game_path, n, self.__ip1, self.__ip2) def refresh(self): print('Refreshing') pass # with xmlrpc.client.ServerProxy("http://%s:8001/" % self.__ip1) as proxy: # file_string = proxy.is_even(self.__game_path) # # # Only refresh if it is the next sequence number # if DGA(json.loads(file_string)).get_seq() == self.__ginfo.get_seq() + 1: # with open(self.__game_path, 'w') as f: # f.write(file_string + '\n') # f.close() # return # # with xmlrpc.client.ServerProxy("http://%s:8001/" % self.__ip2) as proxy: # file_string = proxy.is_even(self.__game_path) # # # Only refresh if it is the next sequence number # if DGA(json.loads(file_string)).get_seq() == self.__ginfo.get_seq() + 1: # with open(self.__game_path, 'w') as f: # f.write(file_string + '\n') # f.close() def __init__(self, game_id: str, ip1: str, ip2): self.__game_id = game_id self.__game_path = 'games/%s.dga' % game_id self.__ip1 = ip1 self.__ip2 = ip2 self.__playable = False self.__game_is_updated = False if game_id is not None: with open(self.__game_path, 'r') as f: time, game_info = f.read().splitlines()[-1].split('$') self.__ginfo: DGA = DGA(json.loads(game_info)) self.__curr_game = self.__ginfo.get_board() if self._validate(self.__curr_game): if not self.__ginfo.game_is_initiated(): if self.__ginfo.can_i_update(): self._update() print('Game is leaving the loop') self.is_looping = False if self.__ginfo.get_player(self._get_turn_of()) == self.get_who_am_i()\ and self.get_ginfo().get_status() == State.ONGOING: self.__playable = True else: print('Not validated?') def get_turn_of(self) -> str: p = self._get_turn_of() return p + ': ' + self.__ginfo.get_player(p) def get_who_am_i(self) -> str: return list(self.__ginfo.get_dic().keys())[list(self.__ginfo.get_dic().values()).index(self.__ginfo.get_mac())] def get_allowed_moves(self): return [1, 2, 3, 4, 5, 6] def move(self, move: str): move = random.randint(1, 6) if self._get_playable(): self.__ginfo.apply_move(move) self.get_ginfo().inc_seq() self._update() self._set_playable(False) else: print('You cannot make a move.') def get_ginfo(self): return self.__ginfo def forfeit(self): return 'Not possible in this game' def _get_playable(self): return self.__playable def _set_playable(self, state: bool): self.__playable = state def _update(self) -> None: with open(self.__game_path, 'a') as f: f.write(self.get_time() + str(self.__ginfo) + '\n') f.close() self.ping_the_updates(self.__game_path, self.__ip1, self.__ip2, MY_IP) def _validate(self, curr_board: dict) -> bool: with open(self.__game_path, 'r')as f: lines = f.read().splitlines() second_last_line = lines[-2] prev_ginfo = DGA(json.loads(second_last_line.split('$')[1])) # Check if same file/string if str(self.__ginfo) == str(prev_ginfo): print('Absolute same string') self.__game_is_updated = False return True prev_board = prev_ginfo.get_board() # Check only board if str(prev_board) == str(curr_board): print('Same board, but other things changed') self.__game_is_updated = True return True # Check if moves before were legit for move in self.get_allowed_moves(): tmp: DGA = copy.deepcopy(prev_ginfo) tmp.apply_move(str(move)) if str(tmp.get_board()) == str(curr_board): self.__game_is_updated = True print('Valid move was made: %s' % move) return True print('An opponent seems to be cheating... Game aborted.') self.__ginfo.set_status(State.CHEATED) self.__ginfo.inc_seq() self._update() print(self.__ginfo.get_status()) return False def _get_turn_of(self) -> str: return self.__ginfo.get_playing_rn() def _get_game_id(self) -> str: return self.__game_id def get_board(self) -> dict: return self.__curr_game
2.40625
2
JDComment/JDComment/spiders/JDCommentSpider.py
Dengqlbq/JDSpider
6
12788566
<filename>JDComment/JDComment/spiders/JDCommentSpider.py<gh_stars>1-10 from scrapy_redis.spiders import RedisSpider from JDComment.items import JDCommentItem from scrapy.utils.project import get_project_settings import scrapy import json import re class JDCommentSpider(RedisSpider): # 获取指定商品的评论(完整评论,非摘要) name = 'JDCommentSpider' allow_domains = ['www.jd.com'] redis_key = 'JDCommentSpider' settings = get_project_settings() comment_url = settings['COMMENT_URL'] def parse(self, response): try: comment_json = json.loads(response.text) except json.decoder.JSONDecodeError: return good_number = re.findall(r'productId=(\d+)', response.url)[0] max_page_num = comment_json['maxPage'] for com in comment_json['comments']: item = JDCommentItem() item['good_num'] = good_number item['content'] = com['content'] yield item for i in range(2, max_page_num): yield scrapy.Request(self.comment_url.format(good_number, i), callback=self.get_leftover) def get_leftover(self, response): try: comment_json = json.loads(response.text) except json.decoder.JSONDecodeError: return good_number = re.findall(r'productId=(\d+)', response.url)[0] for com in comment_json['comments']: item = JDCommentItem() item['good_num'] = good_number item['content'] = com['content'] yield item
2.515625
3
interactive/shell.py
vodik/pytest-interactive
0
12788567
""" An extended shell for test selection """ from IPython.terminal.embed import InteractiveShellEmbed from IPython.core.magic import (Magics, magics_class, line_magic) from IPython.core.history import HistoryManager class PytestShellEmbed(InteractiveShellEmbed): """Custom ip shell with a slightly altered exit message """ def init_history(self): """Sets up the command history, and starts regular autosaves. .. note:: A separate history db is allocated for this plugin separate from regular ip shell sessions such that only relevant commands are retained. """ self.history_manager = HistoryManager( shell=self, parent=self, hist_file=self.pytest_hist_file) self.configurables.append(self.history_manager) def exit(self): """Handle interactive exit. This method calls the ``ask_exit`` callback and if applicable prompts the user to verify the current test selection """ if getattr(self, 'selection', None): print(" \n".join(self.selection.keys())) msg = "\nYou have selected the above {} test(s) to be run."\ "\nWould you like to run pytest now? ([y]/n)?"\ .format(len(self.selection)) else: msg = 'Do you really want to exit ([y]/n)?' if self.ask_yes_no(msg, 'y'): self.ask_exit() @magics_class class SelectionMagics(Magics): """Custom magics for performing multiple test selections within a single session """ def ns_eval(self, line): '''Evalutate line in the embedded ns and return result ''' ns = self.shell.user_ns return eval(line, ns) @property def tt(self): return self.ns_eval('tt') @property def selection(self): return self.tt._selection @property def tr(self): return self.tt._tr def err(self, msg="No tests selected"): self.tr.write("ERROR: ", red=True) self.tr.write_line(msg) @line_magic def add(self, line): '''Add tests from a test set to the current selection. Usage: add tt : add all tests in the current tree add tt[4] : add 5th test in the current tree add tt.tests[1:10] : add tests 1-9 found under the 'tests' module ''' if line: ts = self.ns_eval(line) if ts: self.selection.addtests(ts) else: raise TypeError("'{}' is not a test set".format(ts)) else: print("No test set provided?") @line_magic def remove(self, line, delim=','): """Remove tests from the current selection using a slice syntax using a ',' delimiter instead of ':'. Usage: remove : remove all tests from the current selection remove -1 : remove the last item from the selection remove 1, : remove all but the first item (same as [1:]) remove ,,-3 : remove every third item (same as [::-3]) """ selection = self.selection if not self.selection: self.err() return if not line: selection.clear() return # parse out slice if delim in line: slc = slice(*map(lambda x: int(x.strip()) if x.strip() else None, line.split(delim))) for item in selection[slc]: selection.remove(item) else: # just an index try: selection.remove(selection[int(line)]) except ValueError: self.err("'{}' is not and index or slice?".format(line)) @line_magic def show(self, test_set): '''Show all currently selected test by pretty printing to the console. Usage: show: print currently selected tests ''' items = self.selection.values() if items: self.tt._tprint(items) else: self.err()
2.765625
3
vmtkScripts/contrib/vmtksurfacetagger.py
michelebucelli/vmtk
1
12788568
#!/usr/bin/env python ## Program: VMTK ## Module: $RCSfile: vmtksurfaceclipper.py,v $ ## Language: Python ## Date: $Date: 2006/05/26 12:35:13 $ ## Version: $Revision: 1.9 $ ## Copyright (c) <NAME>, <NAME>. All rights reserved. ## See LICENSE file for details. ## This software is distributed WITHOUT ANY WARRANTY; without even ## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ## PURPOSE. See the above copyright notices for more information. ## Note: this class was contributed by ## <NAME> (<EMAIL>) ## Politecnico di Milano from __future__ import absolute_import #NEEDS TO STAY AS TOP LEVEL MODULE FOR Py2-3 COMPATIBILITY import vtk import sys import math from vmtk import vmtkrenderer from vmtk import pypes class vmtkSurfaceTagger(pypes.pypeScript): def __init__(self): pypes.pypeScript.__init__(self) self.Surface = None self.Method = 'cliparray' self.CellEntityIdsArrayName = 'CellEntityIds' self.CellEntityIdsArray = None self.ArrayName = None self.Array = None self.Value = None self.Range = None self.InsideTag = 2 self.OutsideTag = 1 self.OverwriteOutsideTag = 0 self.InsideOut = 0 self.TagsToModify = None self.ConnectivityOffset = 1 self.TagSmallestRegion = 1 self.CleanOutput = 1 self.PrintTags = 1 self.Tags = None self.HarmonicRadius = 1.0 self.HarmonicGenerateTag = 0 self.HarmonicCleaningFixPoints = 0 self.SetScriptName('vmtksurfacetagger') self.SetScriptDoc('tag a surface exploiting an array defined on it') self.SetInputMembers([ ['Surface','i','vtkPolyData',1,'','the input surface','vmtksurfacereader'], ['Method','method','str',1,'["cliparray","array","harmonic","connectivity","constant","drawing"]','tagging method (cliparray: exploit an array to clip the surface at a certain value tagging the two parts, it creates skew triangles that need a successive remeshing; array: the same of cliparray, but without clipping the original triangles, thus creating a zig-zag tag; harmonic: move harmonically the original points of the input surface toward the array value in order to be able to obtain a precise tag also with a successive call of the array method without the need of remeshing; connectivity: given an already tagged surface, tag disconnected part of each input tag; constant: assign a constant tag to the input surface; drawing: interactive drawing a region)'], ['CellEntityIdsArrayName','entityidsarray','str',1,'','name of the array where the tags are stored'], ['ArrayName','array','str',1,'','name of the array with which to define the boundary between tags'], ['Value','value','float',1,'','scalar value of the array identifying the boundary between tags'], ['Range','range','float',2,'','range scalar values of the array identifying the region for the new tag (alternative to value, only array method)'], ['InsideTag','inside','int',1,'','tag of the inside region (i.e. where the Array is lower than Value; used also in case of "constant" method)'], ['HarmonicRadius','harmonicradius','float',1,'','buffer zone radius for the harmonic method beyond which the points are not moved'], ['HarmonicGenerateTag','harmonicgeneratetag','float',1,'','toggle tagging with the array method after the harmonic movement, it is suggested not to tag directly the surface, but to recompute the array on the warped surface and to use the array method on the recomputed array'], ['HarmonicCleaningFixPoints','harmoniccleanfixpoints','bool',1,'','toggle if the cleaning harmonic method has to fix the points or to leave them free'], ['OverwriteOutsideTag','overwriteoutside','bool',1,'','overwrite outside value also when the CellEntityIdsArray already exists in the input surface'], ['OutsideTag','outside','int',1,'','tag of the outside region (i.e. where the Array is greater than Value)'], ['InsideOut','insideout','bool',1,'','toggle switching inside and outside tags ("cliparray" and "array" methods, only when specifying value and not range)'], ['TagsToModify','tagstomodify','int',-1,'','if set, new tag is created only in this subset of existing tags ("cliparray" only)'], ['ConnectivityOffset','offset','int',1,'','offset added to the entityidsarray of each disconnected parts of each input tag ("connectivity" only)'], ['TagSmallestRegion','tagsmallestregion','bool',1,'','toggle tagging the smallest or the largest region (drawing only)'], ['CleanOutput','cleanoutput','bool',1,'','toggle cleaning the unused points'], ['PrintTags','printtags','bool',1,'','toggle printing the set of tags'] ]) self.SetOutputMembers([ ['Surface','o','vtkPolyData',1,'','the output surface','vmtksurfacewriter'], ['CellEntityIdsArray','oentityidsarray','vtkIntArray',1,'','the output entity ids array'] ]) def CleanSurface(self): cleaner = vtk.vtkCleanPolyData() cleaner.SetInputData(self.Surface) cleaner.Update() self.Surface = cleaner.GetOutput() self.CellEntityIdsArray = self.Surface.GetCellData().GetArray(self.CellEntityIdsArrayName) def ClipArrayTagger(self,onlyRing=False): from vmtk import vmtkscripts # clip the surface according to the Array clipper = vmtkscripts.vmtkSurfaceClipper() clipper.Surface = self.Surface clipper.Interactive = False clipper.InsideOut = 1-self.InsideOut # inside means regions where the Array is lower than Value clipper.CleanOutput = self.CleanOutput clipper.ClipArrayName = self.ArrayName clipper.ClipValue = self.Value clipper.Execute() if onlyRing: return clipper.CutLines else: insideSurface = clipper.Surface outsideSurface = clipper.ClippedSurface # change values of the inside tags insideCellEntityIdsArray = insideSurface.GetCellData().GetArray( self.CellEntityIdsArrayName ) outsideCellEntityIdsArray = outsideSurface.GetCellData().GetArray( self.CellEntityIdsArrayName ) if self.TagsToModify!=None: for i in range(insideCellEntityIdsArray.GetNumberOfTuples()): if insideCellEntityIdsArray.GetValue(i) in self.TagsToModify: insideCellEntityIdsArray.SetValue(i,self.InsideTag) else: insideCellEntityIdsArray.FillComponent(0,self.InsideTag) # merge the inside and the outside surfaces mergeSurface = vtk.vtkAppendPolyData() mergeSurface.AddInputData(insideSurface) mergeSurface.AddInputData(outsideSurface) mergeSurface.Update() self.Surface = mergeSurface.GetOutput() self.CellEntityIdsArray = self.Surface.GetCellData().GetArray(self.CellEntityIdsArrayName) def ArrayTagger(self,surface=None,arrayName=None,insideTag=None,rangeValues=[]): if surface == None: surface = self.Surface if arrayName == None: arrayName = self.ArrayName if insideTag == None: insideTag = self.InsideTag if rangeValues == []: rangeValues = self.Range pointsToCells = vtk.vtkPointDataToCellData() pointsToCells.SetInputData(surface) pointsToCells.PassPointDataOn() pointsToCells.Update() surface = pointsToCells.GetPolyDataOutput() cellEntityIdsArray = surface.GetCellData().GetArray(self.CellEntityIdsArrayName) cellArray = surface.GetCellData().GetArray(arrayName) for i in range(surface.GetNumberOfCells()): if cellArray.GetValue(i) > rangeValues[0] and cellArray.GetValue(i) < rangeValues[1]: cellEntityIdsArray.SetValue(i,insideTag) return surface def CleanPreciseRingDistance(self,ring): from vmtk import vmtkscripts def nextPointId(ring,cellId,currentPointId): idList = vtk.vtkIdList() ring.GetCellPoints(cellId,idList) if idList.GetId(0) == currentPointId: return idList.GetId(1) else: return idList.GetId(0) def nextCellId(ring,pointId,currentCellId): idList = vtk.vtkIdList() ring.GetPointCells(pointId,idList) if idList.GetId(0) == currentCellId: return idList.GetId(1) else: return idList.GetId(0) def checkThreeConsecutivePointsOnATriangle(lastThreeCellIdLists): for item in lastThreeCellIdLists[2]: if item in lastThreeCellIdLists[1]: if item in lastThreeCellIdLists[0]: return True return False nP = ring.GetNumberOfPoints() nC = ring.GetNumberOfCells() # print ("points and cells: ", nP, ", ", nC) pointLocator = vtk.vtkPointLocator() pointLocator.SetDataSet(self.Surface) pointLocator.BuildLocator() lastThreePointsIds = [] lastThreeCellIdLists = [] distanceCleaned = [0, 0, 0, 0] cleanRingPointsIds = set() currentCellId = 0 pointIdList = vtk.vtkIdList() cellIdList = vtk.vtkIdList() ring.GetCellPoints(currentCellId,pointIdList) currentRingPointId = pointIdList.GetId(0) for i in range(nP): lastThreePointsIds.append(currentRingPointId) currentSurfPointId = pointLocator.FindClosestPoint(ring.GetPoint(currentRingPointId)) self.Surface.GetPointCells(currentSurfPointId,cellIdList) cellIds=[] for k in range(cellIdList.GetNumberOfIds()): cellIds.append(cellIdList.GetId(k)) lastThreeCellIdLists.append(cellIds) currentCellId = nextCellId(ring,currentRingPointId,currentCellId) currentRingPointId = nextPointId(ring,currentCellId,currentRingPointId) if i > 1: # print("last three points: ",lastThreePointsIds) # print("last three cell id Lists: ",lastThreeCellIdLists) answer = checkThreeConsecutivePointsOnATriangle(lastThreeCellIdLists) # print("answer: ", answer) if answer: if distanceCleaned[1] == 0: distanceCleaned[2] = 1 cleanRingPointsIds.add(lastThreePointsIds[1]) else: distanceCleaned[1] = 1 cleanRingPointsIds.add(lastThreePointsIds[0]) # print("distance cleaned: ", distanceCleaned) # print("") lastThreePointsIds.pop(0) lastThreeCellIdLists.pop(0) distanceCleaned.append(0) distanceCleaned.pop(0) cleanRingPointsIds = sorted(cleanRingPointsIds) print(cleanRingPointsIds) if self.HarmonicCleaningFixPoints: outputRing = ring distanceArray = outputRing.GetPointData().GetArray('PreciseRingDistance') else: outputRing = vtk.vtkPolyData() distanceArray = vtk.vtkDoubleArray() if self.HarmonicCleaningFixPoints: for pointId in cleanRingPointsIds: distanceArray.SetComponent(pointId,0,0.0) distanceArray.SetComponent(pointId,1,0.0) distanceArray.SetComponent(pointId,2,0.0) else: points = vtk.vtkPoints() lines = vtk.vtkCellArray() countCleanedPoints = 0 ko = 1 firstInsertedId = 0 while ko: if firstInsertedId not in cleanRingPointsIds: ko = 0 else: firstInsertedId = firstInsertedId + 1 lastInsertedId = firstInsertedId for i in range(lastInsertedId+1,nP): # currentSurfPointId = pointLocator.FindClosestPoint(ring.GetPoint(i)) if i not in cleanRingPointsIds: # print ('IDS: ring = ',i,'; surface = ',currentSurfPointId) points.InsertNextPoint(ring.GetPoint(i)) line = vtk.vtkLine() line.GetPointIds().SetId(0,lastInsertedId) line.GetPointIds().SetId(1,i) lines.InsertNextCell(line) lastInsertedId = i else: countCleanedPoints = countCleanedPoints + 1 # print ('IDS: ring = ',i,'; surface = ',currentSurfPointId) print ('IDS: ring = ',i) # cloase the loop line = vtk.vtkLine() line.GetPointIds().SetId(0,lastInsertedId) line.GetPointIds().SetId(1,firstInsertedId) lines.InsertNextCell(line) print('\ncleaned points: ',countCleanedPoints,'/',nP,'\n') outputRing.SetPoints(points) outputRing.SetLines(lines) surfaceProjection = vmtkscripts.vmtkSurfaceProjection() surfaceProjection.Surface = outputRing surfaceProjection.ReferenceSurface = ring surfaceProjection.Execute() outputRing = surfaceProjection.Surface # FIRST AND LAST POINTS NOT YET CHECKED return outputRing def HarmonicTagger(self): from vmtk import vmtkscripts from vmtk import vmtkcontribscripts from vmtk import vtkvmtk def zigZagRingExtractor(surface,arrayname,tag,rangevalues): surf = vtk.vtkPolyData() surf.DeepCopy(surface) surf = self.ArrayTagger(surf,arrayname,tag,rangevalues) th = vmtkcontribscripts.vmtkThreshold() th.Surface = surf th.ArrayName = self.CellEntityIdsArrayName th.CellData = True th.LowThreshold = tag th.HighThreshold = tag th.Execute() surf = th.Surface # boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() # boundaryExtractor.SetInputData(surf) # boundaryExtractor.Update() # zigZagRing = boundaryExtractor.GetOutput() featureEdges = vtk.vtkFeatureEdges() featureEdges.SetInputData(surf) featureEdges.BoundaryEdgesOn() featureEdges.FeatureEdgesOff() featureEdges.NonManifoldEdgesOff() featureEdges.ManifoldEdgesOff() featureEdges.ColoringOff() featureEdges.CreateDefaultLocator() featureEdges.Update() zigZagRing = featureEdges.GetOutput() return zigZagRing tags = set() for i in range(self.Surface.GetNumberOfCells()): tags.add(self.CellEntityIdsArray.GetComponent(i,0)) tags = sorted(tags) # use clip-array method only to extract the ring preciseRing = self.ClipArrayTagger(True) if self.HarmonicGenerateTag: self.ArrayTagger() zigZagRing = zigZagRingExtractor(self.Surface,self.ArrayName,12345,[-math.inf, self.Value]) surfaceDistance = vmtkscripts.vmtkSurfaceDistance() surfaceDistance.Surface = zigZagRing surfaceDistance.ReferenceSurface = preciseRing surfaceDistance.DistanceVectorsArrayName = 'PreciseRingDistance' surfaceDistance.Execute() zigZagRing = surfaceDistance.Surface passArray = vtk.vtkPassArrays() passArray.SetInputData(zigZagRing) passArray.AddPointDataArray('PreciseRingDistance') passArray.Update() zigZagRing = passArray.GetOutput() zigZagRing = self.CleanPreciseRingDistance(zigZagRing) writer = vtk.vtkXMLPolyDataWriter() writer.SetInputData(zigZagRing) writer.SetFileName('zigZagRing.vtp') writer.SetDataModeToBinary() writer.Write() surfaceDistance2 = vmtkscripts.vmtkSurfaceDistance() surfaceDistance2.Surface = self.Surface surfaceDistance2.ReferenceSurface = zigZagRing surfaceDistance2.DistanceArrayName = 'ZigZagRingDistance' surfaceDistance2.Execute() self.Surface = surfaceDistance2.Surface print('OK!') homogeneousBoundaries = zigZagRingExtractor(self.Surface,'ZigZagRingDistance',2435,[-math.inf,self.HarmonicRadius]) pointLocator = vtk.vtkPointLocator() pointLocator.SetDataSet(self.Surface) pointLocator.BuildLocator() for k in range(3): print("Harmonic extension of component ",k) boundaryIds = vtk.vtkIdList() temperature = vtk.vtkDoubleArray() temperature.SetNumberOfComponents(1) for i in range(homogeneousBoundaries.GetNumberOfPoints()): idb = pointLocator.FindClosestPoint(homogeneousBoundaries.GetPoint(i)) boundaryIds.InsertNextId(idb) temperature.InsertNextTuple1(0.0) warpArray = zigZagRing.GetPointData().GetArray('PreciseRingDistance') for i in range(zigZagRing.GetNumberOfPoints()): idb = pointLocator.FindClosestPoint(zigZagRing.GetPoint(i)) boundaryIds.InsertNextId(idb) #temperature.InsertNextTuple1(1.0) temperature.InsertNextTuple1(warpArray.GetComponent(i,k)) # perform harmonic mapping using temperature as boundary condition harmonicMappingFilter = vtkvmtk.vtkvmtkPolyDataHarmonicMappingFilter() harmonicMappingFilter.SetInputData(self.Surface) harmonicMappingFilter.SetHarmonicMappingArrayName('WarpVector'+str(k)) harmonicMappingFilter.SetBoundaryPointIds(boundaryIds) harmonicMappingFilter.SetBoundaryValues(temperature) harmonicMappingFilter.SetAssemblyModeToFiniteElements() harmonicMappingFilter.Update() self.Surface = harmonicMappingFilter.GetOutput() warpVector = vtk.vtkDoubleArray() warpVector.SetNumberOfComponents(3) warpVector.SetNumberOfTuples(self.Surface.GetNumberOfPoints()) warpVector.SetName('WarpVector') warpVectorX = self.Surface.GetPointData().GetArray('WarpVector0') warpVectorY = self.Surface.GetPointData().GetArray('WarpVector1') warpVectorZ = self.Surface.GetPointData().GetArray('WarpVector2') for i in range(self.Surface.GetNumberOfPoints()): warpVector.SetComponent(i,0,warpVectorX.GetComponent(i,0)) warpVector.SetComponent(i,1,warpVectorY.GetComponent(i,0)) warpVector.SetComponent(i,2,warpVectorZ.GetComponent(i,0)) self.Surface.GetPointData().AddArray(warpVector) warper = vtk.vtkWarpVector() warper.SetInputData(self.Surface) warper.SetInputArrayToProcess(0,0,0,0,'WarpVector') warper.SetScaleFactor(1.) warper.Update() self.Surface = warper.GetOutput() def ConnectivityTagger(self): self.CleanSurface() tags = set() for i in range(self.Surface.GetNumberOfCells()): tags.add(self.CellEntityIdsArray.GetComponent(i,0)) tags = sorted(tags) if self.PrintTags: self.PrintLog('Initial tags: '+str(tags)) surface = [] mergeTags = vtk.vtkAppendPolyData() for k, item in enumerate(tags): th = vtk.vtkThreshold() th.SetInputData(self.Surface) th.SetInputArrayToProcess(0, 0, 0, 1, self.CellEntityIdsArrayName) th.ThresholdBetween(item-0.001,item+0.001) th.Update() gf = vtk.vtkGeometryFilter() gf.SetInputConnection(th.GetOutputPort()) gf.Update() surface.append(gf.GetOutput()) connectivityFilter = vtk.vtkConnectivityFilter() connectivityFilter.SetInputData(surface[k]) connectivityFilter.SetExtractionModeToAllRegions() connectivityFilter.ColorRegionsOn() connectivityFilter.Update() surface[k] = connectivityFilter.GetOutput() cellEntityIdsArray = surface[k].GetCellData().GetArray(self.CellEntityIdsArrayName) regionIdArray = surface[k].GetCellData().GetArray('RegionId') for i in range(surface[k].GetNumberOfCells()): tag = cellEntityIdsArray.GetComponent(i,0) +regionIdArray.GetComponent(i,0)*self.ConnectivityOffset cellEntityIdsArray.SetComponent(i,0,tag) mergeTags.AddInputData(surface[k]) mergeTags.Update() self.Surface = mergeTags.GetOutput() self.CellEntityIdsArray = self.Surface.GetCellData().GetArray(self.CellEntityIdsArrayName) def DrawingTagger(self): from vmtk import vmtkscripts drawer = vmtkscripts.vmtkSurfaceRegionDrawing() drawer.Surface = self.Surface drawer.InsideValue = self.InsideTag drawer.OutsideValue = self.OutsideTag drawer.OverwriteOutsideValue = self.OverwriteOutsideTag drawer.ArrayName = self.CellEntityIdsArrayName drawer.TagSmallestRegion = self.TagSmallestRegion drawer.CellData = 1 drawer.ComputeDisance = 0 drawer.Execute() self.Surface = drawer.Surface def Execute(self): if self.Surface == None: self.PrintError('Error: no Surface.') self.CellEntityIdsArray = self.Surface.GetCellData().GetArray(self.CellEntityIdsArrayName) # initialize the CellEntityIdsArray with OutsideTag in some cases if self.CellEntityIdsArray == None or (self.OverwriteOutsideTag and self.Method != "connectivity"): self.CellEntityIdsArray = vtk.vtkIntArray() self.CellEntityIdsArray.SetName(self.CellEntityIdsArrayName) self.CellEntityIdsArray.SetNumberOfComponents(1) self.CellEntityIdsArray.SetNumberOfTuples(self.Surface.GetNumberOfCells()) self.Surface.GetCellData().AddArray(self.CellEntityIdsArray) self.CellEntityIdsArray.FillComponent(0,self.OutsideTag) if self.Method in ['array','harmonic']: # to be extended also to other method ['cliparray','array','harmonic']: if self.Value == None and self.Range == None: self.PrintError("This method need the definition of a value or a range") elif self.Range == None: if self.InsideOut: self.Range = [self.Value, math.inf] else: self.Range = [-math.inf, self.Value] # print("range: ",self.Range) if self.Method == 'cliparray': self.ClipArrayTagger() elif self.Method == 'array': self.ArrayTagger() elif self.Method == 'harmonic': self.HarmonicTagger() elif self.Method == 'connectivity': self.ConnectivityTagger() elif self.Method == 'constant': self.CellEntityIdsArray.FillComponent(0,self.InsideTag) elif self.Method == 'drawing': self.DrawingTagger() else: self.PrintError("Method unknown (available: cliparray, array, connectivity, constant, drawing)") if self.CleanOutput: self.CleanSurface() if self.PrintTags: self.CellEntityIdsArray = self.Surface.GetCellData().GetArray(self.CellEntityIdsArrayName) self.Tags = set() for i in range(self.Surface.GetNumberOfCells()): self.Tags.add(self.CellEntityIdsArray.GetComponent(i,0)) self.Tags = sorted(self.Tags) self.PrintLog('Tags of the output surface: '+str(self.Tags)) # useless, already triangulated # if self.Triangulate: # triangleFilter = vtk.vtkTriangleFilter() # triangleFilter.SetInputData(self.Surface) # triangleFilter.Update() # self.Surface = triangleFilter.GetOutput() if __name__=='__main__': main = pypes.pypeMain() main.Arguments = sys.argv main.Execute()
2.1875
2
KalmanMachine/Kalman4LogisticReg.py
marc-h-lambert/L-RVGA
0
12788569
<filename>KalmanMachine/Kalman4LogisticReg.py ################################################################################### # THE KALMAN MACHINE LIBRARY # # Code supported by <NAME> # ################################################################################### # Online second order method for logistic regression : # # The extended Kalman filter = online natural gradient # # --> see "Online natural gradient as a Kalman filter, <NAME> 2018" # # The quadratic Kalman filter= online version of the bounded variational approach # # --> see "A variational approach to Bayesian logistic regression models \ # # and their extensions, Jaakkola and Jordan 1997" # # The recursive VGA implicit # # The recursive VGA explicit # # --> see "The recursive variational Gaussian approximation (R-VGA), # # <NAME>, <NAME> and <NAME> 2020" # # The recursive VGA explicit with extragrad # # --> see "The limited memory recursive variational Gaussian approximation(L-RVGA)# # <NAME>, <NAME> and <NAME> 2021" # ################################################################################### from .KUtils import sigmoid, sigp, sigpp, graphix, negbayesianlogisticPdf import numpy as np import numpy.random import numpy.linalg as LA from .KBayesianReg import BayesianRegression, OnlineBayesianRegression import math from math import log, exp from scipy import optimize class LogisticPredictor(object): def __init__(self): super().__init__() def predict(self,X): return np.multiply(self.predict_proba(X)>0.5,1) #prediction of N outputs for inputs X=(N,d) #use approximation of the integration over a Gaussian def predict_proba(self,X): N,d=X.shape beta=math.sqrt(8/math.pi) vec_nu=np.diag(X.dot(self.Cov).dot(X.T)) k=beta/np.sqrt(vec_nu+beta**2).reshape(N,1) return sigmoid(k*X.dot(self._theta)) def plotPredictionMap(self,ax,size=6): N=100 x=np.zeros([2,1]) theta1=np.linspace(-size/2,size/2,N) theta2=np.linspace(-size/2,size/2,N) probaOutput=np.zeros((N,N)) xv,yv=np.meshgrid(theta1,theta2) for i in np.arange(0,N): for j in np.arange(0,N): x[0]=xv[i,j] x[1]=yv[i,j] probaOutput[i,j]=self.predict_proba(x.T) contr=ax.contourf(xv,yv,probaOutput,20,zorder=1,cmap='jet') ax.set_xlim(-size/2, size/2) ax.set_ylim(-size/2, size/2) return contr import time, tracemalloc # Batch Laplace version of Bayesian Logistic Regression (with a Gaussian model) class LaplaceLogisticRegression(BayesianRegression, LogisticPredictor): # !!! implement only for theta0=0 and Cov0=sigma0^2 I, # otherwise using sikit.logreg method produce biased maximum posterior def __init__(self, theta0, Cov0): super().__init__(theta0) self._Cov0=Cov0 # the initial covariance (ie uncertainty on the initial guess) self._Cov=np.copy(self._Cov0) def fit(self,X,y): N,d=X.shape (sign, logdetCov) = LA.slogdet(self._Cov0) logdetCov0=logdetCov invCov0=LA.inv(self._Cov0) tracemalloc.start() tic=time.perf_counter() sol=optimize.minimize(negbayesianlogisticPdf, self._theta0, args=(self._theta0,invCov0,logdetCov0,X,y.reshape(N,),1,),method='L-BFGS-B') self._theta=sol.x toc=time.perf_counter() current, peak = tracemalloc.get_traced_memory() tracemalloc.stop() memoryUsedLAP=current/10**6 timeCostLAP=toc-tic print('Compute MAP with sikkit learn/LBFGS... in {0:.2} s'.format(timeCostLAP)) print('Memory cost for MAP with sikkit learn/LBFGS... is {0:.2} MB'.format(memoryUsedLAP)) tracemalloc.start() tic=time.perf_counter() # the Hessian L=sigmoid(X.dot(self._theta)) K=(L*(1-L)).reshape(N,1,1) # Tensor version #A=X[...,None]*X[:,None] #H=np.sum(K*A,axis=0)+LA.inv(self._Cov0) # Memory free version H=invCov0 for i in range(0,N): xt=X[i,:].reshape(d,1) H=H+K[i]*xt.dot(xt.T) self._Cov=LA.inv(H) toc=time.perf_counter() current, peak = tracemalloc.get_traced_memory() tracemalloc.stop() self.memoryUsedLAP=current/10**6 self.timeCostLAP=toc-tic print('Compute LAP with inversion of Hessian... in {0:.2} s'.format(self.timeCostLAP)) print('Memory cost for LAP ... is {0:.2} MB'.format(self.memoryUsedLAP)) return self def plotEllipsoid(self,ax,nbLevels=1,u=0,v=1,labelize=True): d=self._theta.shape[0] thetaproj,Covproj=graphix.projEllipsoid(self._theta,self._Cov.reshape(d,d),u,v) if labelize: graphix.plot_ellipsoid2d(ax,thetaproj,Covproj,col='r',linewidth=1.2,zorder=3,linestyle='-',label='Laplace') else: graphix.plot_ellipsoid2d(ax,thetaproj,Covproj,col='r',linewidth=1.2,zorder=3,linestyle='-') ax.scatter(self._theta[0],self._theta[1],color='r') @property def Cov(self): return self._Cov @property def maxP(self): return self._theta # The natural gradient or EKF class EKFLogReg(OnlineBayesianRegression, LogisticPredictor): def __init__(self, theta0, Cov0, sigma=1, passNumber=1): super().__init__(theta0, Cov0, sigma, passNumber) def update(self,xt,yt): # intermediate variables nu=xt.T.dot(self._Cov.dot(xt)) Pu=self._Cov.dot(xt) a=xt.T.dot(self._theta) m=sigp(a) m=max(m,1e-100) # update state self._Cov=self._Cov-np.outer(Pu,Pu)/(1/m+nu) self._theta=self._theta+self._Cov.dot(xt)*(yt-sigmoid(a)) # equivalent formulas using the Kalman form # def update(self,xt,yt): # # compute R # mu=sigmoid(xt.T.dot(self._theta)) # R=max(mu*(1-mu),1e-100) # H=R*xt.T # # prediction error # err=yt-mu # # computation of optimal gain # S=R+H.dot(self._Cov).dot(H.T) # K=self._Cov.dot(H.T).dot(LA.inv(S)) # # update state and covariance of state # self._theta=self._theta+K.dot(err) # self._Cov=self._Cov-K.dot(H).dot(self._Cov) # The local variational Kalman or quadratic Kalman class QKFLogReg(OnlineBayesianRegression,LogisticPredictor): def __init__(self, theta0, Cov0, sigma=1, passNumber=1): super().__init__(theta0, Cov0, sigma, passNumber) @staticmethod def eta(x): return -1/(2*x)*(sigmoid(x)-0.5) def update(self,xt,yt): # compute matrix R ksi=math.sqrt(xt.T.dot(self._Cov+np.outer(self._theta,self._theta)).dot(xt)) invR=np.ones([1,1])*(-2*QKFLogReg.eta(ksi)) R=LA.inv(invR) # compute gain K H=xt.T S=R+H.dot(self._Cov).dot(H.T) K=self._Cov.dot(H.T).dot(LA.inv(S)) #update theta self._theta=self._theta+K.dot(R.dot(yt-0.5)-H.dot(self._theta)) #update Cov self._Cov=self._Cov-K.dot(H).dot(self._Cov) # equivalent formulas from Jordan paper: # def update(self,xt,yt): # ksi=math.sqrt(xt.T.dot(self._Cov+np.outer(self._theta,self._theta)).dot(xt)) # print(ksi) # P=LA.inv(LA.inv(self._Cov)-2*QKFLogReg2.eta(ksi)*np.outer(xt,xt)) # self._theta=P.dot(LA.inv(self._Cov).dot(self._theta)+(yt-0.5)*xt) # self._Cov=P # The implicit RVGA (with a Newton solver) class RVGALogReg(OnlineBayesianRegression, LogisticPredictor): def __init__(self, theta0, Cov0, sigma=1,passNumber=1): super().__init__(theta0, Cov0, sigma, passNumber) beta=math.sqrt(8/math.pi) def fun2D(x,alpha0,nu0,y): k=RVGALogReg.beta/math.sqrt(exp(x[1])+RVGALogReg.beta**2) f=x[0]+nu0*sigmoid(x[0]*k)-alpha0-nu0*y g=exp(x[1])-nu0/(1+nu0*k*sigp(x[0]*k)) return [f,g] def jac(x,alpha0,nu0,y): k=RVGALogReg.beta/math.sqrt(exp(x[1])+RVGALogReg.beta**2) kp=-0.5*RVGALogReg.beta*exp(x[1])/((exp(x[1])+RVGALogReg.beta**2)**(3/2)) f_a=1+nu0*k*sigp(x[0]*k) f_gamma=nu0*x[0]*kp*sigp(x[0]*k) g_a=nu0**2*k**2*sigpp(x[0]*k)/((1+nu0*k*sigp(x[0]*k))**2) g_gamma=exp(x[1])+nu0**2*kp*(sigp(x[0]*k)+k*x[0]*sigpp(x[0]*k))/((1+nu0*k*sigp(x[0]*k))**2) return np.array([[f_a,f_gamma],[g_a,g_gamma]]) def optim2D(alpha0,nu0,y): alphaMin=alpha0+nu0*y-nu0 alphaMax=alpha0+nu0*y nuMin=nu0*(1-nu0/(4+nu0)) nuMax=nu0 a=(alphaMin+alphaMax)/2 gamma=log((nuMin+nuMax)/2) #a,nu=alpha0,nu0 sol=optimize.root(RVGALogReg.fun2D, [a,gamma], tol=1e-6, args=(alpha0,nu0,y,),jac=RVGALogReg.jac,method='hybr') return sol.x[0],exp(sol.x[1]) ,sol.nfev def update(self,xt,yt): # init parameters nu0=xt.T.dot(self._Cov.dot(xt)) alpha0=xt.T.dot(self._theta) a,nu,nbInnerLoop=RVGALogReg.optim2D(np.asscalar(alpha0), np.asscalar(nu0), np.asscalar(yt)) #updates k=RVGALogReg.beta/math.sqrt(nu+RVGALogReg.beta**2) self._theta=self._theta+self._Cov.dot(xt)*(yt-sigmoid(k*a)) s=1/(nu0+1/(k*sigp(k*a))) self._Cov=self._Cov-s*np.outer(self._Cov.dot(xt),self._Cov.dot(xt)) # The explicit RVGA (without Newton solver) class RVGALogRegExplicit(OnlineBayesianRegression, LogisticPredictor): def __init__(self, theta0, Cov0, sigma=1, passNumber=1): super().__init__(theta0, Cov0, sigma, passNumber) def update(self,xt,yt): beta=RVGALogReg.beta # beta = math.sqrt(8/math.pi) # intermediate variables nu=xt.T.dot(self._Cov.dot(xt)) # compute sigma(a) k=beta/math.sqrt(nu+beta**2) a=xt.T.dot(self._theta) m=k*sigp(k*a) m=max(m,1e-100) # update covariance Pu=self._Cov.dot(xt) self._Cov=self._Cov-np.outer(Pu,Pu)/(1/m+nu) self._theta=self._theta+self._Cov.dot(xt)*(yt-sigmoid(k*a)) # update state # The explicit RVGA with one extragrad (akka Mirror prox) # the mean is always updated two times, the covariance is updated two times # if updateCovTwoTimes=True class RVGALogRegIterated(OnlineBayesianRegression, LogisticPredictor): def __init__(self, theta0, Cov0, sigma=1, passNumber=1,updateCovTwoTimes=True): super().__init__(theta0, Cov0, sigma, passNumber) self.updateCovTwoTimes=updateCovTwoTimes @staticmethod def updateExpectationParameters(xt,theta,Cov): beta=RVGALogReg.beta nu=xt.T.dot(Cov.dot(xt)) k=beta/math.sqrt(nu+beta**2) a=xt.T.dot(theta) return k,a,nu def update(self,xt,yt): Cov=self._Cov theta=self._theta nuOld=xt.T.dot(self._Cov.dot(xt)) PuOld=self._Cov.dot(xt) k,a,nu=RVGALogRegIterated.updateExpectationParameters(xt,theta,Cov) # update covariance: may be transfer in the loop but pose problem on the # condition number m=k*sigp(k*a) if m<1e-100: print(m) m=max(m,1e-100) # update state Cov=self._Cov-np.outer(PuOld,PuOld)/(1/m+nuOld) theta=self._theta+Cov.dot(xt)*(yt-sigmoid(k*a)) k,a,nu=RVGALogRegIterated.updateExpectationParameters(xt,theta,Cov) m=k*sigp(k*a) if m<1e-100: m=max(m,1e-100) if self.updateCovTwoTimes: Cov=self._Cov-np.outer(PuOld,PuOld)/(1/m+nuOld) theta=self._theta+Cov.dot(xt)*(yt-sigmoid(k*a)) self._Cov=Cov self._theta=theta
1.890625
2
day15_p1.py
venomousmoog/adventofcode2021
0
12788570
<filename>day15_p1.py import heapq import sys def compute(data): map = [[int(e) for e in l] for l in data.split('\n')] w = len(map) h = len(map[0]) end = (w-1, h-1) # pq format is [cost, length, counter, position] q = [[0, 0, 0, (0,0)]] counter = 1 visited = set([(0,0)]) while len(q) > 0: cost, length, _, p = heapq.heappop(q) # print(f'{cost}, {length}, {_}, {p}') if p == end: print(cost) return # add neighbors if they aren't in the path already: neighbors = [(p[0], p[1]+1), (p[0], p[1]-1), (p[0]+1, p[1]), (p[0]-1, p[1])] for n in neighbors: if not n in visited and not (n[0] < 0 or n[0] >= w or n[1] < 0 or n[1] >= h): # print(f'n = ({n[0]}, {n[1]})') heapq.heappush(q, [cost + map[n[0]][n[1]], length+1, counter, n]) counter = counter + 1 visited.add(n) test_data = """1163751742 1381373672 2136511328 3694931569 7463417111 1319128137 1359912421 3125421639 1293138521 2311944581""" data="""4395194575929822238989941988598994946581953236424841813955769288219282998336161199274582725132193662 1715719228759138638397684864996679719167258159599658826174926447916886499139963731181569842792979836 5641957947399279962631596818774779918898868615738299911674929785663922472189972649893918935926989965 2585497851318911812329521892518876883669883794214786673934129871993567882759933254875129861732949942 6326121293629918828545199576444799485199997872984968987116189717399321966789925619859799917896971919 1197891193163157699998465137799499428622885997715629793728799611991922169771186415959393796833328797 9971941176236517711968176833694122359799994332972933319744917758263654615939671218999722759897946883 8999294422711677672138234871949951867361994331595339178487499997983949131794946775549222972399289896 3349291493887252933563637858998292429461181979119894978282958316785791165839546981395193797183659157 7189439835616936936452916284895714389978973983979946899115361688238479929831181859649911588342717174 9919687931991844963923118455824186376858799159986659568599889942949751127924998243532126861192227813 8556752119948211196297781958736978151712384292658126551391659754132796214991112228251319499881769877 1979947819698244184997611639891169294112917898297946132711657818979459522579998285949272941189651219 8526183359487314556663171586821716949298464911898919115161199393481771956882329857552411954641939441 1781919896684119688349391339192196799588645991242746996794955718159288456491121922268271789679196351 1197567977371916661139687299725917634957272938365923151889699976438687129398228799597921729929992714 4612932372899778339369954694952999219672973397661799332114944198582981641791452579999989699742756964 6999162799681597281641651777891979395397835152949992426916756338121612297639319849519239816897924832 2929523873329969919578959424699989299758674993329912629488597872529465316591581194999996221889681928 8228656689838938962979299798868965176111786181396381619674278311396838891887432267914997982584599249 3291189727977984366996998628998999313854947791298837533988923314799893553121114286295795551978824232 1969899739799949932911885277583879342673999999696225694755379718993111283179891261733382476218558941 4139678172235724118199726211119671191998665963518891164122317193835651793851195981494569791148964119 8491859444877458918921985959989568279219722914284989216186773895898218317795329987999133881714858193 2771894559749588998196893858679239272818243739928684589924781981773791798991892831999869587961311167 8698775892993989977451194464865721268484216875311866222111987933418291995941958137194897996649415669 9815831789813838789211849713941639192861814785979938811825669343313889446468439829866799197356199957 8391217969784868593822994733189558658223987532137877169778153978669662784849729448991221591737912928 1286923398138799667979629228969771916586553188988688124597199878412159468838995398755911831124947458 1114829212648462813962865127721383493959596596219921932831948169799141594693396881528179473168999246 8229274989319485131759119628887993878981894123939971871579472951958128273735938172877719459979616966 9499516139937388199431887411757519697113346973918231323926539878654177977781846978129796428916386862 4976998292388572314456265734789687366686748398788899297684913137779698579739992995231592719964862978 2298177775583527949898397959425767832825991552239939999392925878819892226485971811999876289184259875 3598947472448691635139959991352673979496318718231961399989962929352899269143994934946299795998128783 7112174898192377964819299748639161162263488897467958394886818188981289197818113459389985525596199819 9987787819769819287382267885519776534891123996871992292115788186562861498191537481789591841846186882 4932928968769839163293479931958989358947715254682158299764179952675896919281473293998826971956719781 9992216325832365211598714373826949876761198899344963795899592692291996816722739297999357184959969777 8299492186897712559157176181191385891631253997468944991976578985988414979191999779899999718894199893 9599634119932298479281989351167939998231691111219295175188529818284912884666292812879581588751975666 9893411889151989895121929229639869648431989868714855378743883971235628399646641369715828182779286514 8939515728674611191619883917891998789585382765378965697452669997798898499199181191539751395986113886 9985666981399318453128358762184119989474811319212718761249919671981988848392275694674398146181416198 8193892754125669889688695711759861961188261942984936153189888489199611811681269985959959968811384341 8299917437379188117917628771687562449889987984991225519931596159725913681979787939969976651741749698 8285297977988918992157859998969934917144295338397889967636236876746919995248975499929976279814914931 9129499129593186731916693856178488768855292651679735946159317969489119952269991769981967997489693511 7186637914671953873792124571983949693887419197239989992917386832793799278886872648567913786197639677 9667487981719871696217751899991188952177479933799965849967487849683858162517919957637748993181344613 4798696188279263112441176132921127173319858683256972916675925279917946959468161918992879929186429996 1875628214911419676889344457796569819463131975985822779517679476958819822619947289779578492991712138 9729987223699868162597477587276969892989969399943929635225993221991199187491492967948629623789668744 9916111911755127191948896779129983784992661981998299971599989198761289123181443629292169995715974949 1291917878889332658369889135368111113759781552671763529821597651871398558593277892399994199844188899 8857659891128611558849143993177991511814858869793389498556946631129988799922937638978992359857839357 9498927473319717382175369484488993971151116118963956979372884748999382475159478948297342397888172486 8838311993693897959989699851182958819758515849648216159982472145775919486496793748386329827875114795 2646323635456985931835993825299725819616464197571881778646919914938572377378887919941193912366189981 4192777568853894179559191115999836896832987112829422358328999616261299876112799681459689496973841216 4182522211326928934549829947681273461197958221628297222967289879895821718559188491763567998193425175 9941452899981779489899453416943116824565113896695891691999972969869313999989231351588275691638731173 4279199328962391513117193251941896142249199541185874189116658753849872967489875833815972485753775799 2692166517168484891439119972374885161996829937192277189246449949998287236914964598317589854294191818 9691899795175315938351268169518149836746199789392955191246577759192964575629739479919199793594669346 4928854341918568913973278223498427458884195453535861967991191927617293996995778496126372492999583688 1869735122593925853281477159999674511464912381748647211595414615939131393112325927225913832758726989 8673156999937894893938221988172251959669284384873549417558434149199712793826799147878341238872169799 3786244397665631994388328169996499172551393184212436839161983999116249888235795513969896377319987648 3299841254618376148274689819516491144697712179196959898422484829331951929556251191292922792943475111 8979685787892899891511168966657683893794989939899716589793811126757987574288699799754629917678927199 5291969299298572611431791117595444556315389932888323856938713114932929293397712995429591559999339269 5571919139695338299758473188558593632658195263118579497481394132986981877919799978847911917349971951 9447171299311825169951839995999391971743173914736767913282767941796338297879485196369168312316114619 8965937476731877998867589955999781971348978541526728915989299973637949395212351839999632681871119852 7154818129168364927991293583982982964961899491189199159915998987259614876919693993277919976424821339 5863889995599382179127198593932798869731787297368813494929776247986339942885147596969931861841289387 8291299218914728523912933158961272669279911995972979992183926289243118311811961558131192613197929186 8961913468988371188879695178682994979962878269287243998918854923819591848296141587688276923892888765 5496139281898589971291971391186884911787687869879279111147189911627194976288937484497924811159764722 9875395289318577859812192389977827241588661341589921792229379945659193616899945199691585158611997752 9897872534836989139768375684846127999667957297219249999952812149314798361868111441889987449192925623 9138263544984999193841859937147586599945426897796171621827994461911885818295944939999799882269659399 6914856489683269528879792799877759191976961973971938559173939387419513299922889959976555221521424697 1715191986151162997669282366919988483318991958172785998996643612786988727959277619145619891677993797 9942283447167676428491385853611565159691399722133269739927118911631657887991431834279716429273499866 4799972923699768188516165542947747617263791192642512198299894199889995551779128118616736724861699788 4958919625759529361425491889628879199991912868912939317496198948944989139197771291619455967185949537 2223977898998997958945226793679996855922957491361985987152262111657894546195945683493497719917994917 2169115388563391991925213886793982979499187969173993849967129291479453796965869487632218484794186428 8181979148789991463199414217818677797879614992639757619958818656897787992873919194129981917198598753 7298898662149861558411999137899133141939277162229327197891618169842134976193137994322715445297289799 3295636966178697931489122998118891198718116639897914658911799996899497168942241323161993721164174647 1198816571471558697411816978791898982893995992519493175459877178916533784561911924112689959897991892 5618962846185938989183714393155171999657459292691693826899689462277599981997875426218165946485993981 9347291669523992969899819288568678793199991148799181869131292289712895996712494789999957779656718174 1211541591292966678912459115993944851245448935997663676619889855226196181522818261837465192373166996 1797339189173753393939899772787971418172195729879466938989599928482964996915184691991154998224136189 3421551897114792849579376681776925441448992599913934985689149424792976946888488111919491919499858968 1971473988843177925911719936118862197889673997928889139314775919195258317837961344298715732432565457""" compute(data)
3.0625
3
bp/common/maths/Maths.py
JAlvarezJarreta/pecan
5
12788571
<gh_stars>1-10 #!/usr/bin/env python #Copyright (C) 2006-2011 by <NAME> (<EMAIL>) # #Released under the MIT license, see LICENSE.txt #!/usr/bin/env python import sys import os import re import math NEG_INFINITY = -1e30000 def exp(x): #return math.exp(x) if x > -2: if x > -0.5: if x > 0: return math.exp(x) return ((((0.03254409303190190000 * x + 0.16280432765779600000)\ * x + 0.49929760485974900000)\ * x + 0.99995149601363700000)\ * x + 0.99999925508501600000) if x > -1: return ((((0.01973899026052090000 * x + 0.13822379685007000000)\ * x + 0.48056651562365000000)\ * x + 0.99326940370383500000)\ * x + 0.99906756856399500000) return ((((0.00940528203591384000 * x + 0.09414963667859410000)\ * x + 0.40825793595877300000)\ * x + 0.93933625499130400000)\ * x + 0.98369508190545300000) if x > -8: if x > -4: return ((((0.00217245711583303000 * x + 0.03484829428350620000)\ * x + 0.22118199801337800000)\ * x + 0.67049462206469500000)\ * x + 0.83556950223398500000) return ((((0.00012398771025456900 * x + 0.00349155785951272000)\ * x + 0.03727721426017900000)\ * x + 0.17974997741536900000)\ * x + 0.33249299994217400000) if x > -16: return ((((0.00000051741713416603 * x + 0.00002721456879608080)\ * x + 0.00053418601865636800)\ * x + 0.00464101989351936000)\ * x + 0.01507447981459420000) return 0 def log(x): return math.log(x) def logAddQuality(x, y): if x < y: if x <= NEG_INFINITY: return y return math.log(math.exp(x - y) + 1) + y if y <= NEG_INFINITY: return x return math.log(math.exp(y - x) + 1) + x __LOG_UNDERFLOW_THRESHOLD = 7.5 __LOG_ZERO = -2e20 # three decimal places def logAdd(x, y): """ if x < y: if x <= __LOG_ZERO or y - x >= __LOG_UNDERFLOW_THRESHOLD: return y return lookup(y - x) + x if y <= __LOG_ZERO or x - y >= __LOG_UNDERFLOW_THRESHOLD: return x return lookup(x - y) + y; """ return logAddQuality(x, y) def lookup(x): #return (float)Math.log (Math.exp(x) + 1); if x <= 2.50: if x <= 1.00: return ((-0.009350833524763 * x + 0.130659527668286)\ * x + 0.498799810682272)\ * x + 0.693203116424741 return ((-0.014532321752540 * x + 0.139942324101744)\ * x + 0.495635523139337)\ * x + 0.692140569840976 if x <= 4.50: return ((-0.004605031767994 * x + 0.063427417320019)\ * x + 0.695956496475118)\ * x + 0.514272634594009 return ((-0.000458661602210 * x + 0.009695946122598) * x + 0.930734667215156)\ * x + 0.168037164329057 def main(): pass def _test(): import doctest return doctest.testmod() if __name__ == '__main__': _test() main()
2.546875
3
gehomesdk/erd/converters/laundry/tank_status_converter.py
bendavis/gehome
0
12788572
import logging from gehomesdk.erd.converters.abstract import ErdReadOnlyConverter from gehomesdk.erd.converters.primitives import * from gehomesdk.erd.values.laundry import ErdTankStatus, TankStatus, TANK_STATUS_MAP _LOGGER = logging.getLogger(__name__) class TankStatusConverter(ErdReadOnlyConverter[TankStatus]): def erd_decode(self, value: str) -> TankStatus: try: om = ErdTankStatus(erd_decode_int(value)) return TANK_STATUS_MAP[om].value except (KeyError, ValueError): return ErdTankStatus.NA
2.171875
2
pdc/apps/common/serializers.py
hluk/product-definition-center
18
12788573
<filename>pdc/apps/common/serializers.py # # Copyright (c) 2015 Red Hat # Licensed under The MIT License (MIT) # http://opensource.org/licenses/MIT # from rest_framework import serializers from contrib.drf_introspection.serializers import StrictSerializerMixin from .models import Label, Arch, SigKey class LabelSerializer(StrictSerializerMixin, serializers.HyperlinkedModelSerializer): """ Label Serializer """ class Meta: model = Label fields = ('url', 'name', 'description') class ArchSerializer(StrictSerializerMixin, serializers.ModelSerializer): class Meta: model = Arch fields = ('name',) class SigKeySerializer(StrictSerializerMixin, serializers.HyperlinkedModelSerializer): name = serializers.CharField(default=None) description = serializers.CharField(required=False, default="") class Meta: model = SigKey fields = ('name', 'key_id', 'description')
2.171875
2
generator/make-permutations.py
Badisches-Landesmuseum/also-known-as
2
12788574
<gh_stars>1-10 import argparse def main (): parser = argparse.ArgumentParser() parser.add_argument("inputFilePath", help="path of input file") parser.add_argument("outputFilePath", help="path of output file") parser.add_argument("--german", help="add -es suffix behind german base adjectives", action="store_true") args = parser.parse_args() make_permutations(args.inputFilePath, args.outputFilePath, args.german) def make_permutations(inputFilePath, outputFilePath, german=False): with open(inputFilePath, 'r') as readFile: lines = readFile.readlines() lines2 = lines[:] print("read " + str(len(lines)) + " lines from " + inputFilePath) suffix = "es" if german else "" permutations = [w1.strip()+suffix+'-'+w2.strip()+suffix for w1 in lines for w2 in lines2 if w1 != w2] with open(outputFilePath, 'w') as writeFile: for perm in permutations: writeFile.write(perm+"\n") print("written " + str(len(permutations)) + " permutations to " + outputFilePath) if __name__ == '__main__': main()
3.5
4
web/impact/impact/v1/helpers/criterion_option_spec_helper.py
masschallenge/impact-api
5
12788575
<reponame>masschallenge/impact-api # MIT License # Copyright (c) 2017 MassChallenge, Inc. from accelerator.models import CriterionOptionSpec from impact.v1.helpers.model_helper import ( ModelHelper, OPTIONAL_FLOAT_FIELD, OPTIONAL_INTEGER_FIELD, PK_FIELD, REQUIRED_INTEGER_FIELD, REQUIRED_STRING_FIELD, ) from impact.v1.helpers.criterion_helper import CriterionHelper from impact.v1.helpers.validators import ( validate_string, validate_integer, validate_float, ) CRITERION_OPTION_SPEC_FIELDS = { "id": PK_FIELD, "option": REQUIRED_STRING_FIELD, "count": OPTIONAL_INTEGER_FIELD, "weight": OPTIONAL_FLOAT_FIELD, "criterion_id": REQUIRED_INTEGER_FIELD, } class CriterionOptionSpecHelper(ModelHelper): '''Encapsulates business logic for CriterionOptionSpecs, including logic around allocation, analysis, and cloning. ''' model = CriterionOptionSpec VALIDATORS = { "option": validate_string, "count": validate_integer, "weight": validate_float, "criterion_id": validate_integer, } REQUIRED_KEYS = [ "option", "criterion_id", ] ALL_KEYS = REQUIRED_KEYS + [ "count", "weight", ] INPUT_KEYS = ALL_KEYS def __init__(self, subject, criterion_helpers=None): super().__init__(subject) criterion = subject.criterion if criterion_helpers is not None: self.criterion_helper = criterion_helpers.get(criterion.id) else: CriterionHelper.find_helper(criterion) def options(self, apps): return self.criterion_helper.options(self.subject, apps) def app_count(self, apps, option_name): return self.criterion_helper.app_count(apps, option_name) @classmethod def fields(cls): return CRITERION_OPTION_SPEC_FIELDS @classmethod def clone_option_specs(cls, clones): for original_id, copy_id in clones: cls.clone_options(original_id, copy_id) @classmethod def clone_options(cls, original_id, copy_id): option_specs = cls.model.objects.filter(criterion_id=original_id) cls.model.objects.bulk_create([ cls.model(option=spec.option, count=spec.count, weight=spec.weight, criterion_id=copy_id) for spec in option_specs])
1.96875
2
rlscore/measure/fscore_measure.py
vishalbelsare/RLScore
61
12788576
<reponame>vishalbelsare/RLScore<filename>rlscore/measure/fscore_measure.py # # The MIT License (MIT) # # This file is part of RLScore # # Copyright (c) 2010 - 2016 <NAME>, <NAME> # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import numpy as np from .measure_utilities import multitask from rlscore.utilities import array_tools from rlscore.measure.measure_utilities import UndefinedPerformance def fscore_singletask(Y, P): correct = Y predictions = P if not np.all((Y==1) + (Y==-1)): raise UndefinedPerformance("fscore accepts as Y-values only 1 and -1") assert len(correct) == len(predictions) TP = 0 FP = 0 FN = 0 for i in range(len(correct)): if correct[i] == 1: if predictions[i] > 0.: TP += 1 else: FN += 1 elif correct[i] == -1: if predictions[i] > 0.: FP += 1 else: assert False P = float(TP)/(TP+FP) R = float(TP)/(TP+FN) F = 2.*(P*R)/(P+R) return F def fscore_multitask(Y, P): return multitask(Y, P, fscore_singletask) def fscore(Y, P): """F1-Score. A performance measure for binary classification problems. F1 = 2*(Precision*Recall)/(Precision+Recall) If 2-dimensional arrays are supplied as arguments, then macro-averaged F-score is computed over the columns. Parameters ---------- Y : {array-like}, shape = [n_samples] or [n_samples, n_labels] Correct labels, must belong to set {-1,1} P : {array-like}, shape = [n_samples] or [n_samples, n_labels] Predicted labels, can be any real numbers. P[i]>0 is treated as a positive, and P[i]<=0 as a negative class prediction. Returns ------- fscore : float number between 0 and 1 """ Y = array_tools.as_2d_array(Y) P = array_tools.as_2d_array(P) if not Y.shape == P.shape: raise UndefinedPerformance("Y and P must be of same shape") return np.mean(fscore_multitask(Y,P)) fscore.iserror = False
1.617188
2
cve-manager/cve_manager/tests/test_function/test_cache.py
seandong37tt4qu/jeszhengq
0
12788577
#!/usr/bin/python3 # ****************************************************************************** # Copyright (c) Huawei Technologies Co., Ltd. 2021-2022. All rights reserved. # licensed under the Mulan PSL v2. # You can use this software according to the terms and conditions of the Mulan PSL v2. # You may obtain a copy of Mulan PSL v2 at: # http://license.coscl.org.cn/MulanPSL2 # THIS SOFTWARE IS PROVIDED ON AN 'AS IS' BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR # PURPOSE. # See the Mulan PSL v2 for more details. # ******************************************************************************/ """ Time: Author: Description: """ import unittest from cve_manager.function.cache import LRUCache class TestCache(unittest.TestCase): def setUp(self): self.cache = LRUCache(2) def test_common(self): self.cache.put('a', [1]) self.cache.put('b', 2) self.cache.put('a', 3) self.assertEqual(len(self.cache.queue), 2) res = self.cache.get('a') self.assertEqual(res, 3)
2.265625
2
src/app.py
tdmalone/bitbucket-approvals-to-jira
0
12788578
<filename>src/app.py<gh_stars>0 # get PR details from incoming approve webhook # quit if all approvers have not approved # look for ticket ID in branch name # look up ticket for any other unapproved PRs (if not possible thru Jira API, use bitbucket API - will have to spread across every repo in the team, though!) - quit if any # make a request to an AfJ webhook to transition ticket from Code Review to Code Review Passed # bonus: work out which jira user should be the actor of the transition change (if that's possible) OR just set a custom field to the user - if we can find them based on the bitbucket user, that is from flask import Flask, request from os import getenv app = Flask(__name__) @app.route('/', methods=['POST']) def handle_webhook(): payload = request.get_json() return 'Hello, world! I don\'t do a lot just yet.'
2.203125
2
unit_testing/test_transect_methods.py
British-Oceanographic-Data-Centre/NEMO-ENTRUST
0
12788579
""" """ # IMPORT modules. Must have unittest, and probably coast. import coast from coast import general_utils import unittest import numpy as np import os.path as path import xarray as xr import matplotlib.pyplot as plt import unit_test_files as files class test_transect_methods(unittest.TestCase): def test_determine_extract_transect_indices(self): nemo_t = coast.Gridded(files.fn_nemo_grid_t_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_t_grid) yt, xt, length_of_line = nemo_t.transect_indices([51, -5], [49, -9]) # Test transect indices yt_ref = [ 164, 163, 162, 162, 161, 160, 159, 158, 157, 156, 156, 155, 154, 153, 152, 152, 151, 150, 149, 148, 147, 146, 146, 145, 144, 143, 142, 142, 141, 140, 139, 138, 137, 136, 136, 135, 134, ] xt_ref = [ 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, ] length_ref = 37 check1 = xt == xt_ref check2 = yt == yt_ref check3 = length_of_line == length_ref self.assertTrue(check1, msg="check1") self.assertTrue(check2, msg="check2") self.assertTrue(check3, msg="check3") def test_calculate_transport_velocity_and_depth(self): with self.subTest("Calculate_transports and velocties and depth"): nemo_t = coast.Gridded( fn_data=files.fn_nemo_grid_t_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_t_grid ) nemo_u = coast.Gridded( fn_data=files.fn_nemo_grid_u_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_u_grid ) nemo_v = coast.Gridded( fn_data=files.fn_nemo_grid_v_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_v_grid ) nemo_f = coast.Gridded(fn_domain=files.fn_nemo_dom, config=files.fn_config_f_grid) tran_f = coast.TransectF(nemo_f, (54, -15), (56, -12)) tran_f.calc_flow_across_transect(nemo_u, nemo_v) cksum1 = tran_f.data_cross_tran_flow.normal_velocities.sum(dim=("t_dim", "z_dim", "r_dim")).item() cksum2 = tran_f.data_cross_tran_flow.normal_transports.sum(dim=("t_dim", "r_dim")).item() check1 = np.isclose(cksum1, -253.6484375) check2 = np.isclose(cksum2, -48.67562136873888) self.assertTrue(check1, msg="check1") self.assertTrue(check2, msg="check2") with self.subTest("plot_transect_on_map"): fig, ax = tran_f.plot_transect_on_map() ax.set_xlim([-20, 0]) # Problem: nice to make the land appear. ax.set_ylim([45, 65]) # But can not call plt.show() before adjustments are made... # fig.tight_layout() fig.savefig(files.dn_fig + "transect_map.png") plt.close("all") with self.subTest("plot_normal_velocity"): plot_dict = {"fig_size": (5, 3), "title": "Normal velocities"} fig, ax = tran_f.plot_normal_velocity(time=0, cmap="seismic", plot_info=plot_dict, smoothing_window=2) fig.tight_layout() fig.savefig(files.dn_fig + "transect_velocities.png") plt.close("all") with self.subTest("plot_depth_integrated_transport"): plot_dict = {"fig_size": (5, 3), "title": "Transport across AB"} fig, ax = tran_f.plot_depth_integrated_transport(time=0, plot_info=plot_dict, smoothing_window=2) fig.tight_layout() fig.savefig(files.dn_fig + "transect_transport.png") plt.close("all") def test_transect_density_and_pressure(self): nemo_t = coast.Gridded( fn_data=files.fn_nemo_grid_t_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_t_grid ) tran_t = coast.TransectT(nemo_t, (54, -15), (56, -12)) tran_t.construct_pressure() cksum1 = tran_t.data.density_zlevels.sum(dim=["t_dim", "r_dim", "depth_z_levels"]).compute().item() cksum2 = tran_t.data.pressure_h_zlevels.sum(dim=["t_dim", "r_dim", "depth_z_levels"]).compute().item() cksum3 = tran_t.data.pressure_s.sum(dim=["t_dim", "r_dim"]).compute().item() check1 = np.isclose(cksum1, 23800545.87457855) check2 = np.isclose(cksum2, 135536478.93335825) check3 = np.isclose(cksum3, -285918.5625) self.assertTrue(check1, msg="check1") self.assertTrue(check2, msg="check2") self.assertTrue(check3, msg="check3") def test_cross_transect_geostrophic_flow(self): nemo_f = coast.Gridded(fn_domain=files.fn_nemo_dom, config=files.fn_config_f_grid) tran_f = coast.TransectF(nemo_f, (54, -15), (56, -12)) nemo_t = coast.Gridded( fn_data=files.fn_nemo_grid_t_dat, fn_domain=files.fn_nemo_dom, config=files.fn_config_t_grid ) tran_f.calc_geostrophic_flow(nemo_t, config_u=files.fn_config_u_grid, config_v=files.fn_config_v_grid) cksum1 = tran_f.data_cross_tran_flow.normal_velocity_hpg.sum(dim=("t_dim", "depth_z_levels", "r_dim")).item() cksum2 = tran_f.data_cross_tran_flow.normal_velocity_spg.sum(dim=("t_dim", "r_dim")).item() cksum3 = tran_f.data_cross_tran_flow.normal_transport_hpg.sum(dim=("t_dim", "r_dim")).item() cksum4 = tran_f.data_cross_tran_flow.normal_transport_spg.sum(dim=("t_dim", "r_dim")).item() check1 = np.isclose(cksum1, 84.8632969783) check2 = np.isclose(cksum2, -5.09718418121) check3 = np.isclose(cksum3, 115.2587369660) check4 = np.isclose(cksum4, -106.7897376093) self.assertTrue(check1, msg="check1") self.assertTrue(check2, msg="check2") self.assertTrue(check3, msg="check3") self.assertTrue(check4, msg="check4")
2.5
2
DataReader.py
DezhengLee/Labster
1
12788580
import numpy as np from csv import reader from decimal import * def SDM(datalist): """ 逐差法 :param datalist: :return: """ length = len(datalist) resultlist = [] halfLen = int(length/2) for i in range(0, halfLen): resultlist.append((Decimal(datalist[i+halfLen]) - Decimal(datalist[i])).to_eng_string()) return resultlist class DataReader: def __init__(self, filename): self.filename = filename with open(filename, 'rt', encoding='UTF-8') as raw_data: readers = reader(raw_data, delimiter=',') overx = list(readers) data = np.array(overx) self.data = data self.resultVar = data[0][1] self.resultUnit = data[0][3] self.function = data[1][1] self.P = float(data[0][5]) if data[1][3] == 'Y': self.flag = True elif data[1][3] == 'N': self.flag = False else: raise IOError('Y or N wanted, not ' + data[1][3]) experimentdata = data[4:len(data)] tempvarlist = [] tempunitlist = [] tempdatalist = [] tempUblist = [] tempSDMflag = [] tempUbFunclist = [] tempfunctionlist = [] for item in experimentdata: tempvarlist.append(item[0]) tempunitlist.append(item[1]) tempUbFunclist.append(item[2]) temptempdata = [] for j in range(3, len(item)): if j == 3: tempUblist.append(item[j]) elif j == 4: tempSDMflag.append(item[j]) elif j == 5: tempfunctionlist.append(item[j]) else: if not item[j] == '': temptempdata.append(item[j]) tempdatalist.append(temptempdata) self.varList = tempvarlist self.unitList = tempunitlist self.UbList = tempUblist self.UbFuncList = tempUbFunclist self.SDMflagList = tempSDMflag self.TempFunctionList = tempfunctionlist for i in range(0, len(tempSDMflag)): if tempSDMflag[i] == 'Y': tempdatalist[i] = SDM(tempdatalist[i]) self.dataList = tempdatalist
2.984375
3
CodeGen/hmlFhirConverterCodeGenerator/codegen/PathYamlGenerator.py
nmdp-bioinformatics/service-hmlFhirConverter
1
12788581
from swagger import RoutingSpecGenerator import os def replace_class_instances(className, fileContents): fileContents = replace_class_named_instances(className, fileContents) fileContents = str(fileContents).replace('**CLASSNAME**', className) return replace_class_plural_instances(className, fileContents) def replace_class_named_instances(className, fileContents): return str(fileContents).replace('**classname**', js_camel_case_string(className)) def replace_class_plural_instances(className, fileContents): pluralUpperClass = transform_class_name_to_plural(className) pluralLowerClass = transform_class_name_to_plural(className.lower()) fileContents = str(fileContents).replace('**PLURAL**', pluralUpperClass) return str(fileContents).replace('**plural**', pluralLowerClass) def transform_class_name_to_plural(className): if className[len(className) - 1] == "y": return str(className)[:(len(className) - 1)] + "ies" return className + "s" def js_camel_case_string(string): return str(string[0]).lower() + string[1:] swagger_paths_spec_dir = r'/Source/API/service-hmlFhirConverter/src/main/resources/swagger/paths' routingSpecGenerator = RoutingSpecGenerator.RoutingSpecGenerator() modelNames = routingSpecGenerator.get_model_names() for model in modelNames: modelTemplate = routingSpecGenerator.get_template() modelTemplate = replace_class_instances(model, modelTemplate) routingSpecGenerator.write_file(os.path.join(swagger_paths_spec_dir, model + '.yaml'), modelTemplate)
2.421875
2
tondo/tests.py
feliperuhland/tondo-api
0
12788582
# -*- coding: utf-8 -*- import random import unittest import tondo class TestSequenceFunctions(unittest.TestCase): JSON_ITEMS = [ 'content', 'contributor', 'type', 'url' ] def setUp(self): self.json = tondo.loadjsons() def test_json_integrity(self): for json_file in self.json: for item in self.json[json_file]: self.assertListEqual(item.keys(), self.JSON_ITEMS) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions) unittest.TextTestRunner(verbosity=2).run(suite)
2.734375
3
migrations/versions/a7acd67386c9_users_table.py
Armalon/PizzaTask
0
12788583
"""users table Revision ID: a7acd67386c9 Revises: Create Date: 2020-07-21 16:17:36.492935 """ from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = '<KEY>' down_revision = None branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('user', sa.Column('id', sa.Integer(), nullable=False), sa.Column('username', sa.String(length=64), nullable=True), sa.Column('address', sa.String(length=256), nullable=True), sa.Column('phone', sa.String(length=20), nullable=True), sa.Column('last_password_hash', sa.String(length=32), nullable=True), sa.PrimaryKeyConstraint('id') ) op.create_index(op.f('ix_user_address'), 'user', ['address'], unique=True) op.create_index(op.f('ix_user_phone'), 'user', ['phone'], unique=True) op.create_index(op.f('ix_user_username'), 'user', ['username'], unique=True) # ### end Alembic commands ### def downgrade(): # ### commands auto generated by Alembic - please adjust! ### op.drop_index(op.f('ix_user_username'), table_name='user') op.drop_index(op.f('ix_user_phone'), table_name='user') op.drop_index(op.f('ix_user_address'), table_name='user') op.drop_table('user') # ### end Alembic commands ###
1.867188
2
tobiko/openstack/stacks/_ubuntu.py
4383/tobiko
0
12788584
# Copyright 2019 Red Hat # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from __future__ import absolute_import import tobiko from tobiko import config from tobiko.openstack import glance from tobiko.openstack.stacks import _nova CONF = config.CONF UBUNTU_IMAGE_URL = \ ('http://cloud-images.ubuntu.com/bionic/current/' 'bionic-server-cloudimg-amd64.img') class UbuntuImageFixture(glance.URLGlanceImageFixture): image_url = CONF.tobiko.ubuntu.image_url or UBUNTU_IMAGE_URL image_name = CONF.tobiko.ubuntu.image_name image_file = CONF.tobiko.ubuntu.image_file disk_format = CONF.tobiko.ubuntu.disk_format or "qcow2" container_format = CONF.tobiko.ubuntu.container_format or "bare" username = CONF.tobiko.ubuntu.username or 'ubuntu' password = <PASSWORD>.password class UbuntuFlavorStackFixture(_nova.FlavorStackFixture): ram = 512 class UbuntuServerStackFixture(_nova.ServerStackFixture): #: Glance image used to create a Nova server instance image_fixture = tobiko.required_setup_fixture(UbuntuImageFixture) #: Flavor used to create a Nova server instance flavor_stack = tobiko.required_setup_fixture(UbuntuFlavorStackFixture)
1.4375
1
backend/tests/wallet_tests/services/offchain/test_offchain.py
tanshuai/reference-wallet
14
12788585
# Copyright (c) The Diem Core Contributors # SPDX-License-Identifier: Apache-2.0 import dataclasses import context import wallet.services.offchain.p2p_payment as pc_service import wallet.services.offchain.utils as utils from diem import identifier, LocalAccount, jsonrpc from diem_utils.types.currencies import DiemCurrency from tests.wallet_tests.resources.seeds.one_user_seeder import OneUser from wallet import storage from wallet.services import offchain as offchain_service from wallet.services.account import ( generate_new_subaddress, ) from wallet.services.offchain import offchain as offchain_service from wallet.storage import db_session from wallet import storage import offchain from wallet.types import TransactionStatus CID = "35a1b548-3170-438f-bf3a-6ca0fef85d15" currency = DiemCurrency.XUS def test_save_outbound_payment_command(monkeypatch): user = OneUser.run( db_session, account_amount=100_000_000_000, account_currency=currency ) amount = 10_000_000_000 receiver = LocalAccount.generate() sub_address = identifier.gen_subaddress() cmd = pc_service.save_outbound_payment_command( user.account_id, receiver.account_address, sub_address, amount, currency ) assert cmd is not None assert cmd.reference_id() is not None model = storage.get_payment_command(cmd.reference_id()) assert model is not None assert model.reference_id is not None assert model.status == TransactionStatus.OFF_CHAIN_OUTBOUND with monkeypatch.context() as m: m.setattr( context.get().offchain_client, "send_command", lambda c, _: offchain.reply_request(c.cid), ) offchain_service.process_offchain_tasks() db_session.refresh(model) assert model.status == TransactionStatus.OFF_CHAIN_WAIT def test_process_inbound_payment_command(monkeypatch): hrp = context.get().config.diem_address_hrp() user = OneUser.run( db_session, account_amount=100_000_000_000, account_currency=currency ) amount = 10_000_000_000 sender = LocalAccount.generate() sender_sub_address = identifier.gen_subaddress() receiver_sub_address = generate_new_subaddress(user.account_id) cmd = offchain.PaymentCommand.init( sender_account_id=identifier.encode_account( sender.account_address, sender_sub_address, hrp ), sender_kyc_data=utils.user_kyc_data(user.account_id), receiver_account_id=identifier.encode_account( context.get().config.vasp_address, receiver_sub_address, hrp ), amount=amount, currency=currency.value, inbound=True, ) with monkeypatch.context() as m: client = context.get().offchain_client m.setattr( client, "deserialize_jws_request", lambda _, c: client.create_inbound_payment_command(c.cid, c.payment), ) m.setattr( client, "process_inbound_request", lambda c, _: client.create_inbound_payment_command(c.cid, c.payment), ) m.setattr( client, "send_command", lambda c, _: offchain.reply_request(c.cid), ) code, resp = offchain_service.process_inbound_command( cmd.payment.sender.address, cmd ) assert code == 200 assert resp model = storage.get_payment_command(cmd.reference_id()) assert model assert model.status == TransactionStatus.OFF_CHAIN_RECEIVER_OUTBOUND assert model.inbound, str(cmd) def test_submit_txn_when_both_ready(monkeypatch): user = OneUser.run( db_session, account_amount=100_000_000_000, account_currency=currency ) amount = 10_000_000_000 receiver = LocalAccount.generate() sub_address = identifier.gen_subaddress() cmd = pc_service.save_outbound_payment_command( user.account_id, receiver.account_address, sub_address, amount, currency ) receiver_cmd = dataclasses.replace( cmd, my_actor_address=cmd.payment.receiver.address ) receiver_ready_cmd = receiver_cmd.new_command( recipient_signature=b"recipient_signature".hex(), status=offchain.Status.ready_for_settlement, kyc_data=utils.user_kyc_data(user.account_id), ) model = storage.get_payment_command(cmd.reference_id()) assert model assert model.status == TransactionStatus.OFF_CHAIN_OUTBOUND assert not model.inbound, str(model) with monkeypatch.context() as m: client = context.get().offchain_client m.setattr( context.get().offchain_client, "deserialize_jws_request", lambda _, c: client.create_inbound_payment_command(c.cid, c.payment), ) m.setattr( client, "process_inbound_request", lambda c, _: client.create_inbound_payment_command(c.cid, c.payment), ) code, resp = offchain_service.process_inbound_command( cmd.payment.receiver.address, receiver_ready_cmd ) assert code == 200 assert resp model = storage.get_payment_command(cmd.reference_id()) assert model assert model.status == TransactionStatus.OFF_CHAIN_INBOUND assert model.inbound, str(model) # sync command and submit with monkeypatch.context() as m: m.setattr( context.get().offchain_client, "send_command", lambda c, _: offchain.reply_request(c.cid), ) m.setattr( context.get(), "p2p_by_travel_rule", jsonrpc_txn_sample, ) offchain_service.process_offchain_tasks() model = storage.get_payment_command(cmd.reference_id()) assert model.status == TransactionStatus.COMPLETED, model.reference_id tx = storage.get_transaction_by_reference_id(model.reference_id) assert tx.status == TransactionStatus.COMPLETED assert tx.sequence == 5 assert tx.blockchain_version == 3232 def jsonrpc_txn_sample(*args): return jsonrpc.Transaction( version=3232, transaction=jsonrpc.TransactionData(sequence_number=5), hash="3232-hash", )
1.789063
2
slack_bot/bot.py
dietrichsimon/slack-bot
0
12788586
import logging import sqlalchemy as db import pandas as pd from slack import WebClient import config # establish connection to postgres database try: engine = db.create_engine("postgres://postgres:1234@postgresdb:5432") except: logging.critical('Could not establish connection to postgres database.') initialize connection with slack client = WebClient(token=config.ACCESS_TOKEN_SLACK) # select most recent tweet from database query = f"""SELECT * FROM tweets;""" df = pd.read_sql(query, engine) tweet = str(df['tweet'].tail(1)) # post tweet on Slack response = client.chat_postMessage( channel="#bot_playground", text=f"Time for a tweet: {tweet}")
2.9375
3
cra_helper/server_check.py
Maronato/django-cra-helper
54
12788587
from urllib import request, error as url_error from django.conf import settings from cra_helper.logging import logger def hosted_by_liveserver(file_url: str) -> bool: # Ignore the server check if we're in production if settings.DEBUG: try: resp = request.urlopen(file_url) if resp.status == 200: logger.debug('{} is being hosted by liveserver'.format(file_url)) return True else: logger.warning('Create-React-App liveserver is up but not serving files') return False except url_error.URLError as err: logger.debug('{} is not being hosted by liveserver'.format(file_url)) return False else: logger.debug('Liveserver host check disabled in production') return False
2.34375
2
dist/Basilisk/fswAlgorithms/inertial3DSpin/inertial3DSpin.py
ian-cooke/basilisk_mag
0
12788588
# This file was automatically generated by SWIG (http://www.swig.org). # Version 3.0.12 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. from sys import version_info as _swig_python_version_info if _swig_python_version_info >= (2, 7, 0): def swig_import_helper(): import importlib pkg = __name__.rpartition('.')[0] mname = '.'.join((pkg, '_inertial3DSpin')).lstrip('.') try: return importlib.import_module(mname) except ImportError: return importlib.import_module('_inertial3DSpin') _inertial3DSpin = swig_import_helper() del swig_import_helper elif _swig_python_version_info >= (2, 6, 0): def swig_import_helper(): from os.path import dirname import imp fp = None try: fp, pathname, description = imp.find_module('_inertial3DSpin', [dirname(__file__)]) except ImportError: import _inertial3DSpin return _inertial3DSpin try: _mod = imp.load_module('_inertial3DSpin', fp, pathname, description) finally: if fp is not None: fp.close() return _mod _inertial3DSpin = swig_import_helper() del swig_import_helper else: import _inertial3DSpin del _swig_python_version_info try: _swig_property = property except NameError: pass # Python < 2.2 doesn't have 'property'. try: import builtins as __builtin__ except ImportError: import __builtin__ def _swig_setattr_nondynamic(self, class_type, name, value, static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'SwigPyObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name, None) if method: return method(self, value) if (not static): if _newclass: object.__setattr__(self, name, value) else: self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self, class_type, name, value): return _swig_setattr_nondynamic(self, class_type, name, value, 0) def _swig_getattr(self, class_type, name): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name, None) if method: return method(self) raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except __builtin__.Exception: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) try: _object = object _newclass = 1 except __builtin__.Exception: class _object: pass _newclass = 0 def new_doubleArray(nelements): return _inertial3DSpin.new_doubleArray(nelements) new_doubleArray = _inertial3DSpin.new_doubleArray def delete_doubleArray(ary): return _inertial3DSpin.delete_doubleArray(ary) delete_doubleArray = _inertial3DSpin.delete_doubleArray def doubleArray_getitem(ary, index): return _inertial3DSpin.doubleArray_getitem(ary, index) doubleArray_getitem = _inertial3DSpin.doubleArray_getitem def doubleArray_setitem(ary, index, value): return _inertial3DSpin.doubleArray_setitem(ary, index, value) doubleArray_setitem = _inertial3DSpin.doubleArray_setitem def new_longArray(nelements): return _inertial3DSpin.new_longArray(nelements) new_longArray = _inertial3DSpin.new_longArray def delete_longArray(ary): return _inertial3DSpin.delete_longArray(ary) delete_longArray = _inertial3DSpin.delete_longArray def longArray_getitem(ary, index): return _inertial3DSpin.longArray_getitem(ary, index) longArray_getitem = _inertial3DSpin.longArray_getitem def longArray_setitem(ary, index, value): return _inertial3DSpin.longArray_setitem(ary, index, value) longArray_setitem = _inertial3DSpin.longArray_setitem def new_intArray(nelements): return _inertial3DSpin.new_intArray(nelements) new_intArray = _inertial3DSpin.new_intArray def delete_intArray(ary): return _inertial3DSpin.delete_intArray(ary) delete_intArray = _inertial3DSpin.delete_intArray def intArray_getitem(ary, index): return _inertial3DSpin.intArray_getitem(ary, index) intArray_getitem = _inertial3DSpin.intArray_getitem def intArray_setitem(ary, index, value): return _inertial3DSpin.intArray_setitem(ary, index, value) intArray_setitem = _inertial3DSpin.intArray_setitem def new_shortArray(nelements): return _inertial3DSpin.new_shortArray(nelements) new_shortArray = _inertial3DSpin.new_shortArray def delete_shortArray(ary): return _inertial3DSpin.delete_shortArray(ary) delete_shortArray = _inertial3DSpin.delete_shortArray def shortArray_getitem(ary, index): return _inertial3DSpin.shortArray_getitem(ary, index) shortArray_getitem = _inertial3DSpin.shortArray_getitem def shortArray_setitem(ary, index, value): return _inertial3DSpin.shortArray_setitem(ary, index, value) shortArray_setitem = _inertial3DSpin.shortArray_setitem def getStructSize(self): try: return eval('sizeof_' + repr(self).split(';')[0].split('.')[-1]) except (NameError) as e: typeString = 'sizeof_' + repr(self).split(';')[0].split('.')[-1] raise NameError(e.message + '\nYou tried to get this size macro: ' + typeString + '\n It appears to be undefined. \nYou need to run the SWIG GEN_SIZEOF' + ' SWIG macro against the class/struct in your SWIG file if you want to ' + ' make this call.\n') def protectSetAttr(self, name, value): if(hasattr(self, name) or name == 'this'): object.__setattr__(self, name, value) else: raise ValueError('You tried to add this variable: ' + name + '\n' + 'To this class: ' + str(self)) def protectAllClasses(moduleType): import inspect clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass) for member in clsmembers: try: exec(str(member[0]) + '.__setattr__ = protectSetAttr') exec(str(member[0]) + '.getStructSize = getStructSize') except (AttributeError, TypeError) as e: pass Update_inertial3DSpin = _inertial3DSpin.Update_inertial3DSpin SelfInit_inertial3DSpin = _inertial3DSpin.SelfInit_inertial3DSpin CrossInit_inertial3DSpin = _inertial3DSpin.CrossInit_inertial3DSpin Reset_inertial3DSpin = _inertial3DSpin.Reset_inertial3DSpin sizeof_inertial3DSpinConfig = _inertial3DSpin.sizeof_inertial3DSpinConfig sizeof_AttRefFswMsg = _inertial3DSpin.sizeof_AttRefFswMsg class inertial3DSpinConfig(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, inertial3DSpinConfig, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, inertial3DSpinConfig, name) __repr__ = _swig_repr __swig_setmethods__["sigma_RN"] = _inertial3DSpin.inertial3DSpinConfig_sigma_RN_set __swig_getmethods__["sigma_RN"] = _inertial3DSpin.inertial3DSpinConfig_sigma_RN_get if _newclass: sigma_RN = _swig_property(_inertial3DSpin.inertial3DSpinConfig_sigma_RN_get, _inertial3DSpin.inertial3DSpinConfig_sigma_RN_set) __swig_setmethods__["omega_spin"] = _inertial3DSpin.inertial3DSpinConfig_omega_spin_set __swig_getmethods__["omega_spin"] = _inertial3DSpin.inertial3DSpinConfig_omega_spin_get if _newclass: omega_spin = _swig_property(_inertial3DSpin.inertial3DSpinConfig_omega_spin_get, _inertial3DSpin.inertial3DSpinConfig_omega_spin_set) __swig_setmethods__["priorTime"] = _inertial3DSpin.inertial3DSpinConfig_priorTime_set __swig_getmethods__["priorTime"] = _inertial3DSpin.inertial3DSpinConfig_priorTime_get if _newclass: priorTime = _swig_property(_inertial3DSpin.inertial3DSpinConfig_priorTime_get, _inertial3DSpin.inertial3DSpinConfig_priorTime_set) __swig_setmethods__["outputDataName"] = _inertial3DSpin.inertial3DSpinConfig_outputDataName_set __swig_getmethods__["outputDataName"] = _inertial3DSpin.inertial3DSpinConfig_outputDataName_get if _newclass: outputDataName = _swig_property(_inertial3DSpin.inertial3DSpinConfig_outputDataName_get, _inertial3DSpin.inertial3DSpinConfig_outputDataName_set) __swig_setmethods__["outputMsgID"] = _inertial3DSpin.inertial3DSpinConfig_outputMsgID_set __swig_getmethods__["outputMsgID"] = _inertial3DSpin.inertial3DSpinConfig_outputMsgID_get if _newclass: outputMsgID = _swig_property(_inertial3DSpin.inertial3DSpinConfig_outputMsgID_get, _inertial3DSpin.inertial3DSpinConfig_outputMsgID_set) __swig_setmethods__["inputRefName"] = _inertial3DSpin.inertial3DSpinConfig_inputRefName_set __swig_getmethods__["inputRefName"] = _inertial3DSpin.inertial3DSpinConfig_inputRefName_get if _newclass: inputRefName = _swig_property(_inertial3DSpin.inertial3DSpinConfig_inputRefName_get, _inertial3DSpin.inertial3DSpinConfig_inputRefName_set) __swig_setmethods__["inputRefID"] = _inertial3DSpin.inertial3DSpinConfig_inputRefID_set __swig_getmethods__["inputRefID"] = _inertial3DSpin.inertial3DSpinConfig_inputRefID_get if _newclass: inputRefID = _swig_property(_inertial3DSpin.inertial3DSpinConfig_inputRefID_get, _inertial3DSpin.inertial3DSpinConfig_inputRefID_set) __swig_setmethods__["attRefOut"] = _inertial3DSpin.inertial3DSpinConfig_attRefOut_set __swig_getmethods__["attRefOut"] = _inertial3DSpin.inertial3DSpinConfig_attRefOut_get if _newclass: attRefOut = _swig_property(_inertial3DSpin.inertial3DSpinConfig_attRefOut_get, _inertial3DSpin.inertial3DSpinConfig_attRefOut_set) def __init__(self): this = _inertial3DSpin.new_inertial3DSpinConfig() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _inertial3DSpin.delete_inertial3DSpinConfig __del__ = lambda self: None inertial3DSpinConfig_swigregister = _inertial3DSpin.inertial3DSpinConfig_swigregister inertial3DSpinConfig_swigregister(inertial3DSpinConfig) def computeReference_inertial3DSpin(ConfigData, omega_R0N_N, domega_R0N_N, omega_RR0_R, dt): return _inertial3DSpin.computeReference_inertial3DSpin(ConfigData, omega_R0N_N, domega_R0N_N, omega_RR0_R, dt) computeReference_inertial3DSpin = _inertial3DSpin.computeReference_inertial3DSpin class AttRefFswMsg(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, AttRefFswMsg, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, AttRefFswMsg, name) __repr__ = _swig_repr __swig_setmethods__["sigma_RN"] = _inertial3DSpin.AttRefFswMsg_sigma_RN_set __swig_getmethods__["sigma_RN"] = _inertial3DSpin.AttRefFswMsg_sigma_RN_get if _newclass: sigma_RN = _swig_property(_inertial3DSpin.AttRefFswMsg_sigma_RN_get, _inertial3DSpin.AttRefFswMsg_sigma_RN_set) __swig_setmethods__["omega_RN_N"] = _inertial3DSpin.AttRefFswMsg_omega_RN_N_set __swig_getmethods__["omega_RN_N"] = _inertial3DSpin.AttRefFswMsg_omega_RN_N_get if _newclass: omega_RN_N = _swig_property(_inertial3DSpin.AttRefFswMsg_omega_RN_N_get, _inertial3DSpin.AttRefFswMsg_omega_RN_N_set) __swig_setmethods__["domega_RN_N"] = _inertial3DSpin.AttRefFswMsg_domega_RN_N_set __swig_getmethods__["domega_RN_N"] = _inertial3DSpin.AttRefFswMsg_domega_RN_N_get if _newclass: domega_RN_N = _swig_property(_inertial3DSpin.AttRefFswMsg_domega_RN_N_get, _inertial3DSpin.AttRefFswMsg_domega_RN_N_set) def __init__(self): this = _inertial3DSpin.new_AttRefFswMsg() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _inertial3DSpin.delete_AttRefFswMsg __del__ = lambda self: None AttRefFswMsg_swigregister = _inertial3DSpin.AttRefFswMsg_swigregister AttRefFswMsg_swigregister(AttRefFswMsg) import sys protectAllClasses(sys.modules[__name__]) # This file is compatible with both classic and new-style classes.
1.695313
2
Source/Squiddy/src/tema-android-adapter-3.2-sma/AndroidAdapter/screencapture.py
samini/gort-public
1
12788589
# -*- coding: utf-8 -*- # Copyright (c) 2006-2010 Tampere University of Technology # # 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. """ Uses the android screenshot application to capture device screen Screenshot is a Java-application delivered with the android source and must be compiled and set up with the following instructions: 1. copy <androidsource>\sdk\screenshot\src\com folder to <androidsdk>\tools 2. with command line, go to <androidsdk>\tools 3. compile the code: javac -classpath lib\ddmlib.jar com\android\screenshot\Screenshot.java 4. set the sdk's tools folder and the <androidsdk>\tools\lib\ddmlib.jar to the CLASSPATH environment variable 5. You should now be able to run the application from any path with the command: java com.android.screenshot.Screenshot """ import subprocess def captureScreen(out_file, serial_id): retcode = subprocess.call(["java", "com.android.screenshot.Screenshot", "-s", serial_id , out_file],stdout = subprocess.PIPE,stderr = subprocess.PIPE) if retcode != 0: print "Error: screenshot application not configured!" if __name__ == "__main__": captureScreen("pic.png", "emulator-5554")
1.6875
2
dynamic_programming/fibonacci_modified.py
laanak08/algorithms
0
12788590
def main(): A,B,N = raw_input().split(" ") print T(int(A),int(B),int(N)) def T(A,B,N): if N == 1: return A elif N == 2: return B else: return ( T(A,B,(N-1)) ** 2 ) + T(A,B,(N-2)) main()
3.515625
4
care/facility/migrations/0190_auto_20201001_1134.py
gigincg/care
189
12788591
<filename>care/facility/migrations/0190_auto_20201001_1134.py<gh_stars>100-1000 # Generated by Django 2.2.11 on 2020-10-01 06:04 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('facility', '0189_auto_20200929_1258'), ] operations = [ migrations.AlterField( model_name='shiftingrequest', name='status', field=models.IntegerField(choices=[(10, 'PENDING'), (15, 'ON HOLD'), (20, 'APPROVED'), (30, 'REJECTED'), (40, 'DESTINATION APPROVED'), (50, 'DESTINATION REJECTED'), (60, 'AWAITING TRANSPORTATION'), (70, 'TRANSFER IN PROGRESS'), (80, 'COMPLETED')], default=10), ), ]
1.554688
2
nuplan/planning/metrics/evaluation_metrics/common/ego_lat_jerk.py
motional/nuplan-devkit
128
12788592
<gh_stars>100-1000 from typing import List from nuplan.planning.metrics.evaluation_metrics.base.within_bound_metric_base import WithinBoundMetricBase from nuplan.planning.metrics.metric_result import MetricStatistics from nuplan.planning.metrics.utils.state_extractors import extract_ego_jerk from nuplan.planning.scenario_builder.abstract_scenario import AbstractScenario from nuplan.planning.simulation.history.simulation_history import SimulationHistory class EgoLatJerkStatistics(WithinBoundMetricBase): """Ego lateral jerk metric.""" def __init__(self, name: str, category: str) -> None: """ Initializes the EgoLatJerkStatistics class :param name: Metric name :param category: Metric category. """ super().__init__(name=name, category=category) def compute(self, history: SimulationHistory, scenario: AbstractScenario) -> List[MetricStatistics]: """ Returns the lateral jerk metric :param history: History from a simulation engine :param scenario: Scenario running this metric :return the estimated lateral jerk metric. """ return self._compute_statistics( # type: ignore history=history, scenario=scenario, statistic_unit_name='meters_per_second_cubed', extract_function=extract_ego_jerk, extract_function_params={'acceleration_coordinate': 'y'}, )
2.34375
2
examples/many_frames.py
RcSepp/asyncframes
2
12788593
# -*- coding: utf-8 -*- # Copyright (c) <NAME>. All Rights Reserved. # Distributed under the MIT License. See LICENSE file for more info. import time from asyncframes import Frame, PFrame, sleep, all_ from asyncframes.asyncio_eventloop import EventLoop @Frame async def main_frame(): subframes = [sub_frame(i) for i in range(10000)] print(sum(1 if result == True else 0 for result in await all_(*subframes))) @PFrame async def sub_frame(i): time.sleep(0.001) return i % 2 == 0 loop = EventLoop() loop.run(main_frame)
3.21875
3
backend/FlaskAPI/mf_insert_table_data.py
steruel/CovalentMFFPrototype
0
12788594
<reponame>steruel/CovalentMFFPrototype # coding: utf-8 # In[1]: ##Includes from flask import request, url_for from flask_api import FlaskAPI, status, exceptions from flask_cors import CORS, cross_origin from flask import Blueprint, render_template, abort import numpy as np # linear algebra import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv) import pickle import json import sqlite3 mf_insert_table_data = Blueprint('mf_insert_table_data', __name__) CORS(mf_insert_table_data) CORS(mf_insert_table_data,resources={r"/mf_insert_table_data/*/": {"origins": "*"}}) #cors = CORS(app, resources={r"/api/*": {"origins": "*"}}) ######flask_api ########## ##Pass header=0 if first line in text file contains header def read_csv_file(filename, seperator, header): df = pd.read_csv(filename,sep=seperator,header=header) return df def df_give_columnnames(df,colnames_array): df.columns = colnames_array return df def write_json_file(df,filename): df.to_json(filename,orient='records') #http://localhost:5000/mf_insert_table_data/model_metadata/model_id=m1&model_description=testmodel #http://localhost:5000/mf_insert_table_data/model_metadata/ @mf_insert_table_data.route("/mf_insert_table_data/model_metadata/", methods=['GET','POST']) @cross_origin() def insertinto_model_metadata(): print ('innnn1') list_records = [] dbname = 'mf' db_file = '../database/'+dbname+'.db' tablename = 'model_metadata' model_id = request.json['model_id'] model_description = request.json['model_description'] datasetid = request.json['datasetid'] print (model_id,model_description,datasetid) conn = sqlite3.connect(db_file) cursor = conn.cursor() status = "ok" try: sql = "insert into model_metadata(model_id, model_description,datasetid) VALUES ('"+model_id+"','"+model_description+"',"+str(datasetid)+")" print sql cursor.execute(sql) print cursor.lastrowid except: print "error" status = "error" conn.commit() conn.close() json = {'status':status} return json
2.203125
2
abc/abc063/abc063c.py
c-yan/atcoder
1
12788595
N = int(input()) s = [int(input()) for _ in range(N)] result = sum(s) if result % 10 != 0: print(result) exit() t = [i for i in s if i % 10 != 0] if len(t) == 0: print(0) else: result -= min(t) print(result)
2.6875
3
scale/job/messages/failed_jobs.py
kaydoh/scale
121
12788596
<filename>scale/job/messages/failed_jobs.py """Defines a command message that sets FAILED status for job models""" from __future__ import unicode_literals import logging from collections import namedtuple from django.db import transaction from error.models import get_error from job.models import Job from messaging.messages.message import CommandMessage from util.parse import datetime_to_string, parse_datetime from util.retry import retry_database_query # This is the maximum number of job models that can fit in one message. This maximum ensures that every message of this # type is less than 25 KiB long. MAX_NUM = 100 FailedJob = namedtuple('FailedJob', ['job_id', 'exe_num', 'error_id']) logger = logging.getLogger(__name__) def create_failed_jobs_messages(failed_jobs, when): """Creates messages to fail the given jobs :param failed_jobs: The failed jobs :type failed_jobs: :func:`list` :param when: When the jobs failed :type when: :class:`datetime.datetime` :return: The list of messages :rtype: :func:`list` """ messages = [] message = None for failed_job in failed_jobs: if not message: message = FailedJobs() message.ended = when elif not message.can_fit_more(): messages.append(message) message = FailedJobs() message.ended = when message.add_failed_job(failed_job) if message: messages.append(message) return messages class FailedJobs(CommandMessage): """Command message that sets FAILED status for job models """ def __init__(self): """Constructor """ super(FailedJobs, self).__init__('failed_jobs') self._count = 0 self._failed_jobs = {} # {Error ID: [FailedJob]} self.ended = None def add_failed_job(self, failed_job): """Adds the given failed job to this message :param failed_job: The failed job :type failed_job: :class:`job.messages.failed_jobs.FailedJob` """ self._count += 1 if failed_job.error_id in self._failed_jobs: self._failed_jobs[failed_job.error_id].append(failed_job) else: self._failed_jobs[failed_job.error_id] = [failed_job] def can_fit_more(self): """Indicates whether more failed jobs can fit in this message :return: True if more failed jobs can fit, False otherwise :rtype: bool """ return self._count < MAX_NUM def to_json(self): """See :meth:`messaging.messages.message.CommandMessage.to_json` """ error_list = [] for error_id, job_list in self._failed_jobs.items(): jobs_list = [] for failed_job in job_list: jobs_list.append({'id': failed_job.job_id, 'exe_num': failed_job.exe_num}) error_list.append({'id': error_id, 'jobs': jobs_list}) return {'ended': datetime_to_string(self.ended), 'errors': error_list} @staticmethod def from_json(json_dict): """See :meth:`messaging.messages.message.CommandMessage.from_json` """ message = FailedJobs() message.ended = parse_datetime(json_dict['ended']) for error_dict in json_dict['errors']: error_id = error_dict['id'] for job_dict in error_dict['jobs']: job_id = job_dict['id'] exe_num = job_dict['exe_num'] message.add_failed_job(FailedJob(job_id, exe_num, error_id)) return message @retry_database_query(max_tries=5, base_ms_delay=1000, max_ms_delay=5000) def execute(self): """See :meth:`messaging.messages.message.CommandMessage.execute` """ from queue.messages.queued_jobs import create_queued_jobs_messages, QueuedJob job_ids = [] for job_list in self._failed_jobs.values(): for failed_job in job_list: job_ids.append(failed_job.job_id) root_recipe_ids = set() with transaction.atomic(): # Retrieve locked job models job_models = {} for job in Job.objects.get_locked_jobs(job_ids): job_models[job.id] = job if job.root_recipe_id: root_recipe_ids.add(job.root_recipe_id) # Get job models with related fields # TODO: once long running job types are gone, the related fields are not needed for job in Job.objects.get_jobs_with_related(job_ids): job_models[job.id] = job jobs_to_retry = [] all_failed_job_ids = [] for error_id, job_list in self._failed_jobs.items(): error = get_error(error_id) jobs_to_fail = [] for failed_job in job_list: job_model = job_models[failed_job.job_id] # If job cannot be failed or execution number does not match, then this update is obsolete if not job_model.can_be_failed() or job_model.num_exes != failed_job.exe_num: # Ignore this job continue # Re-try job if error supports re-try and there are more tries left retry = error.should_be_retried and job_model.num_exes < job_model.max_tries # Also re-try long running jobs retry = retry or job_model.job_type.is_long_running # Do not re-try superseded jobs retry = retry and not job_model.is_superseded if retry: jobs_to_retry.append(QueuedJob(job_model.id, job_model.num_exes)) else: jobs_to_fail.append(job_model) # Update jobs that failed with this error if jobs_to_fail: failed_job_ids = Job.objects.update_jobs_to_failed(jobs_to_fail, error_id, self.ended) logger.info('Set %d job(s) to FAILED status with error %s', len(failed_job_ids), error.name) all_failed_job_ids.extend(failed_job_ids) # Need to update recipes of failed jobs so that dependent jobs are BLOCKED if root_recipe_ids: from recipe.messages.update_recipe import create_update_recipe_messages_from_node self.new_messages.extend(create_update_recipe_messages_from_node(root_recipe_ids)) # Place jobs to retry back onto the queue if jobs_to_retry: self.new_messages.extend(create_queued_jobs_messages(jobs_to_retry, requeue=True)) # Send messages to update recipe metrics from recipe.messages.update_recipe_metrics import create_update_recipe_metrics_messages_from_jobs self.new_messages.extend(create_update_recipe_metrics_messages_from_jobs(job_ids)) return True
2.65625
3
hoc/5_clear.py
DolceVii/astropi
2
12788597
from sense_hat import SenseHat sense = SenseHat() sense.set_rotation(270) magenta=(255,0,255) sense.clear(magenta)
1.5625
2
sources/algorithms/sweepln/rstdregioncyclesweep.py
tipech/OverlapGraph
0
12788598
#!/usr/bin/env python """ Restricted Cyclic Multi-Pass Sweep-line Algorithm for RegionSet Implements an cyclic multi-pass sweep-line algorithm over a set of Regions, within a restricting Region (all Begin and End events must have context Regions that intersect with the specified restricting Region) and within a specified subset of Regions. Implements RestrictedRegionCycleSweep class that executes the specific details and actions of the sweep-line algorithm, when encountering: Init, Begin, End or Done events. Classes: - RestrictedRegionCycleSweep """ from typing import List from sources.core import RegionEvent from .regioncyclesweep import RegionCycleSweep from .rstdregionsweep import RestrictedRegionSweep class RestrictedRegionCycleSweep(RestrictedRegionSweep, RegionCycleSweep): """ A cyclic multi-pass sweep-line algorithm over a set of Regions with restricting Region and subset of Regions. Subscribes to and is evaluated by the cyclic multi-pass sweep-line algorithm along a dimension on the set of Regions. Extends: RestrictedRegionSweep RegionCycleSweep """ def __init__(self, *args, **kwargs): """ Initialize the cyclic multi-pass sweep-line algorithm over a restricted set of Regions. Args: args, kwargs: Arguments for RestrictedRegionSweep.initialize(). """ RestrictedRegionSweep.initialize(self, *args, **kwargs) RegionCycleSweep.__init__(self, self.regions) ### Methods: Event Handlers def on_begin(self, event: RegionEvent): """ Handle Event when cyclic multi-pass sweep-line algorithm encounters the beginning of a Region. Overrides: RestrictedRegionSweep.on_begin RegionSweep.on_begin Args: event: The Region beginning Event. """ if self._should_process(event): RegionCycleSweep.on_begin(self, event) def on_end(self, event: RegionEvent): """ Handle Event when cyclic multi-pass sweep-line algorithm encounters the ending of a Region. Overrides: RestrictedRegionSweep.on_end RegionSweep.on_end Args: event: The Region ending Event. """ if self._should_process(event): RegionCycleSweep.on_end(self, event)
2.984375
3
tests/test_input_checker.py
pzarabadip/PopOff
4
12788599
<gh_stars>1-10 #! /usr/bin/env python3 import pytest import numpy as np from mock import Mock from popoff.fitting_code import FitModel from popoff.lammps_data import LammpsData from popoff.atom_types import AtomType from popoff.input_checker import (check_coreshell, check_scaling_limits, check_spring, check_buckingham, setup_error_checks) @pytest.fixture def mock_fit_data(mock_lammps_data): fit_data = Mock(FitModel) fit_data.lammps_data = [mock_lammps_data] return fit_data @pytest.mark.parametrize( 'label', [('dq_Li'),('dq_Ba')]) def test_typeerror_for_label_in_check_coreshell(label, bounds, mock_fit_data): with pytest.raises(TypeError): check_coreshell(label, bounds, mock_fit_data) @pytest.mark.parametrize( 'bounds', [((-0.9,0.9)),((0,-0.9)),((0.9,1.1)),((1.1,7)),((0.9,0.8))]) def test_valueerror_for_bounds_in_check_coreshell(bounds, mock_fit_data): with pytest.raises(ValueError): check_coreshell("dq_O", bounds, mock_fit_data) @pytest.mark.parametrize( 'bounds', [((-0.9,0.9)),((0,-0.9)),((0.9,1.1)),((1.1,1.1)),((0.9,0.8))]) def test_valueerror_for_bounds_in_check_scaling_limits(bounds): with pytest.raises(ValueError): check_scaling_limits(bounds) @pytest.mark.parametrize( 'bounds', [((-0.9,0.9)),((0,-0.9)),((0.9,0.8))]) def test_valueerror_for_bounds_in_check_spring(bounds, params): with pytest.raises(ValueError): check_spring('O-O spring', bounds, params) @pytest.mark.parametrize( 'label', [('Ni-Ni spring'),('Li-Li spring'),('Li-O spring')]) def test_typeerror_for_label_in_check_spring(label, bounds, params): with pytest.raises(TypeError): check_spring(label, bounds, params) @pytest.mark.parametrize( 'bounds', [((-0.9,0.9)),((0,-0.9)),((0.9,0.8))]) def test_valueerror_for_bounds_in_check_buckingham(bounds, params): with pytest.raises(ValueError): check_buckingham('Li_O_a', bounds, params) @pytest.mark.parametrize( 'label', [('Ni_O_a'),('Li_B_a'),('Li_O_aa')]) def test_typeerror_for_bounds_in_check_buckingham(label, bounds, params): with pytest.raises(TypeError): check_buckingham(label, bounds, params) def test_indexerror_in_setup_error_checks(labels, bounds, params): mock_fit_data = Mock(FitModel) labels = labels[:-1] with pytest.raises(IndexError): setup_error_checks(labels, bounds, mock_fit_data, params) def test_typeerror_in_setup_error_checks(labels, bounds, params): mock_fit_data = Mock(FitModel) labels[0] = 'test' with pytest.raises(TypeError): setup_error_checks(labels, bounds, mock_fit_data, params)
2.0625
2
app/helpers/helpers_search.py
geoadmin/service-search-wsgi
0
12788600
<gh_stars>0 import logging import math import unicodedata from decimal import Decimal from functools import reduce import pyproj.exceptions from pyproj import Proj from pyproj import Transformer from shapely.geometry.base import BaseGeometry from shapely.ops import transform as shape_transform from shapely.wkt import dumps as shape_dumps from shapely.wkt import loads as shape_loads from app import cache from app.lib import sphinxapi logger = logging.getLogger(__name__) # pylint: disable=invalid-name PROJECTIONS = {} # Rounding to abount 0.1 meters COORDINATES_DECIMALS_FOR_METRIC_PROJ = 1 COORDINATES_DECIMALS_FOR_DEGREE_PROJ = 6 # Number of element in an iterator def ilen(iterable): return reduce(lambda sum, element: sum + 1, iterable, 0) def format_search_text(input_str): return remove_accents(escape_sphinx_syntax(input_str)) def format_locations_search_text(input_str): if input_str is None: return input_str # only remove trailing and leading dots input_str = ' '.join([w.strip('.') for w in input_str.split()]) # remove double quotation marks input_str = input_str.replace('"', '') return format_search_text(input_str) def remove_accents(input_str): if input_str is None: return input_str input_str = input_str.replace('ü', 'ue') input_str = input_str.replace('Ü', 'ue') input_str = input_str.replace('ä', 'ae') input_str = input_str.replace('Ä', 'ae') input_str = input_str.replace('ö', 'oe') input_str = input_str.replace('Ö', 'oe') return ''.join( c for c in unicodedata.normalize('NFD', input_str) if unicodedata.category(c) != 'Mn' ) def escape_sphinx_syntax(input_str): if input_str is None: return input_str return sphinxapi.SphinxClient.EscapeString(input_str) def get_proj_from_srid(srid): if srid in PROJECTIONS: return PROJECTIONS[srid] proj = Proj(f'EPSG:{srid}') PROJECTIONS[srid] = proj return proj def get_precision_for_proj(srid): precision = COORDINATES_DECIMALS_FOR_METRIC_PROJ proj = get_proj_from_srid(srid) if proj.crs.is_geographic: precision = COORDINATES_DECIMALS_FOR_DEGREE_PROJ return precision def _round_bbox_coordinates(bbox, precision=None): tpl = f'%.{precision}f' if precision is not None: return [float(Decimal(tpl % c)) for c in bbox] return bbox def _round_shape_coordinates(shape, precision=None): if precision is None: return shape return shape_loads(shape_dumps(shape, rounding_precision=precision)) def round_geometry_coordinates(geom, precision=None): if isinstance(geom, ( list, tuple, )): return _round_bbox_coordinates(geom, precision=precision) if isinstance(geom, BaseGeometry): return _round_shape_coordinates(geom, precision=precision) return geom @cache.memoize(timeout=60) def transform_round_geometry(geom, srid_from, srid_to, rounding=True): if srid_from == srid_to: if rounding: precision = get_precision_for_proj(srid_to) return round_geometry_coordinates(geom, precision=precision) return geom if isinstance(geom, ( list, tuple, )): return _transform_coordinates(geom, srid_from, srid_to, rounding=rounding) return _transform_shape(geom, srid_from, srid_to, rounding=rounding) TRANSFORMER = {} def get_transformer(srid_from, srid_to): transformer_id = f'{srid_from}-to-{srid_to}' if transformer_id in TRANSFORMER: return TRANSFORMER[transformer_id] TRANSFORMER[transformer_id] = Transformer.from_crs(srid_from, srid_to, always_xy=True) return TRANSFORMER[transformer_id] # used by transform_round_geometry used by search.py # Reprojecting pairs of coordinates and rounding them if necessary # Only a point or a line are considered def _transform_coordinates(coordinates, srid_from, srid_to, rounding=True): if len(coordinates) % 2 != 0: logger.error("Invalid coordinates %s, must be two numbers", coordinates) raise ValueError(f"Invalid coordinates {coordinates}, must be two numbers") new_coords = [] transformer = get_transformer(srid_from, srid_to) coords_iter = iter(coordinates) try: for pnt in zip(coords_iter, coords_iter): new_pnt = transformer.transform(pnt[0], pnt[1]) new_coords += new_pnt if rounding: precision = get_precision_for_proj(srid_to) new_coords = _round_bbox_coordinates(new_coords, precision=precision) except (pyproj.exceptions.CRSError) as e: logger.error( "Cannot transform coordinates %s from %s to %s, %s", coordinates, srid_from, srid_to, e ) raise ValueError( f"Cannot transform coordinates {coordinates} from {srid_from} to {srid_to}" ) from e return new_coords # indirectly used by search.py def _transform_shape(geom, srid_from, srid_to, rounding=True): transformer = get_transformer(srid_from, srid_to) new_geom = shape_transform(transformer.transform, geom) if rounding: precision = get_precision_for_proj(srid_to) return _round_shape_coordinates(new_geom, precision=precision) return new_geom # float('NaN') does not raise an Exception. This function does. # used by validation_search.py def float_raise_nan(val): ret = float(val) if math.isnan(ret): raise ValueError('nan is not considered valid float') return ret # used by search.py def parse_box2d(stringBox2D): extent = stringBox2D.replace('BOX(', '').replace(')', '').replace(',', ' ') # Python2/3 box = map(float, extent.split(' ')) if not isinstance(box, list): box = list(box) return box # used by center_from_box_2d used by search.py def is_box2d(box2D): # Python2/3 if not isinstance(box2D, list): box2D = list(box2D) # Bottom left to top right only if len(box2D) != 4 or box2D[0] > box2D[2] or box2D[1] > box2D[3]: raise ValueError(f'Invalid box2D {box2D}.') return box2D # used by search.py def center_from_box2d(box2D): box2D = is_box2d(box2D) return [box2D[0] + ((box2D[2] - box2D[0]) / 2), box2D[1] + ((box2D[3] - box2D[1]) / 2)] # used by validation_search.py and search.py def shift_to(coords, srid): cds = [] x_offset = 2e6 y_offset = 1e6 coords_copy = coords[:] while len(coords_copy) > 0: c = coords_copy.pop(0) if not isinstance(c, (int, float)): raise TypeError('Coordinates should be of type int or float') if srid == 2056: cds.append(c + x_offset if len(coords_copy) % 2 else c + y_offset) elif srid == 21781: cds.append(c - x_offset if len(coords_copy) % 2 else c - y_offset) return cds
2.09375
2
deployer/__init__.py
cezio/deployer
0
12788601
#!/usr/bin/env python # -*- coding: utf-8 -*- import os, sys import subprocess from flask import Flask, Response, request from deployer.runner import run_child app = Flask('deployer') @app.route('/incoming/<deployment_name>/', methods=["POST"]) def incoming(deployment_name): r = request config_path = os.environ.get('DEPLOYER_CONFIG') if not config_path: return Response(response='no deployment config path', status=500) final_path = os.path.join(config_path, '{}.conf'.format(deployment_name)) if not os.path.exists(final_path): return Response(response='no deployment config', status=404) run_child(final_path) response = 'ok' status = 200 r = Response(response=response, status=status) return r if __name__ == '__main__': app.run()
2.1875
2
build_dataset/check_track.py
hotelll/Music_Plagiarism_Detection
2
12788602
import pretty_midi import numpy as np ''' Note class: represent note, including: 1. the note pitch 2. the note duration 3. downbeat 4. intensity of note sound ''' class Note: def __init__(self): self.pitch = 0 self.length = 0 self.downbeat = False self.force = 0 ''' Midi2Numpy: tool to convert midi file to numpy list of Note input_path: the path of the input midi file track_index: the index of the melody track of midi output_path: the path to save the numpy array ''' def Midi2Numpy(input_path, output_path, track_index): midi_data = pretty_midi.PrettyMIDI(input_path) notes = midi_data.instruments[track_index].notes downbeats = midi_data.get_downbeats() dataset = [] for n in notes: note = Note() for i in downbeats: ''' the downbeat locates in this note's duration we see the note as downbeat ''' if n.start <= i < n.end: note.downbeat = True note.pitch = n.pitch note.length = n.end - n.start note.force = n.velocity dataset.append(note) np.save(output_path, dataset) path = 'plag/23_ma este meg.mid' test = pretty_midi.PrettyMIDI() midi_data = pretty_midi.PrettyMIDI(path) # decide the track index track_index = 0 notes = midi_data.instruments[track_index] test.instruments.append(notes) test.write('test.mid') test.write("newdata" + path[4:])
3.125
3
Q/mindmaps/migrations/0001_initial.py
ES-DOC/esdoc-questionnaire
0
12788603
<reponame>ES-DOC/esdoc-questionnaire # -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ] operations = [ migrations.CreateModel( name='MindMapDomain', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('domain', models.URLField()), ], options={ 'verbose_name': 'MindMap Domain', 'verbose_name_plural': 'MindMap Domains', }, ), migrations.CreateModel( name='MindMapSource', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('name', models.CharField(unique=True, max_length=64)), ('enabled', models.BooleanField(default=True)), ], options={ 'verbose_name': 'MindMap Source', 'verbose_name_plural': 'MindMap Sources', }, ), migrations.AddField( model_name='mindmapdomain', name='source', field=models.ForeignKey(related_name='domains', to='mindmaps.MindMapSource'), ), ]
1.703125
2
6 - Python/Strings/2 - String Split And Join.py
Terence-Guan/Python.HackerRank
88
12788604
l = input() print('-'.join(input().split())) # print(l.replace(" ", "-"))
3.546875
4
dataspace/count/__init__.py
Sam-prog-sudo/dataspace
3
12788605
<gh_stars>1-10 from .count import _count_empty_, _count_null_, _count_unique_, _count_zero_
1.03125
1
allenact_plugins/manipulathor_plugin/manipulathor_viz.py
zcczhang/allenact
2
12788606
"""Utility functions and classes for visualization and logging.""" import os from datetime import datetime import cv2 import imageio import numpy as np from allenact_plugins.manipulathor_plugin.manipulathor_utils import initialize_arm from allenact_plugins.manipulathor_plugin.manipulathor_utils import ( reset_environment_and_additional_commands, transport_wrapper, ) class LoggerVisualizer: def __init__(self, exp_name="", log_dir=""): if log_dir == "": log_dir = self.__class__.__name__ if exp_name == "": exp_name = "NoNameExp" now = datetime.now() self.exp_name = exp_name log_dir = os.path.join( "experiment_output/visualizations", exp_name, log_dir + "_" + now.strftime("%m_%d_%Y_%H_%M_%S_%f"), ) self.log_dir = log_dir os.makedirs(self.log_dir, exist_ok=True) self.log_queue = [] self.action_queue = [] self.logger_index = 0 def log(self, environment, action_str): raise Exception("Not Implemented") def is_empty(self): return len(self.log_queue) == 0 def finish_episode_metrics(self, episode_info, task_info, metric_results): pass def finish_episode(self, environment, episode_info, task_info): pass class TestMetricLogger(LoggerVisualizer): def __init__(self, **kwargs): super().__init__(**kwargs) self.total_metric_dict = {} log_file_name = os.path.join( self.log_dir, "test_metric_{}.txt".format(self.exp_name) ) self.metric_log_file = open(log_file_name, "w") def average_dict(self): result = {} for (k, v) in self.total_metric_dict.items(): result[k] = sum(v) / len(v) return result def finish_episode_metrics(self, episode_info, task_info, metric_results=None): if metric_results is None: print("had to reset") self.log_queue = [] self.action_queue = [] return for k in metric_results.keys(): if "metric" in k or k in ["ep_length", "reward", "success"]: self.total_metric_dict.setdefault(k, []) self.total_metric_dict[k].append(metric_results[k]) print( "total", len(self.total_metric_dict["success"]), "average test metric", self.average_dict(), ) # save the task info and all the action queue and results log_dict = { "task_info_metrics": metric_results, "action_sequence": self.action_queue, "logger_number": self.logger_index, } self.logger_index += 1 self.metric_log_file.write(str(log_dict)) self.metric_log_file.write("\n") print("Logging to", self.metric_log_file.name) self.log_queue = [] self.action_queue = [] def log(self, environment, action_str): # We can add agent arm and state location if needed self.action_queue.append(action_str) self.log_queue.append(action_str) class BringObjImageVisualizer(LoggerVisualizer): def finish_episode(self, environment, episode_info, task_info): now = datetime.now() time_to_write = now.strftime("%m_%d_%Y_%H_%M_%S_%f") time_to_write += "log_ind_{}".format(self.logger_index) self.logger_index += 1 print("Loggigng", time_to_write, "len", len(self.log_queue)) source_object_id = task_info["source_object_id"] goal_object_id = task_info["goal_object_id"] pickup_success = episode_info.object_picked_up episode_success = episode_info._success # Put back if you want the images # for i, img in enumerate(self.log_queue): # image_dir = os.path.join(self.log_dir, time_to_write + '_seq{}.png'.format(str(i))) # cv2.imwrite(image_dir, img[:,:,[2,1,0]]) episode_success_offset = "succ" if episode_success else "fail" pickup_success_offset = "succ" if pickup_success else "fail" gif_name = ( time_to_write + "_from_" + source_object_id.split("|")[0] + "_to_" + goal_object_id.split("|")[0] + "_pickup_" + pickup_success_offset + "_episode_" + episode_success_offset + ".gif" ) concat_all_images = np.expand_dims(np.stack(self.log_queue, axis=0), axis=1) save_image_list_to_gif(concat_all_images, gif_name, self.log_dir) this_controller = environment.controller scene = this_controller.last_event.metadata["sceneName"] reset_environment_and_additional_commands(this_controller, scene) self.log_start_goal( environment, task_info["visualization_source"], tag="start", img_adr=os.path.join(self.log_dir, time_to_write), ) self.log_start_goal( environment, task_info["visualization_target"], tag="goal", img_adr=os.path.join(self.log_dir, time_to_write), ) self.log_queue = [] self.action_queue = [] def log(self, environment, action_str): image_tensor = environment.current_frame self.action_queue.append(action_str) self.log_queue.append(image_tensor) def log_start_goal(self, env, task_info, tag, img_adr): object_location = task_info["object_location"] object_id = task_info["object_id"] agent_state = task_info["agent_pose"] this_controller = env.controller # We should not reset here # for start arm from high up as a cheating, this block is very important. never remove event1, event2, event3 = initialize_arm(this_controller) if not ( event1.metadata["lastActionSuccess"] and event2.metadata["lastActionSuccess"] and event3.metadata["lastActionSuccess"] ): print("ERROR: ARM MOVEMENT FAILED in logging! SHOULD NEVER HAPPEN") event = transport_wrapper(this_controller, object_id, object_location) if event.metadata["lastActionSuccess"] == False: print("ERROR: oh no could not transport in logging") event = this_controller.step( dict( action="TeleportFull", standing=True, x=agent_state["position"]["x"], y=agent_state["position"]["y"], z=agent_state["position"]["z"], rotation=dict( x=agent_state["rotation"]["x"], y=agent_state["rotation"]["y"], z=agent_state["rotation"]["z"], ), horizon=agent_state["cameraHorizon"], ) ) if event.metadata["lastActionSuccess"] == False: print("ERROR: oh no could not teleport in logging") image_tensor = this_controller.last_event.frame image_dir = ( img_adr + "_obj_" + object_id.split("|")[0] + "_pickup_" + tag + ".png" ) cv2.imwrite(image_dir, image_tensor[:, :, [2, 1, 0]]) # Saving the mask target_object_id = task_info["object_id"] all_visible_masks = this_controller.last_event.instance_masks if target_object_id in all_visible_masks: mask_frame = all_visible_masks[target_object_id] else: mask_frame = np.zeros(env.controller.last_event.frame[:, :, 0].shape) mask_dir = ( img_adr + "_obj_" + object_id.split("|")[0] + "_pickup_" + tag + "_mask.png" ) cv2.imwrite(mask_dir, mask_frame.astype(float) * 255.0) class ImageVisualizer(LoggerVisualizer): def finish_episode(self, environment, episode_info, task_info): now = datetime.now() time_to_write = now.strftime("%m_%d_%Y_%H_%M_%S_%f") time_to_write += "log_ind_{}".format(self.logger_index) self.logger_index += 1 print("Loggigng", time_to_write, "len", len(self.log_queue)) object_id = task_info["objectId"] pickup_success = episode_info.object_picked_up episode_success = episode_info._success # Put back if you want the images # for i, img in enumerate(self.log_queue): # image_dir = os.path.join(self.log_dir, time_to_write + '_seq{}.png'.format(str(i))) # cv2.imwrite(image_dir, img[:,:,[2,1,0]]) episode_success_offset = "succ" if episode_success else "fail" pickup_success_offset = "succ" if pickup_success else "fail" gif_name = ( time_to_write + "_obj_" + object_id.split("|")[0] + "_pickup_" + pickup_success_offset + "_episode_" + episode_success_offset + ".gif" ) concat_all_images = np.expand_dims(np.stack(self.log_queue, axis=0), axis=1) save_image_list_to_gif(concat_all_images, gif_name, self.log_dir) self.log_start_goal( environment, task_info["visualization_source"], tag="start", img_adr=os.path.join(self.log_dir, time_to_write), ) self.log_start_goal( environment, task_info["visualization_target"], tag="goal", img_adr=os.path.join(self.log_dir, time_to_write), ) self.log_queue = [] self.action_queue = [] def log(self, environment, action_str): image_tensor = environment.current_frame self.action_queue.append(action_str) self.log_queue.append(image_tensor) def log_start_goal(self, env, task_info, tag, img_adr): object_location = task_info["object_location"] object_id = task_info["object_id"] agent_state = task_info["agent_pose"] this_controller = env.controller scene = this_controller.last_event.metadata[ "sceneName" ] # maybe we need to reset env actually] reset_environment_and_additional_commands(this_controller, scene) # for start arm from high up as a cheating, this block is very important. never remove event1, event2, event3 = initialize_arm(this_controller) if not ( event1.metadata["lastActionSuccess"] and event2.metadata["lastActionSuccess"] and event3.metadata["lastActionSuccess"] ): print("ERROR: ARM MOVEMENT FAILED in logging! SHOULD NEVER HAPPEN") event = transport_wrapper(this_controller, object_id, object_location) if event.metadata["lastActionSuccess"] == False: print("ERROR: oh no could not transport in logging") event = this_controller.step( dict( action="TeleportFull", standing=True, x=agent_state["position"]["x"], y=agent_state["position"]["y"], z=agent_state["position"]["z"], rotation=dict( x=agent_state["rotation"]["x"], y=agent_state["rotation"]["y"], z=agent_state["rotation"]["z"], ), horizon=agent_state["cameraHorizon"], ) ) if event.metadata["lastActionSuccess"] == False: print("ERROR: oh no could not teleport in logging") image_tensor = this_controller.last_event.frame image_dir = ( img_adr + "_obj_" + object_id.split("|")[0] + "_pickup_" + tag + ".png" ) cv2.imwrite(image_dir, image_tensor[:, :, [2, 1, 0]]) def save_image_list_to_gif(image_list, gif_name, gif_dir): gif_adr = os.path.join(gif_dir, gif_name) seq_len, cols, w, h, c = image_list.shape pallet = np.zeros((seq_len, w, h * cols, c)) for col_ind in range(cols): pallet[:, :, col_ind * h : (col_ind + 1) * h, :] = image_list[:, col_ind] if not os.path.exists(gif_dir): os.makedirs(gif_dir) imageio.mimsave(gif_adr, pallet.astype(np.uint8), format="GIF", duration=1 / 5) print("Saved result in ", gif_adr)
2.46875
2
hijackingprevention/user.py
michardy/account-hijacking-prevention
3
12788607
import logging from tornado import gen import hijackingprevention.db_int as db_int logger = logging.getLogger(__name__) class User(db_int.Interface): """This class handles reading, writing, and manipulating user objects.""" def __init__(self, uid, site, db): self.__id_type = "uid" self.__id = uid self.__data_type= 'userData_site-' self.data = {} self.code = None #verification token self.__site = str(site) self.__db = db super(User, self).__init__(db, self.__data_type, str(site), self.__id_type, uid, self.__combine) @gen.coroutine def read_db(self): """Reads user object from DB.""" sud = self.__db[self.__data_type + self.__site] user = yield sud.find_one({'uid':self.__id}) #Try to find user if user is not None: self.data = user['data'] try: self.code = user['code'] except KeyError: pass def add_data(self, data): """Adds data to user.""" for k in data.keys(): if k in self.data.keys(): self.data[k].append(data[k]) else: self.data[k] = [data[k]] def __combine(self): """Returns user object as dictionary""" return({self.__id_type:self.__id, 'data':self.data, 'code':self.code})
2.671875
3
utils/fit.py
sean-mackenzie/gdpyt-analysis
0
12788608
<gh_stars>0 # gdpyt-analysis: utils.fit """ Notes """ # imports import math import numpy as np from scipy.optimize import curve_fit, minimize from scipy.interpolate import SmoothBivariateSpline import functools from utils import functions # scripts def gauss_1d_function(x, a, x0, sigma): return a * np.exp(-(x - x0) ** 2 / (2 * sigma ** 2)) def fit(x, y, fit_function=None, bounds=None): # fit the function if fit_function is None: popt, pcov = curve_fit(functions.parabola, x, y) fit_function = functions.parabola else: if bounds is not None: popt, pcov = curve_fit(fit_function, x, y, bounds=bounds) else: popt, pcov = curve_fit(fit_function, x, y) return popt, pcov, fit_function def fit_3d(points, fit_function): return fit_3d_plane(points) def fit_3d_plane(points): fun = functools.partial(functions.plane_error, points=points) params0 = np.array([0, 0, 0]) res = minimize(fun, params0) a = res.x[0] b = res.x[1] c = res.x[2] point = np.array([0.0, 0.0, c]) normal = np.array(functions.cross([1, 0, a], [0, 1, b])) d = -point.dot(normal) popt = [a, b, c, d, normal] minx = np.min(points[:, 0]) miny = np.min(points[:, 1]) maxx = np.max(points[:, 0]) maxy = np.max(points[:, 1]) xx, yy = np.meshgrid([minx, maxx], [miny, maxy]) z = (-normal[0] * xx - normal[1] * yy - d) * 1. / normal[2] return xx, yy, z, popt def fit_3d_spline(x, y, z, kx=1, ky=2): w = np.ones_like(x) bispl = SmoothBivariateSpline(x, y, z, w=w, kx=kx, ky=ky) rmse = np.sqrt(bispl.get_residual() / len(x)) return bispl, rmse def fit_3d_sphere(X, Y, Z): """ Fit a sphere to data points (X, Y, Z) and return the sphere radius and center of best fit. Reference: <NAME> (2016); https://jekel.me/2015/Least-Squares-Sphere-Fit/ :param X: :param Y: :param Z: :return: """ # Assemble the A matrix X = np.array(X) Y = np.array(Y) Z = np.array(Z) A = np.zeros((len(X), 4)) A[:, 0] = X * 2 A[:, 1] = Y * 2 A[:, 2] = Z * 2 A[:, 3] = 1 # Assemble the f matrix f = np.zeros((len(X), 1)) f[:, 0] = (X * X) + (Y * Y) + (Z * Z) C, residules, rank, singval = np.linalg.lstsq(A, f) xc, yc, zc = C[0], C[1], C[2] # solve for the radius t = (xc * xc) + (yc * yc) + (zc * zc) + C[3] radius = math.sqrt(t) return radius, xc, yc, zc def fit_3d_sphere_from_center(spX, spY, spZ, xc, yc): """ Fit a sphere to data points (spX, spY, spZ) given the sphere center in x-y coordinates. :param spX: :param spY: :param spZ: :param xc: :param yc: :return: """ # Assemble the A matrix spX = np.array(spX) spY = np.array(spY) spZ = np.array(spZ) A = np.zeros((len(spX), 2)) A[:, 0] = spZ * 2 A[:, 1] = 1 # Assemble the f matrix f = np.zeros((len(spX), 1)) f[:, 0] = (spX * spX) + (spY * spY) + (spZ * spZ) - (2 * spX * xc) - (2 * spY * yc) # least squares fit C, residules, rank, singval = np.linalg.lstsq(A, f) zc = C[0] # solve for the radius t = (xc ** 2) + (yc ** 2) + (zc ** 2) + C[1] radius = math.sqrt(t) return radius, C[0] def fit_ellipsoid_from_center(X, Y, Z, xc, yc, zc, r): """ Fit a 3D ellipsoid given the x, y, z center coordinates, x-radius, and y-radius. Somewhat helpful reference: https://jekel.me/2020/Least-Squares-Ellipsoid-Fit/ :param X: :param Y: :param Z: :param xc: :param yc: :param zc: :param r: :return: """ X = np.array(X) Y = np.array(Y) Z = np.array(Z) f = np.zeros((len(X), 1)) f[:, 0] = -1 * ((Z * Z) - (2 * zc * Z) + (zc * zc)) A = np.zeros((len(X), 1)) A[:, 0] = ((X * X) - (2 * xc * X) + (xc * xc) + (Y * Y) - (2 * yc * Y) + (yc * yc)) / (r * r) - 1 # least squares fit C, residules, rank, singval = np.linalg.lstsq(A, f) # solve for radius in z-dir. r_z = math.sqrt(C[0]) return r_z def fit_ellipsoid_non_linear(X, Y, Z): """ Non-linear regression + optimization to find ellipsoid parameters. Reference: https://jekel.me/2021/A-better-way-to-fit-Ellipsoids/ :param X: :param Y: :param Z: :return: """ x, y, z = X, Y, Z pass def fit_smooth_surface(df, z_param='z'): """ Uses the 'smooth_surface' fit function on a dataframe. :param df: :return: """ # convert data into proper format x_data = df.x.to_numpy() y_data = df.y.to_numpy() z_data = df[z_param].to_numpy() data = [x_data, y_data] # get fit parameters from scipy curve fit fittedParameters, covariance = curve_fit(functions.smooth_surface, data, z_data) # --- calculate prediction errors rmse, r_squared = calculate_fit_error(fit_results=None, data_fit_to=z_data, fit_func=functions.smooth_surface, fit_params=fittedParameters, data_fit_on=data, ) # deprecated prediction errors """modelPredictions = functions.smooth_surface(data, *fittedParameters) absError = modelPredictions - z_data SE = np.square(absError) # squared errors MSE = np.mean(SE) # mean squared errors RMSE = np.sqrt(MSE) # Root Mean Squared Error, RMSE Rsquared = 1.0 - (np.var(absError) / np.var(z_data))""" return rmse, r_squared, fittedParameters # ----------------------------------------------- HELPER FUNCTIONS ----------------------------------------------------- def calculate_fit_error(fit_results, data_fit_to, fit_func=None, fit_params=None, data_fit_on=None): """ Two options for calculating fit error: 1. fit_func + fit_params: the fit results are calculated. 2. fit_results: the fit results are known for each data point. :param fit_func: the function used to calculate the fit. :param fit_params: generally, popt. :param fit_results: the outputs at each input data point ('data_fit_on') :param data_fit_on: the input data that was inputted to fit_func to generate the fit. :param data_fit_to: the output data that fit_func was fit to. :return: """ # --- calculate prediction errors if fit_results is None: fit_results = fit_func(data_fit_on, *fit_params) abs_error = fit_results - data_fit_to se = np.square(abs_error) # squared errors mse = np.mean(se) # mean squared errors rmse = np.sqrt(mse) # Root Mean Squared Error, RMSE r_squared = 1.0 - (np.var(abs_error) / np.var(data_fit_to)) return rmse, r_squared # ----------------------------------------------- DEPRECATED FUNCTIONS ------------------------------------------------- def fit_dficts(dficts, fit_function=None, xparameter=None, yparameter='z'): popts = [] pcovs = [] for name, df in dficts.items(): # throw out NaNs df = df.dropna(axis=0, subset=[yparameter]) # get x- and y-arrays if xparameter is None: x = df.index else: x = df[xparameter] y = df[yparameter] # fit the function if fit_function is None: popt, pcov = curve_fit(functions.parabola, x, y) fit_function = functions.parabola else: popt, pcov = curve_fit(fit_function, x, y) popts.append(popt) pcovs.append(pcov) return popts, pcovs, fit_function
2.375
2
examples/gt.py
bhatiadivij/kgtk
0
12788609
<gh_stars>0 import kgtk.gt.io_utils as gtio import kgtk.gt.analysis_utils as gtanalysis #datadir='data/' mowgli_nodes=f'{datadir}nodes_v002.csv' mowgli_edges=f'{datadir}edges_v002.csv' output_gml=f'{datadir}graph.graphml' gtio.transform_to_graphtool_format(mowgli_nodes, mowgli_edges, output_gml, True) g=gtio.load_gt_graph(output_gml.replace(".graphml", '.gt')) print(g.num_edges())
2.234375
2
transforms/__init__.py
arpastrana/coronary-mesh-convolution
26
12788610
<reponame>arpastrana/coronary-mesh-convolution from .feature_descriptors import FeatureDescriptors from .flow_extensions import RemoveFlowExtensions from .geodesics import InletGeodesics from .heat_sampling import HeatSamplingCluster from .rotation import RandomRotation
0.601563
1
tests/integrations/config/session.py
josephmancuso/masonite
35
12788611
import os DRIVERS = { "default": "cookie", "cookie": {}, "redis": { "host": "127.0.0.1", "port": 6379, "password": "", "options": {"db": 1}, # redis module driver specific options "timeout": 60*60, "namespace": "masonite4", }, }
1.78125
2
source/Screen.py
dibala21/Ergocycle
0
12788612
<filename>source/Screen.py<gh_stars>0 # Screen class # Imports (libraries) import sys import math from PyQt5.QtWidgets import QApplication from PyQt5.QtWidgets import QHBoxLayout from PyQt5.QtWidgets import QWidget from PyQt5.QtWidgets import QLabel from PyQt5.QtWidgets import QLineEdit from PyQt5.QtWidgets import QPushButton # Imports (classes) from Menu import Menu class Screen: # Constuctor def __init__(self, function_dictionary): print("THIS IS A TEST") self.width = 640 self.height = 480 self.speed = 100 self.application = QApplication([]) self.window = QWidget() self.window.setWindowTitle('Test interface graphique') self.window.setFixedWidth(self.width) self.window.setFixedHeight(self.height) layout = QHBoxLayout() layout.addWidget(QLabel('Amplitude:')) self.amplitude_edit = QLineEdit() layout.addWidget(self.amplitude_edit) self.send_button = QPushButton("Commander amplitude") layout.addWidget(self.send_button) self.test_button = QPushButton("Tester événements") layout.addWidget(self.test_button) # Connect before the show or the exec print("Widgets:") for i in range(0, layout.count()): widget = layout.itemAt(i).widget() #print(widget) #print(type(widget)) if type(widget) is QPushButton: # print the push buttons labels #print(widget.text()) label = widget.text() if label in function_dictionary: widget.clicked.connect(function_dictionary[label]) print("CONNECTED BUTTON TO ERGOCYCLE") self.window.setLayout(layout) self.window.show() def start_application(self): #sys.exit(self.app.exec_()) self.application.exec_() def get_amplitude(self): return self.amplitude_edit.text()
2.796875
3
carball/json_parser/actor/team.py
unitedroguegg/carball
119
12788613
<reponame>unitedroguegg/carball from .ball import * class TeamHandler(BaseActorHandler): @classmethod def can_handle(cls, actor: dict) -> bool: return actor['ClassName'] == 'TAGame.Team_Soccar_TA' def update(self, actor: dict, frame_number: int, time: float, delta: float) -> None: self.parser.team_dicts[actor['Id']] = actor self.parser.team_dicts[actor['Id']]['colour'] = 'blue' if actor["TypeName"] == "Archetypes.Teams.Team0" else \ 'orange'
2.359375
2
zongheng/zongheng_lib/machine.py
meetbill/zongheng
0
12788614
#!/usr/bin/env python # -*- coding: utf-8 -*- import g def show_machines(): ml = load_machine_list() for m in ml: print m def load_machine_list(skip_ban=True): client = g.mongo_client() db = client.cap cursor = db.machines.find() results = [] ban_list = load_banned_machine_list() for s in cursor: if skip_ban: if s["host"] not in ban_list: results.append(s) else: results.append(s) return results def save_machine_list(machines): client = g.mongo_client() db = client.cap db.machines.drop() db.machines.insert(machines) def update_machine_memory(host, mem_used): client = g.mongo_client() db = client.cap db.machines.update({"host": host}, {"$inc": {"mem_used": mem_used}}) def load_banned_machine_list(): client = g.mongo_client() db = client.cap cursor = db.banned_machines.find() results = [] for s in cursor: results.append(s["host"]) return results def save_banned_machine_list(hosts): client = g.mongo_client() db = client.cap for host in hosts: db.banned_machines.insert({"host": host}) def remove_banned_machine_list(hosts): client = g.mongo_client() db = client.cap for host in hosts: db.banned_machines.remove({"host": host}) def add_banned_machine_list(hosts): save_banned_machine_list(hosts) def update_machine_list(raw_file): """ 格式可变,目前格式是<host> <mem_total> <mem_used> """ machines = [] for line in open(raw_file, "r"): xs = line.strip().split(" ") host = g.ip2hostname(xs[0]) host = host[:-10] machine_info = { "host": host, "mem_total": int(xs[1]), # in MB "mem_used": int(xs[2]), # in MB "plan": g.pick_std_plan(xs[1]), "idc": g.idc(host), "logic_machine_room": g.logic_machine_room(host), "machine_room": g.machine_room(host), } machines.append(machine_info) save_machine_list(machines) return machines
2.921875
3
app/main.py
hesusruiz/Canispy
0
12788615
# Standard python library import logging # The Fastapi web server from fastapi import FastAPI from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates # Import uvicorn for debugging import uvicorn # The settings for the system from settings import settings # Acces to the bockchain from blockchain import trustframework as tf # Create logger logging.basicConfig( format='%(levelname)s - %(asctime)s - %(message)s', level=logging.INFO) log = logging.getLogger(__name__) # Create the FastAPi server app = FastAPI( title="FIWARE Canis Major with EBSI/Alastria APIs", description="FIWARE blockchain integration with SSI and Verifiable Credentials with interoperability EBSI-Alastria Red T", version="0.2.0", openapi_url="/api/v1/openapi.json", ) # The routes for the Canis Major NGSI API functionality from routers import ngsi_api app.include_router(ngsi_api.router) # The routes for Resolver APIs from routers import resolver_api app.include_router(resolver_api.router, include_in_schema=True) # The routes for Issuer APIs from routers import issuer_api app.include_router(issuer_api.router, include_in_schema=False) # The route for Verifying a credential from routers import verify_credential_api app.include_router(verify_credential_api.router, include_in_schema=False) # Support for API keys to secure invocations of APIs from fastapi_simple_security import api_key_router app.include_router(api_key_router, prefix="/auth", tags=["API-key Authorization"]) # APIs to check for server health from routers import server_health app.include_router(server_health.router, include_in_schema=True) # APIS to implement a simple, fast a secure messaging server from routers import secure_messaging_router app.include_router(secure_messaging_router.router, include_in_schema=False) # For serving static assets. # Should be the last route added because it is serving the root ("/") #app.mount("/", StaticFiles(directory="static", html=True), name="static") # Template directory for dynamic HTML pages templates = Jinja2Templates(directory="templates") # Perform startup processing @app.on_event("startup") async def startup_event(): """Connect to blockchain when starting the server""" log.info("######### Configuration values #########") if settings.PRODUCTION: log.info(f"Running in PRODUCTION") else: log.info(f"Running in DEVELOPMENT") log.info(f"Current directory: {settings.INITIAL_DIR}") log.info(f"SmartContract source dir: {settings.CONTRACTS_DIR}") log.info(f"SmartContract binary dir: {settings.CONTRACTS_OUTPUT_DIR}") log.info(f"Blockchain IP: {settings.BLOCKCHAIN_NODE_IP}") log.info(f"Database Dir: {settings.DATABASE_DIR}") tf.connect_blockchain(settings.BLOCKCHAIN_NODE_IP) log.info(f"Connected to the blockchain provider") log.info("########################################") # This is for running the server in test mode if __name__ == "__main__": uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
2.015625
2
contest_questions/Nth_no_prime.py
mukul20-21/python_datastructure
0
12788616
import math num = int(input("Enter the number:")) try: result = math.factorial(num) print(result) except: print("factorial is not print for negative number")
4.125
4
sra2variant/VCF2CSV.py
wuaipinglab/sra2variant
0
12788617
<filename>sra2variant/VCF2CSV.py import sys import pathlib from sra2variant.pipeline.cmd_wrapper import ErrorTolerance from sra2variant.artifacts.base_file import _FileArtifacts from sra2variant.artifacts.vcf_file import init_vcf_file from sra2variant.vcfparser.vcf2csv import vcf2csv from sra2variant.cmdutils.parser_maker import base_parser from sra2variant.cmdutils.parser_checker import check_base_parser def main(sysargs=sys.argv[1:]): parser = base_parser("Convert VCF to CSV") params, _ = check_base_parser(sysargs, parser) vcf_dir = params["input_dir"] csv_dir = params["csv_dir"] error_dir = params["error_dir"] max_errors = params["max_errors"] ErrorTolerance.set_max_errors(max_errors) for vcf_file in pathlib.Path(vcf_dir).glob(f"**/*.vcf"): vcf_file: _FileArtifacts = init_vcf_file( vcf_file=vcf_file, csv_dir=csv_dir ) task_log_file = vcf_file.log_file() try: vcf2csv(vcf_file) except Exception as e: error_tolerance = ErrorTolerance(error_dir, task_log_file) error_tolerance.handle(e)
2.546875
3
dfme/dfme/approximate_gradients.py
cleverhans-lab/model-extraction-iclr
0
12788618
<reponame>cleverhans-lab/model-extraction-iclr<filename>dfme/dfme/approximate_gradients.py import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import scipy.linalg import matplotlib.pyplot as plt import network from tqdm import tqdm import torchvision.models as models import torchvision.transforms as transforms from time import time import socket from time import sleep import pickle HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server server_address = (HOST, PORT) def estimate_gradient_objective(args, victim_model, clone_model, x, epsilon = 1e-7, m = 5, verb=False, num_classes=10, device = "cpu", pre_x=False): # Sampling from unit sphere is the method 3 from this website: # http://extremelearning.com.au/how-to-generate-uniformly-random-points-on-n-spheres-and-n-balls/ #x = torch.Tensor(np.arange(2*1*7*7).reshape(-1, 1, 7, 7)) if pre_x and args.G_activation is None: raise ValueError(args.G_activation) clone_model.eval() victim_model.eval() timequery = 0 quers = None if args.usenetwork == "yes": usenetwork = True else: usenetwork = False with torch.no_grad(): # Sample unit noise vector N = x.size(0) C = x.size(1) S = x.size(2) dim = S**2 * C u = np.random.randn(N * m * dim).reshape(-1, m, dim) # generate random points from normal distribution d = np.sqrt(np.sum(u ** 2, axis = 2)).reshape(-1, m, 1) # map to a uniform distribution on a unit sphere u = torch.Tensor(u / d).view(-1, m, C, S, S) u = torch.cat((u, torch.zeros(N, 1, C, S, S)), dim = 1) # Shape N, m + 1, S^2 u = u.view(-1, m + 1, C, S, S) evaluation_points = (x.view(-1, 1, C, S, S).cpu() + epsilon * u).view(-1, C, S, S) if pre_x: evaluation_points = args.G_activation(evaluation_points) # Apply args.G_activation function # Compute the approximation sequentially to allow large values of m pred_victim = [] pred_clone = [] max_number_points = 32*156 # Hardcoded value to split the large evaluation_points tensor to fit in GPU for i in (range(N * m // max_number_points + 1)): pts = evaluation_points[i * max_number_points: (i+1) * max_number_points] if args.dataset == "mnist" or args.dataset == "fashion-mnist": x = [] for blah in range(pts.size(0)): temp = pts[blah] temp = transforms.Compose([ transforms.ToPILImage(), transforms.Grayscale(num_output_channels=1),transforms.ToTensor(),])(temp) x.append(temp.reshape(1,1,32,32)) pts2 = torch.cat(x) pts = pts.to(device) pts2 = pts2.to(device) starttime = time() if usenetwork: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(server_address) try: datastr = pickle.dumps(pts2) sock.sendall(datastr) sleep(0.1) str = "done" sock.sendall(str.encode()) data = [] while True: packet = sock.recv(4096) if packet == b'donesend': break if not packet or packet == b'done': break data.append(packet) # output = sock.recv(4096) # output = pickle.loads(output) pred_victim_pts = pickle.loads(b"".join(data)) sleep(0.1) str = "doneiter" sock.sendall(str.encode()) finally: sock.close() else: pred_victim_pts = victim_model(pts2).detach() # pts converted to grayscale as pts2 since victim_model is for mnist endtime = time() if quers == None: quers = pts2 else: quers = torch.cat((quers, pts2), dim=0) timequery += endtime - starttime else: # TODO: Add server client here as well pts = pts.to(device) starttime = time() pred_victim_pts = victim_model(pts).detach() if quers == None: quers = pts else: quers = torch.cat((quers, pts), dim=0) endtime = time() timequery += endtime - starttime pred_clone_pts = clone_model(pts) pred_victim.append(pred_victim_pts) pred_clone.append(pred_clone_pts) pred_victim = torch.cat(pred_victim, dim=0).to(device) pred_victim2 = pred_victim pred_clone = torch.cat(pred_clone, dim=0).to(device) u = u.to(device) if args.loss == "l1": loss_fn = F.l1_loss if args.no_logits: pred_victim = F.log_softmax(pred_victim, dim=1).detach() if args.logit_correction == 'min': pred_victim -= pred_victim.min(dim=1).values.view(-1, 1).detach() elif args.logit_correction == 'mean': pred_victim -= pred_victim.mean(dim=1).view(-1, 1).detach() elif args.loss == "kl": loss_fn = F.kl_div pred_clone = F.log_softmax(pred_clone, dim=1) pred_victim = F.softmax(pred_victim.detach(), dim=1) else: raise ValueError(args.loss) # Compute loss if args.loss == "kl": loss_values = - loss_fn(pred_clone, pred_victim, reduction='none').sum(dim = 1).view(-1, m + 1) else: loss_values = - loss_fn(pred_clone, pred_victim, reduction='none').mean(dim = 1).view(-1, m + 1) # Compute difference following each direction differences = loss_values[:, :-1] - loss_values[:, -1].view(-1, 1) differences = differences.view(-1, m, 1, 1, 1) # Formula for Forward Finite Differences gradient_estimates = 1 / epsilon * differences * u[:, :-1] if args.forward_differences: gradient_estimates *= dim if args.loss == "kl": gradient_estimates = gradient_estimates.mean(dim = 1).view(-1, C, S, S) else: gradient_estimates = gradient_estimates.mean(dim = 1).view(-1, C, S, S) / (num_classes * N) clone_model.train() loss_G = loss_values[:, -1].mean() return gradient_estimates.detach(), loss_G, pred_victim2, quers, timequery def compute_gradient(args, victim_model, clone_model, x, pre_x=False, device="cpu"): if pre_x and args.G_activation is None: raise ValueError(args.G_activation) clone_model.eval() N = x.size(0) x_copy = x.clone().detach().requires_grad_(True) x_ = x_copy.to(device) if pre_x: x_ = args.G_activation(x_) if args.dataset == 'mnist' or args.dataset == "fashion-mnist": cur = [] for blah in range(N): temp = x_[blah] temp = transforms.Compose([ transforms.ToPILImage(), transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), ])(temp) cur.append(temp.reshape(1, 1, 32, 32)) x_2 = torch.cat(cur) # print(pts.size()) x_2 = x_2.to(device) pred_victim = victim_model(x_2) pred_clone = clone_model(x_) else: pred_victim = victim_model(x_) pred_clone = clone_model(x_) if args.loss == "l1": loss_fn = F.l1_loss if args.no_logits: pred_victim_no_logits = F.log_softmax(pred_victim, dim=1) if args.logit_correction == 'min': pred_victim = pred_victim_no_logits - pred_victim_no_logits.min(dim=1).values.view(-1, 1) elif args.logit_correction == 'mean': pred_victim = pred_victim_no_logits - pred_victim_no_logits.mean(dim=1).view(-1, 1) else: pred_victim = pred_victim_no_logits elif args.loss == "kl": loss_fn = F.kl_div pred_clone = F.log_softmax(pred_clone, dim=1) pred_victim = F.softmax(pred_victim, dim=1) else: raise ValueError(args.loss) loss_values = -loss_fn(pred_clone, pred_victim, reduction='mean') # print("True mean loss", loss_values) loss_values.backward() clone_model.train() return x_copy.grad, loss_values class Args(dict): def __init__(self, **args): for k,v in args.items(): self[k] = v def get_classifier(classifier, pretrained=True, resnet34_8x_file=None, num_classes=10): if classifier == "none": return NullTeacher(num_classes=num_classes) else: raise ValueError("Only Null Teacher should be used") if classifier == 'vgg11_bn': return vgg11_bn(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg13_bn': return vgg13_bn(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg16_bn': return vgg16_bn(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg19_bn': return vgg19_bn(pretrained=pretrained, num_classes=num_classes) if classifier == 'vgg11': return models.vgg11(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg13': return models.vgg13(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg16': return models.vgg16(pretrained=pretrained, num_classes=num_classes) elif classifier == 'vgg19': return models.vgg19(pretrained=pretrained, num_classes=num_classes) elif classifier == 'resnet18': return resnet18(pretrained=pretrained, num_classes=num_classes) elif classifier == 'resnet34': return resnet34(pretrained=pretrained, num_classes=num_classes) elif classifier == 'resnet50': return resnet50(pretrained=pretrained, num_classes=num_classes) elif classifier == 'densenet121': return densenet121(pretrained=pretrained, num_classes=num_classes) elif classifier == 'densenet161': return densenet161(pretrained=pretrained, num_classes=num_classes) elif classifier == 'densenet169': return densenet169(pretrained=pretrained, num_classes=num_classes) elif classifier == 'mobilenet_v2': return mobilenet_v2(pretrained=pretrained, num_classes=num_classes) elif classifier == 'googlenet': return googlenet(pretrained=pretrained, num_classes=num_classes) elif classifier == 'inception_v3': return inception_v3(pretrained=pretrained, num_classes=num_classes) elif classifier == "resnet34_8x": net = network.resnet_8x.ResNet34_8x(num_classes=num_classes) if pretrained: if resnet34_8x_file is not None: net.load_state_dict( torch.load( resnet34_8x_file) ) else: raise ValueError("Cannot load pretrained resnet34_8x from here") return net else: raise NameError(f'Please enter a valid classifier {classifier}') classifiers = [ "resnet34_8x", # Default DFAD # "vgg11", # "vgg13", # "vgg16", # "vgg19", "vgg11_bn", "vgg13_bn", "vgg16_bn", "vgg19_bn", "resnet18", "resnet34", "resnet50", "densenet121", "densenet161", "densenet169", "mobilenet_v2", "googlenet", "lenet5" "inception_v3", ]
2.484375
2
Image_classification_sorter.py
OpenVessel/RedTinSaintBernard-for-BraTS2021-challenge
0
12788619
# https://www.tensorflow.org/tutorials/images/classification import matplotlib.pyplot as plt import numpy as np import os import PIL import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.models import Sequential #Load PNGs using image_dataset_from_directory - untility #PNG to tf.data.Dataset our folder system ## to png ## then call DataSet # main_directory/ # ...class_a/ # ......a_image_1.jpg # ......a_image_2.jpg # ...class_b/ # ......b_image_1.jpg # ......b_image_2.jpg # https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image_dataset_from_directory # https://www.tensorflow.org/tutorials/load_data/images ## CREATE datasett batch_size = 32 img_height = 180 img_width = 180
3.125
3
keras/mlflow/model/pipeline_train.py
PipelineAI/models
44
12788620
<reponame>PipelineAI/models<filename>keras/mlflow/model/pipeline_train.py """ Example of image classification with MLflow using Keras to classify flowers from photos. The data is taken from ``http://download.tensorflow.org/example_images/flower_photos.tgz`` and may be downloaded during running this project if it is missing. """ import math import os import time import click import keras from keras.utils import np_utils from keras.models import Model from keras.callbacks import Callback from keras.applications import vgg16 from keras.layers import Input, Dense, Flatten, Lambda import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import mlflow from image_pyfunc import decode_and_resize_image, log_model, KerasImageClassifierPyfunc from datetime import datetime import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') #from utils import plot_history #import matplotlib.pyplot as plt # # See https://nbviewer.jupyter.org/github/WillKoehrsen/Data-Analysis/blob/master/slack_interaction/Interacting%20with%20Slack.ipynb for more details. # class SlackUpdate(Callback): """Custom Keras callback that posts to Slack while training a neural network""" def __init__(self, channel, slack_webhook_url): self.channel = channel self.slack_webhook_url = slack_webhook_url def file_upload(self, path, title): pass def report_stats(self, text): """Report training stats""" import subprocess try: cmd = 'curl -X POST --data-urlencode "payload={\\"unfurl_links\\": true, \\"channel\\": \\"%s\\", \\"username\\": \\"pipelineai_bot\\", \\"text\\": \\"%s\\"}" %s' % (self.channel, text, self.slack_webhook_url) response = subprocess.check_output(cmd, shell=True).decode('utf-8') return True except: return False def on_train_begin(self, logs={}): from timeit import default_timer as timer self.report_stats(text=f'Training started at {datetime.now()}') self.start_time = timer() self.train_acc = [] self.valid_acc = [] self.train_loss = [] self.valid_loss = [] self.n_epochs = 0 def on_epoch_end(self, batch, logs={}): self.train_acc.append(logs.get('acc')) self.valid_acc.append(logs.get('val_acc')) self.train_loss.append(logs.get('loss')) self.valid_loss.append(logs.get('val_loss')) self.n_epochs += 1 message = f'Epoch: {self.n_epochs} Training Loss: {self.train_loss[-1]:.4f} Validation Loss: {self.valid_loss[-1]:.4f}' self.report_stats(message) def on_train_end(self, logs={}): best_epoch = np.argmin(self.valid_loss) valid_loss = self.valid_loss[best_epoch] train_loss = self.train_loss[best_epoch] train_acc = self.train_acc[best_epoch] valid_acc = self.valid_acc[best_epoch] message = f'Trained for {self.n_epochs} epochs. Best epoch was {best_epoch + 1}.' self.report_stats(message) message = f'Best validation loss = {valid_loss:.4f} Training Loss = {train_loss:.2f} Validation accuracy = {100*valid_acc:.2f}%' self.report_stats(message) def on_train_batch_begin(self, batch, logs={}): pass def on_train_batch_end(self, batch, logs={}): pass def download_input(): import requests url = 'http://download.tensorflow.org/example_images/flower_photos.tgz' print("downloading '{}' into '{}'".format(url, os.path.abspath("flower_photos.tgz"))) r = requests.get(url) with open('flower_photos.tgz', 'wb') as f: f.write(r.content) import tarfile print("decompressing flower_photos.tgz to '{}'".format(os.path.abspath("flower_photos"))) with tarfile.open("flower_photos.tgz") as tar: tar.extractall(path="./") @click.command(help="Trains an Keras model on flower_photos dataset." "The input is expected as a directory tree with pictures for each category in a" " folder named by the category." "The model and its metrics are logged with mlflow.") @click.option("--epochs", type=click.INT, default=1, help="Maximum number of epochs to evaluate.") @click.option("--batch-size", type=click.INT, default=16, help="Batch size passed to the learning algo.") @click.option("--image-width", type=click.INT, default=224, help="Input image width in pixels.") @click.option("--image-height", type=click.INT, default=224, help="Input image height in pixels.") @click.option("--seed", type=click.INT, default=97531, help="Seed for the random generator.") @click.option("--training-data", type=click.STRING, default='./flower_photos') @click.option("--test-ratio", type=click.FLOAT, default=0.2) def run(training_data, test_ratio, epochs, batch_size, image_width, image_height, seed): image_files = [] labels = [] domain = {} print("Training model with the following parameters:") for param, value in locals().items(): print(" ", param, "=", value) if training_data == "./flower_photos" and not os.path.exists(training_data): print("Input data not found, attempting to download the data from the web.") download_input() for (dirname, _, files) in os.walk(training_data): for filename in files: if filename.endswith("jpg"): image_files.append(os.path.join(dirname, filename)) clazz = os.path.basename(dirname) if clazz not in domain: domain[clazz] = len(domain) labels.append(domain[clazz]) train(image_files, labels, domain, epochs=epochs, test_ratio=test_ratio, batch_size=batch_size, image_width=image_width, image_height=image_height, seed=seed) class MLflowLogger(Callback): """ Keras callback for logging metrics and final model with MLflow. Metrics are logged after every epoch. The logger keeps track of the best model based on the validation metric. At the end of the training, the best model is logged with MLflow. """ def __init__(self, model, x_train, y_train, x_valid, y_valid, **kwargs): self._model = model self._best_val_loss = math.inf self._train = (x_train, y_train) self._valid = (x_valid, y_valid) self._pyfunc_params = kwargs self._best_weights = None def on_epoch_end(self, epoch, logs=None): """ Log Keras metrics with MLflow. Update the best model if the model improved on the validation data. """ if not logs: return for name, value in logs.items(): if name.startswith("val_"): name = "valid_" + name[4:] else: name = "train_" + name mlflow.log_metric(name, value) val_loss = logs["val_loss"] if val_loss < self._best_val_loss: # Save the "best" weights self._best_val_loss = val_loss self._best_weights = [x.copy() for x in self._model.get_weights()] def on_train_end(self, *args, **kwargs): """ Log the best model with MLflow and evaluate it on the train and validation data so that the metrics stored with MLflow reflect the logged model. """ self._model.set_weights(self._best_weights) x, y = self._train train_res = self._model.evaluate(x=x, y=y) for name, value in zip(self._model.metrics_names, train_res): mlflow.log_metric("train_{}".format(name), value) x, y = self._valid valid_res = self._model.evaluate(x=x, y=y) for name, value in zip(self._model.metrics_names, valid_res): mlflow.log_metric("valid_{}".format(name), value) log_model(keras_model=self._model, **self._pyfunc_params) def on_train_batch_begin(self, batch, logs={}): pass def on_train_batch_end(self, batch, logs={}): pass def _imagenet_preprocess_tf(x): return (x / 127.5) - 1 def _create_model(input_shape, classes): image = Input(input_shape) lambda_layer = Lambda(_imagenet_preprocess_tf) preprocessed_image = lambda_layer(image) model = vgg16.VGG16(classes=classes, input_tensor=preprocessed_image, weights=None, include_top=False) x = Flatten(name='flatten')(model.output) x = Dense(4096, activation='relu', name='fc1')(x) x = Dense(4096, activation='relu', name='fc2')(x) x = Dense(classes, activation='softmax', name='predictions')(x) return Model(inputs=model.input, outputs=x) def train(image_files, labels, domain, image_width=224, image_height=224, epochs=1, batch_size=16, test_ratio=0.2, seed=None): """ Train VGG16 model on provided image files. This will create a new MLflow run and log all parameters, metrics and the resulting model with MLflow. The resulting model is an instance of KerasImageClassifierPyfunc - a custom python function model that embeds all necessary preprocessing together with the VGG16 Keras model. The resulting model can be applied directly to image base64 encoded image data. :param image_height: Height of the input image in pixels. :param image_width: Width of the input image in pixels. :param image_files: List of image files to be used for training. :param labels: List of labels for the image files. :param domain: Dictionary representing the domain of the reponse. Provides mapping label-name -> label-id. :param epochs: Number of epochs to train the model for. :param batch_size: Batch size used during training. :param test_ratio: Fraction of dataset to be used for validation. This data will not be used during training. :param seed: Random seed. Used e.g. when splitting the dataset into train / validation. """ assert len(set(labels)) == len(domain) input_shape = (image_width, image_height, 3) #mlflow.set_tracking_uri('http://mlflow-tracking-host:port') # This will create and set the experiment mlflow.set_experiment(str(int(time.time()))[2:] + 'flower-v1') with mlflow.start_run() as run: mlflow.log_param("epochs", str(epochs)) mlflow.log_param("batch_size", str(batch_size)) mlflow.log_param("validation_ratio", str(test_ratio)) if seed: mlflow.log_param("seed", str(seed)) def _read_image(filename): with open(filename, "rb") as f: return f.read() with tf.Graph().as_default() as g: with tf.Session(graph=g).as_default(): dims = input_shape[:2] x = np.array([decode_and_resize_image(_read_image(x), dims) for x in image_files]) y = np_utils.to_categorical(np.array(labels), num_classes=len(domain)) train_size = 1 - test_ratio x_train, x_valid, y_train, y_valid = train_test_split(x, y, random_state=seed, train_size=train_size) model = _create_model(input_shape=input_shape, classes=len(domain)) model.compile( optimizer=keras.optimizers.SGD(decay=1e-5, nesterov=True, momentum=.9), loss=keras.losses.categorical_crossentropy, metrics=["accuracy"]) sorted_domain = sorted(domain.keys(), key=lambda x: domain[x]) slack_update = SlackUpdate(channel='#slack-after-dark', slack_webhook_url='https://hooks.slack.com/services/T/B/G') history = model.fit( x=x_train, y=y_train, validation_data=(x_valid, y_valid), epochs=epochs, batch_size=batch_size, callbacks=[MLflowLogger(model=model, x_train=x_train, y_train=y_train, x_valid=x_valid, y_valid=y_valid, artifact_path="model", domain=sorted_domain, image_dims=input_shape), slack_update]) # From the following: https://keras.io/visualization/ # Plot training & validation accuracy values plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() plt.savefig('training_accuracy.png') # Plot training & validation loss values plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() # plot_history(history.history) plt.savefig('training_loss.png') #slack_update.file_upload(path='training_charts.png', # title='Charts') if __name__ == '__main__': run()
2.984375
3
bindings/python/scripts/__init__.py
matthieuvigne/pinocchio
1
12788621
# # Copyright (c) 2015-2016,2018 CNRS # import numpy as np from pinocchio.robot_wrapper import RobotWrapper from . import libpinocchio_pywrap as pin from . import utils from .explog import exp, log from .libpinocchio_pywrap import * from .deprecated import * from .shortcuts import * pin.AngleAxis.__repr__ = lambda s: 'AngleAxis(%s)' % s.vector()
1.734375
2
calculate_single_lstm_cell_error.py
placibo/LSTM
0
12788622
<reponame>placibo/LSTM #calculate error for single lstm cell def calculate_single_lstm_cell_error(activation_output_error,next_activation_error,next_cell_error,parameters,lstm_activation,cell_activation,prev_cell_activation): #activation error = error coming from output cell and error coming from the next lstm cell activation_error = activation_output_error + next_activation_error #output gate error oa = lstm_activation['oa'] eo = np.multiply(activation_error,tanh_activation(cell_activation)) eo = np.multiply(np.multiply(eo,oa),1-oa) #cell activation error cell_error = np.multiply(activation_error,oa) cell_error = np.multiply(cell_error,tanh_derivative(tanh_activation(cell_activation))) #error also coming from next lstm cell cell_error += next_cell_error #input gate error ia = lstm_activation['ia'] ga = lstm_activation['ga'] ei = np.multiply(cell_error,ga) ei = np.multiply(np.multiply(ei,ia),1-ia) #gate gate error eg = np.multiply(cell_error,ia) eg = np.multiply(eg,tanh_derivative(ga)) #forget gate error fa = lstm_activation['fa'] ef = np.multiply(cell_error,prev_cell_activation) ef = np.multiply(np.multiply(ef,fa),1-fa) #prev cell error prev_cell_error = np.multiply(cell_error,fa) #get parameters fgw = parameters['fgw'] igw = parameters['igw'] ggw = parameters['ggw'] ogw = parameters['ogw'] #embedding + hidden activation error embed_activation_error = np.matmul(ef,fgw.T) embed_activation_error += np.matmul(ei,igw.T) embed_activation_error += np.matmul(eo,ogw.T) embed_activation_error += np.matmul(eg,ggw.T) input_hidden_units = fgw.shape[0] hidden_units = fgw.shape[1] input_units = input_hidden_units - hidden_units #prev activation error prev_activation_error = embed_activation_error[:,input_units:] #input error (embedding error) embed_error = embed_activation_error[:,:input_units] #store lstm error lstm_error = dict() lstm_error['ef'] = ef lstm_error['ei'] = ei lstm_error['eo'] = eo lstm_error['eg'] = eg return prev_activation_error,prev_cell_error,embed_error,lstm_error
2.703125
3
chapter 3/sampleCode6.py
DTAIEB/Thoughtful-Data-Science
15
12788623
<gh_stars>10-100 [[GitHubTracking]] @route(query="*") @templateArgs def do_search(self, query): self.first_url = "https://api.github.com/search/repositories?q={}".format(query) self.prev_url = None self.next_url = None self.last_url = None response = requests.get(self.first_url) if not response.ok: return "<div>An Error occurred: {{response.text}}</div>" total_count = response.json()['total_count'] self.next_url = response.links.get('next', {}).get('url', None) self.last_url = response.links.get('last', {}).get('url', None) return """ <h1><center>{{total_count}} repositories were found</center></h1> <ul class="pagination"> <li><a href="#" pd_options="page=first_url" pd_target="body{{prefix}}">First</a></li> <li><a href="#" pd_options="page=prev_url" pd_target="body{{prefix}}">Prev</a></li> <li><a href="#" pd_options="page=next_url" pd_target="body{{prefix}}">Next</a></li> <li><a href="#" pd_options="page=last_url" pd_target="body{{prefix}}">Last</a></li> </ul> <table class="table"> <thead> <tr> <th>Repo Name</th> <th>Lastname</th> <th>URL</th> <th>Stars</th> </tr> </thead> <tbody id="body{{prefix}}"> {{this.invoke_route(this.do_retrieve_page, page='first_url')}} </tbody> </table> """
2.75
3
tests/auth_tests/test_apps.py
carlospalol/django
1
12788624
<filename>tests/auth_tests/test_apps.py import os import shutil import subprocess import sys import tempfile import unittest from django.db import ConnectionHandler SETTINGS = """ SECRET_KEY = 'django_auth_tests_secret_key' INSTALLED_APPS = [ 'django.contrib.auth.apps.BaseAuthConfig', 'django.contrib.contenttypes', ] MIGRATION_MODULES = {'auth': None} DATABASES = %(databases)r """ class AppConfigTests(unittest.TestCase): def test_no_migrations(self): project_path = tempfile.mkdtemp() try: databases = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(project_path, 'db.sqlite3'), } } with open(os.path.join(project_path, 'no_migrations.py'), 'w') as fp: fp.write(SETTINGS % {'databases': databases}) with open(os.devnull, 'wb') as devnull: cmd = [ sys.executable, '-m', 'django', 'migrate', '--settings', 'no_migrations', '--pythonpath', project_path, ] returncode = subprocess.call(cmd, stdout=devnull, stderr=devnull) # Migrate command ran without errors. self.assertEqual(returncode, 0) # Auth tables weren't created. conns = ConnectionHandler(databases) try: self.assertEqual( set(conns['default'].introspection.table_names()), {'django_content_type', 'django_migrations'}, ) finally: conns.close_all() finally: shutil.rmtree(project_path)
2.328125
2
Assignments/CH485---Artificial-Intelligence-and-Chemistry-master/Practice 06/gcn_logP.py
SeungsuKim/CH485--AI-and-Chemistry
2
12788625
import numpy as np import tensorflow as tf import matplotlib.pyplot as plt plt.switch_backend('agg') from utils import read_ZINC_smiles, smiles_to_onehot, convert_to_graph from rdkit import Chem, DataStructs from rdkit.Chem import AllChem import sys import time # execution) python gcn_logP.py 3 64 256 0.001 gsc # Default option num_layer = 3 hidden_dim1 = 64 hidden_dim2 = 256 init_lr = 0.001 using_sc = 'gsc' # 'sc, 'gsc, 'no' if( len(sys.argv) == 6 ): # Note that sys.argv[0] is gcn_logP.py num_layer = int(sys.argv[1]) hidden_dim1 = int(sys.argv[2]) hidden_dim2 = int(sys.argv[3]) init_lr = float(sys.argv[4]) using_sc = sys.argv[5] # 'sc, 'gsc, 'no' model_name = 'gcn_logP_' + str(num_layer) + '_' + str(hidden_dim1) + '_' + str(hidden_dim2) + '_' + str(init_lr) + '_' + using_sc #1. Prepare data - X : fingerprint, Y : logP # and split to (training:validation:test) set smi_total, logP_total, tpsa_total = read_ZINC_smiles(50000) num_train = 30000 num_validation = 10000 num_test = 10000 smi_train = smi_total[0:num_train] logP_train = logP_total[0:num_train] smi_validation = smi_total[num_train:(num_train+num_validation)] logP_validation = logP_total[num_train:(num_train+num_validation)] smi_test = smi_total[(num_train+num_validation):] logP_test = logP_total[(num_train+num_validation):] #2. Construct a neural network def skip_connection(input_X, new_X, act): # Skip-connection, H^(l+1)_sc = H^(l) + H^(l+1) inp_dim = int(input_X.get_shape()[2]) out_dim = int(new_X.get_shape()[2]) if(inp_dim != out_dim): output_X = act(new_X + tf.layers.dense(input_X, units=out_dim, use_bias=False)) else: output_X = act(new_X + input_X) return output_X def gated_skip_connection(input_X, new_X, act): # Skip-connection, H^(l+1)_gsc = z*H^(l) + (1-z)*H^(l+1) inp_dim = int(input_X.get_shape()[2]) out_dim = int(new_X.get_shape()[2]) def get_gate_coefficient(input_X, new_X, out_dim): X1 = tf.layers.dense(input_X, units=out_dim, use_bias=True) X2 = tf.layers.dense(new_X, units=out_dim, use_bias=True) gate_coefficient = tf.nn.sigmoid(X1 + X2) return gate_coefficient if(inp_dim != out_dim): input_X = tf.layers.dense(input_X, units=out_dim, use_bias=False) gate_coefficient = get_gate_coefficient(input_X, new_X, out_dim) output_X = tf.multiply(new_X, gate_coefficient) + tf.multiply(input_X, 1.0-gate_coefficient) return output_X def graph_convolution(input_X, input_A, hidden_dim, act, using_sc): # Graph Convolution, H^(l+1) = A{H^(l)W^(l)+b^(l)) output_X = tf.layers.dense(input_X, units=hidden_dim, use_bias=True, activation=None, kernel_initializer=tf.contrib.layers.xavier_initializer()) output_X = tf.matmul(input_A, output_X) if( using_sc == 'sc' ): output_X = skip_connection(input_X, output_X, act) elif( using_sc == 'gsc' ): output_X = gated_skip_connection(input_X, output_X, act) elif( using_sc == 'no' ): output_X = act(output_X) else: output_X = gated_skip_connection(input_X, output_X) return output_X # Readout def readout(input_X, hidden_dim, act): # Readout, Z = sum_{v in G} NN(H^(L)_v) output_Z = tf.layers.dense(input_X, units=hidden_dim, use_bias=True, activation=None, kernel_initializer=tf.contrib.layers.xavier_initializer()) output_Z = tf.reduce_sum(output_Z, axis=1) output = act(output_Z) return output_Z num_atoms=50 num_features=58 X = tf.placeholder(tf.float64, shape=[None, num_atoms, num_features]) A = tf.placeholder(tf.float64, shape=[None, num_atoms, num_atoms]) Y = tf.placeholder(tf.float64, shape=[None, ]) is_training = tf.placeholder(tf.bool, shape=()) h = X # Graph convolution layers for i in range(num_layer): h = graph_convolution(h, A, hidden_dim1, tf.nn.relu, using_sc) # Readout layer h = readout(h, hidden_dim2, tf.nn.sigmoid) # Predictor composed of MLPs(multi-layer perceptron) h = tf.layers.dense(h, units=hidden_dim2, use_bias=True, activation=tf.nn.relu, kernel_initializer=tf.contrib.layers.xavier_initializer()) h = tf.layers.dense(h, units=hidden_dim2, use_bias=True, activation=tf.nn.tanh, kernel_initializer=tf.contrib.layers.xavier_initializer()) Y_pred = tf.layers.dense(h, units=1, use_bias=True, kernel_initializer=tf.contrib.layers.xavier_initializer()) #3. Set a loss function, in this case we will use a MSE-loss (l2-norm) Y_pred = tf.reshape(Y_pred, shape=[-1,]) Y_pred = tf.cast(Y_pred, tf.float64) Y = tf.cast(Y, tf.float64) loss = tf.reduce_mean( (Y_pred - Y)**2 ) #4. Set an optimizer lr = tf.Variable(0.0, trainable = False) # learning rate opt = tf.train.AdamOptimizer(lr).minimize(loss) # Note that we use the Adam optimizer in this practice. #opt = tf.train.GradientDescentOptimizer(lr).minimize(loss) sess = tf.Session() init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver() #5. Training & validation batch_size = 100 epoch_size = 100 decay_rate = 0.95 batch_train = int(num_train/batch_size) batch_validation = int(num_validation/batch_size) batch_test = int(num_test/batch_size) total_iter = 0 total_time = 0.0 for t in range(epoch_size): pred_train = [] sess.run(tf.assign( lr, init_lr*( decay_rate**t ) )) st = time.time() for i in range(batch_train): total_iter += 1 smi_batch = smi_train[i*batch_size:(i+1)*batch_size] X_batch, A_batch = convert_to_graph(smi_batch) Y_batch = logP_train[i*batch_size:(i+1)*batch_size] _opt, _Y, _loss = sess.run([opt, Y_pred, loss], feed_dict = {X : X_batch, A : A_batch, Y : Y_batch, is_training : True}) pred_train.append(_Y.flatten()) #print("Epoch :", t, "\t batch:", i, "Loss :", _loss, "\t Training") pred_train = np.concatenate(pred_train, axis=0) error = (logP_train-pred_train) mae = np.mean(np.abs(error)) rmse = np.sqrt(np.mean(error**2)) stdv = np.std(error) print ("MAE :", mae, "RMSE :", rmse, "Std :", stdv, "\t Training, \t Epoch :", t) pred_validation = [] for i in range(batch_validation): smi_batch = smi_validation[i*batch_size:(i+1)*batch_size] X_batch, A_batch = convert_to_graph(smi_batch) Y_batch = logP_validation[i*batch_size:(i+1)*batch_size] _Y, _loss = sess.run([Y_pred, loss], feed_dict = {X : X_batch, A : A_batch, Y : Y_batch, is_training : False}) #print("Epoch :", t, "\t batch:", i, "Loss :", _loss, "\t validation") pred_validation.append(_Y.flatten()) pred_validation = np.concatenate(pred_validation, axis=0) error = (logP_validation-pred_validation) mae = np.mean(np.abs(error)) rmse = np.sqrt(np.mean(error**2)) stdv = np.std(error) et = time.time() print ("MAE :", mae, "RMSE :", rmse, "Std :", stdv, "\t Validation, \t Epoch :", t, "\t Time per epoch", (et-st)) total_time += (et-st) ### save model ckpt_path = 'save/'+model_name+'.ckpt' saver.save(sess, ckpt_path, global_step=total_iter) #6. Test pred_test = [] for i in range(batch_test): smi_batch = smi_test[i*batch_size:(i+1)*batch_size] X_batch, A_batch = convert_to_graph(smi_batch) Y_batch = logP_test[i*batch_size:(i+1)*batch_size] _Y, _loss = sess.run([Y_pred, loss], feed_dict = {X : X_batch, A : A_batch, Y : Y_batch, is_training : False}) pred_test.append(_Y.flatten()) pred_test = np.concatenate(pred_test, axis=0) error = (logP_test-pred_test) mae = np.mean(np.abs(error)) rmse = np.sqrt(np.mean(error**2)) stdv = np.std(error) print ("MSE :", mae, "RMSE :", rmse, "Std :", stdv, "\t Test", "\t Total time :", total_time) plt.figure() plt.scatter(logP_test, pred_test, s=3) plt.xlabel('logP - Truth', fontsize=15) plt.ylabel('logP - Prediction', fontsize=15) x = np.arange(-4,6) plt.plot(x,x,c='black') plt.tight_layout() plt.savefig('./figures/'+model_name+'_results.png')
2.171875
2
Evaluation/pairwise_distance.py
DigitalPhonetics/SpeechRepresentationFinetuning
1
12788626
# Average Pariwsie Distance: import argparse import pickle import pandas as pd from scipy.spatial import distance parser = argparse.ArgumentParser( description="Average Pariwsie Distance Evaluation (Quality Analysis)" ) parser.add_argument("embed_type", type=str, metavar="N", help="") parser.add_argument("label_name", type=str, metavar="N", help="") arg = parser.parse_args() # TODO: label class automatically update based on label name noise_lable_transfer = { "Clean": "Clean", "Babble": "Noisy", "Telephone": "Noisy", "Music": "Noisy", } age_lable_transfer = { 60: 50, 70: 50, } def filter(data_dict): filter_dict = data_dict.copy() for key in data_dict: emo_list = data_dict[key]["emotion"] if len(emo_list) != 0: filter_dict[key]["emotion"] = emo_list[0] else: del filter_dict[key] return filter_dict class PairwiseDistance: """ 1. extract all classes we have 2. calculate the centroid(mean of all point belonged to the class) of all class 3. calcuate the distance between this centroid and all other centroid, and average 4. print average pairwise distnce for all class 5. average all value to get final average Args: embed_type: 'contrastive', 'barlowtwins', or 'combined' label_name: 'valence_arousal', 'age', 'gender', 'noise' label_classes: based on label name train_result_path: path to trained embedding result test_result_path: path to test embedding result (we evaluate this frist) """ def __init__(self, embed_type, label_name, train_result_path, test_result_path): self.embed_type = embed_type self.label_name = label_name self.train_result_path = train_result_path self.test_result_path = test_result_path def extract_embedding_label(self, embed_type, label_name, file_path): """ return embeddings and corresponding labels """ with open(file_path, "rb") as fp: data = pickle.load(fp) if self.label_name == "emotion": filter(data) df_data = pd.DataFrame.from_dict(data, orient="index") df_data = df_data[[embed_type, label_name]] df_data = df_data.dropna(subset=[embed_type]) return df_data def _get_avg_pairwise_dist(self, centroids) -> dict: """ Given dictionary of label-centroid point, return label-average pairwise distance """ result_dict = {} for label, centroid in centroids.items(): centroids_cp = centroids.copy() pairwise_dist = 0.0 del centroids_cp[label] for other_label, other_centroid in centroids_cp.items(): dist = distance.euclidean(centroid, other_centroid) pairwise_dist += dist result_dict[label] = pairwise_dist # / len(centroids) print(result_dict) return result_dict def avg_distances_per_class(self): """ Calculate the centroid given embeddings(a list of 1D vector) Euclidan distance between each data point in a cluster to its respective cluster centroid, put in pandas df """ train_pair_distances = {} test_pair_distances = {} # data type of embedding: numpy.ndarray here train_df_data = self.extract_embedding_label( embed_type=self.embed_type, label_name=self.label_name, file_path=self.train_result_path, ) test_df_data = self.extract_embedding_label( embed_type=self.embed_type, label_name=self.label_name, file_path=self.test_result_path, ) if self.label_name == "noise_type": train_df_data["noise_type"] = train_df_data["noise_type"].replace( noise_lable_transfer ) test_df_data["noise_type"] = test_df_data["noise_type"].replace( noise_lable_transfer ) if self.label_name == "age": train_df_data["age"] = train_df_data["age"].replace(age_lable_transfer) test_df_data["age"] = test_df_data["age"].replace(age_lable_transfer) label_classes = train_df_data[self.label_name].unique().tolist() # put all in pandas data strcture, so we can extract embedding base on label for label in label_classes: # get centroid/mean of vectors from each class, and calculate the average euclidean distance between it and all datapoint # training set train_one_class = train_df_data[train_df_data[self.label_name] == label] # all vectors belong to this class one_class_vectors = train_one_class[self.embed_type].to_numpy() # get centroid of those vectors one_class_centriod = one_class_vectors.mean(axis=0) train_pair_distances[label] = one_class_centriod # test set test_one_class = test_df_data[test_df_data[self.label_name] == label] test_one_class_vectors = test_one_class[self.embed_type].to_numpy() test_one_class_centriod = test_one_class_vectors.mean(axis=0) test_pair_distances[label] = test_one_class_centriod # get average pairwise distance train_avg_distances = self._get_avg_pairwise_dist(train_pair_distances) test_avg_distances = self._get_avg_pairwise_dist(test_pair_distances) # return result in the pandas format train_avg_pair_distances = pd.DataFrame.from_dict( train_avg_distances, orient="index", columns=["avg_pairwise_dist"], ) print( "--- Average Pariwsie Distance of {}/{} (train)--- \n{}".format( self.label_name, self.embed_type, train_avg_pair_distances ) ) test_avg_pair_distances = pd.DataFrame.from_dict( test_avg_distances, orient="index", columns=["avg_pairwise_dist"], ) print( "--- Average Pariwsie Distance of {}/{} (test)--- \n{}".format( self.label_name, self.embed_type, test_avg_pair_distances ) ) # TODO: write into csv file? (better copy-paste) return train_avg_pair_distances, test_avg_pair_distances if __name__ == "__main__": embed_type = arg.embed_type label_name = arg.label_name # TODO: auto search file in cache avg_pair_distance = PairwiseDistance( embed_type=embed_type, label_name=label_name, # train_result_path=iemocap_barlowtwins_train, # test_result_path=iemocap_barlowtwins_test, ) avg_pair_distance.avg_distances_per_class()
3.015625
3
views/__init__.py
nakpisang/dicoding
0
12788627
<filename>views/__init__.py from PIL import Image from flask import Flask, Blueprint, render_template, request, jsonify, redirect, url_for, g, session from torch_mtcnn import detect_faces from flask_bootstrap import Bootstrap from util import is_same, ModelLoaded base = Blueprint('base', __name__, template_folder='templates') THRESHOLD = 1.5 # bootstrap = Bootstrap(base) @base.before_request def before_request(): g.user = None if 'user_id' in session: user = [x for x in users if x.id == session['user_id']][0] g.user = user class User: def __init__(self, id, username, password): self.id = id self.username = username self.password = password def __repr__(self): return f'<User: {self.username}>' users = [] users.append(User(id=1, username='nakpisang', password='password')) users.append(User(id=2, username='zul', password='password')) users.append(User(id=3, username='rizal', password='password')) users.append(User(id=4, username='admin', password='password')) @base.route('/index') def index(): return render_template('index.html') @base.route('/home') def home(): return render_template('indexx.html') @base.route('/', methods=['GET', 'POST']) def login(): if request.method == 'POST': session.pop('user_id', None) username = request.form['username'] password = request.form['password'] user = [x for x in users if x.username == username][0] if user and user.password == password: session['user_id'] = user.id return redirect(url_for('base.home')) return redirect(url_for('base.login')) return render_template('loginn.html') @base.route('/logout') def logout(): session.clear() return redirect(url_for('base.login')) @base.route('/predict', methods=['post']) def predict(): files = request.files img_left = Image.open(files.get('imgLeft')).convert('RGB') img_right = Image.open(files.get('imgRight')).convert('RGB') bbox_left, _ = detect_faces(img_left) bbox_right, _ = detect_faces(img_right) if bbox_left.shape[0] > 0: a, b, c, d, _ = bbox_left[0] img_left = img_left.crop((a, b, c, d)) if bbox_right.shape[0] > 0: a, b, c, d, _ = bbox_right[0] img_right = img_right.crop((a, b, c, d)) distance, similar = is_same(img_left, img_right, THRESHOLD) model_acc = ModelLoaded.acc return jsonify(same=('BERBEDA', 'SAMA')[similar.item()], score=distance.item(), model_acc=model_acc, threshold=THRESHOLD)
2.375
2
product_search_python/tests/run_unittests.py
sp4350/Test
34
12788628
#!/usr/bin/env python2.7 # # Copyright 2012 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import optparse import os import sys import unittest import logging USAGE = """%prog SDK_PATH TEST_PATH Run unit tests for App Engine apps. SDK_PATH Path to the SDK installation TEST_PATH Path to package containing test modules""" def main(sdk_path, test_path): sys.path.insert(0, sdk_path) import dev_appserver dev_appserver.fix_sys_path() project_dir = os.path.dirname(os.path.dirname(__file__)) suite = unittest.loader.TestLoader().discover(test_path, top_level_dir=project_dir) unittest.TextTestRunner(verbosity=2).run(suite) if __name__ == '__main__': parser = optparse.OptionParser(USAGE) options, args = parser.parse_args() if len(args) != 2: print 'Error: Exactly 2 arguments required.' parser.print_help() sys.exit(1) sdk_path = args[0] test_path = args[1] logging.getLogger().setLevel(logging.ERROR) main(sdk_path, test_path)
2.4375
2
ROI_Arrival_Viewer.py
alangburl/NWIC_Spectrum_Viewer
0
12788629
import numpy as np from ROI_Arrival import ROI_Arrival,ROI_Location #prefined imports import sys,time,winsound import numpy as np from PyQt5.QtWidgets import (QApplication, QPushButton,QWidget,QGridLayout, QSizePolicy,QLineEdit, QMainWindow,QAction,QVBoxLayout ,QDockWidget,QListView, QAbstractItemView,QLabel,QFileDialog,QTextEdit, QInputDialog,QSlider,QMdiArea,QMdiSubWindow, QMessageBox) from PyQt5.QtGui import QFont from PyQt5.QtCore import Qt #import numpy as np from matplotlib.figure import Figure from matplotlib.backends.backend_qt5agg import ( FigureCanvas, NavigationToolbar2QT as NavigationToolbar) class ROI_Viewer(QMainWindow): done=False def __init__(self,list_time,list_channel,sync_time,calibration): super().__init__() self.num_sync=sync_time.size self.num_pulses=list_time.size self.list_time,self.list_channel=list_time,list_channel self.sync_time,self.calibration=sync_time,calibration self.sync_delta=sync_time[2]-sync_time[1] self.lower,self.upper=9.5,10.9 self.font1=QFont() self.font1.setPointSize(12) self.size_policy=QSizePolicy.Expanding self.menu() self.showMaximized() self.setWindowTitle('ROI Timing Arrival') self.geometry() # self.process() self.show() def menu(self): self.menuFile=self.menuBar().addMenu('&File') self.save_file=QAction('&Save Spectrum') self.save_file.triggered.connect(self.save_spectrum) self.save_file.setShortcut('CTRL+S') self.save_file.setEnabled(False) # self.save_roi=QAction('&Save ROI') # self.save_roi.triggered.connect(self.save_roi_csv) # self.save_roi.setEnabled(True) self.menuFile.addActions([self.save_file]) def geometry(self): r1_label=QLabel(r'Region 1-2 divider: [us]') r1_label.setFont(self.font1) r2_label=QLabel(r'Region 2-3 divider: [us]') r2_label.setFont(self.font1) self.r_1_slider=QSlider(Qt.Horizontal) self.r_1_slider.setSizePolicy(self.size_policy,self.size_policy) self.r_1_slider.setMinimum(0) self.r_1_slider.setMaximum(self.sync_delta-1) self.r_1_slider.setSingleStep(1) self.r_1_slider.setTickInterval(50) self.r_1_slider.setValue(100) self.r_1_slider.setTickPosition(QSlider.TicksBelow) self.r_1_slider.valueChanged.connect(self.update_r_1) self.r_1_slider.setFont(self.font1) self.r_2_slider=QSlider(Qt.Horizontal) self.r_2_slider.setSizePolicy(self.size_policy,self.size_policy) self.r_2_slider.setMinimum(101) self.r_2_slider.setMaximum(self.sync_delta) self.r_2_slider.setSingleStep(1) self.r_2_slider.setTickInterval(50) self.r_2_slider.setValue(101) self.r_2_slider.setTickPosition(QSlider.TicksBelow) self.r_2_slider.valueChanged.connect(self.update_r_2) self.r_2_slider.setFont(self.font1) self.r_1_label=QLabel(self) self.r_1_label.setSizePolicy(self.size_policy,self.size_policy) self.r_1_label.setText(str(self.r_1_slider.value())) self.r_1_label.setFont(self.font1) self.r_2_label=QLabel(self) self.r_2_label.setSizePolicy(self.size_policy,self.size_policy) self.r_2_label.setText(str(self.r_2_slider.value())) self.r_2_label.setFont(self.font1) self.processer=QPushButton('Process',self) self.processer.clicked.connect(self.process) self.processer.setFont(self.font1) lower_label=QLabel('Lower ROI: [MeV]',self) lower_label.setFont(self.font1) upper_label=QLabel('Upper ROI: [MeV]',self) upper_label.setFont(self.font1) self.lower_text=QLineEdit(self) self.lower_text.setFont(self.font1) self.lower_text.setText(str(self.lower)) self.upper_text=QLineEdit(self) self.upper_text.setFont(self.font1) self.upper_text.setText(str(self.upper)) self.time_plot=QWidget() self.time_figure=Figure() self.time_canvas=FigureCanvas(self.time_figure) self.time_toolbar=NavigationToolbar(self.time_canvas,self) layout=QVBoxLayout() layout.addWidget(self.time_toolbar) layout.addWidget(self.time_canvas) self.time_plot.setLayout(layout) self.time_ax=self.time_canvas.figure.subplots() self.time_ax.set_title('Time') main_=QWidget() layout=QGridLayout(self) layout.addWidget(r1_label,0,0) layout.addWidget(self.r_1_slider,0,1) layout.addWidget(self.r_1_label,0,2) layout.addWidget(lower_label,0,3) layout.addWidget(self.lower_text,0,4) layout.addWidget(upper_label,1,3) layout.addWidget(self.upper_text,1,4) layout.addWidget(r2_label,1,0) layout.addWidget(self.r_2_slider,1,1) layout.addWidget(self.r_2_label,1,2) layout.addWidget(self.processer,2,0) layout.addWidget(self.time_plot,3,0,1,5) main_.setLayout(layout) self.setCentralWidget(main_) def update_r_1(self): self.r_2_slider.setMinimum(self.r_1_slider.value()+1) self.r_1_label.setText(str(self.r_1_slider.value())) def update_r_2(self): self.r_2_label.setText(str(self.r_2_slider.value())) def process(self): self.save_file.setEnabled(True) # self.save_roi.setEnabled(True) s1=time.time() delt=(self.sync_time[2]-self.sync_time[1]) self.lower=float(self.lower_text.text()) self.upper=float(self.upper_text.text()) self.arrival,self.height,self.raw=ROI_Arrival(self.sync_time,self.list_time, self.num_sync,self.list_channel, self.num_pulses,self.lower, self.upper,self.calibration) num_bins=int(delt/4) bins=np.linspace(0,delt,num_bins) self.bins=bins s=len(self.arrival) self.output=ROI_Location(self.arrival,bins,num_bins,s) r1,r2,r3=0,0,0 print('Process ROI Arrivals in {:.3f}s'.format(time.time()-s1)) for i in range(num_bins): if bins[i]<=self.r_1_slider.value(): r1+=self.output[i] elif bins[i]>self.r_1_slider.value() and bins[i]<=self.r_2_slider.value(): r2+=self.output[i] else: r3+=self.output[i] self.time_ax.clear() self.time_ax.plot(bins,self.output,'r*') self.time_ax.axvline(self.r_1_slider.value(),label='Region 1-2 divider at {:.2f}'.format(self.r_1_slider.value())) self.time_ax.axvline(self.r_2_slider.value(),label='Region 2-3 divider at {:.2f}'.format(self.r_2_slider.value())) # self.time_ax.set_yscale('log') self.time_ax.set_ylabel('Counts',fontsize=18) self.time_ax.set_xlabel(r'Arrival Time [$\mu s$]',fontsize=18) self.time_canvas.draw() self.done=True self.percentages=[r1/(r1+r2+r3)*100, r2/(r1+r2+r3)*100, r3/(r1+r2+r3)*100] QMessageBox.information(self, 'ROI Perecentages','''Region 1:{:.2f}%\nRegion 2:{:.2f}%\nRegion 3:{:.2f}%'''.format( r1/(r1+r2+r3)*100, r2/(r1+r2+r3)*100,r3/(r1+r2+r3)*100), QMessageBox.Ok) # print('Region 1 total ROI percentage: {:.2f}%'.format(r1/(r1+r2+r3)*100)) # print('Region 2 total ROI percentage: {:.2f}%'.format(r2/(r1+r2+r3)*100)) # print('Region 3 total ROI percentage: {:.2f}%'.format(r3/(r1+r2+r3)*100)) def save_spectrum(self): name=QFileDialog.getSaveFileName(self,'File Name','', 'Text File (*.txt);;Comma Seperated File (*.csv)') if name[0]!=' ': f=open(name[0],'w') f.write('%{:.2f},{:.2f},{:.2f}\n'.format(*self.percentages)) for i in range(len(self.bins)): f.write('{:.6f},{}\n'.format(self.bins[i],self.output[i])) f.close() # def save_roi_csv(self): # name,ok=QFileDialog.getSaveFileName(self,'Safe File Name','', # 'Comma Seperated File (*.csv)') # if ok: # f=open(name,'w') # f.write('Pulse_Height(MeV),Time(s)\n') # print(len(self.height)) # for i in range(len(self.height)): # f.write('{:.3f},{:.3f}\n'.format(self.height[i],self.raw[i]*1e-6)) # f.close() # print('All finished')
2.109375
2
scripts/aggregate_tool_info.py
dhrithideshpande/review-technology-dictates-algorithms
3
12788630
<reponame>dhrithideshpande/review-technology-dictates-algorithms import numpy as np import pandas as pd if __name__ == '__main__': table_df = pd.read_csv('../summary_data/table1_final.csv') table_df.loc[:,'seed_type'] = table_df.loc[:,'fix_length_seed'] + table_df.loc[:,'spaced_seed'] + table_df.loc[:,'seed_chaining'] tool_df = table_df.groupby(['indexing', 'seed_type', 'pairwise_alignment']).size().to_frame(name = 'count').reset_index().to_csv(index=False, path_or_buf="../raw_data/aggregate_tool_info.csv")
2.578125
3
src/gausskernel/dbmind/sqldiag/test/test_demo.py
wotchin/openGauss-server
1
12788631
""" Copyright (c) 2020 Huawei Technologies Co.,Ltd. openGauss is licensed under Mulan PSL v2. You can use this software according to the terms and conditions of the Mulan PSL v2. You may obtain a copy of Mulan PSL v2 at: http://license.coscl.org.cn/MulanPSL2 THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. See the Mulan PSL v2 for more details. """ from main import train, predict import matplotlib.pyplot as plt from sklearn.metrics import r2_score trans2sec = 10 ** 12 def main(): train_file = 'data/train.csv' test_file = 'data/test.csv' label_file = 'data/label.csv' # create dataset test_label = list() with open(label_file) as f: for line in f.readlines(): line = line.strip() test_label += [float(line)] cluster_number, top_sql = train('data/train.csv', 'data/', 2000, 40) print('Best cluster number is: ' + str(cluster_number)) print('Typical SQL template is: ') print(top_sql) result = predict('data/test.csv', 'data/', 0.1) # plot x = range(len(result)) scores = r2_score(test_label, result, multioutput='variance_weighted') plt.scatter(x, test_label, marker='o', label='actual value') plt.scatter(x, result, marker='*', label='predicted value') plt.title("acc: " + str(scores * 100)) plt.legend() plt.show() if __name__ == '__main__': main()
2.390625
2
deep_gw_pe_followup/plotting/corner.py
avivajpeyi/gw_pe_judge
0
12788632
from corner import corner import numpy as np CORNER_KWARGS = dict( smooth=0.9, label_kwargs=dict(fontsize=30), title_kwargs=dict(fontsize=16), color="tab:blue", truth_color="tab:orange", quantiles=[0.16, 0.84], levels=(1 - np.exp(-0.5), 1 - np.exp(-2), 1 - np.exp(-9.0 / 2.0)), plot_density=False, plot_datapoints=False, fill_contours=True, max_n_ticks=3, verbose=False, use_math_text=True, ) LABELS = dict( q=r"$q$", xeff=r"$\chi_{\rm eff}$", a_1=r"$a_1$", a_2=r"$a_2$", cos_tilt_1=r"$\cos \theta_1$", cos_tilt_2=r"$\cos \theta_2$", ) def plot_corner(df, fname="corner.png"): labels = [LABELS.get(i, i.replace("_", "")) for i in df.columns.values] fig = corner(df, labels=labels, **CORNER_KWARGS) fig.savefig(fname)
2.609375
3
223_test_time_augmentation_for_semantic_segmentation.py
Data-Laboratory/WorkExamples
1
12788633
#Ref: <NAME> """ # TTA - Should be called prediction time augmentation #We can augment each input image, predict augmented images and average all predictions """ import os import cv2 from PIL import Image import numpy as np from matplotlib import pyplot as plt import tensorflow as tf import random model = tf.keras.models.load_model("mitochondria_load_from_disk_focal_dice_50epochs.hdf5", compile=False) image_directory = 'data2/test_images/test/' mask_directory = 'data2/test_masks/test/' SIZE = 256 image_dataset = [] mask_dataset = [] images = os.listdir(image_directory) for i, image_name in enumerate(images): #Remember enumerate method adds a counter and returns the enumerate object if (image_name.split('.')[1] == 'tif'): #print(image_directory+image_name) image = cv2.imread(image_directory+image_name) image = Image.fromarray(image) image = image.resize((SIZE, SIZE)) image_dataset.append(np.array(image)) #Iterate through all images in Uninfected folder, resize to 64 x 64 #Then save into the same numpy array 'dataset' but with label 1 masks = os.listdir(mask_directory) for i, image_name in enumerate(masks): if (image_name.split('.')[1] == 'tif'): image = cv2.imread(mask_directory+image_name, 0) image = Image.fromarray(image) image = image.resize((SIZE, SIZE)) mask_dataset.append(np.array(image)) # image_dataset = np.array(image_dataset) / 255. #D not normalize masks, just rescale to 0 to 1. mask_dataset = (np.array(mask_dataset)) /255. #Demonstrate TTP on single image n = random.randint(0, mask_dataset.shape[0]) temp_test_img = image_dataset[n,:,:,:] temp_test_img = image_dataset[n,:,:,:] temp_mask = mask_dataset[n,:,:] p0 = model.predict(np.expand_dims(temp_test_img, axis=0))[0][:, :, 0] p1 = model.predict(np.expand_dims(np.fliplr(temp_test_img), axis=0))[0][:, :, 0] p1 = np.fliplr(p1) p2 = model.predict(np.expand_dims(np.flipud(temp_test_img), axis=0))[0][:, :, 0] p2 = np.flipud(p2) p3 = model.predict(np.expand_dims(np.fliplr(np.flipud(temp_test_img)), axis=0))[0][:, :, 0] p3 = np.fliplr(np.flipud(p3)) thresh = 0.3 p = (((p0 + p1 + p2 + p3) / 4) > thresh).astype(np.uint8) plt.figure(figsize=(12, 12)) plt.subplot(231) plt.title('Original mask') plt.imshow(temp_mask, cmap='gray') plt.subplot(232) plt.title('Prediction No Aug') plt.imshow(p0>thresh, cmap='gray') plt.subplot(233) plt.title('Prediction LR') plt.imshow(p1>thresh, cmap='gray') plt.subplot(234) plt.title('Prediction UD') plt.imshow(p2>thresh, cmap='gray') plt.subplot(235) plt.title('Prediction LR and UD') plt.imshow(p3>thresh, cmap='gray') plt.subplot(236) plt.title('Average Prediction') plt.imshow(p>thresh, cmap='gray') plt.show() #Now that we know the transformations are working, let us extend to all predictions predictions = [] for image in image_dataset: pred_original = model.predict(np.expand_dims(image, axis=0))[0][:, :, 0] pred_lr = model.predict(np.expand_dims(np.fliplr(image), axis=0))[0][:, :, 0] pred_lr = np.fliplr(pred_lr) pred_ud = model.predict(np.expand_dims(np.flipud(image), axis=0))[0][:, :, 0] pred_ud = np.flipud(pred_ud) pred_lr_ud = model.predict(np.expand_dims(np.fliplr(np.flipud(image)), axis=0))[0][:, :, 0] pred_lr_ud = np.fliplr(np.flipud(pred_lr_ud)) preds = (pred_original + pred_lr + pred_ud + pred_lr_ud) / 4 predictions.append(preds) predictions = np.array(predictions) threshold = 0.5 predictions_th = predictions > threshold import random test_img_number = random.randint(0, mask_dataset.shape[0]-1) test_img = image_dataset[test_img_number] ground_truth=mask_dataset[test_img_number] #test_img_norm=test_img[:,:,0][:,:,None] test_img_input=np.expand_dims(test_img, 0) prediction = predictions_th[test_img_number] plt.figure(figsize=(16, 8)) plt.subplot(231) plt.title('Testing Image') plt.imshow(test_img, cmap='gray') plt.subplot(232) plt.title('Testing Label') plt.imshow(ground_truth, cmap='gray') plt.subplot(233) plt.title('Prediction on test image') plt.imshow(prediction, cmap='gray') plt.show()
2.8125
3
constants.py
Sinica-SLAM/COSPRO-mix
5
12788634
<reponame>Sinica-SLAM/COSPRO-mix NUM_BANDS = 4 SNR_THRESH = -6. PRE_NOISE_SECONDS = 2.0 SAMPLERATE = 16000 MAX_SAMPLE_AMP = 0.95 MIN_SNR_DB = -3. MAX_SNR_DB = 6. PRE_NOISE_SAMPLES = PRE_NOISE_SECONDS * SAMPLERATE
1.3125
1
ArraysAndStrings/bfs.py
ashaik4/CodeVault
0
12788635
<reponame>ashaik4/CodeVault from collections import deque """ Find the minimum distance required to move the robot (9) from the field. Idea: BFS """ class Point: def __init__(self, x, y): self.x = x self.y = y class QueueNode: def __init__(self, pt, distance): self.point = pt self.dist = distance def isValid(grid, row, col): ROW = len(grid) COL = len(grid[0]) return (row >= 0 and row < ROW) and col >= 0 and col < COL rowNum = [-1, 0, 0, 1] colNum = [0, -1, 1, 0] def find_robot(grid): for i in range(len(grid)): for j in range(len(grid[0])): if grid[i][j] == 9: return Point(i, j) def bfs(matrix, src, dest): ROW = len(grid) COL = len(grid[0]) if matrix[src.x][src.y] == 0 or matrix[dest.x][dest.y] == 0: return -1 visited = [[False for i in range(ROW)] for j in range(COL)] visited[src.x][src.y] = True q = deque() s = QueueNode(src, 0) q.append(s) while q: current = q[0] pt = current.point if pt.x == dest.x and pt.y == dest.y: return current.dist q.popleft() for i in range(4): row = pt.x + rowNum[i] col = pt.y + colNum[i] if isValid(grid, row, col) and matrix[row][col] \ and not visited[row][col]: visited[row][col] = True adjCell = QueueNode(Point(row, col), current.dist + 1) q.append(adjCell) return -1 """ grid = [[1,1,1,9,0], [1,0,0,1,0], [1,1,1,1,0], [1,1,1,1,0], [0,0,0,0,0]] """ grid = [[9]] destination = find_robot(grid) source = Point(0, 0) print(bfs(grid, source, destination))
3.875
4
analyze/lookup.py
patarapolw/HanziSRS
10
12788636
<gh_stars>1-10 import re from HanziSRS.dir import database_path class Cedict: def __init__(self): super().__init__() self.dictionary = dict() with open(database_path('cedict_ts.u8'), encoding='utf8') as f: for row in f.readlines(): result = re.fullmatch(r'(\w+) (\w+) \[(.+)\] /(.+)/\n', row) if result is not None: trad, simp, pinyin, eng = result.groups() self.dictionary.setdefault(simp, []) self.dictionary.setdefault(trad, []) self.dictionary[simp].append({ 'traditional': trad, 'simplified': simp, 'reading': pinyin, 'english': eng }) if trad != simp: self.dictionary[trad].append(self.dictionary[simp][-1]) def get(self, vocab): return self.dictionary.get(vocab, [dict()])[0] class SpoonFed: def __init__(self): self.entries = [] with open(database_path('SpoonFed.tsv')) as f: next(f) for row in f: contents = row.split('\t') self.entries.append({ 'Chinese': contents[2], 'English': contents[0] }) def formatted_lookup(self, vocab): result = '' for item in self.iter_lookup(vocab): result += item['Chinese'] + '<br />' result += item['English'] + '<br />' return result def iter_lookup(self, vocab): if vocab: for entry in self.entries: if re.search(vocab.replace('…', '.*'), entry['Chinese']): yield entry class HanziVariant: def __init__(self): self.entries = dict() with open(database_path('hanzi_variant.tsv')) as f: next(f) for row in f: contents = row.split('\t') self.entries[contents[1]] = contents[-3] def get(self, hanzi): return self.entries.get(hanzi, '') if __name__ == '__main__': print(HanziVariant().entries)
2.875
3
flask-backend/migrations/versions/ca6c6171cdbe_added_task_model.py
harshagrawal523/OpenMF
92
12788637
"""Added task model Revision ID: ca6c6171cdbe Revises: 989dbc01a9b0 Create Date: 2021-06-11 08:31:03.584401 """ from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = 'ca6c6171cdbe' down_revision = '989dbc01a9b0' branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('task', sa.Column('id', sa.Integer(), nullable=False), sa.Column('title', sa.String(length=255), nullable=False), sa.Column('description', sa.Text(), nullable=False), sa.Column('assinged_on', sa.DateTime(), nullable=False), sa.Column('due_on', sa.DateTime(), nullable=True), sa.Column('admin_id', sa.Integer(), nullable=False), sa.Column('is_completed', sa.Boolean(), nullable=True), sa.Column('extractor_id', sa.Integer(), nullable=True), sa.Column('management_id', sa.Integer(), nullable=True), sa.ForeignKeyConstraint(['admin_id'], ['admin.id'], ), sa.ForeignKeyConstraint(['extractor_id'], ['extractor.id'], ), sa.ForeignKeyConstraint(['management_id'], ['management.id'], ), sa.PrimaryKeyConstraint('id') ) # ### end Alembic commands ### def downgrade(): # ### commands auto generated by Alembic - please adjust! ### op.drop_table('task') # ### end Alembic commands ###
1.71875
2
test/test_crosscorr.py
thunder-project/thunder-register
16
12788638
<gh_stars>10-100 import pytest from numpy import arange, allclose, asarray, expand_dims from scipy.ndimage.interpolation import shift from registration import CrossCorr pytestmark = pytest.mark.usefixtures("eng") def test_fit(eng): reference = arange(25).reshape(5, 5) algorithm = CrossCorr() deltas = [[1, 2], [-2, 1]] shifted = [shift(reference, delta, mode='wrap', order=0) for delta in deltas] model = algorithm.fit(shifted, reference=reference) assert allclose(model.toarray(), deltas) def test_fit_3d(eng): reference = arange(125).reshape(5, 5, 5) algorithm = CrossCorr() deltas = [[1, 0, 2], [0, 1, 2]] shifted = [shift(reference, delta, mode='wrap', order=0) for delta in deltas] model = algorithm.fit(shifted, reference=reference) assert allclose(model.toarray(), deltas) def test_fit_axis(eng): reference = arange(60).reshape(2, 5, 6) algorithm = CrossCorr(axis=0) a = shift(reference[0], [1, 2], mode='wrap', order=0) b = shift(reference[1], [-2, 1], mode='wrap', order=0) c = shift(reference[0], [2, 1], mode='wrap', order=0) d = shift(reference[1], [1, -2], mode='wrap', order=0) shifted = [asarray([a, b]), asarray([c, d]),] model = algorithm.fit(shifted, reference=reference) assert allclose(model.toarray(), [[[1, 2], [-2, 1]], [[2, 1], [1, -2]]])
1.890625
2
src/limecc/first.py
avakar/limecc
2
12788639
""" This module defines some basic operations on words and sets of words. A word is any iterable of symbols (strings), i.e. ('list', 'item') is a word. The iterable must support slices, joining with operator + and must return their length through the 'len' function. """ from .rule import Rule from .grammar import Grammar def first(word, k=1): """Returns FIRST_k(word). The implied grammar is taken to be empty and all symbols are treated as terminals. See <http://www.jambe.co.nz/UNI/FirstAndFollowSets.html> for more information. >>> first('hello, world', k=7) 'hello, ' >>> first(('list', 'item', 'item', 'item', 'item'), k=2) ('list', 'item') """ return word[:k] def oplus(left, right, k=1): """Returns the set { FIRST_k(vw) | v in left, w in right } and the length of its shortest member. The 'left' and 'right' are iterables of words. The function return type is a pair (s, l), where 's' is the first-set and 'l' is the length of its shortest member. If 's' is empty, 'l' is set equal to 'k'. The type of 's' is unspecified, but is guaranteed to be an iterable of words and to support operators 'in' and 'not in'. >>> s, l = oplus(['ab', 'ac', ''], ['zz', 'y', ''], k=3) >>> sorted(list(s)) ['', 'ab', 'aby', 'abz', 'ac', 'acy', 'acz', 'y', 'zz'] >>> l 0 >>> s, l = oplus(['ab', 'ac'], ['zz', 'y'], k=3) >>> sorted(list(s)) ['aby', 'abz', 'acy', 'acz'] >>> l 3 """ res = set() min_len = k for lword in left: for rword in right: w = first(lword + rword, k) if len(w) < min_len: min_len = len(w) res.add(w) return res, min_len class First: """Represents the first-set for a given grammar. The grammar and 'k' parameter are passed during construction. >>> g = Grammar(Rule('list', ()), Rule('list', ('list', 'item'))) >>> f = First(g, k=2) >>> f.grammar Grammar(Rule('list', ()), Rule('list', ('list', 'item'))) The objects are callable and, for a given word 'w', return the set { FIRST_k(u) | w =>* u, u terminal }. >>> sorted(list(f(('item', 'item', 'item')))) [('item', 'item')] >>> sorted(list(f(()))) [()] >>> sorted(list(f(('list',)))) [(), ('item',), ('item', 'item')] If the constructor parameter `nonterms` is set to True, the first sets are extended to sentential forms, i.e. `{ FIRST_k(u) | w =>* u, u is a sentential form }`. >>> f = First(g, k=2, nonterms=True) >>> sorted(list(f(('list',)))) [(), ('item',), ('item', 'item'), ('list',), ('list', 'item')] """ def __init__(self, grammar, k=1, nonterms=False): """ Given a grammar and a 'k', constructs the first-set table for all non-terminals. The table is then used by the '__call__' method. For the construction algorithm, see the Dragon book. """ self.grammar = grammar self.k = k if nonterms: self.table = dict((nonterm, set([(nonterm,)])) for nonterm in grammar.nonterms()) else: self.table = dict((nonterm, set()) for nonterm in grammar.nonterms()) # The sets in the table start empty and are iteratively filled. # The termination is guaranteed by the existence of the least fixed point. done = False while not done: done = True for rule in grammar: for word in self(rule.right): if word not in self.table[rule.left]: self.table[rule.left].add(word) done = False def __call__(self, word): """Returns FIRST_k(word) with respect to the associated grammar.""" res = set([()]) for symbol in word: if symbol not in self.table: rset = set([(symbol,)]) else: rset = self.table[symbol] res, c = oplus(res, rset, self.k) if c == self.k: break return res
3.9375
4
tests.py
ctcampbell/veracode-python
13
12788640
<filename>tests.py if __name__ == '__main__': import doctest from veracode import application, sandbox, build from veracode.exceptions import * try: doctest.testmod(application, raise_on_error=True) doctest.testmod(sandbox, raise_on_error=True) doctest.testmod(build, raise_on_error=True) except: pass finally: app = application.Application('TEST_APPLICATION') app.delete() # pycco veracode/*.py veracode/SDK veracode/API -ips
1.679688
2
src/medius/mediuspackets/policy.py
Metroynome/robo
8
12788641
<gh_stars>1-10 from enums.enums import MediusEnum, CallbackStatus from utils import utils from medius.mediuspackets.policyresponse import PolicyResponseSerializer class PolicySerializer: data_dict = [ {'name': 'mediusid', 'n_bytes': 2, 'cast': None}, {'name': 'message_id', 'n_bytes': MediusEnum.MESSAGEID_MAXLEN, 'cast': None}, {'name': 'session_key', 'n_bytes': MediusEnum.SESSIONKEY_MAXLEN, 'cast': None} ] class PolicyHandler: def process(self, serialized, monolith, con): def chunks(s, n): """Produce `n`-character chunks from `s`.""" res = [] for start in range(0, len(s), n): res.append(s[start:start+n]) return res policy = monolith.get_policy() packets = [] policy_split = chunks(policy, MediusEnum.POLICY_MAXLEN-1) for i, policy_substr in enumerate(policy_split): end_of_list = int((i == (len(policy_split)-1))) packets.append(PolicyResponseSerializer.build( serialized['message_id'], CallbackStatus.SUCCESS, policy_substr, end_of_list )) return packets
2.53125
3
Users/forms.py
tifat58/lsv-c4-django-webexperiment
1
12788642
<gh_stars>1-10 from django import forms from django.utils.translation import activate from Common import constants from Users.enums import * from Users.models import * from django.utils.translation import ugettext_lazy as _ from django.contrib.auth.forms import PasswordChangeForm class UserInfoForm(forms.Form): """ User info form """ # languageCode= 'en' def __init__(self, *args, **kwargs): # self.webLanguageId = kwargs.pop(CookieFields.WebsiteLanguageId) self.languageCode = kwargs.pop('languageCode','en') # excluding the australian and britain english and order by web language qs_language = Language.objects.exclude(language_code__in=['en-au','en-gb','pt-br','es-ar','es-mx','es-ni','es-ve']).order_by('language_name_'+self.languageCode) qs_country = Country.objects.order_by('country_name_'+self.languageCode) super(UserInfoForm, self).__init__(*args, **kwargs) self.fields['area_country'].queryset = qs_country self.fields['education_country'].queryset = qs_country self.fields['area_language'].queryset = qs_language self.fields['living_area_language'].queryset = qs_language self.fields['native_language'].queryset = qs_language self.fields['home_language'].queryset = qs_language self.fields['learned_language'].queryset = qs_language age = forms.CharField(widget=forms.TextInput(attrs={'class': 'onlyInt number-input form-control'}), required=True) gender = forms.ModelChoiceField(queryset=Gender.objects.all(), to_field_name="name", widget=forms.Select(attrs={'class': 'form-control'}), required=True) area_country = forms.ModelChoiceField(queryset=Country.objects.order_by('country_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=True) area_language = forms.ModelChoiceField(queryset=Language.objects.order_by('language_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=False) living_period = forms.CharField( widget=forms.TextInput(attrs={'class': 'form-control onlyInt lessThanEqualAge number-input'}), required=True) is_lived_in_other_area = forms.BooleanField(widget=forms.RadioSelect( choices=((False, constants.CommonConstants.NO_TEXT), (True, constants.CommonConstants.YES_TEXT))), initial=False, required=False) #living_area_language = forms.TypedChoiceField(choices=LanguageList, widget=forms.Select(attrs={'class': 'form-control'}), required=False) living_area_language = forms.ModelChoiceField(queryset=Language.objects.order_by('language_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=False) living_area_period = forms.CharField( widget=forms.TextInput(attrs={'class': 'form-control onlyInt lessThanAge number-input'}), required=False) is_multilingual = forms.BooleanField(widget=forms.RadioSelect( choices=[(False, constants.CommonConstants.NO_TEXT), (True, constants.CommonConstants.YES_TEXT)]), initial=False, required=False) native_language = forms.ModelChoiceField(queryset=Language.objects.all(), widget=forms.Select(attrs={'class': 'form-control'}), required=False) education_country = forms.ModelChoiceField(queryset=Country.objects.order_by('country_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=False) education_time = forms.CharField( widget=forms.TextInput(attrs={'class': 'form-control onlyInt lessThanAge number-input'}), required=False) home_language = forms.ModelChoiceField(queryset=Language.objects.order_by('language_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=False) learned_language = forms.ModelChoiceField(queryset=Language.objects.order_by('language_name'), widget=forms.Select(attrs={'class': 'form-control'}), required=False) learned_language_time = forms.CharField( widget=forms.TextInput(attrs={'class': 'form-control onlyInt lessThanAge number-input'}), required=False) # EducationDegree highest_education_degree = forms.ModelChoiceField(queryset=EducationDegree.objects.all(), widget=forms.Select(attrs={'class': 'form-control'}), required=False) have_linguistics_degree = forms.BooleanField(widget=forms.RadioSelect( choices=[(False, constants.CommonConstants.NO_TEXT), (True, constants.CommonConstants.YES_TEXT)]), initial=False, required=False) prolific_id = forms.CharField( widget=forms.TextInput(attrs={'class': 'form-control'}), required=False) class PasswordChangeCustomForm(PasswordChangeForm): old_password = forms.CharField(required=True, widget=forms.PasswordInput(attrs={ 'placeholder': _('OLD_PASSWORD_TEXT')})) new_password1 = forms.CharField(required=True,widget=forms.PasswordInput(attrs={ 'placeholder': _('NEW_PASSWORD_TEXT')})) new_password2 = forms.CharField(required=True, widget=forms.PasswordInput(attrs={ 'placeholder': _("NEW_PASSWORD_CONFIRMATION_TEXT")})) class PasswordResetConfirmationForm(forms.Form): new_password1 = forms.CharField(required=True,widget=forms.PasswordInput(attrs={ 'placeholder': _('NEW_PASSWORD_TEXT')})) new_password2 = forms.CharField(required=True, widget=forms.PasswordInput(attrs={ 'placeholder': _("NEW_PASSWORD_CONFIRMATION_TEXT")}))
2.171875
2
datasets/regdb_dataset.py
JDAI-CV/CM-NAS
31
12788643
<reponame>JDAI-CV/CM-NAS<gh_stars>10-100 import os import random import numpy as np from PIL import Image import torch.utils.data as data class RegDBData(data.Dataset): def __init__(self, data_root, trial, transform=None, visibleIndex=None, thermalIndex=None, img_size=(128,256)): # Load training images (path) and labels train_visible_list = os.path.join(data_root, 'idx/train_visible_{}.txt'.format(trial)) train_thermal_list = os.path.join(data_root, 'idx/train_thermal_{}.txt'.format(trial)) visible_img_file, train_visible_label = load_data(train_visible_list) thermal_img_file, train_thermal_label = load_data(train_thermal_list) train_visible_image = [] for i in range(len(visible_img_file)): img = Image.open(os.path.join(data_root, visible_img_file[i])) img = img.resize(img_size, Image.ANTIALIAS) pix_array = np.array(img) train_visible_image.append(pix_array) train_visible_image = np.array(train_visible_image) train_thermal_image = [] for i in range(len(thermal_img_file)): img = Image.open(os.path.join(data_root, thermal_img_file[i])) img = img.resize(img_size, Image.ANTIALIAS) pix_array = np.array(img) train_thermal_image.append(pix_array) train_thermal_image = np.array(train_thermal_image) # BGR to RGB self.train_visible_image = train_visible_image self.train_visible_label = train_visible_label # BGR to RGB self.train_thermal_image = train_thermal_image self.train_thermal_label = train_thermal_label self.transform = transform self.vIndex = visibleIndex self.tIndex = thermalIndex def __getitem__(self, index): img_v, target_v = self.train_visible_image[self.vIndex[index]], self.train_visible_label[self.vIndex[index]] img_t, target_t = self.train_thermal_image[self.tIndex[index]], self.train_thermal_label[self.tIndex[index]] img_v = self.transform(img_v) img_t = self.transform(img_t) return img_v, img_t, target_v, target_t def __len__(self): # return len(self.train_visible_label) return len(self.vIndex) def process_test_regdb(data_root, trial=1, modality='visible'): if modality=='visible': data_path = os.path.join(data_root, 'idx/test_visible_{}.txt'.format(trial)) elif modality=='thermal': data_path = os.path.join(data_root, 'idx/test_thermal_{}.txt'.format(trial)) file_image, file_label = load_data(data_path) file_image = [os.path.join(data_root, f) for f in file_image] return file_image, np.array(file_label) def load_data(data_path): with open(data_path, 'r') as f: data_file_list = f.read().splitlines() # Get full list of image and labels file_image = [s.split(' ')[0] for s in data_file_list] file_label = [int(s.split(' ')[1]) for s in data_file_list] return file_image, file_label
2.296875
2
wqxlib-python/wqxlib/wqx_v3_0/ComparableAnalyticalMethod.py
FlippingBinary/wqxlib
0
12788644
<reponame>FlippingBinary/wqxlib from ..common import WQXException from .SimpleContent import ( MethodIdentifier, MethodIdentifierContext, MethodModificationText ) from yattag import Doc class ComparableAnalyticalMethod: """Identifies the procedures, processes, and references required to determine the analytical methods used to obtain a result.""" __methodIdentifier: MethodIdentifier __methodIdentifierContext: MethodIdentifierContext __methodModificationText: MethodModificationText def __init__(self, o=None, *, methodIdentifier:MethodIdentifier = None, methodIdentifierContext:MethodIdentifierContext = None, methodModificationText:MethodModificationText = None ): if isinstance(o, ComparableAnalyticalMethod): # Assign attributes from object without typechecking self.__methodIdentifier = o.methodIdentifier self.__methodIdentifierContext = o.methodIdentifierContext self.__methodModificationText = o.methodModificationText elif isinstance(o, dict): # Assign attributes from dictionary with typechecking self.methodIdentifier = o.get('methodIdentifier', default = None) self.methodIdentifierContext = o.get('methodIdentifierContext', default = None) self.methodModificationText = o.get('methodModificationText', default = None) else: # Assign attributes from named keywords with typechecking self.methodIdentifier = methodIdentifier self.methodIdentifierContext = methodIdentifierContext self.methodModificationText = methodModificationText @property def methodIdentifier(self) -> MethodIdentifier: return self.__methodIdentifier @methodIdentifier.setter def methodIdentifier(self, val:MethodIdentifier) -> None: self.__methodIdentifier = MethodIdentifier(val) @property def methodIdentifierContext(self) -> MethodIdentifierContext: return self.__methodIdentifierContext @methodIdentifierContext.setter def methodIdentifierContext(self, val:MethodIdentifierContext) -> None: self.__methodIdentifierContext = MethodIdentifierContext(val) @property def methodModificationText(self) -> MethodModificationText: return self.__methodModificationText @methodModificationText.setter def methodModificationText(self, val:MethodModificationText) -> None: self.__methodModificationText = None if val is None else MethodModificationText(val) def generateXML(self, name:str = 'ComparableAnalyticalMethod') -> str: doc, tag, text, line = Doc().ttl() with tag(name): if self.__methodIdentifier is None: raise WQXException("Attribute 'methodIdentifier' is required.") line('MethodIdentifier', self.__methodIdentifier) if self.__methodIdentifierContext is None: raise WQXException("Attribute 'methodIdentifierContext' is required.") line('MethodIdentifierContext', self.__methodIdentifierContext) if self.__methodModificationText is not None: line('MethodModificationText', self.__methodModificationText) return doc.getvalue()
2.265625
2
lightctr/layer.py
yanyachen/LightCTR
0
12788645
import tensorflow as tf class ResidualDense(tf.keras.layers.Layer): def __init__( self, units, activation=None, dropout=None, kernel_initializer=None, kernel_regularizer=None, output_activation=None ): super(ResidualDense, self).__init__() self.units = units self.activation = activation self.dropout = dropout self.kernel_initializer = kernel_initializer self.kernel_regularizer = kernel_regularizer if output_activation is None: self.output_activation = self.activation else: self.output_activation = self.output_activation def build(self, input_shape): last_dim_units = input_shape[-1].value self.layer0 = tf.keras.layers.Dense( units=self.units, activation=self.activation, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer ) if self.dropout is not None and self.dropout > 0: self.dropout_layer = tf.keras.layers.Dropout( rate=float(self.dropout) ) self.layer1 = tf.keras.layers.Dense( units=last_dim_units, activation=tf.keras.activations.linear, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer ) def call(self, inputs, training): net = self.layer0(inputs) if self.dropout is not None and self.dropout > 0: net = self.dropout_layer(net, training=training) net = self.layer1(net) outputs = self.activation(inputs + net) return outputs def compute_output_shape(self, input_shape): return input_shape class LayerNormalization(tf.keras.layers.Layer): def __init__(self): super(LayerNormalization, self).__init__() def build(self, input_shape): last_dim = input_shape[-1].value self.scale = tf.Variable( initial_value=tf.ones([last_dim]), trainable=True, name='layer_norm_scale', dtype=tf.float32, ) self.bias = tf.Variable( initial_value=tf.zeros([last_dim]), trainable=True, name='layer_norm_bias', dtype=tf.float32, ) def call(self, inputs, epsilon=1e-6): mean = tf.reduce_mean( input_tensor=inputs, axis=[-1], keepdims=True ) variance = tf.reduce_mean( input_tensor=tf.square(inputs - mean), axis=[-1], keepdims=True ) norm_inputs = (inputs - mean) * tf.math.rsqrt(variance + epsilon) return norm_inputs * self.scale + self.bias def compute_output_shape(self, input_shape): return input_shape class AdversarialNoise(tf.keras.layers.Layer): def __init__(self, eps): super(AdversarialNoise, self).__init__() self.eps = eps def _scale_l2(self, x): ndim = tf.keras.backend.ndim(x) feature_dims = [i for i in range(1, ndim)] alpha = tf.reduce_max( input_tensor=tf.abs(x), axis=feature_dims, keepdims=True ) + 1e-12 l2_norm = alpha * tf.sqrt( tf.reduce_sum( input_tensor=tf.pow(x / alpha, 2), axis=feature_dims, keepdims=True ) + 1e-6 ) x_unit = x / l2_norm return x_unit def _truncated_normal_eps(self, x): ndim = tf.keras.backend.ndim(x) sample_eps = tf.keras.backend.truncated_normal( shape=tf.keras.backend.shape(x)[:1], mean=tf.cast(self.eps, dtype=tf.float32) / 2.0, stddev=tf.square(tf.cast(self.eps, dtype=tf.float32) / 4.0) ) sample_eps = tf.tile( input=tf.reshape( sample_eps, [-1] + [1 for i in range(ndim-1)] ), multiples=[1] + list(tf.keras.backend.int_shape(x)[1:]) ) return sample_eps def call(self, inputs, loss, training): if training: inputs_grad = tf.gradients( ys=loss, xs=inputs, aggregation_method=( tf.AggregationMethod.EXPERIMENTAL_ACCUMULATE_N ) ) inputs_grad_dense = tf.squeeze( tf.stop_gradient(inputs_grad), axis=0 ) noise_unit = self._scale_l2(inputs_grad_dense) sample_eps = self._truncated_normal_eps(noise_unit) noise = noise_unit * sample_eps return inputs + noise else: return inputs def compute_output_shape(self, input_shape): return input_shape class TargetedDense(tf.keras.layers.Dense): def __init__( self, units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, targeted_dropout_type=None, target_rate=0.50, dropout_rate=0.50, **kwargs ): super(TargetedDense, self).__init__( units=units, activation=activation, use_bias=use_bias, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer, activity_regularizer=activity_regularizer, kernel_constraint=kernel_constraint, bias_constraint=bias_constraint, **kwargs ) self.targeted_dropout_type = targeted_dropout_type self.target_rate = target_rate self.dropout_rate = dropout_rate def targeted_weight_dropout( self, w, target_rate, dropout_rate, is_training ): w_shape = w.shape w = tf.reshape(w, [-1, w_shape[-1]]) norm = tf.abs(w) idx = tf.cast( target_rate * tf.cast(tf.shape(input=w)[0], dtype=tf.float32), dtype=tf.int32 ) threshold = tf.sort(norm, axis=0)[idx] mask = norm < threshold[None, :] if not is_training: w = (1.0 - tf.cast(mask, dtype=tf.float32)) * w w = tf.reshape(w, w_shape) return w mask = tf.cast( tf.logical_and( tf.random.uniform(tf.shape(input=w)) < dropout_rate, mask ), dtype=tf.float32 ) w = (1.0 - mask) * w w = tf.reshape(w, w_shape) return w def targeted_unit_dropout( self, w, target_rate, dropout_rate, is_training ): w_shape = w.shape w = tf.reshape(w, [-1, w_shape[-1]]) norm = tf.norm(tensor=w, axis=0) idx = int(target_rate * int(w.shape[1])) sorted_norms = tf.sort(norm) threshold = sorted_norms[idx] mask = (norm < threshold)[None, :] mask = tf.tile(mask, [w.shape[0], 1]) mask = tf.compat.v1.where( tf.logical_and( (1.0 - dropout_rate) < tf.random.uniform(tf.shape(input=w)), mask ), tf.ones_like(w, dtype=tf.float32), tf.zeros_like(w, dtype=tf.float32) ) w = (1.0 - mask) * w w = tf.reshape(w, w_shape) return w def call(self, inputs, training): inputs = tf.convert_to_tensor(value=inputs, dtype=self.dtype) rank = inputs._rank() if (self.targeted_dropout_type == 'weight'): self.kernel.assign( self.targeted_weight_dropout( self.kernel, self.target_rate, self.dropout_rate, training ) ) elif (self.targeted_dropout_type == 'unit'): self.kernel.assign( self.targeted_unit_dropout( self.kernel, self.target_rate, self.dropout_rate, training ) ) if rank > 2: # Broadcasting is required for the inputs. outputs = tf.tensordot(inputs, self.kernel, [[rank - 1], [0]]) # Reshape the output back to the original ndim of the input. if not tf.executing_eagerly(): shape = inputs.get_shape().as_list() output_shape = shape[:-1] + [self.units] outputs.set_shape(output_shape) else: outputs = tf.linalg.matmul(inputs, self.kernel) if self.use_bias: outputs = tf.nn.bias_add(outputs, self.bias) if self.activation is not None: return self.activation(outputs) # pylint: disable=not-callable return outputs class VectorDense(tf.keras.layers.Layer): def __init__( self, units, activation=None, use_bias=True, kernel_initializer=None, kernel_regularizer=None, dropout=None ): super(VectorDense, self).__init__() self.units = units self.dropout = dropout self.permute_layer = tf.keras.layers.Permute( dims=(2, 1) ) if self.dropout is not None and self.dropout > 0: self.dropout_layer = tf.keras.layers.Dropout( rate=float(self.dropout) ) self.dense_layer = tf.keras.layers.Dense( units=units, activation=activation, use_bias=use_bias, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer ) def call(self, inputs, training): net = self.permute_layer(inputs) if self.dropout is not None and self.dropout > 0: net = self.dropout_layer(net, training=training) net = self.dense_layer(net) outputs = self.permute_layer(net) return outputs def compute_output_shape(self, input_shape): output_shape = tf.TensorShape(input_shape).as_list() output_shape[1] = self.units return tf.TensorShape(output_shape)
2.65625
3
mutatest/transformers.py
EvanKepner/m
49
12788646
""" Transformers ------------ Transformers defines the mutations that can be applied. The ``CATEGORIES`` dictionary lists all valid category codes that are valid filters. The primary classes are: 1. ``LocIndex`` 2. ``MutateAST`` The ``LocIndex`` is a location index within a given Abstract Syntax Tree (AST) that can be mutated. The ``MutateAST`` class walks the AST of a given source file to identify all of the locations, and optionally create the mutation at that node. These are implemented in the ``Genome`` object. ``MutateAST`` is constructed from ``MutateBase`` and the appropriate mixin class - either ``ConstantMixin`` for Python 3.8, or ``NameConstantMixin`` for Python 3.7. """ import ast import logging import sys from pathlib import Path #################################################################################################### # AST TRANSFORMERS #################################################################################################### from typing import Any, Dict, List, NamedTuple, Optional, Set, Type, Union try: # Python 3.8 from typing import Protocol except ImportError: # Python 3.7 from typing_extensions import Protocol # type: ignore LOGGER = logging.getLogger(__name__) CATEGORIES = { "AugAssign": "aa", "BinOp": "bn", "BinOpBC": "bc", "BinOpBS": "bs", "BoolOp": "bl", "Compare": "cp", "CompareIn": "cn", "CompareIs": "cs", "If": "if", "Index": "ix", "NameConstant": "nc", "SliceUS": "su", } #################################################################################################### # CORE TYPES #################################################################################################### class LocIndex(NamedTuple): """Location index within AST to mark mutation targets. The ``end_lineno`` and ``end_col_offset`` properties are set to ``None`` by default as they are only used distinctly in Python 3.8. """ ast_class: str lineno: int col_offset: int op_type: Any # varies based on the visit_Node definition in MutateAST # New in Python 3.8 AST: https://docs.python.org/3/whatsnew/3.8.html#improved-modules # These values are always set to None if running Python 3.7. # The NodeSpan class is used to manage setting the values end_lineno: Optional[int] = None end_col_offset: Optional[int] = None class MutationOpSet(NamedTuple): """Container for compatible mutation operations. Also used in the CLI display.""" name: str desc: str operations: Set[Any] category: str class LocIndexNode(Protocol): """Type protocol for AST Nodes that include lineno and col_offset properties.""" lineno: int col_offset: int class NodeSpan(NamedTuple): """Node span to support Py3.7 and 3.8 compatibility for locations. This is used to generate the set the values in the LocIndex as a general class. """ node: LocIndexNode @property def lineno(self) -> int: """Line number for the node.""" return self.node.lineno @property def col_offset(self) -> int: """Col offset for the node.""" return self.node.col_offset @property def end_lineno(self) -> Optional[int]: """End line no: Python 3.8 will have this defined, in Python 3.7 it will be None.""" eline: Optional[int] = getattr(self.node, "end_lineno", None) return eline @property def end_col_offset(self) -> Optional[int]: """End col offset: Python 3.8 will have this defined, in Python 3.7 it will be None.""" ecol: Optional[int] = getattr(self.node, "end_col_offset", None) return ecol #################################################################################################### # MUTATE AST Definitions # Includes MutateBase and Mixins for 3.7 and 3.8 AST support # MutateAST is constructed from Base + Mixins depending on sys.version_info #################################################################################################### class MutateBase(ast.NodeTransformer): """AST NodeTransformer to replace nodes with mutations by visits.""" def __init__( self, target_idx: Optional[LocIndex] = None, mutation: Optional[Any] = None, readonly: bool = False, src_file: Optional[Union[Path, str]] = None, ) -> None: """Create the AST node transformer for mutations. If readonly is set to True then no transformations are applied; however, the locs attribute is updated with the locations of nodes that could be transformed. This allows the class to function both as an inspection method and as a mutation transformer. Note that different nodes handle the ``LocIndex`` differently based on the context. For example, ``visit_BinOp`` uses direct AST types, while ``visit_NameConstant`` uses values, and ``visit_AugAssign`` uses custom strings in a dictionary mapping. All ``visit_`` methods take the ``node`` as an argument and rely on the class properties. This MutateBase class is designed to be implemented with the appropriate Mixin Class for supporting either Python 3.7 or Python 3.8 ASTs. If the base class is used directly certain operations - like ``visit_If`` and ``visit_NameConstant`` will not work as intended.. Args: target_idx: Location index for the mutatest in the AST mutation: the mutatest to apply, may be a type or a value readonly: flag for read-only operations, used to visit nodes instead of transform src_file: Source file name, used for logging purposes """ self.locs: Set[LocIndex] = set() # managed via @property self._target_idx = target_idx self._mutation = mutation self._readonly = readonly self._src_file = src_file @property def target_idx(self) -> Optional[LocIndex]: """Location index for the mutation in the AST""" return self._target_idx @property def mutation(self) -> Optional[Any]: """The mutation to apply, may be a type or a value""" return self._mutation @property def readonly(self) -> bool: """A flag for read-only operations, used to visit nodes instead of transform""" return self._readonly @property def src_file(self) -> Optional[Union[Path, str]]: """Source file name, used for logging purposes""" return self._src_file @property def constant_type(self) -> Union[Type[ast.NameConstant], Type[ast.Constant]]: """Overridden using the MixinClasses for NameConstant(3.7) vs. Constant(3.8).""" raise NotImplementedError def visit_AugAssign(self, node: ast.AugAssign) -> ast.AST: """AugAssign is ``-=, +=, /=, *=`` for augmented assignment.""" self.generic_visit(node) log_header = f"visit_AugAssign: {self.src_file}:" # custom mapping of string keys to ast operations that can be used # in the nodes since these overlap with BinOp types aug_mappings = { "AugAssign_Add": ast.Add, "AugAssign_Sub": ast.Sub, "AugAssign_Mult": ast.Mult, "AugAssign_Div": ast.Div, } rev_mappings = {v: k for k, v in aug_mappings.items()} idx_op = rev_mappings.get(type(node.op), None) # edge case protection in case the mapping isn't known for substitution # in that instance, return the node and take no action if not idx_op: LOGGER.debug( "%s (%s, %s): unknown aug_assignment: %s", log_header, node.lineno, node.col_offset, type(node.op), ) return node node_span = NodeSpan(node) idx = LocIndex( ast_class="AugAssign", lineno=node_span.lineno, col_offset=node_span.col_offset, op_type=idx_op, end_lineno=node_span.end_lineno, end_col_offset=node_span.end_col_offset, ) self.locs.add(idx) if idx == self.target_idx and self.mutation in aug_mappings and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) return ast.copy_location( ast.AugAssign( target=node.target, op=aug_mappings[self.mutation](), # awkward syntax to call type from mapping value=node.value, ), node, ) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_BinOp(self, node: ast.BinOp) -> ast.AST: """BinOp nodes are bit-shifts and general operators like add, divide, etc.""" self.generic_visit(node) log_header = f"visit_BinOp: {self.src_file}:" # default case for this node, can be BinOpBC or BinOpBS ast_class = "BinOp" op_type = type(node.op) # binop_bit_cmp_types: Set[type] = {ast.BitAnd, ast.BitOr, ast.BitXor} if op_type in {ast.BitAnd, ast.BitOr, ast.BitXor}: ast_class = "BinOpBC" # binop_bit_shift_types: Set[type] = {ast.LShift, ast.RShift} if op_type in {ast.LShift, ast.RShift}: ast_class = "BinOpBS" node_span = NodeSpan(node) idx = LocIndex( ast_class=ast_class, lineno=node_span.lineno, col_offset=node_span.col_offset, op_type=op_type, end_lineno=node_span.end_lineno, end_col_offset=node_span.end_col_offset, ) self.locs.add(idx) if idx == self.target_idx and self.mutation and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) return ast.copy_location( ast.BinOp(left=node.left, op=self.mutation(), right=node.right), node ) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST: """Boolean operations, AND/OR.""" self.generic_visit(node) log_header = f"visit_BoolOp: {self.src_file}:" node_span = NodeSpan(node) idx = LocIndex( ast_class="BoolOp", lineno=node_span.lineno, col_offset=node_span.col_offset, op_type=type(node.op), end_lineno=node_span.end_lineno, end_col_offset=node_span.end_col_offset, ) self.locs.add(idx) if idx == self.target_idx and self.mutation and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) return ast.copy_location(ast.BoolOp(op=self.mutation(), values=node.values), node) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_Compare(self, node: ast.Compare) -> ast.AST: """Compare nodes are ``==, >=, is, in`` etc. There are multiple Compare categories.""" self.generic_visit(node) log_header = f"visit_Compare: {self.src_file}:" # taking only the first operation in the compare node # in basic testing, things like (a==b)==1 still end up with lists of 1, # but since the AST docs specify a list of operations this seems safer. # idx = LocIndex("CompareIs", node.lineno, node.col_offset, type(node.ops[0])) cmpop_is_types: Set[type] = {ast.Is, ast.IsNot} cmpop_in_types: Set[type] = {ast.In, ast.NotIn} op_type = type(node.ops[0]) node_span = NodeSpan(node) locidx_kwargs = { "lineno": node_span.lineno, "col_offset": node_span.col_offset, "op_type": op_type, "end_lineno": node_span.end_lineno, "end_col_offset": node_span.end_col_offset, } if op_type in cmpop_is_types: idx = LocIndex(ast_class="CompareIs", **locidx_kwargs) # type: ignore elif op_type in cmpop_in_types: idx = LocIndex(ast_class="CompareIn", **locidx_kwargs) # type: ignore else: idx = LocIndex(ast_class="Compare", **locidx_kwargs) # type: ignore self.locs.add(idx) if idx == self.target_idx and self.mutation and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) # TODO: Determine when/how this case would actually be called if len(node.ops) > 1: # unlikely test case where the comparison has multiple values LOGGER.debug("%s multiple compare ops in node, len: %s", log_header, len(node.ops)) existing_ops = [i for i in node.ops] mutation_ops = [self.mutation()] + existing_ops[1:] return ast.copy_location( ast.Compare(left=node.left, ops=mutation_ops, comparators=node.comparators), node, ) else: # typical comparison case, will also catch (a==b)==1 as an example. LOGGER.debug("%s single comparison node operation", log_header) return ast.copy_location( ast.Compare( left=node.left, ops=[self.mutation()], comparators=node.comparators ), node, ) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_If(self, node: ast.If) -> ast.AST: """If statements e.g. If ``x == y`` is transformed to ``if True`` and ``if False``. This visit method only works when the appropriate Mixin is used. """ self.generic_visit(node) log_header = f"visit_If: {self.src_file}:" # default for a comparison is "If_Statement" which will be changed to True/False # If_Statement is not set as a mutation target, controlled in get_mutations function if_type = "If_Statement" # Py 3.7 vs 3.8 - 3.7 uses NameConstant, 3.8 uses Constant if_mutations = { "If_True": self.constant_type(value=True), "If_False": self.constant_type(value=False), } if type(node.test) == self.constant_type: if_type: str = f"If_{bool(node.test.value)}" # type: ignore node_span = NodeSpan(node) idx = LocIndex( ast_class="If", lineno=node_span.lineno, col_offset=node_span.col_offset, op_type=if_type, end_lineno=node_span.end_lineno, end_col_offset=node_span.end_col_offset, ) self.locs.add(idx) if idx == self.target_idx and self.mutation and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) return ast.fix_missing_locations( ast.copy_location( ast.If(test=if_mutations[self.mutation], body=node.body, orelse=node.orelse), node, ) ) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_Index(self, node: ast.Index) -> ast.AST: """Index visit e.g. ``i[0], i[0][1]``.""" self.generic_visit(node) log_header = f"visit_Index: {self.src_file}:" # Index Node has a value attribute that can be either Num node or UnaryOp node # depending on whether the value is positive or negative. n_value = node.value idx = None index_mutations = { "Index_NumZero": ast.Num(n=0), "Index_NumPos": ast.Num(n=1), "Index_NumNeg": ast.UnaryOp(op=ast.USub(), operand=ast.Num(n=1)), } node_span = NodeSpan(n_value) locidx_kwargs = { "ast_class": "Index", "lineno": node_span.lineno, "col_offset": node_span.col_offset, "end_lineno": node_span.end_lineno, "end_col_offset": node_span.end_col_offset, } # index is a non-negative number e.g. i[0], i[1] if isinstance(n_value, ast.Num): # positive integer case if n_value.n != 0: idx = LocIndex(op_type="Index_NumPos", **locidx_kwargs) # type: ignore self.locs.add(idx) # zero value case else: idx = LocIndex(op_type="Index_NumZero", **locidx_kwargs) # type: ignore self.locs.add(idx) # index is a negative number e.g. i[-1] if isinstance(n_value, ast.UnaryOp): idx = LocIndex(op_type="Index_NumNeg", **locidx_kwargs) # type: ignore self.locs.add(idx) if idx == self.target_idx and self.mutation and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) mutation = index_mutations[self.mutation] # uses AST.fix_missing_locations since the values of ast.Num and ast.UnaryOp also need # lineno and col-offset values. This is a recursive fix. return ast.fix_missing_locations(ast.copy_location(ast.Index(value=mutation), node)) LOGGER.debug( "%s (%s, %s): no mutations applied.", log_header, n_value.lineno, n_value.col_offset ) return node def mixin_NameConstant(self, node: Union[ast.NameConstant, ast.Constant]) -> ast.AST: """Constants: ``True, False, None``. This method is called by using the Mixin classes for handling the difference of ast.NameConstant (Py 3.7) an ast.Constant (Py 3.8). """ self.generic_visit(node) log_header = f"visit_NameConstant: {self.src_file}:" node_span = NodeSpan(node) idx = LocIndex( ast_class="NameConstant", lineno=node_span.lineno, col_offset=node_span.col_offset, op_type=node.value, end_lineno=node_span.end_lineno, end_col_offset=node_span.end_col_offset, ) self.locs.add(idx) if idx == self.target_idx and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) return ast.copy_location(self.constant_type(value=self.mutation), node) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node def visit_Subscript(self, node: ast.Subscript) -> ast.AST: """Subscript slice operations e.g., ``x[1:]`` or ``y[::2]``.""" self.generic_visit(node) log_header = f"visit_Subscript: {self.src_file}:" idx = None # Subscripts have slice properties with col/lineno, slice itself does not have line/col # Index is also a valid Subscript slice property slice = node.slice if not isinstance(slice, ast.Slice): LOGGER.debug("%s (%s, %s): not a slice node.", log_header, node.lineno, node.col_offset) return node # Built "on the fly" based on the various conditions for operation types # The RangeChange options are added in the later if/else cases slice_mutations: Dict[str, ast.Slice] = { "Slice_UnboundUpper": ast.Slice(lower=slice.upper, upper=None, step=slice.step), "Slice_UnboundLower": ast.Slice(lower=None, upper=slice.lower, step=slice.step), "Slice_Unbounded": ast.Slice(lower=None, upper=None, step=slice.step), } node_span = NodeSpan(node) locidx_kwargs = { "lineno": node_span.lineno, "col_offset": node_span.col_offset, "end_lineno": node_span.end_lineno, "end_col_offset": node_span.end_col_offset, } # Unbounded Swap Operation # upper slice range e.g. x[:2] will become x[2:] if slice.lower is None and slice.upper is not None: idx = LocIndex( ast_class="SliceUS", op_type="Slice_UnboundLower", **locidx_kwargs # type: ignore ) self.locs.add(idx) # lower slice range e.g. x[1:] will become x[:1] if slice.upper is None and slice.lower is not None: idx = LocIndex( ast_class="SliceUS", op_type="Slice_UnboundUpper", **locidx_kwargs # type: ignore ) self.locs.add(idx) # Apply Mutation if idx == self.target_idx and not self.readonly: LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation) mutation = slice_mutations[str(self.mutation)] # uses AST.fix_missing_locations since the values of ast.Num and ast.UnaryOp also need # lineno and col-offset values. This is a recursive fix. return ast.fix_missing_locations( ast.copy_location( ast.Subscript(value=node.value, slice=mutation, ctx=node.ctx), node ) ) LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset) return node class NameConstantMixin: """Mixin for Python 3.7 AST applied to MutateBase.""" @property def constant_type(self) -> Type[ast.NameConstant]: return ast.NameConstant def visit_NameConstant(self, node: ast.NameConstant) -> ast.AST: """NameConstants: ``True, False, None``.""" return self.mixin_NameConstant(node) # type: ignore class ConstantMixin: """Mixin for Python 3.8 AST applied to MutateBase.""" @property def constant_type(self) -> Type[ast.Constant]: return ast.Constant def visit_Constant(self, node: ast.Constant) -> ast.AST: """Constants: https://bugs.python.org/issue32892 NameConstant: ``True, False, None``. Num: isinstance(int, float) Str: isinstance(str) """ # NameConstant behavior consistent with Python 3.7 if isinstance(node.value, bool) or node.value is None: return self.mixin_NameConstant(node) # type: ignore return node # PYTHON 3.7 if sys.version_info < (3, 8): class MutateAST(NameConstantMixin, MutateBase): """Implementation of the MutateAST class based on running environment.""" pass # PYTHON 3.8 else: class MutateAST(ConstantMixin, MutateBase): """Implementation of the MutateAST class based on running environment.""" pass #################################################################################################### # TRANSFORMER FUNCTIONS #################################################################################################### def get_compatible_operation_sets() -> List[MutationOpSet]: """Utility function to return a list of compatible AST mutations with names. All of the mutation transformation sets that are supported by mutatest are defined here. See: https://docs.python.org/3/library/ast.html#abstract-grammar This is used to create the search space in finding mutations for a target, and also to list the support operations in the CLI help function. Returns: List of ``MutationOpSets`` that have substitutable operations """ # AST operations that are sensible mutations for each other binop_types: Set[type] = {ast.Add, ast.Sub, ast.Div, ast.Mult, ast.Pow, ast.Mod, ast.FloorDiv} binop_bit_cmp_types: Set[type] = {ast.BitAnd, ast.BitOr, ast.BitXor} binop_bit_shift_types: Set[type] = {ast.LShift, ast.RShift} cmpop_types: Set[type] = {ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE} cmpop_is_types: Set[type] = {ast.Is, ast.IsNot} cmpop_in_types: Set[type] = {ast.In, ast.NotIn} boolop_types: Set[type] = {ast.And, ast.Or} # Python built-in constants (singletons) that can be used with NameConstant AST node named_const_singletons: Set[Union[bool, None]] = {True, False, None} # Custom augmentation ops to differentiate from bin_op types # these are defined for substitution within the visit_AugAssign node and need to match aug_assigns: Set[str] = {"AugAssign_Add", "AugAssign_Sub", "AugAssign_Mult", "AugAssign_Div"} # Custom references for substitutions of zero, positive, and negative iterable indicies index_types: Set[str] = {"Index_NumPos", "Index_NumNeg", "Index_NumZero"} # Custom references for If statement substitutions # only If_True and If_False will be applied as mutations if_types: Set[str] = {"If_True", "If_False", "If_Statement"} # Custom references for subscript substitutions for slice mutations slice_bounded_types: Set[str] = {"Slice_UnboundUpper", "Slice_UnboundLower", "Slice_Unbounded"} return [ MutationOpSet( name="AugAssign", desc="Augmented assignment e.g. += -= /= *=", operations=aug_assigns, category=CATEGORIES["AugAssign"], ), MutationOpSet( name="BinOp", desc="Binary operations e.g. + - * / %", operations=binop_types, category=CATEGORIES["BinOp"], ), MutationOpSet( name="BinOp Bit Comparison", desc="Bitwise comparison operations e.g. x & y, x | y, x ^ y", operations=binop_bit_cmp_types, category=CATEGORIES["BinOpBC"], ), MutationOpSet( name="BinOp Bit Shifts", desc="Bitwise shift operations e.g. << >>", operations=binop_bit_shift_types, category=CATEGORIES["BinOpBS"], ), MutationOpSet( name="BoolOp", desc="Boolean operations e.g. and or", operations=boolop_types, category=CATEGORIES["BoolOp"], ), MutationOpSet( name="Compare", desc="Comparison operations e.g. == >= <= > <", operations=cmpop_types, category=CATEGORIES["Compare"], ), MutationOpSet( name="Compare In", desc="Compare membership e.g. in, not in", operations=cmpop_in_types, category=CATEGORIES["CompareIn"], ), MutationOpSet( name="Compare Is", desc="Comapre identity e.g. is, is not", operations=cmpop_is_types, category=CATEGORIES["CompareIs"], ), MutationOpSet( name="If", desc="If statement tests e.g. original statement, True, False", operations=if_types, category=CATEGORIES["If"], ), MutationOpSet( name="Index", desc="Index values for iterables e.g. i[-1], i[0], i[0][1]", operations=index_types, category=CATEGORIES["Index"], ), MutationOpSet( name="NameConstant", desc="Named constant mutations e.g. True, False, None", operations=named_const_singletons, category=CATEGORIES["NameConstant"], ), MutationOpSet( name="Slice Unbounded Swap", desc=( "Slice mutations to swap lower/upper values, x[2:] (unbound upper) to x[:2]," " (unbound lower). Steps are not changed." ), operations=slice_bounded_types, category=CATEGORIES["SliceUS"], ), ] def get_mutations_for_target(target: LocIndex) -> Set[Any]: """Given a target, find all the mutations that could apply from the AST definitions. Args: target: the location index target Returns: Set of types that can mutated into the target location. """ search_space: List[Set[Any]] = [m.operations for m in get_compatible_operation_sets()] mutation_ops: Set[Any] = set() for potential_ops in search_space: if target.op_type in potential_ops: LOGGER.debug("Potential mutatest operations found for target: %s", target.op_type) mutation_ops = potential_ops.copy() mutation_ops.remove(target.op_type) # Special case for If_Statement since that is a default to transform to True or False # but not a validation mutation target by itself if "If_Statement" in mutation_ops: mutation_ops.remove("If_Statement") break return mutation_ops
2.453125
2
examples/connect.py
adrienverge/aiocouch
0
12788647
import asyncio from aiocouch import CouchDB async def main_with(): async with CouchDB( "http://localhost:5984", user="admin", password="<PASSWORD>" ) as couchdb: database = await couchdb["config"] async for doc in database.docs(["db-hta"]): print(doc) if __name__ == "__main__": loop = asyncio.get_event_loop() loop.run_until_complete(main_with())
2.484375
2
tests/test_hotfix_class.py
wo1fsea/PyHotfixer
0
12788648
<filename>tests/test_hotfix_class.py # -*- coding: utf-8 -*- """---------------------------------------------------------------------------- Author: <NAME> <EMAIL> Date: 2019/8/19 Description: test_hotfix_class.py ----------------------------------------------------------------------------""" import unittest import os import sys import shutil from pyhotfixer import hotfix FILE_NAME = "class_test.py" FILE_NAME_V1 = "class_test_v1.py" FILE_NAME_V2 = "class_test_v2.py" class HotfixClassTestCase(unittest.TestCase): def setUp(self): cur_dir = os.path.dirname(os.path.abspath(__file__)) self.module_file = os.path.join(cur_dir, FILE_NAME) self.module_file_v1 = os.path.join(cur_dir, FILE_NAME_V1) self.module_file_v2 = os.path.join(cur_dir, FILE_NAME_V2) if os.path.exists(self.module_file): os.remove(self.module_file) def tearDown(self): if os.path.exists(self.module_file): os.remove(self.module_file) def test_hotfix_class(self): shutil.copy(self.module_file_v1, self.module_file) sys.modules.pop("class_test", None) import class_test hotfix_class_obj = class_test.HotfixClass() self.assertEqual(hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(hotfix_class_obj.hotfix_data, 1) self.assertEqual(hotfix_class_obj.no_hotfix_method(), 1) self.assertEqual(hotfix_class_obj.hotfix_method(), 1) self.assertEqual(hotfix_class_obj.no_hotfix_classmethod(), 1) self.assertEqual(hotfix_class_obj.hotfix_classmethod(), 1) self.assertEqual(hotfix_class_obj.hotfix_property, 1) self.assertEqual(hotfix_class_obj.no_hotfix_property, 1) self.assertEqual(hotfix_class_obj.replace_data_with_func, 1) self.assertEqual(hotfix_class_obj.replace_data_with_static_method, 1) self.assertEqual(hotfix_class_obj.replace_data_with_class_method, 1) self.assertEqual(class_test.HotfixClass.InnerClass1.func(), 1) self.assertEqual(class_test.HotfixClass.InnerClass2.func(), 1) self.assertEqual(class_test.HotfixClass.InnerClass, class_test.HotfixClass.InnerClass1) no_hotfix_class_obj = class_test.NoHotfixClass() self.assertEqual(no_hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(no_hotfix_class_obj.no_hotfix_method(), 1) another_no_hotfix_class_obj = class_test.AnotherNoHotfixClass() self.assertEqual(another_no_hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(another_no_hotfix_class_obj.no_hotfix_method(), 1) shutil.copy(self.module_file_v2, self.module_file) hotfix(["class_test"]) self.assertEqual(hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(hotfix_class_obj.hotfix_data, 2) self.assertEqual(hotfix_class_obj.no_hotfix_method(), 1) self.assertEqual(hotfix_class_obj.hotfix_method(), 2) self.assertEqual(hotfix_class_obj.no_hotfix_classmethod(), 1) self.assertEqual(hotfix_class_obj.hotfix_classmethod(), 2) self.assertEqual(hotfix_class_obj.no_hotfix_property, 1) self.assertEqual(hotfix_class_obj.hotfix_property, 2) self.assertEqual(hotfix_class_obj.replace_data_with_func(), 2) self.assertEqual(hotfix_class_obj.replace_data_with_static_method(), 2) self.assertEqual(hotfix_class_obj.replace_data_with_class_method(), 2) self.assertEqual(class_test.HotfixClass.InnerClass1.func(), 2) self.assertEqual(class_test.HotfixClass.InnerClass2.func(), 2) self.assertEqual(class_test.HotfixClass.InnerClass, class_test.HotfixClass.InnerClass2) no_hotfix_class_obj = class_test.NoHotfixClass() self.assertEqual(no_hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(no_hotfix_class_obj.no_hotfix_method(), 1) another_no_hotfix_class_obj = class_test.AnotherNoHotfixClass() self.assertEqual(another_no_hotfix_class_obj.no_hotfix_data, 1) self.assertEqual(another_no_hotfix_class_obj.no_hotfix_method(), 1)
2.53125
3
scaffoldgraph/core/fragment.py
shenwanxiang/ScaffoldGraph
0
12788649
<reponame>shenwanxiang/ScaffoldGraph<gh_stars>0 """ scaffoldgraph.core.fragment """ from abc import ABC, abstractmethod from rdkit import RDLogger from rdkit.Chem import ( RWMol, MolToSmiles, rdmolops, SanitizeMol, GetMolFrags, BondType, CHI_UNSPECIFIED, SANITIZE_ALL, SANITIZE_CLEANUP, SANITIZE_CLEANUPCHIRALITY, SANITIZE_FINDRADICALS, ) from rdkit.Chem.Scaffolds import MurckoScaffold from scaffoldgraph.core.scaffold import Scaffold rdlogger = RDLogger.logger() class Fragmenter(ABC): """Abstract base class for scaffold fragmentation methods. Fragmenters should be designed to be used for generating scaffold graphs. subclasses may use attributes to store an internal state or property used during fragmentation. Subclasses should define the fragment method which takes a scaffold (sg.core.Scaffold) as an argument and returns the next set of scaffolds i.e. the next hierarchical level. """ def __call__(self, scaffold): return self.fragment(scaffold) @abstractmethod def fragment(self, scaffold): """Subclasses should implement this method. Parameters ---------- scaffold (sg.core.Scaffold): a scaffoldgraph scaffold object Returns ------- This method should return the next set of scaffolds. i.e. the next hierarchical level. """ raise NotImplementedError() class MurckoRingFragmenter(Fragmenter): """A Fragmenter class for the removal of peripheral rings from a Murcko scaffold. Designed to be used for the generation of a scaffold graph. The fragment's fragment method takes a scaffold (sg.core.Scaffold) and returns the next set of murcko fragments. i.e. scaffolds with 1 less ring than the child scaffold. """ def __init__(self, use_scheme_4=False): """Initialize the MurckoRingFragmenter Parameters ---------- use_scheme_4: if True use scheme 4 from the paper: The Scaffold Tree − Visualization of the Scaffold Universe by Hierarchical Scaffold Classification. This scheme should be used when generating scaffold trees with the original prioritization rules. Notes ----- Scheme 4 (description taken from paper): The fusion bond connecting a three-membered ring with other rings is converted into a double bond. This rule is intended to deal with epoxides and aziridines. This rule treats such systems as functional groups which are removed beforehand, rather than as rings. This reflects the situation that epoxides are usually generated by the oxidation of a double bond, and also many natural products exist often in forms with and without epoxidized double bonds. """ super(MurckoRingFragmenter, self).__init__() self.use_scheme_4 = use_scheme_4 def fragment(self, scaffold): """Fragment a scaffold into its next set of murcko fragments. Parameters ---------- scaffold (sg.core.Scaffold): scaffold to be fragmented. Returns ------- parents (list): a list of the next scaffold parents. """ parents = [] # container for parent scaffolds rings = scaffold.rings # ring information for rix, ring in enumerate(rings): # Loop through all rings and remove edit = RWMol(scaffold.mol) # Editable molecule # Collect all removable atoms in the molecule remove_atoms = set() for index, atom in zip(ring.aix, ring.atoms): if rings.info.NumAtomRings(index) == 1: if atom.GetDegree() > 2: # Evoke linker collection collect_linker_atoms(edit.GetAtomWithIdx(index), remove_atoms) else: # Add ring atom to removable set remove_atoms.add(index) else: # Atom is shared between multiple rings correct_atom_props(edit.GetAtomWithIdx(index)) # Collect removable bonds (this needs to be done to prevent the case where when deleting # a ring two atoms belonging to the same bond are also part of separate other rings. # This bond must be broken to prevent an incorrect output) remove_bonds = set() for bix in {x for x in ring.bix if rings.info.NumBondRings(x) == 1}: bond = edit.GetBondWithIdx(bix) b_x, b_y = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx() if b_x not in remove_atoms and b_y not in remove_atoms: remove_bonds.add((b_x, b_y)) correct_atom_props(edit.GetAtomWithIdx(b_x)) correct_atom_props(edit.GetAtomWithIdx(b_y)) # Scheme 4 (scaffold tree rule) if self.use_scheme_4 is not False and len(ring) == 3: atomic_nums = [a.GetAtomicNum() for a in ring.atoms] if len([a for a in atomic_nums if a != 1 and a != 6]) == 1: shared = {x for x in ring.bix if rings.info.NumBondRings(x) > 1} if len(shared) == 1: bond = edit.GetBondWithIdx(shared.pop()) bond.SetBondType(BondType.DOUBLE) # Remove collected atoms and bonds for bix in remove_bonds: edit.RemoveBond(*bix) for aix in sorted(remove_atoms, reverse=True): edit.RemoveAtom(aix) # Add new parent scaffolds to parent list for parent in get_scaffold_frags(edit): if parent.rings.count == len(rings) - 1: parent.removed_ring_idx = rix parents.append(parent) return parents class MurckoRingSystemFragmenter(Fragmenter): """A Fragmenter class for the removal of peripheral ring systems from a Murcko scaffold. Designed to be used for the generation of a scaffold graph. Unlike the MurckoRingFragmenter this fragmenter will not dissect fused ring systems. This fragmenter is thus used for HierS network generation The fragment's fragment method takes a scaffold (sg.core.Scaffold) and returns the next set of murcko fragments. i.e. scaffolds with 1 less ring than the child scaffold. """ def __init__(self): super(MurckoRingSystemFragmenter, self).__init__() def fragment(self, scaffold): """Fragment a scaffold into its next set of murcko fragments. This fragmenter will not dissect fused ring systems. Parameters ---------- scaffold (sg.core.Scaffold): scaffold to be fragmented. Returns ------- parents (list): a list of the next scaffold parents. """ parents = [] rings = scaffold.ring_systems # ring system information info = scaffold.rings.info if rings.count == 1: return [] for rix, ring in enumerate(rings): edit = RWMol(scaffold.mol) remove_atoms = set() for index, atom in zip(ring.aix, ring.atoms): if info.NumAtomRings(index) == 1: if atom.GetDegree() > 2: # Evoke linker collection collect_linker_atoms(edit.GetAtomWithIdx(index), remove_atoms) else: remove_atoms.add(index) else: remove_atoms.add(index) for aix in sorted(remove_atoms, reverse=True): edit.RemoveAtom(aix) for parent in get_scaffold_frags(edit): if parent.ring_systems.count == len(rings) - 1: parent.removed_ring_idx = rix parents.append(parent) return parents def collect_linker_atoms(origin, remove_atoms): """Used during fragmentation to collect atoms that are part of a linker""" visited = set() # Visited bond indexes def collect(origin_atom): for bond in origin_atom.GetBonds(): bond_id = bond.GetIdx() if bond_id in visited or bond.IsInRing(): continue other_atom = bond.GetOtherAtom(origin_atom) other_degree = other_atom.GetDegree() if other_degree == 1: # Terminal side-chain remove_atoms.add(origin_atom.GetIdx()) remove_atoms.add(other_atom.GetIdx()) correct_atom_props(origin_atom) visited.add(bond_id) elif other_degree == 2: # Two neighboring atoms (remove) remove_atoms.add(origin_atom.GetIdx()) visited.add(bond_id) collect(other_atom) elif other_degree > 2: # Branching point # Determine number of non-terminal branches non_terminal_branches = 0 for neighbor in other_atom.GetNeighbors(): if neighbor.GetDegree() != 1: non_terminal_branches += 1 if non_terminal_branches < 3: # Continue with deletion remove_atoms.add(origin_atom.GetIdx()) visited.add(bond_id) collect(other_atom) else: # Branching point links two rings # Test for exolinker double bond if not bond.GetBondType() == BondType.DOUBLE: remove_atoms.add(origin_atom.GetIdx()) correct_atom_props(other_atom) visited.add(bond_id) pass # Linker is recursively collected # Linker atoms are added to the existing set 'remove_atoms' collect(origin) def get_scaffold_frags(frag): """Get fragments from a disconnected structure. Used by fragmentation methods.""" try: # frag.ClearComputedProps() # frag.UpdatePropertyCache() # Chem.GetSymmSSSR(frag) partial_sanitization(frag) except ValueError as e: # This error is caught as dissecting an aromatic ring system, # may lead to an undefined state where the resultant system # is no longer aromatic. We make no attempt to prevent this # but log it for reference. # This behaviour may be desirable for a scaffold tree and is # equivalent to the behavior of SNG (I believe...) # logger.debug(e) return set() frags = {Scaffold(f) for f in GetMolFrags(frag, True, False)} return frags def correct_atom_props(atom): """Used during fragmentation to correct atom properties where an adjacent atom is removed""" if atom.GetIsAromatic() and atom.GetAtomicNum() != 6: atom.SetNumExplicitHs(1) elif atom.GetNoImplicit() or atom.GetChiralTag() != CHI_UNSPECIFIED: atom.SetNoImplicit(False) atom.SetNumExplicitHs(0) atom.SetChiralTag(CHI_UNSPECIFIED) def partial_sanitization(mol): """Partially sanitize a molecule (used during fragmentation)""" SanitizeMol(mol, sanitizeOps=SANITIZE_ALL ^ SANITIZE_CLEANUP ^ SANITIZE_CLEANUPCHIRALITY ^ SANITIZE_FINDRADICALS) def get_murcko_scaffold(mol, generic=False): """Get the murcko scaffold for an input molecule Parameters ---------- mol (Chem.Mol): an rdkit molecule generic (bool): if True return a generic scaffold (CSK) Returns ------- murcko (Chem.Mol): an rdkit molecule (scaffold) """ murcko = MurckoScaffold.GetScaffoldForMol(mol) if generic: murcko = MurckoScaffold.MakeScaffoldGeneric(murcko) return murcko def get_annotated_murcko_scaffold(mol, scaffold=None, as_mol=True): """Return an annotated murcko scaffold where side chains are replaced with a dummy atom ('*'). Parameters ---------- mol (Chem.Mol): input molecule. scaffold (Chem.Mol): If a murcko scaffold is already calculated for the mol, this can be supplied as a template. (optional, default: None) as_mol (bool): if True return rdkit Mol object else return a SMILES string representation. (optional, default: True) """ if not scaffold: scaffold = MurckoScaffold.GetScaffoldForMol(mol) annotated = rdmolops.ReplaceSidechains(mol, scaffold) if as_mol: return annotated if annotated is None: return '' return MolToSmiles(annotated) def get_next_murcko_fragments(murcko_scaffold, break_fused_rings=True): """Fragment a scaffold into its next set of murcko fragments. The fragmenter assumes that a murcko scaffold is supplied. Parameters ---------- murcko_scaffold (Chem.Mol): An rdkit Mol containing a murcko scaffold break_fused_rings (bool): If True dissect fused rings (default: True) Returns ------- parents (list): a list of parent scaffolds (next hierarchy [num_rings - 1]) """ rdlogger.setLevel(4) if break_fused_rings: fragmenter = MurckoRingFragmenter() else: fragmenter = MurckoRingSystemFragmenter() parents = [f.mol for f in set(fragmenter.fragment(Scaffold(murcko_scaffold)))] rdlogger.setLevel(3) return parents def get_all_murcko_fragments(mol, break_fused_rings=True): """Get all possible murcko fragments from a molecule through recursive removal of peripheral rings Parameters ---------- mol: rdkit molecule to be processed break_fused_rings (bool): If True dissect fused rings (default: True) Returns ------- A list of rdkit Mols representing all possible murcko fragments """ rdlogger.setLevel(4) if break_fused_rings: fragmenter = MurckoRingFragmenter() else: fragmenter = MurckoRingSystemFragmenter() mol = get_murcko_scaffold(mol) rdmolops.RemoveStereochemistry(mol) scaffold = Scaffold(mol) parents = {scaffold} def recursive_generation(child): for parent in fragmenter.fragment(child): if parent in parents: continue parents.add(parent) recursive_generation(parent) recursive_generation(scaffold) rdlogger.setLevel(3) return [f.mol for f in parents]
2.40625
2
sekh/highlighting.py
movermeyer/django-sekh
4
12788650
<reponame>movermeyer/django-sekh """Highlighting for django-sekh""" from bs4 import BeautifulSoup from sekh.utils import compile_terms from sekh.settings import PROTECTED_MARKUPS from sekh.settings import HIGHLIGHTING_PATTERN def highlight(content, terms): """ Highlight the HTML with BeautifulSoup. """ index = 1 update_content = False soup = BeautifulSoup(content) terms = compile_terms(terms) for term in terms: for text in soup.find_all(text=term): if text.parent.name in PROTECTED_MARKUPS: continue def highlight(match): match_term = match.group(0) return HIGHLIGHTING_PATTERN % { 'index': index, 'term': match_term} new_text = term.sub(highlight, text) text.replace_with(BeautifulSoup(new_text)) update_content = True # Reload the entire soup, because substituion # doesn't rebuild the document tree soup = BeautifulSoup(str(soup)) index += 1 if update_content: return str(soup) return content
2.59375
3